web-dev-qa-db-fra.com

Comment puis-je exporter ma clé privée à partir d'un magasin de clés Java Keytool?

Je souhaite exporter ma clé privée à partir d'un magasin de clés Java Keytool, afin de pouvoir l'utiliser avec openssl. Comment faire?

appseccryptographykey-managementcertificatesjava
117
Jonas

Utilisez Java keytool pour convertir de JKS en P12 ...

Exporter de keytool au format propriétaire (appelé "JKS") vers un format standardisé PKCS # 12 :

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

... puis utilisez openssl pour exporter de P12 vers PEM

Exporter le certificat à l'aide de openssl:

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

Exporter la clé privée non chiffrée:

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

Depuis Java 6, vous pouvez importer/exporter des clés privées dans PKCS # 12 (.p12) fichiers utilisant keytool, avec l'option -importkeystore (non disponible dans les versions précédentes).

Par exemple:

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

Le PKCS12 le type de fichier de clés est également pris en charge en tant que type de fichier de clés standard dans le fournisseur de sécurité Oracle/Sun par défaut.

62
Bruno

Essayez "Keystore Explorer"

Je suis d'accord avec Bruno. Keytool est un outil ultime pour traiter avec Java keystore, mais il existe un outil gratuit fantaisie et assez puissant: Keystore Explorer

Je l'utilise beaucoup et n'ai jamais eu besoin d'autre chose.

23
Tiho

Si quelqu'un se retrouve ici à essayer d'obtenir une clé privée d'un magasin de clés de type JCEKS, j'ai constaté que les instructions keytool et openssl décrites dans d'autres réponses ne fonctionnaient pas. J'ai dû utiliser la classe Java Java ci-dessous pour sortir la clé.

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

Usage:

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

Il existe un format qui permet le déplacement des clés privées appelé PKCS # 12. Ce format est venu plus tard dans l'évolution des certificats PKI et des magasins de clés associés à mesure que le besoin évoluait. Si vous considérez les problèmes de chaîne de confiance créés par l'accès et le transport de la clé privée, vous pouvez voir pourquoi elle n'a pas été incluse dans les fonctionnalités initiales mais est venue après la pression du besoin opérationnel. C'est la raison principale du défi.

Les magasins de clés Java étaient l'un des premiers utilisateurs du format PKCS # 12 mais en tant qu'importateurs et non exportateurs. Il semble que la conception de sécurité des magasins de clés Java ne prenne toujours pas en charge l'exportation de clés privées en tant que fonctionnalité standard. Encore une fois, il existe de bonnes raisons de sécurité pour ce fait. Cela dit, les routines privées ont été écrites comme référencées ici: http://www.startux.de/index.php/Java/44-dealing-with-Java-keystoresyvComment44

Si possible, j'envisagerais de créer un nouveau fichier de clés dans OpenSSL et de nouvelles clés plutôt que d'essayer d'extraire la clé privée du fichier de clés Java. En ouvrant le magasin de clés Java et en extrayant la clé privée, on va au-delà des fonctionnalités de sécurité conçues. La fonctionnalité d'exportation PKCS # 12 est souhaitée depuis de nombreuses années mais n'est toujours pas prise en charge en Java. Je pense que c'est pour de très bonnes raisons cryptologiques, donc j'apprendrais à prendre cette mesure à moins qu'elle ne soit absolument nécessaire.

2
zedman9991