Come importare un certificato X.509 esistente e una chiave privata nel keystore Java da utilizzare in SSL?

StackOverflow https://stackoverflow.com/questions/906402

  •  05-09-2019
  •  | 
  •  

Domanda

Ho questo in una configurazione ActiveMQ:

<sslContext>
        <sslContext keyStore="file:/home/alex/work/amq/broker.ks"  
 keyStorePassword="password" trustStore="file:${activemq.base}/conf/broker.ts" 
 trustStorePassword="password"/>
</sslContext>

Ho una coppia di certificati X.509 e un file chiave.

Come posso importare questi due per utilizzarli nei connettori SSL e SSL+stomp?Tutti gli esempi in cui potrei sempre generare la chiave su Google da soli, ma ho già una chiave.

Ho provato

keytool -import  -keystore ./broker.ks -file mycert.crt

ma questo importa solo il certificato e non il file chiave e risulta

2009-05-25 13:16:24,270 [localhost:61612] ERROR TransportConnector - Could not accept connection : No available certificate or key corresponds to the SSL cipher suites which are enabled.

Ho provato a concatenare il certificato e la chiave ma ho ottenuto lo stesso risultato.

Come faccio a importare la chiave?

È stato utile?

Soluzione

Che ci crediate o no, keytool non fornisce tale funzionalità di base come l'importazione di chiave privata per chiavi. Si può provare questo soluzione con la fusione di file PKSC12 con la chiave privata di un archivio di chiavi.

o semplicemente usare più user-friendly KeyMan da IBM per la gestione invece di keytool.exe chiavi.

Altri suggerimenti

Ho usato le seguenti due passaggi che ho trovato nei commenti / messaggi legati nelle altre risposte:

Fase uno: Convertire il CERT X.509 e chiave in un file PKCS12 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root

Nota: Assicurati di mettere una password sul file PKCS12 - altrimenti si otterrà un'eccezione di puntatore nullo quando si tenta di importarlo. (Nel caso in cui nessun altro ha avuto questo mal di testa). ( Grazie jocull! )

Nota 2: Si potrebbe desiderare di aggiungere l'opzione -chain per preservare la catena di certificati. ( Grazie Mafuba )

Fase due: Convertire il file PKCS12 ad un chiavi Java 

keytool -importkeystore \
        -deststorepass [changeit] -destkeypass [changeit] -destkeystore server.keystore \
        -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass some-password \
        -alias [some-alias]

Finito

OPTIONAL Passaggio a zero: Creazione di un'autocertificazione 

openssl genrsa -out server.key 2048
openssl req -new -out server.csr -key server.key
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Cheers!

Keytool in Java 6 ha questa capacità: Importazione di chiavi private in un Java keystore utilizzando keytool

Ecco i dettagli di base di quel post.

  1. Convertire il CERT esistente in un PKCS12 utilizzando OpenSSL. è necessaria una password quando ha chiesto o il 2 ° gradino si lamenterà. 

    openssl pkcs12 -export -in [my_certificate.crt] -inkey [my_key.key] -out [keystore.p12] -name [new_alias] -CAfile [my_ca_bundle.crt] -caname root

  2. Convertire il PKCS12 in un file Java chiavi. 

    keytool -importkeystore -deststorepass [new_keystore_pass] -destkeypass [new_key_pass] -destkeystore [keystore.jks] -srckeystore [keystore.p12] -srcstoretype PKCS12 -srcstorepass [pass_used_in_p12_keystore] -alias [alias_used_in_p12_keystore]

E un altro: 

#!/bin/bash

# We have:
#
# 1) $KEY : Secret key in PEM format ("-----BEGIN RSA PRIVATE KEY-----") 
# 2) $LEAFCERT : Certificate for secret key obtained from some
#    certification outfit, also in PEM format ("-----BEGIN CERTIFICATE-----")   
# 3) $CHAINCERT : Intermediate certificate linking $LEAFCERT to a trusted
#    Self-Signed Root CA Certificate 
#
# We want to create a fresh Java "keystore" $TARGET_KEYSTORE with the
# password $TARGET_STOREPW, to be used by Tomcat for HTTPS Connector.
#
# The keystore must contain: $KEY, $LEAFCERT, $CHAINCERT
# The Self-Signed Root CA Certificate is obtained by Tomcat from the
# JDK's truststore in /etc/pki/java/cacerts

# The non-APR HTTPS connector (APR uses OpenSSL-like configuration, much
# easier than this) in server.xml looks like this 
# (See: https://tomcat.apache.org/tomcat-6.0-doc/ssl-howto.html):
#
#  <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
#                SSLEnabled="true"
#                maxThreads="150" scheme="https" secure="true"
#                clientAuth="false" sslProtocol="TLS"
#                keystoreFile="/etc/tomcat6/etl-web.keystore.jks"
#                keystorePass="changeit" />
#

# Let's roll:    

TARGET_KEYSTORE=/etc/tomcat6/foo-server.keystore.jks
TARGET_STOREPW=changeit

TLS=/etc/pki/tls

KEY=$TLS/private/httpd/foo-server.example.com.key
LEAFCERT=$TLS/certs/httpd/foo-server.example.com.pem
CHAINCERT=$TLS/certs/httpd/chain.cert.pem

# ----
# Create PKCS#12 file to import using keytool later
# ----

# From https://www.sslshopper.com/ssl-converter.html:
# The PKCS#12 or PFX format is a binary format for storing the server certificate,
# any intermediate certificates, and the private key in one encryptable file. PFX
# files usually have extensions such as .pfx and .p12. PFX files are typically used 
# on Windows machines to import and export certificates and private keys.

TMPPW=$$ # Some random password

PKCS12FILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary PKCS12 file failed -- exiting" >&2; exit 1
fi

TRANSITFILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary transit file failed -- exiting" >&2; exit 1
fi

cat "$KEY" "$LEAFCERT" > "$TRANSITFILE"

openssl pkcs12 -export -passout "pass:$TMPPW" -in "$TRANSITFILE" -name etl-web > "$PKCS12FILE"

/bin/rm "$TRANSITFILE"

# Print out result for fun! Bug in doc (I think): "-pass " arg does not work, need "-passin"

openssl pkcs12 -passin "pass:$TMPPW" -passout "pass:$TMPPW" -in "$PKCS12FILE" -info

# ----
# Import contents of PKCS12FILE into a Java keystore. WTF, Sun, what were you thinking?
# ----

if [[ -f "$TARGET_KEYSTORE" ]]; then
  /bin/rm "$TARGET_KEYSTORE"
fi

keytool -importkeystore \
   -deststorepass  "$TARGET_STOREPW" \
   -destkeypass    "$TARGET_STOREPW" \
   -destkeystore   "$TARGET_KEYSTORE" \
   -srckeystore    "$PKCS12FILE" \
   -srcstoretype  PKCS12 \
   -srcstorepass  "$TMPPW" \
   -alias foo-the-server

/bin/rm "$PKCS12FILE"

# ----
# Import the chain certificate. This works empirically, it is not at all clear from the doc whether this is correct
# ----

echo "Importing chain"

TT=-trustcacerts

keytool -import $TT -storepass "$TARGET_STOREPW" -file "$CHAINCERT" -keystore "$TARGET_KEYSTORE" -alias chain

# ----
# Print contents
# ----

echo "Listing result"

keytool -list -storepass "$TARGET_STOREPW" -keystore "$TARGET_KEYSTORE"

Sì, è davvero un fatto triste che keytool non ha alcuna funzionalità per importare una chiave privata.

Per la cronaca, alla fine sono andato con la soluzione descritta qui

Per prima convertire in p12: 

openssl pkcs12 -export -in [filename-certificate] -inkey [filename-key] -name [host] -out [filename-new-PKCS-12.p12]

Crea nuovo JKS da p12: 

keytool -importkeystore -deststorepass [password] -destkeystore [filename-new-keystore.jks] -srckeystore [filename-new-PKCS-12.p12] -srcstoretype PKCS12

Nel mio caso ho avuto un file PEM che conteneva due certificati e una chiave privata cifrata per essere utilizzato in autenticazione reciproca SSL. Quindi il mio file PEM si presentava così: 

-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,C8BF220FC76AA5F9
...
-----END RSA PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

Ecco quello che ho fatto:

dividere il file in tre file separati, in modo che ciascuno di essi contiene solo una voce, inizia con "--- BEGIN .." e termina con "--- fine .." linee. Assumiamo ora abbiamo tre file: cert2.pem cert1.pem e pkey.pem

Convertire pkey.pem in formato DER utilizzando OpenSSL e la seguente sintassi:

openssl pkcs8 -topk8 -nocrypt -in pkey.pem -inform PEM -out pkey.der -outform DER

Si noti che se la chiave privata è crittografata è necessario fornire una password (ottenere dal fornitore del file PEM originale) convertire in formato DER, OpenSSL vi chiederà la password in questo modo: "inserire una Phraze pass per pkey.pem:" Se la conversione ha successo, si otterrà un nuovo file chiamato "pkey.der"

Crea un nuovo archivio chiavi Java e importare la chiave privata e dei certificati: 

String keypass = "password";  // this is a new password, you need to come up with to protect your java key store file
String defaultalias = "importkey";
KeyStore ks = KeyStore.getInstance("JKS", "SUN");

// this section does not make much sense to me, 
// but I will leave it intact as this is how it was in the original example I found on internet:   
ks.load( null, keypass.toCharArray());
ks.store( new FileOutputStream ( "mykeystore"  ), keypass.toCharArray());
ks.load( new FileInputStream ( "mykeystore" ),    keypass.toCharArray());
// end of section..


// read the key file from disk and create a PrivateKey

FileInputStream fis = new FileInputStream("pkey.der");
DataInputStream dis = new DataInputStream(fis);
byte[] bytes = new byte[dis.available()];
dis.readFully(bytes);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

byte[] key = new byte[bais.available()];
KeyFactory kf = KeyFactory.getInstance("RSA");
bais.read(key, 0, bais.available());
bais.close();

PKCS8EncodedKeySpec keysp = new PKCS8EncodedKeySpec ( key );
PrivateKey ff = kf.generatePrivate (keysp);


// read the certificates from the files and load them into the key store:

Collection  col_crt1 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert1.pem"));
Collection  col_crt2 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert2.pem"));

Certificate crt1 = (Certificate) col_crt1.iterator().next();
Certificate crt2 = (Certificate) col_crt2.iterator().next();
Certificate[] chain = new Certificate[] { crt1, crt2 };

String alias1 = ((X509Certificate) crt1).getSubjectX500Principal().getName();
String alias2 = ((X509Certificate) crt2).getSubjectX500Principal().getName();

ks.setCertificateEntry(alias1, crt1);
ks.setCertificateEntry(alias2, crt2);

// store the private key
ks.setKeyEntry(defaultalias, ff, keypass.toCharArray(), chain );

// save the key store to a file         
ks.store(new FileOutputStream ( "mykeystore" ),keypass.toCharArray());

(opzionale) Verificare il contenuto del tuo nuovo negozio chiave:

keytool -list -keystore mykeystore -storepass password

  

Tipo Keystore: JKS fornitore Keystore: SUN

     

Il tuo chiavi contiene 3 voci

     

CN = ..., ou = ..., o = .., 2 Settembre 2014, trustedCertEntry, Certificato   impronte digitali (SHA1): 2C: B8: ...

     

importkey, 2 Settembre 2014, PrivateKeyEntry, impronte digitali Certificato   (SHA1): 9C: B0: ...

     

CN = ..., o = ...., 2 settembre, 2014, trustedCertEntry, impronte digitali Certificato   (SHA1): 83:63: ...

(opzionale) Metti alla prova i certificati e la chiave privata dal vostro nuovo negozio chiave contro il vostro server SSL: (Si consiglia di attivare il debug come opzione VM: -Djavax.net.debug = tutti) 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        SSLSocketFactory factory = sclx.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket( "192.168.1.111", 443 );
        socket.startHandshake();

        //if no exceptions are thrown in the startHandshake method, then everything is fine..

Infine registrare i certificati con HttpsURLConnection se prevede di utilizzare: 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        HostnameVerifier hv = new HostnameVerifier()
        {
            public boolean verify(String urlHostName, SSLSession session)
            {
                if (!urlHostName.equalsIgnoreCase(session.getPeerHost()))
                {
                    System.out.println("Warning: URL host '" + urlHostName + "' is different to SSLSession host '" + session.getPeerHost() + "'.");
                }
                return true;
            }
        };

        HttpsURLConnection.setDefaultSSLSocketFactory( sclx.getSocketFactory() );
        HttpsURLConnection.setDefaultHostnameVerifier(hv);

In base alle risposte di cui sopra, ecco come creare un nuovo keystore per il server web basato su Java, di un CERT Comodo creato autonomamente e la chiave privata utilizzando keytool (richiede JDK 1.6 +)

  1. Immettere questo comando e alla richiesta di password entrano somepass - 'server.crt' è cert del server e 'server.key' è la chiave privata si è utilizzato per il rilascio del CSR: openssl pkcs12 -export -in server.crt -inkey server.key -out server.p12 -name www.yourdomain.com -CAfile AddTrustExternalCARoot.crt -caname "AddTrust External CA Root"

  2. Quindi utilizzare keytool per convertire l'archivio di chiavi p12 in un Archivio chiavi JKS: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Poi importare gli altri due root / certs intermedi ricevuti da Comodo:

  1. Importa COMODORSAAddTrustCA.crt: keytool -import -trustcacerts -alias cert1 -file COMODORSAAddTrustCA.crt -keystore keystore.jks

  2. Importa COMODORSADomainValidationSecureServerCA.crt: keytool -import -trustcacerts -alias cert2 -file COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks

È possibile utilizzare questa procedura per importare la chiave di un archivio chiavi esistente. Le istruzioni sono combinati dalle risposte a questa discussione e altri siti. Queste istruzioni lavorato per me (l'archivio di chiavi Java):

  1. Esegui

openssl pkcs12 -export -in yourserver.crt -inkey yourkey.key -out server.p12 -name somename -certfile yourca.crt -caname root

(Se necessario inserire l'opzione di catena a. Mettere che non è riuscito per me). Questo vi chiederà di inserire la password - si deve dare la password corretta altrimenti otterrete un errore (Errore o errore di imbottitura ecc voce).

  1. Ti verrà chiesto di inserire una nuova password - è necessario inserire una password qui - indicare nulla, ma lo ricordo. (Supponiamo si entra Aragorn).
  2. Questo creerà il file server.p12 nel formato PKCS.
  3. Ora per importarlo nel file di corsa *.jks:
    keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
    (Molto importante -. Non lasciare fuori il deststorepass ei parametri destkeypass)
  4. E vi chiederà la password dell'archivio chiavi src. Inserisci Aragorn e premi invio. Il certificato e la chiave è ora importati nel chiavi Java esistente.

Le risposte precedenti sottolineano correttamente che è possibile farlo solo con gli strumenti JDK standard convertendo prima il file JKS nel formato PKCS #12.Se sei interessato, ho messo insieme un'utilità compatta per importare chiavi derivate da OpenSSL in un archivio di chiavi formattato JKS senza dover prima convertire l'archivio di chiavi in ​​PKCS #12: http://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art049

Utilizzeresti l'utilità collegata in questo modo:

$ openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.csr -subj "/CN=localhost"

(firma la CSR, recupera localhost.cer)

$ openssl rsa -in localhost.key -out localhost.rsa
Enter pass phrase for localhost.key:
writing RSA key
$ java -classpath . KeyImport -keyFile localhost.rsa -alias localhost -certificateFile localhost.cer -keystore localhost.jks -keystorePassword changeit -keystoreType JKS -keyPassword changeit

Se hai un file PEM (ad es. server.pem) contenente:

  • il certificato attendibile
  • la chiave privata

quindi puoi importare il certificato e la chiave in un archivio chiavi JKS in questo modo:

1) Copiare la chiave privata dal file PEM in un file ascii (es. server.key)

2) Copiare il certificato dal file PEM in un file ascii (es. server.crt)

3) Esportare il certificato e la chiave in un file PKCS12:

$ openssl pkcs12 -export -in server.crt -inkey server.key \
                 -out server.p12 -name [some-alias] -CAfile server.pem -caname root
  • il file PEM può essere utilizzato come argomento per il file -CAfile opzione.
  • ti verrà richiesta una password di 'esportazione'.
  • se lo fai in git bash, aggiungi winpty all'inizio del comando in modo da poter inserire la password di esportazione.

4) Converti il ​​file PKCS12 in un archivio chiavi JKS:

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit
  • IL srcstorepass la password deve corrispondere alla password di esportazione del passaggio 3)

Quello che stavo cercando di ottenere era utilizzare la chiave privata e il certificato già forniti per firmare il messaggio che stava andando da qualche parte per garantire che il messaggio provenisse da me (le chiavi private firmano mentre le chiavi pubbliche crittografano).

Quindi, se hai già un file .key e un file .crt?

Prova questo:

Passo 1: Converti la chiave e il certificato nel file .p12

openssl pkcs12 -export -in certificate.crt -inkey privateKey.key -name alias -out yourconvertedfile.p12

Passo 2: Importa la chiave e crea un file .jsk con un singolo comando

keytool -importkeystore -deststorepass changeit -destkeystore keystore.jks -srckeystore umeme.p12 -srcstoretype PKCS12

Passaggio 3: Nel tuo Java:

char[] keyPassword = "changeit".toCharArray();

KeyStore keyStore = KeyStore.getInstance("JKS");
InputStream keyStoreData = new FileInputStream("keystore.jks");

keyStore.load(keyStoreData, keyPassword);
KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(keyPassword);
KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry("alias", entryPassword);

System.out.println(privateKeyEntry.toString());

Se devi firmare una stringa utilizzando questa chiave, procedi come segue:

Passo 1:Converti il ​​testo che desideri crittografare

byte[] data = "test".getBytes("UTF8");

Passo 2:Ottieni la chiave privata codificata base64

keyStore.load(keyStoreData, keyPassword);

//get cert, pubkey and private key from the store by alias
Certificate cert = keyStore.getCertificate("localhost");
PublicKey publicKey = cert.getPublicKey();
KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

//sign with this alg
Signature sig = Signature.getInstance("SHA1WithRSA");
sig.initSign(keyPair.getPrivate());
sig.update(data);
byte[] signatureBytes = sig.sign();
System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

sig.initVerify(keyPair.getPublic());
sig.update(data);

System.out.println(sig.verify(signatureBytes));

Riferimenti:

  1. Come importare un certificato x509 esistente e una chiave privata nel keystore Java da utilizzare in SSL?
  2. http://tutorials.jenkov.com/java-cryptography/keystore.html
  3. http://www.java2s.com/Code/Java/Security/RetrievingaKeyPairfromaKeyStore.htm
  4. Come firmare una stringa con chiave privata

Programma definitivo

public static void main(String[] args) throws Exception {

    byte[] data = "test".getBytes("UTF8");

    // load keystore
    char[] keyPassword = "changeit".toCharArray();

    KeyStore keyStore = KeyStore.getInstance("JKS");
    //System.getProperty("user.dir") + "" < for a file in particular path 
    InputStream keyStoreData = new FileInputStream("keystore.jks");
    keyStore.load(keyStoreData, keyPassword);

    Key key = keyStore.getKey("localhost", keyPassword);

    Certificate cert = keyStore.getCertificate("localhost");

    PublicKey publicKey = cert.getPublicKey();

    KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

    Signature sig = Signature.getInstance("SHA1WithRSA");

    sig.initSign(keyPair.getPrivate());
    sig.update(data);
    byte[] signatureBytes = sig.sign();
    System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

    sig.initVerify(keyPair.getPublic());
    sig.update(data);

    System.out.println(sig.verify(signatureBytes));
}

Basta fare un keystore PKCS12, Java può utilizzare direttamente la società. In realtà, se si elencano un keystore in stile Java, keytool si avverte il fatto che PKCS12 è ora il formato preferito. 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root -chain

Si dovrebbe aver ricevuto tutte e tre le file (server.crt, server.key, ca.crt) dal provider certificato. Non sono sicuro di quello che "root -caname" significa in realtà, ma sembra devono essere specificati in questo modo.

Nel codice Java, assicurarsi di specificare il tipo di chiavi destra. 

KeyStore.getInstance("PKCS12")

ho ottenuto il mio comodo.com-rilasciato certificato SSL lavorando bene in NanoHTTPD questo modo.

Utilizzo dei certificati Let's Encrypt

Supponendo che tu abbia creato i tuoi certificati e le tue chiavi private con Crittifichiamo In /etc/letsencrypt/live/you.com:

1.Creare un PKCS #12 file

openssl pkcs12 -export -in fullchain.pem -inkey privkey.pem -out pkcs.p12 \
        -name letsencrypt

Questo combina il tuo certificato SSL fullchain.pem e la tua chiave privata privkey.pem in un unico file, pkcs.p12.

Ti verrà richiesta una password per pkcs.p12.

IL export L'opzione specifica che verrà creato un file PKCS #12 anziché analizzato (from il manuale).

2.Creare l'archivio chiavi Java

keytool -importkeystore -destkeystore keystore.jks -srckeystore pkcs.p12 \
        -srcstoretype PKCS12 -alias letsencrypt

Se keystore.jks non esiste, verrà creato contenente il file pkcs.12 file creato sopra.Altrimenti importerai pkcs.12 nel keystore esistente.

Queste istruzioni derivano da questo post del blog.

Ecco di più sui diversi tipi di file in /etc/letsencrypt/live/you.com/.

in un caso di curve ellittiche e rispondere alla domanda Importa un certificato x509 esistente e la chiave privata in Java keystore , si consiglia di dare un'occhiata anche a questo thread Come leggere CE chiave privata in java che è in formato di file .pem

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top