Comment importer un X. 509 certificat et la clé privée en Java fichier de clés à utiliser dans le protocole SSL?

Croyez-le ou pas, keytool ne fournit pas ces fonctionnalités de base comme l'importation de la clé privée de magasin de clés. Vous pouvez essayer cette solution de contournement avec la fusion PKSC12 fichier avec la clé privée dans un fichier de clés.

Ou tout simplement plus convivial KeyMan d'IBM pour le fichier de stockage des clés de la manipulation au lieu de keytool.exe.

Keytool dans la version 6 de Java n'ont cette capacité: L'importation de clés privées dans un keystore Java à l'aide de keytool

Voici les détails de base de ce poste.

1. De convertir les cert à un PKCS12 utilisant OpenSSL. Un mot de passe est requis lors de la demande ou de la 2ème étape va se plaindre.

   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 PKCS12 à Java Fichier de magasin de clés.

   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]

Oui, c'est en effet un triste fait que keytool n'a pas de fonctionnalité d'importation d'une clé privée.

Pour l'enregistrement, à la fin, je suis allé avec la solution décrite ici

Dans mon cas, j'ai eu un fichier pem qui contenait deux certificats et chiffrée de la clé privée utilisée dans la mutuelle authentification SSL.
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 j'ai fait:

Diviser le fichier en trois fichiers distincts, de sorte que chacun d'eux contient juste une entrée,
en commençant par "---COMMENCER.." et finissant par "---FIN.." lignes. Supposons que nous avons maintenant trois fichiers: cert1.pem cert2.pem et pkey.pem

Convertir pkey.pem dans DER format à l'aide d'openssl et de la syntaxe suivante:

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

Noter, que si la clé privée est chiffrée, vous devez fournir un mot de passe( l'obtenir à partir du fournisseur de l'original du fichier pem )
pour convertir au format DER,
openssl va vous demander le mot de passe comme ceci: "entrez un pass phraze pour pkey.pem:"
Si la conversion est réussie, vous obtiendrez un nouveau fichier appelé "pkey.der"

Créer un nouveau java magasin de clés et importer les clés privées 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 Keystore fournisseur de: SOLEIL

Votre fichier de clés contient 3 entrées

cn=...,ou=...,o=.., Sep 2, 2014, trustedCertEntry, Certificat
d'empreintes digitales (SHA1): 2C:B8: ...

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

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

(en option) Test de votre certificat et la clé privée à partir de votre nouveau magasin de clés à l'encontre de votre serveur SSL:
( Vous souhaiterez peut-être activer le débogage comme une VM option: -Djavax.net.debug=tous )

        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 enregistrer vos certificats avec HttpsURLConnection si l'intention 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);

Vous pouvez utiliser ces étapes pour importer la clé d'un fichier de clés existant. Les instructions sont associées à partir des réponses dans ce fil et sur d'autres sites. Ces instructions ont travaillé 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, mettre la chaîne en option. La mise qui a échoué pour moi).
Cela va demander le mot de passe, vous devez donner le mot de passe correct sinon vous obtiendrez un message d'erreur
(erreur de cap ou de rembourrage d'erreur, etc).

1. Il va vous demander de saisir un nouveau mot de passe, vous devez entrer un mot de passe - entrez ce que vous voulez, mais rappelez-vous il. (Nous supposons que vous entrez Aragorn).
2. Cela va créer le serveur.p12 fichier au format pkcs.
3. Maintenant l'importer dans le *.jks de l'exécution du fichier:
   
   
keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12
-destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword

   
   (Très important - ne pas laisser les deststorepass et la destkeypass paramètres).
4. Il vous demandera de la src mot de passe du magasin de clés. Entrez Aragorn et appuyez sur entrée.
   Le certificat et la clé est maintenant importé dans votre keystore java.

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

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

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

1) Copie de la clé privée à partir 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 certificat 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 la -CAfile option.
• vous êtes invité pour un "exporter" le mot de passe.
• si cela dans git bash puis ajouter winpty le début de la commande si l'exportation de mot de passe peuvent être saisis.

4) de Convertir le fichier PKCS12 à un JKS keystore:

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
-destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
-srcstorepass changeit

• la srcstorepass mot de passe doit correspondre à l'exportation mot de passe à partir de l'étape 3)

Il suffit de faire une PKCS12 keystore Java peut l'utiliser directement maintenant. En fait, si vous indiquez un Java-style de magasin de clés, keytool lui-même vous alerte sur le 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 (serveur de.crt, serveur.la clé, ca.crt) à partir de votre fournisseur de certificats. Je ne suis pas sûr de ce que "-caname racine" signifie réellement, mais il semble être définis de cette façon.

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

KeyStore.getInstance("PKCS12")

J'ai obtenu mon comodo.com-délivré un certificat SSL fonctionne très bien dans NanoHTTPD de cette façon.

À l'aide de Let's Encrypt certificats

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

1. Créer un PKCS #12 fichier

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

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

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

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

2. Créer le keystore Java

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

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

Ces instructions sont dérivées à partir de ce blog.

Voici plus d' sur les différents types de fichiers dans /etc/letsencrypt/live/you.com/.