Konvertieren eines Java-Keystores in das PEM-Format

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

Anstatt den Keystore direkt in PEM zu konvertieren, habe ich versucht, zuerst eine PKCS12-Datei zu erstellen und dann in die entsprechende PEM-Datei und den Keystore zu konvertieren. Aber ich konnte mit ihnen keine Verbindung herstellen. (Beachten Sie, dass ich nur eine PEM-Datei und eine Keystore-Datei benötige, um eine gesicherte Verbindung zu implementieren. Es gibt keine Einschränkung wie "Von einer Java-Keystore-Datei starten". :) Daher ist es in meinem Fall akzeptabel, von anderen Formaten aus zu starten.)

Eine direkte Konvertierungsmethode von jks zu pem ist jedoch vorzuziehen.

Es ist ziemlich einfach, zumindest mit jdk6 ...

bash $ keytool -keystore foo.jks -genkeypair -alias foo \
        -dname 'CN = foo.example.com, L = Melbourne, ST = Victoria, C = AU'
Geben Sie das Keystore-Passwort ein:  
Neues Passwort erneut eingeben: 
Geben Sie das Schlüsselkennwort für ein 
        (RETURN, wenn es mit dem Keystore-Passwort identisch ist):  
bash $ keytool -keystore foo.jks -exportcert -alias foo | \.
       openssl x509 -inform der -text
Geben Sie das Keystore-Passwort ein: asdasd
Zertifikat:
    Daten:
        Version: 3 (0x2)
        Seriennummer: 1237334757 (0x49c03ae5)
        Signaturalgorithmus: dsaWithSHA1
        Emittent: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Gültigkeit
            Nicht vorher: 18. März 00:05:57 2009 GMT
            Nicht danach: 16. Juni 00:05:57 2009 GMT
        Betreff: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Betreff Public Key Info:
            Public-Key-Algorithmus: dsaEncryption
            Öffentlicher DSA-Schlüssel:
                Kneipe: 
                    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
Geben Sie das Passwort für den Zielschlüsselspeicher ein:  
Neues Passwort erneut eingeben: 
Geben Sie das Passwort für den Quell-Keystore ein:  
Eintrag für Alias ​​foo erfolgreich importiert.
Importbefehl abgeschlossen: 1 Einträge erfolgreich importiert, 0 Einträge fehlgeschlagen oder abgebrochen

bash $ openssl pkcs12 -in foo.p12 -out foo.pem
Importkennwort eingeben:
MAC verifiziert OK
Geben Sie die PEM-Passphrase ein:
Überprüfen - Geben Sie die PEM-Passphrase ein:

bash $ openssl x509 -text -in foo.pem
Zertifikat:
    Daten:
        Version: 3 (0x2)
        Seriennummer: 1237334757 (0x49c03ae5)
        Signaturalgorithmus: dsaWithSHA1
        Emittent: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Gültigkeit
            Nicht vorher: 18. März 00:05:57 2009 GMT
            Nicht danach: 16. Juni 00:05:57 2009 GMT
        Betreff: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Betreff Public Key Info:
            Public-Key-Algorithmus: dsaEncryption
            Öffentlicher DSA-Schlüssel:
                Kneipe: 
                    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
DSA-Schlüssel lesen
Geben Sie die PEM-Passphrase ein:
Privater Schlüssel: (1024 Bit)
priv:
    00: 8f: b1: af: 55: 63: 92: 7c: d2: 0f: e6: f3: a2: f5: ff:
    1a: 7a: fe: 8c: 39: dd
Kneipe: 
    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:

Am Ende haben Sie:

• foo.jks - Keystore im Java-Format.
• foo.p12 - Keystore im PKCS # 12-Format.
• foo.pem - alle Schlüssel und Zertifikate aus dem Keystore im PEM-Format.

(Diese letzte Datei kann auf Wunsch in Schlüssel und Zertifikate aufgeteilt werden.)

Befehlsübersicht - um einen JKS-Keystore zu erstellen:

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

Befehlsübersicht - Konvertieren des JKS-Keystores in den PKCS # 12-Keystore und anschließend in die 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-Keystore haben und nur das Zertifikat und den Schlüssel exportieren möchten, die einem der Aliase zugeordnet sind, 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 - um den JKS-Keystore mit der PEM-Datei zu vergleichen:

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

openssl x509 -text -in foo.pem

openssl dsa -text -in foo.pem

opensslBei der Verwendung des Befehls von StoBor wurden immer wieder Fehler angezeigt:

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 Grund würde nur dieser Befehlsstil für meine JKS-Datei funktionieren

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

Der Schlüssel war das Setzen destkeypass, der Wert des Arguments spielte keine Rolle.

Mit dem keytoolBefehl können Sie den privaten Schlüssel nicht aus einem Schlüsselspeicher exportieren. Dazu müssen Sie Java-Code schreiben. Öffnen Sie den Schlüsselspeicher, holen Sie sich den gewünschten Schlüssel und speichern Sie ihn in einer Datei im PKCS # 8-Format. Speichern Sie auch das zugehörige Zertifikat.

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

Verwenden Sie OpenSSL-Dienstprogramme, um diese Dateien (die im Binärformat vorliegen) in das PEM-Format zu konvertieren.

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

Direkte Konvertierung von JKS in PEM-Datei mit dem Keytool

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

Vereinfachte Anweisungen zum Konvertieren einer JKS-Datei in das PEM- und KEY-Format (.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>

Ich habe eine sehr interessante Lösung gefunden:

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

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

Das Konvertieren eines JKS KeyStore in eine einzelne PEM-Datei kann einfach mit dem folgenden Befehl durchgeführt werden:

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

Erläuterung:

1. keytool -list -rfc -keystore "myKeystore.jks"listet alles im KeyStore 'myKeyStore.jks' im PEM-Format auf. Es werden jedoch auch zusätzliche Informationen gedruckt.
2. | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d"filtert alles heraus, was wir nicht brauchen. Wir haben nur noch die PEMs von allem im KeyStore.
3. >> "myKeystore.pem" Schreiben Sie die PEMs in die Datei 'myKeyStore.pem'.

Speichern Sie zuerst den Keystore von JKS auf PKCS12

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

Speichern Sie die neue pkcs12-Datei in pem

2. openssl pkcs12 -in intermediär.p12 -knoten -out intermediär.rsa.pem

Sie sollten sowohl das Zertifikat als auch den privaten Schlüssel im PEM-Format haben. Teilen Sie sie auf. Fügen Sie den Teil zwischen "BEGIN CERTIFICATE" und "END CERTIFICATE" in cert.x509.pem ein. Setzen Sie den Teil zwischen "BEGIN RSA PRIVATE KEY" und "END RSA PRIVATE KEY" in private.rsa.pem. Konvertieren Sie den privaten Schlüssel in das pk8-Format als erwartet von signapk

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

Nun, OpenSSL sollte es handlich aus einer # 12-Datei machen:

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 über den Fehler?

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

Der Nachteil ist, dass es meines Wissens keine Kommandozeile gibt. Über die GUI ist es jedoch ziemlich einfach, einen privaten PEM-Schlüssel zu exportieren:

1. Öffnen Sie Ihren JKS-Schlüsselspeicher
2. Klicken Sie mit der rechten Maustaste auf Ihren privaten Schlüsseleintrag und wählen Sie Exportieren

3. Wählen Sie Privater Schlüssel und Zertifikate sowie PEM-Format

   

Versuchen Sie es mit Keystore Explorer http://keystore-explorer.org/

KeyStore Explorer ist ein Open-Source-GUI-Ersatz für das Java-Befehlszeilenprogramm keytool und jarsigner. Es macht auch openssl / pkcs12.

Erstellen Sie zuerst eine Keystore-Datei als

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

Keystore-Passwort eingeben:
Neues Passwort erneut eingeben:
Wie lautet Ihr Vor- und Nachname? Unbekannt: Vorname Nachname
Wie heißt Ihre Organisationseinheit? Unbekannt: Mobile Entwicklung
Wie heißt Ihre Organisation? Unbekannt: Ihr Firmenname
Wie heißt Ihre Stadt oder Ihr Ort? Wie heißt Ihr Bundesstaat oder Ihre Provinz?
Wie lautet der aus zwei Buchstaben bestehende Ländercode für dieses Gerät? Unbekannt: IN // Drücken Sie die Eingabetaste

Jetzt wird es um Bestätigung bitten

Ist CN = Vorname Nachname, OU = Mobile Development, O = Ihr Firmenname, L = Stadtname, ST = Statusname, C = IN korrekt? [nein]: ja

Geben Sie das Schlüsselkennwort ein für (RETURN, wenn es mit dem Schlüsselspeicherkennwort identisch ist): Drücken Sie die Eingabetaste, wenn Sie dasselbe Kennwort wünschen

Der Schlüssel wurde generiert. Jetzt können Sie die PEM-Datei einfach mit dem folgenden Befehl abrufen

C: \ Programme \ Android \ Android Studio \ jre \ bin> keytool -export -rfc -alias androidkey -file android_certificate.pem -keystore androidkey.jks
Geben Sie das Keystore-Passwort ein:
Zertifikat in Datei gespeichert

Konvertieren eines Java-Keystores in das PEM-Format

Die genaueste Antwort von allen muss sein, dass dies NICHT möglich ist.

Ein Java-Keystore ist lediglich eine Speichereinrichtung für kryptografische Schlüssel und Zertifikate, während PEM ein Dateiformat nur für X.509-Zertifikate ist.