Conversion d'un keystore Java au format PEM


132

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.

Réponses:


214

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

12
Les certificats de confiance ne sont pas pris en charge dans cette méthode: il s'agit d'une restriction du format PKS12, je crois voir: java.sun.com/javase/6/docs/technotes/guides/security/jsse/… (section sur java.security.KeyStoreException : TrustedCertEntry non pris en charge)
andygavin

2
J'ai un ancien fichier JKS. Je n'ai pas pu exporter en utilisant la méthode ci-dessus. J'ai finalement pu le faire en définissant keytool arg '-destkeypass' sur une valeur factice. 'keytool' affiche même un avertissement indiquant qu'il ignore la valeur destkeypass? Aucune autre technique ne fonctionnerait. L'utilisation des invites n'a pas fonctionné, fonctionne uniquement à partir de l'argument de ligne de commande. Doit être un bogue dans l'exportation PKCS12, quelqu'un peut-il commenter?
cmcginty

4
"openssl pkcs12 -in foo.p12 -out foo.pem" renvoie l'erreur suivante Enter Import Password: MAC vérifié OK Erreur de sortie des clés et des certificats 139848775526048: erreur: 06065064: routines d'enveloppe numérique: EVP_DecryptFinal_ex: mauvais déchiffrement: evp_enc.c: 539 : 139848775526048: erreur: 23077074: routines PKCS12: PKCS12_pbe_crypt: erreur de chiffrement pkcs12: p12_decr.c: 104: 139848775526048: erreur: 2306A075: routines PKCS12: PKCS12_item_pbe_crypt: erreur de chiffrement pkcs12: p12_decr.c: 104: 139848775526048: erreur: 2306A075: routines PKCS12: PKCS12_item_pbe_crypt: erreur de chiffrement pkcs12: p12_decr.c: 104: 139848775526048: erreur: 2306A075: routines PKCS12: PKCS12_item_decrypt_d2i_be: pkcs12_item_decrypt_d2i_be: pkcs12. Quelle est la solution pour cela?
Udara SS Liyanage

1
un avertissement pour d'autres personnes, la commande keytool prend un certain temps pour une raison quelconque, j'ai dû attendre 30 secondes jusqu'à ce que l'exportation soit terminée
Nicolas Mommaerts

1
@ UdaraS.SLiyanage: regardez la réponse de Casey pour la solution
Nicolas Mommaerts

29

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.


6
Le raisonnement peut être trouvé ici: herongyang.com/PKI / ... Le destkeypass a de l'importance btw
Nicolas Mommaerts

J'ai voté pour ce commentaire mais il mérite son propre message. C'était difficile à trouver ici.
Richie Rich

15

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

Merci erickson .. La conclusion est "Nous ne pouvons pas effectuer une conversion directe de JKS vers PEM en utilisant simplement keytool et openssl". Ai-je raison?
Chathuranga Chandrasekara

4
Il vous suffit d'écrire du code jusqu'à Java 1.4 - à partir de Java 5, keytool et openssl peuvent être combinés pour effectuer une conversion en deux étapes à partir de JKS -> PKCS # 12 -> PEM. Cependant, écrire votre propre outil clé est le seul moyen d'effectuer une CONVERSION DIRECTE à partir de JKS -> PEM.
Stobor

Je pense que c'est à partir du JDK 6. Mais oui, une importation PKCS # 12 est désormais prise en charge.
erickson

13

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

10
Oui, cela exporte le certificat. Cependant, il n'exporte pas les informations clés ...
Stobor

Ceci est la réponse simple , exacte à ce que je cherchais sur des dizaines de keytoolet jbosspages de doc sans succès. Merci!
kratenko

15
CECI N'EXPORTE PAS D'INFORMATIONS DE CLÉS PRIVÉES
James

1
Cela exporte le certificat de clé publique
asami

J'ai essayé d'exécuter cette commande. Il nécessite un mot de passe, entrez le mot de passe du fichier de clés: erreur keytool: java.io.IOException: le fichier de clés a été falsifié ou le mot de passe était incorrect. J'ai utilisé le mot de passe comme (mot de passe) mais il lançait la même erreur
Mohit Singh

9

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>


2

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

3
bash
:!

1
@ user3217883 Vous pouvez essayer quelque chose comme à la sed "s/^\-*BEGIN [A-Z]*\-*$//g;s/^\-*END [A-Z]*\-*$//g"place (avec gnu sed) mais je ne suis pas sûr que ce soit suffisant s'il y a plus d'un certificat dans votre keystore
Idriss Neumann

si vous obtenez bash: !d": event not found: pour bash, un point d'exclamation est une touche courte pour utiliser une commande. Pour utiliser cette réponse, vous devez utiliser des apostrophes à la place des guillemets pour l'option utilisée comme -e pour sedkeytool -list -rfc -keystore "myKeystore.jks" | sed -e '/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d' >> "myKeystore.pem"
B.Adler

Malheureusement, cela n'exporte que le certificat, pas la clé privée
Maddin

2

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

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


1

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?


1

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

    Exporter la clé privée PEM à partir de JKS avec Portcle


0

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.


0

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


0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.