web-dev-qa-db-fra.com

Comment importer un certificat x509 existant et une clé privée dans le magasin de clés Java à utiliser dans le protocole SSL?

J'ai ceci dans la configuration d'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 cert x509 et un fichier de clé

Comment importer ces deux-là pour les utiliser dans les connecteurs ssl et ssl + stomp? Tous les exemples, je pourrais google toujours générer 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 importe seulement le certificat et non le fichier de clé et entraîne 

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é de concaténer le cert et la clé mais j'ai obtenu le même résultat

Comment importer la clé?

javassljmsactivemqjks
198
Aleksandar Ivanisevic

Croyez-le ou non, keytool ne fournit pas une fonctionnalité de base telle que l'importation d'une clé privée dans le magasin de clés. Vous pouvez essayer cette solution workaround en fusionnant le fichier PKSC12 avec la clé privée dans un magasin de clés. 

Ou utilisez simplement KeyMan d'IBM plus convivial pour la gestion du magasin de clés au lieu de keytool.exe. 

66
Matej

J'ai utilisé les deux étapes suivantes que j'ai trouvées dans les commentaires/posts liés dans les autres réponses:

Première étape: convertir le certificat et la clé x509 en 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 p12 - sinon vous obtiendrez une exception de référence null lorsque vous essayez de l'importer. (Si quelqu'un d'autre avait ce mal de tête). ( Merci jocull! )

Remarque 2: Vous souhaiterez peut-être ajouter l'option -chain pour conserver la chaîne de certificats complète. ( Merci Mafuba )

Étape 2: convertissez le fichier pkcs12 en un magasin de clés Java 

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

Fini

Step Zero FACULTATIF, 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

À votre santé!

478
reto

Keytool dans Java 6 a cette capacité: Importation de clés privées dans un magasin de clés Java à l'aide de keytool

Voici les détails de base de ce post.

  1. Convertissez le certificat existant en PKCS12 à l’aide d’OpenSSL. Un mot de passe est requis lorsque demandé ou la 2e é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. Convertissez le PKCS12 en un fichier de clés Java.

    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]
113
CoverosGene

Et un de plus:

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

Oui, il est triste de constater que keytool ne dispose pas de fonctionnalité pour importer une clé privée.

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

8
Aleksandar Ivanisevic

Dans mon cas, j'avais un fichier pem contenant deux certificats et une clé privée cryptée à utiliser dans l'authentification mutuelle SSL . 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 j'ai fait:

Divisez le fichier en trois fichiers distincts, de sorte que chacun ne contienne qu'une seule entrée, commençant par "--- BEGIN .." et finissant par "--- END ..". Supposons que nous avons maintenant trois fichiers: cert1.pem cert2.pem et pkey.pem

Convertissez pkey.pem au 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 (procurez-vous-le auprès du fournisseur du fichier pem d'origine) Pour convertir au format DER, Openssl vous demandera le mot de passe de la manière suivante: " entrez un mot de passe pour pkey.pem: " Si la conversion aboutit, vous obtiendrez un nouveau fichier appelé" pkey.der ".

Créez un nouveau magasin de clés Java et importez 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());

(facultatif) Vérifiez le contenu de votre nouveau magasin de clés:

keytool -list -keystore mykeystore -storepass password

Type de magasin de clés: JKS Fournisseur de magasin de clés: Sun

Votre magasin de clés contient 3 entrées

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

importkey, 2 septembre 2014, PrivateKeyEntry, empreinte digitale du certificat (SHA1): 9C: B0: ...

cn = ..., o = ...., 2 septembre 2014, trustedCertEntry, empreinte digitale du certificat (SHA1): 83:63: ...

(facultatif) Testez vos certificats et votre clé privée de votre nouveau magasin de clés sur votre serveur SSL: .__ (vous pouvez activer le débogage en tant qu'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, enregistrez vos certificats avec HttpsURLConnection si vous prévoyez de l’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);
6
Interkot

D'abord converti en p12:

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

Créez de nouveaux JKS à partir de p12:

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

Sur la base des réponses ci-dessus, voici comment créer un nouveau magasin de clés pour votre serveur Web basé sur Java, à partir d'un cert Comodo et d'une clé privée créés indépendamment à l'aide de keytool (requiert JDK 1.6+).

  1. Émettez cette commande et entrez l'invite "some server" au mot de passe. "Server.crt" est le certificat de votre serveur et "server.key" est la clé privée que vous avez utilisée pour l'émission de la 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 magasin de clés p12 en un magasin de clés jks: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Importez ensuite les deux autres certificats racine/intermédiaires que 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

5
Alex Fotios

Voici les étapes que j'ai suivies pour importer la clé dans un magasin de clés existant - instructions combinées à partir des réponses fournies ici et à d'autres endroits pour obtenir ces étapes qui ont fonctionné pour mon magasin de clés Java: 

  1. Courir 

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

(Si nécessaire, mettez l'option -chain. Cela a échoué pour moi) . Ceci demandera le mot de passe - vous devez donner le mot de passe correct, sinon vous obtiendrez une erreur .__ (erreur de titre ou erreur de remplissage, etc.). 

  1. Il vous demandera de saisir un nouveau mot de passe - vous devez saisir un mot de passe ici - entrez n'importe quoi mais souvenez-vous-en. (Supposons que vous entrez Aragorn). 
  2. Cela créera le fichier server.p12 au format pkcs. 
  3. Maintenant, importez-le dans le fichier *.jks:

keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 - destkeystore yourexistingjavakeystore.jks -deststoreetype JKS -deststore passez le mot-clé javec passé

(Très important - ne laissez pas de côté les paramètres deststorepass et destkeypass.)
5. Il vous demandera le mot de passe src key store. Entrez Aragorn et appuyez sur Entrée . Le certificat et la clé sont maintenant importés dans votre magasin de clés Java existant. 

4
vanval

Les réponses précédentes soulignent correctement que vous ne pouvez le faire qu'avec les outils JDK standard en convertissant d'abord le fichier JKS au format PKCS # 12. Si cela vous intéresse, je propose un utilitaire compact permettant d'importer des clés dérivées d'OpenSSL dans un magasin de clés au format JKS sans avoir à convertir le magasin de clés au format PKCS # 12 au préalable: http://commandlinefanatic.com/cgi-bin/ showarticle.cgi? article = art049

Vous utiliseriez l'utilitaire lié comme ceci:

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

(signez le CSR, retournez 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
3
Joshua Davies

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

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

alors vous pouvez importer le certificat et la clé dans un magasin de clés JKS comme ceci:

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

2 ) Copiez le certificat du fichier PEM dans un fichier ascii (par exemple, server.crt).

3 ) Exportez 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 cela est fait dans git bash, ajoutez winpty au début de la commande pour pouvoir entrer le mot de passe d'exportation.

4 ) Convertissez le fichier PKCS12 en un magasin de clés 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 d'exportation de l'étape 3)
2
Joman68

Ce que j’essayais de faire, c’était d’utiliser une clé privée et un certificat déjà fournis pour signer un message destiné à s’assurer que le message provenait de moi (signature des clés privées lors du chiffrement des clés publiques).

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

Essaye ça:

Étape 1: Convertir la clé et le certificat en fichier .p12

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

Étape 2: Importez la clé et créez 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 à l'aide de cette clé, procédez comme suit:

Étape 1: convertissez le texte que vous souhaitez chiffrer

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

Étape 2: Obtenir la clé privée encodée en 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));

Références:

  1. Comment importer un certificat x509 existant et une clé privée dans le magasin de clés Java à utiliser dans le protocole SSL?
  2. http://tutorials.jenkov.com/Java-cryptography/keystore.html
  3. http://www.Java2s.com/Code/Java/Security/RetrievingaKeyPairfromaKeyStore.htm
  4. Comment signer une chaîne avec une 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));
}
2
Mwa Joe

Utilisation des certificats Let's Encrypt

En supposant que vous ayez créé vos certificats et vos clés privées avec Let's Encrypt dans /etc/letsencrypt/live/you.com:

1. Créez un fichier PKCS # 12

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

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

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

L'option export indique qu'un fichier PKCS # 12 sera créé plutôt qu'analysé (à partir de le manuel ).

2. Créez le magasin de clés Java.

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

Si keystore.jks n'existe pas, il sera créé avec le fichier pkcs.12 créé ci-dessus. Sinon, vous importerez pkcs.12 dans le magasin de clés existant.

Ces instructions sont dérivées de cet article de blog .

En savoir plus sur les différents types de fichiers dans /etc/letsencrypt/live/you.com/.

1
Matthias Braun

dans le cas d'une courbe elliptique et répondez à la question importez un certificat x509 existant et une clé privée dans le magasin de clés Java , vous pouvez également consulter ce fil de discussion Comment lire la clé privée EC en Java qui est au format .pem

0
dilbertside

Créez simplement un magasin de clés PKCS12, Java peut l’utiliser directement maintenant. En fait, si vous répertoriez un magasin de clés de style Java, keytool vous avertit lui-même que PKCS12 est désormais 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 devez avoir reçu les trois fichiers (server.crt, server.key, ca.crt) de votre fournisseur de certificat. Je ne suis pas sûr de ce que "-caname root" signifie réellement, mais il semble devoir être spécifié de cette façon.

Dans le code Java, assurez-vous de spécifier le type de magasin de clés approprié.

KeyStore.getInstance("PKCS12")

Mon certificat SSL délivré par Comodo.com a bien fonctionné sous NanoHTTPD.

0
Stefan Reich