Conversione di un keystore Java in formato PEM

Sto provando a convertire da un file keystore Java in un file PEM usando keytool e le applicazioni openssl. Ma non sono riuscito a trovare un buon modo per fare la conversione. Qualche idea?

Invece di convertire il keystore direttamente in PEM, ho provato prima a creare un file PKCS12 e poi a convertirlo in file PEM e Keystore pertinenti. Ma non sono riuscito a stabilire una connessione usando loro. (Nota che ho solo bisogno di un file PEM e un file Keystore per implementare una connessione protetta. Non ci sono restrizioni come "Inizia da un file java keystore". :) Quindi iniziare da altri formati è accettabile con il mio caso)

Ma è preferibile un metodo di conversione diretta da jks a pem.

È abbastanza semplice, usando almeno jdk6 ...

bash $ keytool -keystore foo.jks -genkeypair -alias foo \
        -dname 'CN = foo.example.com, L = Melbourne, ST = Victoria, C = AU'
Inserisci la password del keystore:  
Reinserire la nuova password: 
Immettere la password chiave per 
        (INVIO se uguale alla password del keystore):  
bash $ keytool -keystore foo.jks -exportcert -alias foo | \
       openssl x509 -inform der -text
Immettere la password del keystore: asdasd
Certificato:
    Dati:
        Versione: 3 (0x2)
        Numero di serie: 1237334757 (0x49c03ae5)
        Algoritmo della firma: dsaWithSHA1
        Emittente: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Validità
            Non prima: 18 marzo 00:05:57 2009 GMT
            Non dopo: 16 giu 00:05:57 2009 GMT
        Oggetto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Informazioni sulla chiave pubblica dell'oggetto:
            Algoritmo di chiave pubblica: dsaEncryption
            Chiave pubblica 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
Inserisci la password del keystore di destinazione:  
Reinserire la nuova password: 
Immettere la password del keystore di origine:  
Voce per alias foo importata correttamente.
Comando di importazione completato: 1 voce importata correttamente, 0 voci non riuscite o annullate

bash $ openssl pkcs12 -in foo.p12 -out foo.pem
Inserisci la password di importazione:
MAC verificato OK
Inserisci la passphrase PEM:
Verifica: inserire la passphrase PEM:

bash $ openssl x509 -text -in foo.pem
Certificato:
    Dati:
        Versione: 3 (0x2)
        Numero di serie: 1237334757 (0x49c03ae5)
        Algoritmo della firma: dsaWithSHA1
        Emittente: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Validità
            Non prima: 18 marzo 00:05:57 2009 GMT
            Non dopo: 16 giu 00:05:57 2009 GMT
        Oggetto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Informazioni sulla chiave pubblica dell'oggetto:
            Algoritmo di chiave pubblica: dsaEncryption
            Chiave pubblica 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
leggere la chiave DSA
Inserisci la passphrase PEM:
Chiave privata: (1024 bit)
priv:
    00: 8f: b1: AF: 55: 63: 92: 7 quater: 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:

Si finisce con:

• foo.jks - keystore in formato java.
• foo.p12 - keystore in formato PKCS # 12.
• foo.pem - tutte le chiavi e i certificati dal keystore, in formato PEM.

(Se lo desideri, quest'ultimo file può essere suddiviso in chiavi e certificati.)

Riepilogo comandi - per creare un keystore JKS:

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

Riepilogo comandi - per convertire il keystore JKS nel keystore PKCS # 12, quindi nel file PEM:

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

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

se si dispone di più certificati nel keystore JKS e si desidera esportare solo il certificato e la chiave associati a uno degli alias, è possibile utilizzare la seguente variante:

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

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

Riepilogo comandi - per confrontare il keystore JKS con il file 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

Continuavo a ricevere errori da opensslquando usavo il comando di 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:

Per qualche motivo, solo questo stile di comando avrebbe funzionato per il mio file JKS

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

La chiave stava impostando destkeypass, il valore dell'argomento non aveva importanza.

Il keytoolcomando non ti consentirà di esportare la chiave privata da un archivio chiavi. Devi scrivere del codice Java per farlo. Apri l'archivio chiavi, ottieni la chiave di cui hai bisogno e salvala in un file nel formato PKCS # 8. Salva anche il certificato associato.

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

Utilizzare i programmi di utilità OpenSSL per convertire questi file (che sono in formato binario) in formato PEM.

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

Conversione diretta da jks a file pem usando il keytool

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

Istruzioni semplificate per convertire un file JKS in formato PEM e 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>

Ho trovato una soluzione molto interessante:

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

Quindi, ho diviso la coppia chiave pubblica / privata in due file private.key publi.pem e funziona!

La conversione di un KeyStore JKS in un singolo file PEM può essere facilmente eseguita utilizzando il seguente comando:

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

Spiegazione:

1. keytool -list -rfc -keystore "myKeystore.jks"elenca tutto nel KeyStore 'myKeyStore.jks' in formato PEM. Tuttavia, stampa anche informazioni aggiuntive.
2. | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d"filtra tutto ciò di cui non abbiamo bisogno. Ci rimane solo il PEM di tutto nel KeyStore.
3. >> "myKeystore.pem" scrivere i PEM nel file "myKeyStore.pem".

Prima scaricare il keystore da JKS a PKCS12

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

Scarica il nuovo file pkcs12 in pem

2. openssl pkcs12 -in intermedio.p12 -nodi -out intermedio.rsa.pem

Dovresti avere sia la chiave cert che la chiave privata in formato pem. Dividili. Inserisci la parte tra "INIZIA CERTIFICATO" e "FINE CERTIFICATO" in cert.x509.pem Inserisci la parte tra "INIZIA RSA PRIVATE KEY" e "END RSA PRIVATE KEY" in private.rsa.pem Converti la chiave privata in formato pk8 come atteso da signapk

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

Bene, OpenSSL dovrebbe farlo comodamente da un file # 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

Forse maggiori dettagli su quale sia l'errore / fallimento?

Se non hai installato openssl e stai cercando una soluzione rapida, c'è un software chiamato portcle che è molto utile e piccolo da scaricare.

Lo svantaggio è che non esiste una riga di comando per quanto ne so. Ma dalla GUI, è piuttosto semplice esportare una chiave privata PEM:

1. Apri il tuo keystore JKS
2. Fare clic con il tasto destro sulla voce della chiave privata e selezionare Esporta

3. Seleziona chiave privata e certificati e formato PEM

   

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

KeyStore Explorer è una sostituzione della GUI open source per il keytool e il jarsigner delle utility da riga di comando Java. Fa anche openssl / pkcs12.

prima creare il file keystore come

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

Inserisci la password del keystore:
Reinserisci la nuova password:
qual è il tuo nome e cognome? Sconosciuto: Nome Cognome Nome
Qual è il nome dell'unità organizzativa? Sconosciuto: sviluppo mobile
Qual è il nome della tua organizzazione? Sconosciuto: il nome della tua azienda
Qual è il nome della tua città o località? Qual è il nome del tuo stato o provincia?
Qual è il codice paese di due lettere per questa unità? Sconosciuto: IN // premere Invio

Ora chiederà di confermare

CN = FirstName LastName, OU = Mobile Development, O = nome della tua azienda, L = CityName, ST = StateName, C = IN sono corretti? [no]: sì

Immettere la password chiave per (INVIO se uguale alla password del keystore): premere Invio se si desidera la stessa password

la chiave è stata generata, ora puoi semplicemente ottenere il file pem usando il seguente comando

C: \ Programmi \ Android \ Android Studio \ jre \ bin> keytool -export -rfc -alias androidkey -file android_certificate.pem -keystore androidkey.jks
Immettere la password del keystore:
certificato archiviato nel file

Conversione di un keystore Java in formato PEM

La risposta più precisa di tutte deve essere che questo NON è possibile.

Un keystore Java è semplicemente una funzione di archiviazione per chiavi crittografiche e certificati mentre PEM è un formato file solo per certificati X.509.