Convertir un Java Keystore a formato PEM

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 un archivo PEM relevante y un 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". :) Así que comenzar con otros formatos es aceptable en 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 \
        -nombre '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 clave para 
        (VOLVER si es la misma que la contraseña del almacén de claves):  
bash $ keytool -keystore foo.jks -exportcert -alias foo | \
       openssl x509 -inform der -text
Introduzca 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 marzo 00:05:57 GMT de 2009
            No después: 16 de junio 00:05:57 GMT de 2009
        Sujeto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Asunto Información de clave pública:
            Algoritmo de clave pública: 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
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 entradas importadas correctamente, 0 entradas fallidas o canceladas

bash $ openssl pkcs12 -in foo.p12 -out foo.pem
Ingrese la contraseña de importación:
MAC verificado OK
Ingrese la frase de paso PEM:
Verificación: ingrese la frase de paso 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 marzo 00:05:57 GMT de 2009
            No después: 16 de junio 00:05:57 GMT de 2009
        Sujeto: C = AU, ST = Victoria, L = Melbourne, CN = foo.example.com
        Asunto Información de clave pública:
            Algoritmo de clave pública: 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
leer clave DSA
Ingrese la frase de paso 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: 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 del comando: 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 del comando: 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

opensslSeguía recibiendo errores 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 era establecer destkeypass, el valor del argumento no importaba.

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

Utilice 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 jks a archivo 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 <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!

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 el 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'.

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

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

Volcar el nuevo archivo pkcs12 en pem

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

Debe tener tanto el certificado como la clave privada en formato pem. Dividirlos Ponga 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 -in private.rsa.pem -inform PEM -out private.pk8 -nocrypt

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?

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 llaves JKS
2. Haga clic derecho sobre su entrada de clave privada y seleccione exportar

3. Seleccione clave privada y certificados y formato PEM

   

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. Hace openssl / pkcs12 también.

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

Ingrese 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
¿Cuál es el nombre de su unidad organizativa? Desconocido: Desarrollo móvil
¿Cuál es el nombre de su organización? Desconocido: el 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 simplemente puede 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
Ingrese la contraseña del almacén de claves:
Certificado almacenado en el archivo

Convertir un Java Keystore a 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 solo para certificados X.509.