Convertir un Java Keystore a formato PEM

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

Pregunta

Estoy tratando de convertir un archivo de almacén de claves Java en un archivo PEM usando keytool y aplicaciones openssl. Pero no pude encontrar una buena manera de hacer la conversión. ¿Algunas ideas?

En lugar de convertir el almacén de claves directamente en PEM, intenté crear primero un archivo PKCS12 y luego convertirlo en el archivo PEM relevante y el Almacén de claves. Pero no pude establecer una conexión con ellos. (Tenga en cuenta que solo necesito un archivo PEM y un archivo de almacén de claves para implementar una conexión segura. No hay restricciones como "Iniciar desde un archivo de almacén de claves de Java". :) Por lo tanto, comenzar con otros formatos es aceptable en mi caso)

Pero es preferible un método de conversión directa de jks a pem.

¿Fue útil?

Solución

Es bastante sencillo, usando jdk6 al menos ... 

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:

Terminas con:

  • foo.jks - almacén de claves en formato java.
  • foo.p12 - almacén de claves en formato PKCS # 12.
  • foo.pem: todas las claves y certificados del almacén de claves, en formato PEM.

(Este último archivo se puede dividir en claves y certificados si lo desea).

Resumen de comandos: para crear un almacén de claves JKS: 

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

Resumen del comando: para convertir el almacén de claves JKS en el almacén de claves PKCS # 12 y luego en el archivo PEM: 

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

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

si tiene más de un certificado en su almacén de claves JKS y desea exportar solo el certificado y la clave asociados con uno de los alias, puede usar la siguiente variación: 

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

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

Resumen de comandos: para comparar el almacén de claves JKS con el archivo 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

Otros consejos

Seguía recibiendo errores de openssl cuando usaba el comando de 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:

Por alguna razón, solo este estilo de comando funcionaría para mi archivo JKS 

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

La clave estaba configurando destkeypass , el valor del argumento no importaba.

El comando keytool no le permitirá exportar la clave privada desde un almacén de claves. Tienes que escribir un código Java para hacer esto. Abra el almacén de claves, obtenga la clave que necesita y guárdela en un archivo en formato PKCS # 8. Guarde también el certificado asociado. 

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

Use las utilidades OpenSSL para convertir estos archivos (que están en formato binario) a formato PEM. 

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

Conversión directa de archivos jks a pem usando la herramienta de herramientas 

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

Instrucciones simplificadas para convertir un archivo JKS a formato PEM y 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>

Encontré una solución muy interesante:

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

Luego, dividí el par de clave pública / privada en dos archivos private.key publi.pem y ¡funciona!

Bueno, OpenSSL debería hacerlo fácilmente desde un archivo # 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

¿Quizás más detalles sobre cuál es el error / falla?

La conversión de un JKS KeyStore en un solo archivo PEM se puede lograr fácilmente con el siguiente comando: 

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

Explicación:

  1. keytool -list -rfc -keystore " myKeystore.jks " enumera todo en KeyStore 'myKeyStore.jks' en formato PEM. Sin embargo, también imprime información adicional.
  2. | sed -e " / - * BEGIN [A-Z] * - * /, / - * END [A-Z] - * /! d " filtra todo lo que no necesitamos. Solo nos quedan los PEM de todo en KeyStore.
  3. > > " myKeystore.pem " escriba los PEM en el archivo 'myKeyStore.pem'.

En caso de que no tenga instalado openssl y esté buscando una solución rápida, existe un software llamado portcle que es muy útil y pequeño para descargar.

La desventaja es que no hay línea de comando hasta donde yo sé. Pero desde la GUI, es bastante sencillo exportar una clave privada PEM:

  1. Abre tu tienda de claves JKS
  2. Haga clic derecho sobre su entrada de clave privada y seleccione exportar

  3. Seleccionar clave privada y certificados y formato PEM

    Exportar clave privada PEM de JKS con Portcle

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

KeyStore Explorer es un reemplazo de GUI de código abierto para las herramientas de línea de comandos de Java keytool y jarsigner. También abre openssl / pkcs12.

primero cree el archivo de almacén de claves como

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

Introduzca la contraseña del almacén de claves:
Vuelva a ingresar la nueva contraseña:
¿Cuál es su nombre y apellido?   Desconocido: Nombre Apellido
Cual es el nombre de tu unidad organizacional?   Desconocido: Desarrollo móvil
¿Cómo se llama su organización?   Desconocido: nombre de su empresa
¿Cuál es el nombre de su ciudad o localidad? ¿Cuál es el nombre de su estado o provincia?
¿Cuál es el código de país de dos letras para esta unidad?   Desconocido: IN // presiona enter

  

Ahora pedirá confirmar

¿CN = FirstName LastName, OU = Mobile Development, O = el nombre de su empresa, L = CityName, ST = StateName, C = IN correcto?   [no]: sí

Ingrese la contraseña clave para         (VOLVER si es la misma que la contraseña del almacén de claves): presione enter si desea la misma contraseña

  Se ha generado la clave

, ahora puede simplemente obtener el archivo pem usando el siguiente comando

C: \ Archivos de programa \ Android \ Android Studio \ jre \ bin > keytool -export -rfc -alias androidkey -file android_certificate.pem -keystore androidkey.jks
Introduzca la contraseña del almacén de claves:
Certificado almacenado en el archivo

Primero volcar el almacén de claves de JKS a PKCS12

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

Volcar el nuevo archivo pkcs12 en pem

  1. openssl pkcs12 -in intermediario.p12 -nodos -out intermediario.rsa.pem

Debe tener tanto la clave cert como la privada en formato pem. Dividirlos Coloque la parte entre & # 8220; BEGIN CERTIFICATE & # 8221; y & # 8220; CERTIFICADO FINAL & # 8221; en cert.x509.pem Ponga la parte entre & # 8220; BEGIN RSA PRIVATE KEY & # 8221; y & # 8220; FINALIZAR CLAVE PRIVADA RSA & # 8221; en private.rsa.pem Convierta la clave privada en formato pk8 como se esperaba por signapk

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

  

Convertir un almacén de claves Java en formato PEM

La respuesta más precisa de todas debe ser que esto NO es posible.

Un almacén de claves Java es simplemente una instalación de almacenamiento para claves criptográficas y certificados, mientras que PEM es un formato de archivo para certificados X.509 únicamente.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top