Konvertieren eines Java-Keystores in das PEM-Format

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

Frage

Ich versuche, mit Keytool und OpenSSL-Anwendungen eine Java-Keystore-Datei in eine PEM-Datei zu konvertieren.Aber ich konnte keinen guten Weg finden, die Konvertierung durchzuführen.Irgendwelche Ideen?

Anstatt den Keystore direkt in PEM zu konvertieren, habe ich versucht, zuerst eine PKCS12-Datei zu erstellen und diese dann in die entsprechende PEM-Datei und den Keystore zu konvertieren.Aber ich konnte damit keine Verbindung herstellen.(Beachten Sie, dass ich nur eine PEM-Datei und eine Keystore-Datei benötige, um eine sichere Verbindung zu implementieren.Es gibt keine Einschränkung wie „Mit einer Java-Keystore-Datei starten“.:) Daher ist es für meinen Fall akzeptabel, von anderen Formaten auszugehen)

Eine direkte Konvertierungsmethode von JKS nach PEM ist jedoch vorzuziehen.

War es hilfreich?

Lösung

Es ist ziemlich einfach, mit jdk6 mindestens ... 

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:

Sie am Ende mit:

  • foo.jks -. Schlüsselspeicher in Java-Format
  • foo.p12 -. Schlüsselspeicher im PKCS # 12-Format
  • foo.pem -. Alle Schlüssel und Zertifikate von Schlüsselspeicher, in PEM-Format

(Diese letzte Datei in Schlüssel und Zertifikate aufgeteilt werden können, wenn Sie mögen.)

Befehl Zusammenfassung - erstellen JKS-Keystor: 

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

Befehl Zusammenfassung - konvertieren JKS-Keystor in PKCS # 12-Schlüsselspeicher, dann in PEM-Datei: 

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

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

Wenn Sie mehr als ein Zertifikat in Ihrem JKS Schlüsselspeicher, und Sie wollen nur das Zertifikat und den Schlüssel mit einem des Aliase zugeordnet exportieren, können Sie die folgende Variante verwenden: 

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

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

Befehlsübersicht - zum Vergleich JKS Schlüsselspeicher zu PEM-Datei: 

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

openssl x509 -text -in foo.pem

openssl dsa -text -in foo.pem

Andere Tipps

Ich hielt Fehler von openssl bekommen, wenn Stobor den Befehl: 

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:

Aus irgendeinem Grunde nur diese Art von Befehl würde für meine JKS-Datei arbeitet 

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

Der Schlüssel einstellt destkeypass, wird der Wert des Arguments spielte keine Rolle.

Der keytool Befehl wird nicht zulassen, dass Sie die privaten Schlüssel von einem Schlüsselspeicher exportieren. Sie haben einige Java-Code zu schreiben, dies zu tun. Öffnen Sie den Schlüsselspeicher, erhalten den Schlüssel, den Sie brauchen, und speichern Sie sie in einer Datei im PKCS # 8-Format. Speichern Sie das zugehörige Zertifikat zu. 

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();

Mit OpenSSL Dienstprogramme, diese Dateien zu konvertieren (die in Binär-Format) sind in der PEM-Format. 

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

Eine direkte Umwandlung von JKS zu pem-Datei mit dem keytool 

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

Anweisungen Vereinfachtes eine JKS-Datei PEM und KEY-Format (.crt & .key) konvertiert: 

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>

fand ich eine sehr interessante Lösung:

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

Dann teilte ich das Paar öffentlicher / privater Schlüssel in zwei Dateien private.key publi.pem und es funktioniert!

Nun, OpenSSL sollte es handlich tun von einer # 12-Datei: 

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

Vielleicht mehr Details auf, was der Fehler / Fehler ist?

Konvertieren ein JKS-Keystor auf eine einzelne PEM-Datei leicht erreicht werden kann, mit dem folgenden Befehl: 

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

Erklärung:

  1. keytool -list -rfc -keystore "myKeystore.jks" listet alles im Format 'myKeyStore.jks' Keystor in PEM. Es ist jedoch auch druckt zusätzliche Informationen.
  2. | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d" filtert alles, was wir nicht brauchen. Wir bleiben mit nur dem PEMs von allem im Schlüsselspeicher.
  3. >> "myKeystore.pem" die PEMs in die Datei 'myKeyStore.pem' schreiben.

Falls Sie nicht OpenSSL installiert haben und Sie suchen nach einer schnellen Lösung, gibt es Software namens portcle , die sehr nützlich und klein ist, zum Download bereit.

Der Nachteil ist, dass es keine Befehlszeile ist, soweit ich weiß. Aber von der GUI, es ist ziemlich geradlinig einen PEM privaten Schlüssel zu exportieren:

  1. Öffnen Sie JKS Schlüsselspeicher
  2. Rechtsklick auf Ihren privaten Schlüssel Eintrag und wählen Sie Export

  3. Wählen Sie Private Key und Zertifikaten und PEM-Format

Versuchen Schlüsselspeicher Explorer http://keystore-explorer.org/

Keystor Explorer ist ein Open-Source-GUI Ersatz für die Java-Befehlszeilenprogramme keytool und jarsigner. Es tut openssl / pkcs12 auch.

erste Schlüsselspeicherdatei als

erstellen

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

Geben Sie Kennwort für Schlüsselspeicher:
Re-neues Passwort eingeben:
Was ist Ihr Vor- und Nachname?   Unbekannt: Vorname Name
Wie lautet der Name Ihrer Organisationseinheit?   Unbekannt: Mobile Development
Wie ist der Name Ihres Unternehmens?   Unbekannt: Ihr Firmenname
Wie lautet der Name Ihrer Stadt oder Ort? Wie ist der Name Ihres Staates oder Provinz?
Was ist der aus zwei Buchstaben bestehenden Ländercode für dieses Gerät?   Unbekannt: IN // drücken Sie die Eingabetaste

  

Nun fragt es bestätigen

Ist CN = Vorname Name, OU = Mobile Development, O = Ihr Firmenname, L = Cityname, ST = Statusname, C = IN richtig?   [No]: Ja

Enter-Taste Passwort für         (Hin und zurück, wenn gleiche wie Kennwort für Schlüsselspeicher): drücken Sie die Eingabetaste, wenn Sie gleiche Passwort wollen

  

Schlüssel erzeugt wurden, jetzt können Sie einfach pem-Datei mit folgendem Befehl erhalten

C: \ Programme \ Android \ Android Studio \ jre \ bin> keytool -export -rfc -alias androidkey -datei android_certificate.pem -keystore androidkey.jks
Geben Sie Kennwort für Schlüsselspeicher:
Zertifikat in der Datei gespeichert

Sichern Sie zunächst den Keystore von JKS nach PKCS12

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

Legen Sie die neue pkcs12-Datei in pem ab

  1. OpenSSL PKCS12 -in Intermediate.p12 -Nodes -Out Intermediate.rsa.pem

Sie sollten sowohl das Zertifikat als auch den privaten Schlüssel im PEM-Format haben.Teilen Sie sie auf.Setzen Sie den Teil zwischen „Beginn -Zertifikat“ und „Endzertifikat“ in cert.x509 ein. erwartet von Signapk

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

  

Konvertieren eines Java Schlüsselspeicher in PEM-Format

Die präziseste Antwort aller muss sein, dass dies nicht möglich ist.

Ein Java-Schlüsselspeicher ist lediglich eine Speicheranlage für kryptographische Schlüssel und Zertifikate während PEM ein Dateiformat für X.509-Zertifikate sind nur.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top