Comment puis-je liste / exportation de clés privées à partir d'un fichier de clés?

D'une portion de code à l'origine à partir de l'Exemple de Dépôt de la liste des alias dans 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(); ) {
        String alias = (String)aliases.nextElement();

        //Does alias refer to a private key?
        boolean b = keystore.isKeyEntry(alias);

        //Does alias refer to a trusted certificate?
        b = keystore.isCertificateEntry(alias);
    }

L'exportation de clés privées, est apparu sur le Soleil forums il y a quelques mois, et u:turingcompleter est venu avec un DumpPrivateKey classe de couture 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  <ul>
*              <li> [0] Keystore filename.
*              <li> [1] Keystore password.
*              <li> [2] alias
*              </ul>
*/
static public void main(String[] args)
throws Exception {
if(args.length < 3) {
throw new IllegalArgumentException("expected args: Keystore filename, Keystore password, alias, <key password: default same tha
n keystore");
}
final String keystoreName = args[0];
final String keystorePassword = args[1];
final String alias = args[2];
final String keyPassword = getKeyPassword(args,keystorePassword);
KeyStore ks = KeyStore.getInstance("jks");
ks.load(new FileInputStream(keystoreName), keystorePassword.toCharArray());
Key key = ks.getKey(alias, keyPassword.toCharArray());
String b64 = new BASE64Encoder().encode(key.getEncoded());
System.out.println("-----BEGIN PRIVATE KEY-----");
System.out.println(b64);
System.out.println("-----END PRIVATE KEY-----");
}
private static String getKeyPassword(final String[] args, final String keystorePassword)
{
String keyPassword = keystorePassword; //default case
if(args.length == 4) {
keyPassword = args[3];
}
return keyPassword;
}
}

Remarque: l'utilisation du forfait Sun, qui est une "mauvaise chose".

Si vous pouvez le télécharger apache commons code, voici une version qui compile sans warning:

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

et donnent 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  <ul>
*              <li> [0] Keystore filename.
*              <li> [1] Keystore password.
*              <li> [2] alias
*              </ul>
*/
static public void main(String[] args)
throws Exception {
if(args.length < 3) {
throw new IllegalArgumentException("expected args: Keystore filename, Keystore password, alias, <key password: default same tha
n keystore");
}
final String keystoreName = args[0];
final String keystorePassword = args[1];
final String alias = args[2];
final String keyPassword = getKeyPassword(args,keystorePassword);
KeyStore ks = KeyStore.getInstance("jks");
ks.load(new FileInputStream(keystoreName), keystorePassword.toCharArray());
Key key = ks.getKey(alias, keyPassword.toCharArray());
//String b64 = new BASE64Encoder().encode(key.getEncoded());
String b64 = new String(Base64.encodeBase64(key.getEncoded(),true));
System.out.println("-----BEGIN PRIVATE KEY-----");
System.out.println(b64);
System.out.println("-----END PRIVATE KEY-----");
}
private static String getKeyPassword(final String[] args, final String keystorePassword)
{
String keyPassword = keystorePassword; //default case
if(args.length == 4) {
keyPassword = args[3];
}
return keyPassword;
}
}

Vous pouvez l'utiliser comme ceci:

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

Si vous n'avez pas besoin de le faire par programmation, mais juste envie de gérer vos clés, puis j'ai utilisé IBM gratuit KeyMan outil pour un long moment maintenant. Très agréable pour l'exportation d'une clé privée dans un fichier PFX (alors vous pouvez facilement utiliser OpenSSL pour le manipuler, extraire, modifier mdp, etc).

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

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

$ openssl pkcs12-in mykeyfile.pfx -info

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

exportation de la clé privée:

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

modifier privé.rsa.pem et de laisser "-----COMMENCER le PRIVATE KEY-----" à "-----FIN de la CLÉ PRIVÉE-----" le paragraphe, puis:

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

à l'exportation de la clé publique:

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

signe apk:

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

Tout d'abord, soyez prudent! Tous de votre sécurité dépend de la... euh... de confidentialité de votre clés privées. Keytool n'a pas de clé à l'exportation construit pour éviter la divulgation accidentelle de ce matériel sensible, de sorte que vous pourriez envisager de certaines garanties supplémentaires qui pourraient être mises en place pour protéger vos clés exportées.

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

KeyStore keys = ...
char[] password = ...
Enumeration<String> aliases = keys.aliases();
while (aliases.hasMoreElements()) {
String 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 un transparent spécification de la clé pour les différents types de clés. Ensuite, vous pouvez obtenir, par exemple, l'exposant de la clé privée RSA et de sortie dans le format désiré. Qui ferait un bon sujet pour une question de suivi.

Un autre moins conventionnelle, mais sans doute plus facile façon de le faire est avec JXplorer. Bien que cet outil est conçu pour parcourir les annuaires LDAP, il a un facile à utiliser l'interface graphique pour manipuler des fichiers de clés. Une telle fonction sur l'interface utilisateur peut exporter les clés privées d'un JKS keystore.