Comment puis-je lister / exporter les clés privées d’un magasin de clés?

Comment puis-je répertorier et exporter une clé privée à partir d’un magasin de clés?

Une partie du code originaire de Example Depot pour répertorier tous les alias d’un magasin de clés:

// Load input stream into keystore keystore.load(is, password.toCharArray()); // List the aliases Enumeration aliases = keystore.aliases(); for (; aliases.hasMoreElements(); ) { Ssortingng alias = (Ssortingng)aliases.nextElement(); // Does alias refer to a private key? boolean b = keystore.isKeyEntry(alias); // Does alias refer to a trusted certificatee? b = keystore.isCertificateEntry(alias); } 

L’exportation des clés privées a été faite sur les forums Sun il y a quelques mois, et u: turingcompleter a créé une classe DumpPrivateKey pour l’assembler dans votre application.

 import java.io.FileInputStream; import java.security.Key; import java.security.KeyStore; import sun.misc.BASE64Encoder; public class DumpPrivateKey { /** * Provides the missing functionality of keytool * that Apache needs for SSLCertificateKeyFile. * * @param args 
    *
  • [0] Keystore filename. *
  • [1] Keystore password. *
  • [2] alias *
*/ static public void main(Ssortingng[] args) throws Exception { if(args.length < 3) { throw new IllegalArgumentException("expected args: Keystore filename, Keystore password, alias,

Note: ce package Sun est une mauvaise chose .
Si vous pouvez télécharger le code apache commons , voici une version qui comstackra sans avertissement:

 javac -classpath .:commons-codec-1.4/commons-codec-1.4.jar DumpPrivateKey.java 

et donnera le même résultat:

 import java.io.FileInputStream; import java.security.Key; import java.security.KeyStore; //import sun.misc.BASE64Encoder; import org.apache.commons.codec.binary.Base64; public class DumpPrivateKey { /** * Provides the missing functionality of keytool * that Apache needs for SSLCertificateKeyFile. * * @param args 
    *
  • [0] Keystore filename. *
  • [1] Keystore password. *
  • [2] alias *
*/ static public void main(Ssortingng[] args) throws Exception { if(args.length < 3) { throw new IllegalArgumentException("expected args: Keystore filename, Keystore password, alias,

Vous pouvez l'utiliser comme ça:

 java -classpath .:commons-codec-1.4/commons-codec-1.4.jar DumpPrivateKey $HOME/.keystore changeit tomcat 

Vous pouvez extraire une clé privée d’un magasin de clés avec Java6 et OpenSSL. Tout dépend du fait que Java et OpenSSL prennent en charge les fichiers de clés au format PKCS # 12. Pour effectuer l’extraction, vous devez d’abord utiliser keytool pour convertir au format standard. Assurez-vous d’ utiliser le même mot de passe pour les deux fichiers (mot de passe de clé privée, pas le mot de passe du fichier de clés) ou vous obtiendrez des échecs plus tard lors de la deuxième étape.

 keytool -importkeystore -srckeystore keystore.jks \ -destkeystore intermediate.p12 -deststoretype PKCS12 

Ensuite, utilisez OpenSSL pour effectuer l’extraction dans PEM:

 openssl pkcs12 -in intermediate.p12 -out extracted.pem -nodes 

Vous devriez être capable de gérer ce fichier PEM assez facilement; c’est du texte simple avec une clé privée non cryptée et un ou des certificates à l’intérieur (dans un format assez évident).

Lorsque vous faites cela, veillez à conserver les fichiers créés en sécurité. Ils contiennent des identifiants secrets. Rien ne vous avertira si vous ne les sécurisez pas correctement. La méthode la plus simple pour les sécuriser consiste à faire tout cela dans un répertoire qui ne dispose d’aucun droit d’access pour quiconque autre que l’utilisateur. Et ne mettez jamais votre mot de passe sur la ligne de commande ou dans les variables d’environnement; c’est trop facile à saisir pour les autres utilisateurs.

Si vous n’avez pas besoin de le faire par programmation, mais que vous souhaitez simplement gérer vos clés, j’ai utilisé depuis longtemps l’outil gratuit KeyMan d’IBM. Très pratique pour exporter une clé privée dans un fichier PFX (alors vous pouvez facilement utiliser OpenSSL pour le manipuler, l’extraire, modifier les pwds, etc.).

https://www.ibm.com/developerworks/mydeveloperworks/groups/service/html/communityview?communityUuid=6fb00498-f6ea-4f65-bf0c-adc5bd0c5fcc

Sélectionnez votre magasin de clés, sélectionnez l’entrée de la clé privée, puis Fichier-> Enregistrer dans un fichier pkcs12 (généralement, * .pfx). Vous pouvez ensuite afficher le contenu avec:

$ openssl pkcs12 -in mykeyfile.pfx -info

Voici une version plus courte du code ci-dessus, dans Groovy. A également un encodage base64 intégré:

 import java.security.Key import java.security.KeyStore if (args.length < 3) throw new IllegalArgumentException('Expected args:     ') def keystoreName = args[0] def keystoreFormat = args[1] def keystorePassword = args[2] def alias = args[3] def keyPassword = args[4] def keystore = KeyStore.getInstance(keystoreFormat) keystore.load(new FileInputStream(keystoreName), keystorePassword.toCharArray()) def key = keystore.getKey(alias, keyPassword.toCharArray()) println "-----BEGIN PRIVATE KEY-----" println key.getEncoded().encodeBase64() println "-----END PRIVATE KEY-----" 

Pour le développement Android, convertir le fichier de clés créé dans eclipse ADT en clé publique et clé privée utilisée dans SignApk.jar:

clé privée d’exportation:

 keytool.exe -importkeystore -srcstoretype JKS -srckeystore my-release-key.keystore -deststoretype PKCS12 -destkeystore keys.pk12.der openssl.exe pkcs12 -in keys.pk12.der -nodes -out private.rsa.pem 

éditer private.rsa.pem et laisser “—– BEGIN PRIVATE KEY —–” à “—– END PRIVATE KEY —–” paragraphe, alors:

 openssl.exe base64 -d -in private.rsa.pem -out private.rsa.der 

clé publique d’exportation:

 keytool.exe -exportcert -keystore my-release-key.keystore -storepass  -alias alias_name -file public.x509.der 

signe apk:

 java -jar SignApk.jar public.x509.der private.rsa.der input.apk output.apk 

Cette question a été soulevée sur la sécurité stackexchange, l’une des suggestions était d’utiliser l’ explorateur Keystore

https://security.stackexchange.com/questions/3779/how-can-i-export-my-private-key-from-a-java-keytool-keystore

Ayant juste essayé, cela fonctionne très bien et je le recommande fortement.

Tout d’abord, soyez prudent! Toute votre sécurité dépend de… er… confidentialité de vos clés privées. Keytool n’a pas d’exportation de clé intégrée pour éviter la divulgation accidentelle de ce matériel sensible. Vous pouvez donc envisager de mettre en place des mesures de protection supplémentaires pour protéger vos clés exscopes.

Voici un code simple qui vous donne PKCS # 8 PrivateKeyInfo non crypté qui peut être utilisé par OpenSSL (voir l’option -nocrypt de son utilitaire pkcs8 ):

 KeyStore keys = ... char[] password = ... Enumeration aliases = keys.aliases(); while (aliases.hasMoreElements()) { Ssortingng alias = aliases.nextElement(); if (!keys.isKeyEntry(alias)) continue; Key key = keys.getKey(alias, password); if ((key instanceof PrivateKey) && "PKCS#8".equals(key.getFormat())) { /* Most PrivateKeys use this format, but check for safety. */ try (FileOutputStream os = new FileOutputStream(alias + ".key")) { os.write(key.getEncoded()); os.flush(); } } } 

Si vous avez besoin d’autres formats, vous pouvez utiliser un KeyFactory pour obtenir une spécification de clé transparente pour différents types de clés. Vous pouvez par exemple obtenir l’exposant privé d’une clé privée RSA et le sortir dans le format souhaité. Cela ferait un bon sujet pour une question complémentaire.

KeyStore Explorer est un autre excellent outil: http://keystore-explorer.sourceforge.net/

Un autre moyen moins conventionnel, mais sans doute plus facile, consiste à utiliser JXplorer . Bien que cet outil soit conçu pour parcourir les annuaires LDAP, il dispose d’une interface graphique conviviale pour la manipulation des fichiers de clés. L’une de ces fonctions sur l’interface graphique peut exporter des clés privées depuis un magasin de clés JKS.