Conversion d'un magasin de clés Java au format PEM

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

Question

J'essaie de convertir un fichier de clés Java en un fichier PEM à l'aide d'applications Keytool et openssl. Mais je ne pouvais pas trouver un bon moyen de faire la conversion. Des idées?

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

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

Était-ce utile?

La solution

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'
Enter keystore password:  
Re-enter new password: 
Enter key password for 
        (RETURN if same as keystore password):  
bash$ keytool -keystore foo.jks -exportcert -alias foo | \
       openssl x509 -inform der -text
Enter keystore password:  asdasd
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 1237334757 (0x49c03ae5)
        Signature Algorithm: dsaWithSHA1
        Issuer: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Validity
            Not Before: Mar 18 00:05:57 2009 GMT
            Not After : Jun 16 00:05:57 2009 GMT
        Subject: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Subject Public Key Info:
            Public Key Algorithm: dsaEncryption
            DSA Public Key:
                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
Enter destination keystore password:  
Re-enter new password: 
Enter source keystore password:  
Entry for alias foo successfully imported.
Import command completed:  1 entries successfully imported, 0 entries failed or cancelled

bash$ openssl pkcs12 -in foo.p12 -out foo.pem
Enter Import Password:
MAC verified OK
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:

bash$ openssl x509 -text -in foo.pem
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 1237334757 (0x49c03ae5)
        Signature Algorithm: dsaWithSHA1
        Issuer: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Validity
            Not Before: Mar 18 00:05:57 2009 GMT
            Not After : Jun 16 00:05:57 2009 GMT
        Subject: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Subject Public Key Info:
            Public Key Algorithm: dsaEncryption
            DSA Public Key:
                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
read DSA key
Enter PEM pass phrase:
Private-Key: (1024 bit)
priv:
    00:8f:b1:af:55:63:92:7c:d2:0f:e6:f3:a2:f5:ff:
    1a:7a:fe:8c:39:dd
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 - le magasin de clés au format java.
  • foo.p12 - magasin de clés au format PKCS # 12.
  • foo.pem - toutes les clés et tous les certificats du magasin de clés, au format PEM.

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

Résumé de la commande - pour créer le magasin de clés 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 fichier de clés JKS en fichier de clés 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 plusieurs certificats dans votre magasin de clés 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 magasin de clés 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

Autres conseils

J'ai continué à avoir des erreurs de openssl en utilisant la commande 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 fonctionne pour mon fichier JKS 

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

La clé configurait destkeypass , la valeur de l'argument importait peu.

La commande keytool ne vous permettra pas d'exporter la clé privée à partir d'un magasin de clés. Pour ce faire, vous devez écrire du code Java. 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 (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 de jks en 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 / clé privée en deux fichiers private.key publi.pem et cela fonctionne!

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 / échec?

Vous pouvez facilement convertir un fichier JKS KeyStore en un fichier PEM à 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 tous les éléments du KeyStore 'myKeyStore.jks' au format PEM. Cependant, il imprime également des informations supplémentaires.
  2. | sed -e "/ - * BEGIN [A-Z] * - * /, / - * FIN [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" écrit les fichiers PEM dans le fichier "myKeyStore.pem".

Si vous n'avez pas installé openssl et recherchez une solution rapide, un logiciel appelé portcle qui est très utile et de petite taille à télécharger.

L’inconvénient est qu’il n’ya pas de ligne de commande à ma connaissance. 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 une clé privée, des certificats et un format PEM

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

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

KeyStore Explorer est une interface graphique à source ouverte remplaçant les utilitaires de ligne de commande Java keytool et jarsigner. Il fait également openssl / pkcs12.

commencez par créer le fichier de clés sous la forme

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

Entrez le mot de passe du magasin de clés:
Ressaisissez votre nouveau mot de passe:
Quel est votre prénom et votre nom?   Inconnu: Prénom Nom
Quel est le nom de votre unité organisationnelle?   Inconnu: Développement mobile
Quel est le nom de votre organisation?   Inconnu: le nom de votre société
Quel est le nom de votre ville ou localité? Quel est le nom de votre état ou province?
Quel est le code de pays à deux lettres pour cette unité?   Inconnu: IN // appuyez sur Entrée

  

Maintenant, il vous sera demandé de confirmer

Est-ce que CN = Prénom Nom, OU = Développement mobile, O = nom de votre société, L = Nom de la ville, ST = Nom de l'État, C = IN correct?   [no]: oui

Entrez le mot de passe clé pour         (RETURN si identique au mot de passe du keystore): appuyez sur enter si vous voulez le même mot de passe

  

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

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

Commencez par vider le magasin de clés de JKS vers PKCS12

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

Importez le nouveau fichier pkcs12 dans pem

  1. openssl pkcs12 -in intermediate.p12 -nodes -out intermediate.rsa.pem

Vous devriez avoir à la fois la clé cert et la clé privée au format pem. Divisez-les. Placez la partie entre & # 8220; BEGIN CERTIFICATE & # 8221; et & # 8220; END CERTIFICATE & # 8221; dans cert.x509.pem Placez la partie entre & # 8220; BEGIN RSA PRIVATE KEY & # 8221; et & # 8220; END RSA PRIVATE KEY & # 8221; dans private.rsa.pem Convertissez la clé privée au format pk8 comme prévu par signapk

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

  

Conversion d'un magasin de clés Java au format PEM

La réponse la plus précise doit être que cela n’est PAS possible.

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

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