it-swarm.dev

Come posso esportare la mia chiave privata da un keystore Java Keytool?

Vorrei esportare la mia chiave privata da un keystore Java Keytool, così posso usarla con openssl. Come lo posso fare?

117
Jonas

Usa Java keytool per convertire da JKS a P12 ...

Esporta dal formato proprietario keytool (chiamato "JKS") al 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 usando 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
135
Jaime Hablutzel

Poiché Java 6, è possibile importare/esportare le chiavi private in PKCS # 12 (.p12) usando keytool, con l'opzione -importkeystore (non disponibile nelle versioni precedenti).

Per esempio:

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

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

62
Bruno

Prova "Keystore Explorer"

Sono d'accordo con Bruno. Keytool è lo strumento ideale quando si ha a che fare con Java, ma esiste uno strumento libero elegante e abbastanza potente: Keystore Explorer

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

23
Tiho

Se qualcuno si trova qui nel tentativo di estrarre 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 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();
    }
}

Uso:

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

Esiste un formato che consente lo spostamento di chiavi private si chiama PKCS # 12. Questo formato è arrivato più tardi nell'evoluzione dei certificati PKI e dei relativi keystore man mano che la necessità si è evoluta. Se si considerano i problemi della catena di fiducia creati accedendo e trasportando la chiave privata, è possibile capire perché non è stato incluso nelle funzionalità iniziali, ma piuttosto è venuto dopo la pressione da esigenze 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 design 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 indicato qui: http://www.startux.de/index.php/Java/44-dealing-with-Java-keystoresyvComment44

Se possibile, prenderei in considerazione la possibilità di creare un nuovo keystore in OpenSSL e nuove chiavi piuttosto che cercare di estrarre 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 sia per ottime ragioni crittoologiche, quindi sarei scortese di fare quel passo se non fosse assolutamente necessario.

2
zedman9991