Conversione di un keystore Java in formato PEM

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

Domanda

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.

È stato utile?

Soluzione

È abbastanza semplice, usando almeno 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:

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.

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

Riepilogo comandi - per creare il 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

Altri suggerimenti

Continuavo a ricevere errori da openssl quando utilizzavo il comando 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 ragione, solo questo stile di comando funzionerebbe 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 comando keytool 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();

Usa le utility 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 & amp; .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!

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 / errore?

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 rimangono solo i PEM di tutto nel KeyStore.
  3. > > " myKeystore.pem " scrivi i PEM nel file "myKeyStore.pem".

Nel caso in cui non sia installato openssl e si cerchi una soluzione rapida, esiste 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. Fai clic con il pulsante destro del mouse sulla voce della chiave privata e seleziona esporta

  3. Seleziona chiave privata, certificati e formato PEM

    Esporta chiave privata PEM da JKS con Portcle

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 opensl / pkcs12.

prima crea 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
Qual è il nome della tua unità organizzativa?   Sconosciuto: Sviluppo mobile
Qual è il nome della tua organizzazione?   Sconosciuto: 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
Inserisci la password del keystore:
Certificato archiviato nel file

Prima scarica 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

  1. 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 & # 8220; INIZIA CERTIFICATO & # 8221; e & # 8220; CERTIFICATO DI FINE & # 8221; in cert.x509.pem Inserisci la parte tra & # 8220; INIZIA TASTO PRIVATO RSA & # 8221; e & # 8220; END RSA PRIVATE KEY & # 8221; in private.rsa.pem Converti la chiave privata in formato pk8 come previsto da signapk

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

  

Conversione di un keystore Java in formato PEM

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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top