Comment importer un certificat X.509 et une clé privée en Java keystore à utiliser dans SSL?

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

  •  05-09-2019
  •  | 
  •  

Question

J'ai cela dans une config ActiveMQ: 

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

J'ai une paire de X.509 cert et un fichier de clé.

Comment importer ces deux afin de les utiliser dans les connecteurs SSL et SSL + Stomp? Tous les exemples que je pourrais google générer toujours la clé eux-mêmes, mais j'ai déjà une clé.

J'ai essayé 

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

mais cela n'importe que le certificat et non le fichier et les résultats clés 

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.

J'ai essayé concaténer le cert et la clé, mais a obtenu le même résultat.

Comment importer la clé?

Était-ce utile?

La solution

Croyez-le ou non, keytool ne fournit pas cette fonctionnalité de base comme clé privée à l'importation keystore. Vous pouvez essayer cette avec la fusion fichier PKSC12 avec la clé privée à un keystore.

Ou tout simplement utiliser plus convivial KeyMan d'IBM pour la manipulation keystore au lieu de keytool.exe.

Autres conseils

J'ai utilisé les deux étapes que je trouve dans les commentaires / messages liés dans les autres réponses suivantes:

Première étape: Convertir le cert X.509 et la clé d'un fichier pkcs12 

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

Remarque: Assurez-vous de mettre un mot de passe sur le fichier pkcs12 - sinon vous aurez une exception de pointeur NULL lorsque vous essayez de l'importer. (Au cas où quelqu'un d'autre a eu ce mal de tête). ( Merci jocull! )

Note 2: Vous pouvez ajouter l'option -chain pour préserver la chaîne de certificat. ( Merci Mafuba )

Deuxième étape: Convertir le fichier pkcs12 à Java keystore 

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

Terminé

EN OPTION Étape zéro: Créer un certificat auto-signé 

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

Vive!

Keytool en Java 6 n'ont cette capacité: Importation des clés privées dans un Java en utilisant keytool keystore

Voici les détails de base de ce poste.

  1. Convertir le cert existant à un PKCS12 en utilisant OpenSSL. Un mot de passe est nécessaire quand on lui demande ou la 2ème étape se plaindra. 

    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. Convertir le PKCS12 à un fichier Java keystore. 

    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]

Et encore: 

#!/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"

Oui, il est bien triste de constater que keytool n'a pas de fonctionnalité pour importer une clé privée.

Pour mémoire, à la fin je suis allé avec la solution décrite ici

Tout d'abord convertir en p12: 

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

Créer une nouvelle JKS de p12: 

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

Dans mon cas, j'avais un fichier pem qui contenait deux certificats et une clé privée chiffrée à utiliser dans l'authentification SSL mutuelle. Donc, mon fichier pem ressemblait à ceci: 

-----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-----

Voici ce que je faisais:

Diviser le fichier en trois fichiers distincts, de sorte que chacun contient une seule entrée, en commençant par « --- BEGIN .. » et se terminant par « --- FIN .. » lignes. Supposons aussi que nous avons maintenant trois fichiers: cert1.pem cert2.pem et pkey.pem

Convertir pkey.pem en format DER en utilisant OpenSSL et la syntaxe suivante:

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

Notez que si la clé privée est cryptée, vous devez fournir un mot de passe (l'obtenir auprès du fournisseur du fichier d'origine GDP) pour convertir au format DER, OpenSSL vous demandera le mot de passe comme ceci: « entrez un Phraze passe pour pkey.pem: » Si la conversion est réussie, vous obtiendrez un nouveau fichier appelé « pkey.der »

Créer un nouveau magasin clé java et importer la clé privée et les certificats: 

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());

(en option) Vérifiez le contenu de votre nouveau magasin clé:

keytool -list -keystore mykeystore -storepass password

  

type de keystore: JKS fournisseur Keystore: SUN

     

Votre keystore contient 3 entrées

     

cn = ..., ou = ..., o = .. 2 Sep 2014, trustedCertEntry, certificat   empreinte digitale (SHA1): 2C: B8: ...

     

importkey 2 Sep 2014, PrivateKeyEntry, empreintes digitales certificat   (SHA1): 9C: B0 ...

     

cn = ..., o = .... 2 Sep 2014, trustedCertEntry, empreintes digitales certificat   (SHA1): 83:63: ...

(en option) Testez vos certificats et clé privée de votre nouveau magasin clé contre votre serveur SSL: (Vous pouvez activer le débogage en option VM: -Djavax.net.debug = all) 

        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..

Enfin inscrire vos certificats avec HttpsURLConnection si vous prévoyez d'utiliser: 

        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);

D'après les réponses ci-dessus, voici comment créer une nouvelle marque pour votre keystore serveur web basé sur Java, à partir d'un cert Comodo créé de façon indépendante et la clé privée en utilisant keytool (nécessite JDK 1.6 +)

  1. Numéro cette commande et à l'invite de mot de passe entrez somepass - « server.crt » est cert votre serveur et « server.key » est la clé privée que vous avez utilisé pour l'émission du 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. Ensuite, utilisez keytool pour convertir le keystore p12 dans un keystore JKS: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Ensuite, importez les deux autres certs racine / intermédiaire vous avez reçus de Comodo:

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

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

Vous pouvez utiliser ces étapes pour importer la clé d'un keystore existant. Les instructions sont combinées de réponses sur ce sujet et d'autres sites. Ces instructions de travail pour moi (le keystore java):

  1. Exécuter

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

(Si nécessaire de mettre l'option -chaîne. Mettre cela a échoué pour moi). Cela vous demandera le mot de passe - vous devez donner le mot de passe sinon vous obtiendrez une erreur (N etc erreur ou erreur de bourrage).

  1. Il vous demandera d'entrer un nouveau mot de passe - vous devez entrer un mot de passe ici - saisir quoi que ce soit, mais en souvenir. (Supposons que vous entrez Aragorn).
  2. Cela va créer le fichier server.p12 dans le format PKCS.
  3. Maintenant, pour l'importer dans l'exécution du fichier *.jks:
    keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
    (Très important -. Ne laissez pas la deststorepass et les paramètres de destkeypass)
  4. Il vous demandera le mot de passe de stockage de clés src. Entrez Aragorn et appuyez sur Entrée. Le certificat et la clé est maintenant importé dans votre keystore Java existant.

réponses précédentes indiquent à juste titre que vous ne pouvez le faire avec les outils standards du JDK en convertissant le fichier JKS en format PKCS # 12 en premier. Si vous êtes intéressé, je mis en place un utilitaire compact pour importer des clés OpenSSL dérivées dans un keystore formaté JKS sans avoir à convertir le keystore à PKCS # 12 d'abord: http://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art049

Vous utilisez l'utilitaire lié à ceci: 

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

(signer la CSR, revenez 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

Si vous avez un fichier PEM (par exemple server.pem) contenant:

  • le certificat de confiance
  • la clé privée

vous pouvez importer le certificat et la clé dans un keystore JKS comme ceci:

1 ) Copiez la clé privée du fichier PEM dans un fichier ascii (par exemple server.key)

2 ) Copier le CERT à partir du fichier PEM dans un fichier ASCII (par exemple server.crt)

3 ) Exporter le cert et la clé dans un fichier PKCS12: 

$ openssl pkcs12 -export -in server.crt -inkey server.key \
                 -out server.p12 -name [some-alias] -CAfile server.pem -caname root
  • le fichier PEM peut être utilisé comme argument de l'option -CAfile .
  • vous êtes invité à entrer un mot de passe 'export'.
  • si le faire dans bash git puis ajoutez winpty au début de la commande si le mot de passe à l'exportation peut être saisi.

4 ) Convertir le fichier PKCS12 à un keystore JKS: 

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit
  • le mot de passe srcstorepass doit correspondre au mot de passe à l'exportation de l'étape 3)

Ce que je tentais d'obtenir utilisait la clé privée déjà fourni et certificat pour signer un message qui allait quelque part que nécessaire pour faire en sorte que le message venait de moi (clés privées signe alors que les clés publiques chiffrent).

Donc, si vous avez déjà un fichier .key et un fichier .crt?

Essayez ceci:

Etape 1: Convertir la clé et cert à .p12 

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

Étape 2: Importer la clé et créer un fichier .jsk avec une seule commande 

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

Étape 3: Dans votre 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());

Si vous devez signer une chaîne en utilisant cette clé, procédez comme suit:

Étape 1: Convertir le texte que vous souhaitez chiffrer 

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

Étape 2: codé en base64 clé privée 

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));

Références:

  1. Comment importer un certificat X509 existant et la clé privée en Java keystore à utiliser dans SSL?
  2. http://tutorials.jenkov.com/java-cryptography/keystore.html
  3. http://www.java2s.com/Code/Java/Security /RetrievingaKeyPairfromaKeyStore.htm
  4. Comment signer la chaîne avec la clé privée

Programme final 

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));
}

Il suffit de faire un keystore PKCS12, Java peut l'utiliser directement maintenant. En fait, si vous listez un style Java keystore, keytool lui-même vous avertit du fait que PKCS12 est maintenant le format préféré. 

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

Vous devriez avoir reçu tous les trois fichiers (server.crt, server.key, ca.crt) de votre fournisseur de certificats. Je ne suis pas sûr de ce que « racine -caname » signifie en fait, mais il semble avoir à préciser de cette façon.

Dans le code Java, assurez-vous de spécifier le type de keystore. 

KeyStore.getInstance("PKCS12")

J'ai obtenu mon certificat SSL émis comodo.com-fonctionne bien dans NanoHTTPD cette façon.

Utilisation des certificats Chiffrer Let

En supposant que vous avez créé vos certificats et les clés privées avec Faisons Crypter /etc/letsencrypt/live/you.com:

1. Créer un PKCS # 12 

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

combine votre certificat SSL fullchain.pem et votre privkey.pem clé privée dans un seul fichier, pkcs.p12.

Vous serez invité à entrer un mot de passe pour pkcs.p12.

L'option export spécifie qu'un fichier PKCS # 12 sera créé au lieu de parsé (de la manuel).

2. Créer Java keystore 

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

Si keystore.jks n'existe pas, il sera créé contenant le fichier pkcs.12 créé ci-dessus. Sinon, vous allez importer pkcs.12 dans le keystore existant.

Ces instructions sont dérivées de ce billet de blog .

est ici plus sur les différents types de les fichiers /etc/letsencrypt/live/you.com/.

dans un cas de Elliptic Curve et répondre à la question importer un certificat X509 existant et la clé privée en Java keystore , vous pouvez jeter un oeil aussi à ce fil Comment lire la clé privée CE en java qui est en format de fichier .pem

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top