Usa lo strumento keytool per convertire da JKS a P12 ...

Esporta dal formato proprietario keytool proprietario (chiamato "JKS") in formato standard PKCS # 12 :

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

... quindi usa openssl per esportare da P12 a PEM

Esporta certificato utilizzando openssl :

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

Esporta chiave privata non crittografata:

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

Da Java 6, puoi importare / esportare chiavi private in file PKCS # 12 ( .p12 ) usando keytool , con l'opzione -importkeystore (non disponibile nelle versioni precedenti).

Ad esempio:

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

Il tipo di keystore PKCS12 è anche supportato come tipo standard di keystore nel provider di sicurezza Oracle / Sun predefinito.

Prova "Keystore Explorer"

Sono d'accordo con Bruno. Keytool è l'ultimo strumento quando si ha a che fare con il keystore Java, ma c'è uno strumento gratuito di fantasia e abbastanza potente: Keystore explorer

Lo uso molto e non ho mai avuto bisogno di qualcos'altro.

Se qualcuno si trova qui cercando di ottenere una chiave privata da un keystore di tipo JCEKS, ho scoperto che le istruzioni keytool e openssl descritte in altre risposte non funzionavano. Ho dovuto usare la seguente classe Java per ottenere la chiave.

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

Utilizzo:

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

C'è un formato che consente lo spostamento delle chiavi private è chiamato PKCS # 12. Questo formato è venuto più tardi nell'evoluzione dei certificati PKI e dei keystore correlati a seconda dell'evoluzione del bisogno. Se si considerano i problemi di catena di fiducia creati accedendo e trasportando la chiave privata, è possibile capire perché non è stato incluso nelle caratteristiche iniziali, ma piuttosto è venuto dopo la pressione dalle necessità operative. Questa è la ragione principale della sfida.

I keystore Java erano uno degli utenti iniziali del formato PKCS # 12 ma come importatori non esportatori. Sembra che il progetto di sicurezza dei keystore Java non supporti ancora l'esportazione di chiavi private come funzionalità standard. Ancora una volta, ci sono buone ragioni di sicurezza per questo fatto. Detto questo, le routine private sono state scritte come referenziate qui: link

Se possibile, prenderei in considerazione la creazione di un nuovo keystore in OpenSSL e nuove chiavi piuttosto che cercare di estrapolare la chiave privata dal keystore Java. Aprendo il keystore Java ed estraendo la chiave privata si sta andando oltre le funzionalità di sicurezza progettate. La funzione di esportazione PKCS # 12 è stata desiderata per molti anni, ma non è ancora supportata in Java. Il mio pensiero è che è per ottime ragioni crittografiche, quindi sarei desideroso di fare quel passo a meno che non sia assolutamente necessario.