Conversión de un Java Keystore en formato PEM

Estoy intentando convertir de un archivo de almacén de claves Java a un archivo PEM usando keytool y las 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, traté de crear primero un archivo PKCS12 y luego convertirlo en un archivo PEM relevante y en el Almacén de claves. Pero no pude establecer una conexión usándolos. (Tenga en cuenta que solo necesito un archivo PEM y un archivo Keystore para implementar una conexión segura. No hay ninguna restricción como “Comenzar desde un archivo java keystore”. 🙂 Por lo tanto, es aceptable comenzar desde otros formatos con mi caso)

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

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'
 Ingrese la contraseña del almacén de claves:  
 Re-ingrese nueva contraseña: 
 Ingrese la contraseña de clave para 
         (RETORNO si es igual que la contraseña del almacén de claves):  
 bash $ keytool -keystore foo.jks -exportcert -alias foo |  \
        openssl x509 -inform der -text
 Ingrese la contraseña del almacén de claves: asdasd
 Certificado:
     Datos:
         Versión: 3 (0x2)
         Número de serie: 1237334757 (0x49c03ae5)
         Algoritmo de firma: dsaWithSHA1
         Emisor: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
         Validez
             No antes: 18 de mar 00:05:57 2009 GMT
             No después: 16 de junio a las 00:05:57 GMT 2009
         Asunto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
         Información de clave pública del sujeto:
             Algoritmo de clave pública: dsaEncryption
             Clave pública 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
 Ingrese la contraseña del almacén de claves de destino:  
 Re-ingrese nueva contraseña: 
 Ingrese la contraseña del almacén de claves de origen:  
 Entrada para alias foo importada con éxito.
 Comando de importación completado: 1 entrada importada con éxito, 0 entradas fallidas o canceladas

 bash $ openssl pkcs12 -en foo.p12 -out foo.pem
 Ingrese la contraseña de importación:
 MAC verificado OK
 Ingrese la frase de contraseña de PEM:
 Verificación: ingrese la frase de contraseña de PEM:

 bash $ openssl x509 -text -in foo.pem
 Certificado:
     Datos:
         Versión: 3 (0x2)
         Número de serie: 1237334757 (0x49c03ae5)
         Algoritmo de firma: dsaWithSHA1
         Emisor: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
         Validez
             No antes: 18 de mar 00:05:57 2009 GMT
             No después: 16 de junio a las 00:05:57 GMT 2009
         Asunto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
         Información de clave pública del sujeto:
             Algoritmo de clave pública: dsaEncryption
             Clave pública 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
 leer clave DSA
 Ingrese la frase de contraseña de PEM:
 Clave privada: (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 – keystore en formato java.
  • foo.p12 – almacén de claves en formato PKCS # 12.
  • foo.pem: todas las claves y certs 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 el almacén de claves JKS:

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

Resumen de comandos: 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 

Seguí recibiendo errores de openssl cuando uso 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 el certificado asociado también.

 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 de OpenSSL para convertir estos archivos (que están en formato binario) al formato PEM.

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

Conversión directa de jks a archivo de pem usando keytool

 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 y .key):

 keytool -importkeystore -srckeystore  -destkeystore  -srcstoretype jks -deststoretype pkcs12 -destkeypass  openssl pkcs12 -in  -out  openssl x509 -outform der -in  -out  openssl rsa -in  -out  

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 de forma práctica 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 

Tal vez más detalles sobre lo que es el error / falla?

La conversión de un JKS KeyStore a un único archivo PEM se puede lograr fácilmente utilizando el siguiente comando:

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

Explicación:

  1. keytool -list -rfc -keystore "myKeystore.jks" lista todo en la KeyStore ‘myKeyStore.jks’ en formato PEM. Sin embargo, también imprime información adicional.
  2. | sed -e "/-*BEGIN [AZ]*-*/,/-*END [AZ]-*/!d" | sed -e "/-*BEGIN [AZ]*-*/,/-*END [AZ]-*/!d" filtra todo lo que no necesitamos. Nos quedan solo los PEM de todo en KeyStore.
  3. >> "myKeystore.pem" escribe los PEM en el archivo ‘myKeyStore.pem’.

En caso de que no tenga instalado openssl y esté buscando una solución rápida, hay 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 crea archivo de almacén de claves como

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

Ingrese la contraseña del almacén de claves:
Re-ingrese 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
¿Cuál es el nombre de tu organización? Desconocido: el nombre de su empresa
¿Cuál es el nombre de su ciudad o localidad? ¿Cuál es el nombre de tu estado o provincia?
¿Cuál es el código de país de dos letras para esta unidad? Desconocido: IN // presione enter

Ahora pedirá confirmar

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

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

se ha generado la clave, ahora usted puede simplemente obtener el archivo pem usando el siguiente comando

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

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

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

Vuelca el nuevo archivo pkcs12 en pem

  1. openssl pkcs12 -in intermediate.p12 -nodes -out intermediate.rsa.pem

Debe tener tanto el certificado como la clave privada en formato de pem. Dividirlos. Coloque la parte entre “BEGIN CERTIFICATE” y “END CERTIFICATE” en cert.x509.pem Coloque la parte entre “BEGIN RSA PRIVATE KEY” y “END RSA PRIVATE KEY” en private.rsa.pem Convierta la clave privada en formato pk8 como esperado por signapk

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

Conversión de un Java Keystore 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 y certificados criptográficos, mientras que PEM es un formato de archivo para certificados X.509 solamente.