Use Java keytool para convertir de JKS a P12 ...

Exporte desde el formato propietario de keytool (llamado "JKS") al formato estandarizado PKCS # 12 :

keytool -importkeystore -srckeystore keystore.jks -destkeystore keystore.p12
-deststoretype PKCS12 -srcalias <jkskeyalias> -deststorepass <password>
-destkeypass <password>

... luego use openssl para exportar desde P12 a PEM

Exportar certificado usando openssl :

openssl pkcs12 -in keystore.p12  -nokeys -out cert.pem

Exportar clave privada sin cifrar:

openssl pkcs12 -in keystore.p12  -nodes -nocerts -out key.pem

Desde Java 6, puede importar / exportar claves privadas en archivos PKCS # 12 ( .p12 ) usando keytool , con la opción -importkeystore (no disponible en versiones anteriores).

Por ejemplo:

keytool -importkeystore -srckeystore existing-store.jks -destkeystore new-store.p12 -deststoretype PKCS12

El tipo de almacén de claves PKCS12 también se admite como un tipo de almacén de claves estándar en el proveedor de seguridad de Oracle / Sun predeterminado.

Pruebe "Keystore Explorer"

Estoy de acuerdo con Bruno. Keytool es la mejor herramienta cuando se trata de un almacén de claves de Java, pero hay una herramienta gratuita muy potente y elegante: Keystore explorer

Lo uso mucho y nunca tuve la necesidad de algo más.

Si alguien se encuentra aquí tratando de obtener una clave privada de un almacén de claves de tipo JCEKS, encontré que las instrucciones de herramienta de teclas y openssl descritas en otras respuestas no funcionaron. Tuve que usar la siguiente clase de Java para sacar la llave.

import sun.misc.BASE64Encoder;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.security.*;

public class ExportPrivateKey
{
    private File keystoreFile;
    private String keyStoreType;
    private char[] keyStorePassword;
    private char[] keyPassword;
    private String alias;
    private File exportedFile;

    public void export() throws Exception {
        KeyStore keystore = KeyStore.getInstance(keyStoreType);
        BASE64Encoder encoder = new BASE64Encoder();
        keystore.load(new FileInputStream(keystoreFile), keyStorePassword);
        Key key = keystore.getKey(alias, keyPassword);
        String encoded = encoder.encode(key.getEncoded());
        FileWriter fw = new FileWriter(exportedFile);
        fw.write("---BEGIN PRIVATE KEY---\n");
        fw.write(encoded);
        fw.write("\n");
        fw.write("---END PRIVATE KEY---");
        fw.close();
    }

    public static void main(String args[]) throws Exception {
        ExportPrivateKey export = new ExportPrivateKey();
        export.keystoreFile = new File(args[0]);
        export.keyStoreType = args[1];
        export.keyStorePassword = args[2].toCharArray();
        export.alias = args[3];
        export.keyPassword = args[4].toCharArray();
        export.exportedFile = new File(args[5]);
        export.export();
    }
}

Uso:

javac ExportPrivateKey.java
java ExportPrivateKey <path_to_keystore> JCEKS <keystore_password> “<key_alias>” <key_password> <output_file_name>

Hay un formato que permite el traslado de claves privadas que se llama PKCS # 12. Este formato se produjo posteriormente en la evolución de los certificados PKI y los almacenes de claves relacionados a medida que la necesidad evolucionó. Si considera los problemas de la cadena de confianza creados al acceder y transportar la clave privada, puede ver por qué no se incluyó en las características iniciales, sino que se produjo después de la presión por la necesidad operativa. Esta es la razón principal del desafío.

Los almacenes de claves Java fueron uno de los usuarios iniciales del formato PKCS # 12, pero como importadores no exportadores. Parece que el diseño de seguridad de los almacenes de claves Java aún no admite la exportación de claves privadas como una característica estándar. Nuevamente, hay buenas razones de seguridad para este hecho. Dicho esto, las rutinas privadas se han escrito como se hace referencia aquí: enlace

Si es posible, consideraría crear un nuevo almacén de claves en OpenSSL y nuevas claves en lugar de intentar extraer la clave privada del almacén de claves de Java. Al abrir el almacén de claves de Java y extraer la clave privada, uno va más allá de las características de seguridad diseñadas. La función de exportación PKCS # 12 se ha deseado durante muchos años, pero aún no es compatible con Java. Mi opinión es que es por muy buenas razones criptológicas, por lo que estaría dispuesto a dar ese paso a menos que fuera absolutamente necesario.