Conversion d'un keystore Java au format PEM

J'essaie de convertir un fichier de keystore Java en un fichier PEM en utilisant des applications keytool et openssl. Mais je n'ai pas pu trouver un bon moyen de faire la conversion. Des idées?

Au lieu de convertir le keystore directement en PEM, j'ai d'abord essayé de créer un fichier PKCS12, puis de le convertir en fichier PEM et Keystore appropriés. Mais je n'ai pas pu établir de connexion en les utilisant. (Notez que j'ai juste besoin d'un fichier PEM et d'un fichier Keystore pour implémenter une connexion sécurisée. Il n'y a pas de restriction comme "Démarrer à partir d'un fichier keystore java". :) Donc, partir d'autres formats est acceptable dans mon cas)

Mais une méthode de conversion directe de jks vers pem est préférable.

C'est assez simple, en utilisant au moins jdk6 ...

bash $ keytool -keystore foo.jks -genkeypair -alias foo \
        -dname 'CN = foo.example.com, L = Melbourne, ST = Victoria, C = AU'
Entrez le mot de passe du fichier de clés:  
Ré-entrez le nouveau mot de passe: 
Entrez le mot de passe clé pour 
        (RETURN si identique au mot de passe du keystore):  
bash $ keytool -keystore foo.jks -exportcert -alias foo | \
       openssl x509 -inform der -text
Entrez le mot de passe du fichier de clés: asdasd
Certificat:
    Les données:
        Version: 3 (0x2)
        Numéro de série: 1237334757 (0x49c03ae5)
        Algorithme de signature: dsaWithSHA1
        Émetteur: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Validité
            Pas avant: 18 mars 00:05:57 2009 GMT
            Pas après: 16 juin 00:05:57 2009 GMT
        Sujet: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Informations sur la clé publique du sujet:
            Algorithme de clé publique: dsaEncryption
            Clé publique DSA:
                pub: 
                    00: e2: 66: 5c: e0: 2e: da: e0: 6b: a6: aa: 97: 64: 59: 14:
                    7e: a6: 2e: 5a: 45: f9: 2f: b5: 2d: f4: 34: 27: e6: 53: c7:
 

bash $ keytool -importkeystore -srckeystore foo.jks \
       -destkeystore foo.p12 \
       -srcstoretype jks \
       -deststoretype pkcs12
Entrez le mot de passe du fichier de clés de destination:  
Ré-entrez le nouveau mot de passe: 
Entrez le mot de passe du fichier de clés source:  
Entrée pour l'alias foo importée avec succès.
Commande d'importation terminée: 1 entrées importées avec succès, 0 entrées échouées ou annulées

bash $ openssl pkcs12 -in foo.p12 -out foo.pem
Entrez le mot de passe d'importation:
MAC vérifié OK
Entrez la phrase de passe PEM:
Vérification - Entrez la phrase de passe PEM:

bash $ openssl x509 -text -in foo.pem
Certificat:
    Les données:
        Version: 3 (0x2)
        Numéro de série: 1237334757 (0x49c03ae5)
        Algorithme de signature: dsaWithSHA1
        Émetteur: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Validité
            Pas avant: 18 mars 00:05:57 2009 GMT
            Pas après: 16 juin 00:05:57 2009 GMT
        Sujet: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Informations sur la clé publique du sujet:
            Algorithme de clé publique: dsaEncryption
            Clé publique DSA:
                pub: 
                    00: e2: 66: 5c: e0: 2e: da: e0: 6b: a6: aa: 97: 64: 59: 14:
                    7e: a6: 2e: 5a: 45: f9: 2f: b5: 2d: f4: 34: 27: e6: 53: c7:
 

bash $ openssl dsa -text -in foo.pem
lire la clé DSA
Entrez la phrase de passe PEM:
Clé privée: (1024 bits)
priv:
    00: 8f: b1: af: 55: 63: 92: 7c: d2: 0f: e6: f3: a2: f5: ff:
    1a: 7a: fe: 8c: 39: jj
pub: 
    00: e2: 66: 5c: e0: 2e: da: e0: 6b: a6: aa: 97: 64: 59: 14:
    7e: a6: 2e: 5a: 45: f9: 2f: b5: 2d: f4: 34: 27: e6: 53: c7:

Vous vous retrouvez avec:

• foo.jks - keystore au format java.
• foo.p12 - keystore au format PKCS # 12.
• foo.pem - toutes les clés et certificats du keystore, au format PEM.

(Ce dernier fichier peut être divisé en clés et certificats si vous le souhaitez.)

Résumé de la commande - pour créer un keystore JKS:

keytool -keystore foo.jks -genkeypair -alias foo \
    -dname 'CN=foo.example.com,L=Melbourne,ST=Victoria,C=AU'

Résumé de la commande - pour convertir le keystore JKS en keystore PKCS # 12, puis en fichier PEM:

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcstoretype jks \
   -deststoretype pkcs12

openssl pkcs12 -in foo.p12 -out foo.pem

Si vous avez plus d'un certificat dans votre keystore JKS et que vous souhaitez exporter uniquement le certificat et la clé associés à l'un des alias, vous pouvez utiliser la variante suivante:

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcalias foo \
   -srcstoretype jks \
   -deststoretype pkcs12

openssl pkcs12 -in foo.p12 -out foo.pem

Résumé de la commande - pour comparer le keystore JKS au fichier PEM:

keytool -keystore foo.jks -exportcert -alias foo | \
   openssl x509 -inform der -text

openssl x509 -text -in foo.pem

openssl dsa -text -in foo.pem

J'ai continué à recevoir des erreurs openssllors de l'utilisation de la commande de StoBor:

MAC verified OK
Error outputting keys and certificates
139940235364168:error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt:evp_enc.c:535:
139940235364168:error:23077074:PKCS12 routines:PKCS12_pbe_crypt:pkcs12 cipherfinal error:p12_decr.c:97:
139940235364168:error:2306A075:PKCS12 routines:PKCS12_item_decrypt_d2i:pkcs12 pbe crypt error:p12_decr.c:123:

Pour une raison quelconque, seul ce style de commande fonctionnerait pour mon fichier JKS

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcstoretype jks \
   -srcalias mykey \
   -deststoretype pkcs12 \
   -destkeypass DUMMY123

La clé était le réglage destkeypass, la valeur de l'argument n'avait pas d'importance.

La keytoolcommande ne vous permettra pas d'exporter la clé privée à partir d'un magasin de clés. Vous devez écrire du code Java pour ce faire. Ouvrez le magasin de clés, obtenez la clé dont vous avez besoin et enregistrez-la dans un fichier au format PKCS # 8. Enregistrez également le certificat associé.

KeyStore ks = KeyStore.getInstance("jks");
/* Load the key store. */
...
char[] password = ...;
/* Save the private key. */
FileOutputStream kos = new FileOutputStream("tmpkey.der");
Key pvt = ks.getKey("your_alias", password);
kos.write(pvt.getEncoded());
kos.flush();
kos.close();
/* Save the certificate. */
FileOutputStream cos = new FileOutputStream("tmpcert.der");
Certificate pub = ks.getCertificate("your_alias");
cos.write(pub.getEncoded());
cos.flush();
cos.close();

Utilisez les utilitaires OpenSSL pour convertir ces fichiers (qui sont au format binaire) au format PEM.

openssl pkcs8 -inform der -nocrypt < tmpkey.der > tmpkey.pem
openssl x509 -inform der < tmpcert.der > tmpcert.pem

Conversion directe du fichier jks au fichier pem à l'aide de l'outil keytool

keytool -exportcert -alias selfsigned -keypass password -keystore test-user.jks -rfc -file test-user.pem

Instructions simplifiées pour convertir un fichier JKS au format PEM et KEY (.crt & .key):

keytool -importkeystore -srckeystore <Source-Java-Key-Store-File> -destkeystore <Destination-Pkcs12-File> -srcstoretype jks -deststoretype pkcs12 -destkeypass <Destination-Key-Password>

openssl pkcs12 -in <Destination-Pkcs12-File> -out <Destination-Pem-File>

openssl x509 -outform der -in <Destination-Pem-File> -out <Destination-Crt-File>

openssl rsa -in <Destination-Pem-File> -out <Destination-Key-File>

J'ai trouvé une solution très intéressante:

http://www.swview.org/node/191

Ensuite, j'ai divisé la paire clé publique / privée en deux fichiers private.key publi.pem et ça marche!

La conversion d'un KeyStore JKS en un seul fichier PEM peut facilement être effectuée à l'aide de la commande suivante:

keytool -list -rfc -keystore "myKeystore.jks" | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d" >> "myKeystore.pem"

Explication:

1. keytool -list -rfc -keystore "myKeystore.jks"répertorie tout dans le KeyStore 'myKeyStore.jks' au format PEM. Cependant, il imprime également des informations supplémentaires.
2. | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d"filtre tout ce dont nous n'avons pas besoin. Il ne nous reste que les PEM de tout ce qui se trouve dans le KeyStore.
3. >> "myKeystore.pem" écrivez les PEM dans le fichier «myKeyStore.pem».

Commencez par vider le keystore de JKS vers PKCS12

1. keytool -importkeystore -srckeystore ~ ​​/ .android / debug.keystore -destkeystore intermediaire.p12 -srcstoretype JKS -deststoretype PKCS12

Vider le nouveau fichier pkcs12 dans pem

2. openssl pkcs12 -in intermediaire.p12 -nodes -out intermediaire.rsa.pem

Vous devez avoir à la fois le certificat et la clé privée au format pem. Divisez-les. Placez la partie entre «BEGIN CERTIFICATE» et «END CERTIFICATE» dans cert.x509.pem Mettez la partie entre «BEGIN RSA PRIVATE KEY» et «END RSA PRIVATE KEY» en private.rsa.pem Convertissez la clé privée au format pk8 comme attendu par signapk

3. openssl pkcs8 -topk8 -outform DER -in private.rsa.pem -inform PEM -out private.pk8 -nocrypt

Eh bien, OpenSSL devrait le faire facilement à partir d'un fichier n ° 12:

openssl pkcs12 -in pkcs-12-certificate-file -out pem-certificate-file
openssl pkcs12 -in pkcs-12-certificate-and-key-file -out pem-certificate-and-key-file

Peut-être plus de détails sur l'erreur / l'échec?

Dans le cas où vous n'avez pas installé openssl et que vous cherchez une solution rapide, il existe un logiciel appelé portcle qui est très utile et petit à télécharger.

L'inconvénient est qu'il n'y a pas de ligne de commande pour autant que je sache. Mais à partir de l'interface graphique, il est assez simple d'exporter une clé privée PEM:

1. Ouvrez votre magasin de clés JKS
2. Faites un clic droit sur votre entrée de clé privée et sélectionnez exporter

3. Sélectionnez la clé privée et les certificats et le format PEM

   

Essayez Keystore Explorer http://keystore-explorer.org/

KeyStore Explorer est un remplacement d'interface graphique open source pour les utilitaires de ligne de commande Java keytool et jarsigner. Il fait également openssl / pkcs12.

créez d'abord le fichier de keystore comme

C: \ Program Files \ Android \ Android Studio \ jre \ bin> keytool -keystore androidkey.jks -genkeypair -alias androidkey

Entrez le mot de passe du fichier de clés:
Entrez à nouveau le nouveau mot de passe:
Quels sont vos nom et prénom? Inconnu: FirstName LastName
Quel est le nom de votre unité organisationnelle? Inconnu: Développement mobile
Quel est le nom de votre organisation? Inconnu: le nom de votre entreprise
Quel est le nom de votre ville ou localité? Quel est le nom de votre état ou province?
Quel est le code du pays à deux lettres pour cet appareil? Inconnu: IN // appuyez sur Entrée

Maintenant, il vous demandera de confirmer

Est-ce que CN = FirstName LastName, OU = Mobile Development, O = le nom de votre entreprise, L = CityName, ST = StateName, C = IN est correct? [non]: oui

Entrez le mot de passe clé pour (RETURN si identique au mot de passe du fichier de clés): appuyez sur Entrée si vous voulez le même mot de passe

clé a été générée, maintenant vous pouvez simplement obtenir le fichier pem en utilisant la commande suivante

C: \ Program Files \ Android \ Android Studio \ jre \ bin> keytool -export -rfc -alias androidkey -file android_certificate.pem -keystore androidkey.jks
Entrez le mot de passe du keystore:
Certificat stocké dans le fichier

Conversion d'un keystore Java au format PEM

La réponse la plus précise de toutes doit être que ce n'est PAS possible.

Un keystore Java est simplement une installation de stockage pour les clés cryptographiques et les certificats, tandis que PEM est un format de fichier pour les certificats X.509 uniquement.