Wie listet/exportiert ich private Schlüssel aus einem Schlüsselspeicher?

Question

Wie liste und exportiere ich einen privaten Schlüssel aus einem Keystore?

Answer 1

Ein Teil des Codes aus Beispiel Depot ursprünglich für alle Aliase in einem Schlüsselspeicher-Eintrag:

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

den Export von privaten Schlüsseln auf dem Sun forums vor ein paar Monaten kam, und u:turingcompleter kam mit einer DumpPrivateKey-Klasse zum Einfügen in Ihre App.

Hinweis: Dies verwenden Sun-Paket, which is a "bad thing".
Wenn Sie apache commons code herunterladen können, hier ist eine Version, die ohne Warnung kompilieren:

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

und wird das gleiche Ergebnis:

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

Sie können es wie so verwenden:

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

Answer 2

Vor allem, sei vorsichtig! All Ihre Sicherheit hängt von der & hellip; er & hellip; Privatsphäre Ihrer privaten Schlüssel. In Keytool ist kein Schlüsselexport eingebaut, um eine versehentliche Offenlegung dieses sensiblen Materials zu vermeiden. Sie sollten daher zusätzliche Sicherheitsvorkehrungen in Erwägung ziehen, um Ihre exportierten Schlüssel zu schützen.

Hier finden Sie einige einfache Code, den Sie unverschlüsselt PKCS # 8 PrivateKeyInfo gibt, die von OpenSSL verwendet werden können (die -nocrypt Option seiner pkcs8 utility sehen):

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

Wenn Sie andere Formate benötigen, können Sie ein verwenden KeyFactory, um eine transparente Schlüsselspezifikation für verschiedene Schlüsseltypen zu erhalten. Dann können Sie beispielsweise den privaten Exponenten eines privaten RSA-Schlüssels erhalten und in Ihrem gewünschten Format ausgeben. Das wäre ein gutes Thema für eine Folgefrage.

Answer 3

Wenn Sie es nicht programmatisch machen müssen, sondern nur Ihre Schlüssel verwalten wollen, dann verwende ich seit langem das kostenlose KeyMan-Tool von IBM. Sehr schön für das Exportieren eines privaten Schlüssels in eine PFX-Datei (dann können Sie OpenSSL leicht verwenden, um es zu manipulieren, es zu extrahieren, Pwds zu ändern usw.).

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

Keystore- auswählen, den privaten Schlüssel Eintrag auswählen, dann File-> Save in eine PKCS12-Datei (* .pfx, in der Regel). Anschließend können Sie den Inhalt mit:

$ openssl pkcs12 -in mykeyfile.pfx -info

Answer 4

Sie können einen privaten Schlüssel aus einem Schlüsselspeicher mit Java6 und OpenSSL extrahieren. Dies hängt davon ab, dass sowohl Java als auch OpenSSL PKCS # 12-formatierte Keystores unterstützen. Um die Extraktion durchzuführen, verwenden Sie zuerst keytool, um in das Standardformat zu konvertieren. Stellen Sie sicher, dass Sie verwenden das gleiche Passwort für beide Dateien (Passwort des privaten Schlüssels, nicht das Keystore-Passwort) oder Sie erhalten ungerade Fehler später im zweiten Schritt.

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

Als nächstes verwenden OpenSSL die Extraktion PEM zu tun:

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

Sie sollten diese PEM-Datei leicht genug zu handhaben können; Es ist reiner Text mit einem unverschlüsselten privaten Schlüssel und Zertifikaten darin (in einem ziemlich offensichtlichen Format).

Wenn Sie dies tun, achten Sie darauf, die erstellten Dateien sicher zu halten. Sie enthalten geheime Anmeldeinformationen. Nichts wird Sie warnen, wenn Sie sie nicht richtig sichern können. Die einfachste Methode, sie zu sichern, besteht darin, all dies in einem Verzeichnis zu tun, das für niemanden außer dem Benutzer Zugriffsrechte besitzt. Und setzen Sie niemals Ihr Passwort in die Befehlszeile oder in Umgebungsvariablen; Es ist zu leicht für andere Benutzer zu greifen.

Answer 5

für Android Entwicklung, Schlüsselspeicher in Eclipse ADT in öffentlichen Schlüssel und einen privaten Schlüssel in SignApk.jar verwendet erstellt konvertieren:

Export privaten Schlüssel:

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 

bearbeiten private.rsa.pem und verlassen "----- PRIVATE KEY ----- BEGIN" auf "----- END PRIVATE KEY -----" Absatz, dann gilt:

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

Export öffentlichen Schlüssel:

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

Zeichen apk:

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

Answer 6

Hier ist eine kürzere Version des obigen Code in Groovy. Auch verfügt über eine integrierte in Base64-Codierung:

import java.security.Key 
import java.security.KeyStore 

if (args.length < 3) 
     throw new IllegalArgumentException('Expected args: <Keystore file> <Keystore format> <Keystore password> <alias> <key password>') 

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-----" 

Answer 7

Ein anderer, weniger konventioneller aber wohl einfacher Weg, dies zu tun mit JXplorer ist. Obwohl dieses Tool zum Durchsuchen von LDAP-Verzeichnissen entwickelt wurde, verfügt es über eine benutzerfreundliche GUI zum Bearbeiten von Schlüsselspeichern. Eine solche Funktion auf der GUI kann private Schlüssel aus einem JKS-Keystore exportieren.

Answer 8

Diese Frage kam auf Stack Sicherheit auf, einen der Vorschläge war Keystore explorer

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

Nachdem es zu benutzen, nur versucht, es funktioniert wirklich gut und ich kann es sehr empfehlen.

Answer 9

Ein weiteres großartiges Werkzeug ist Keystor Explorer: http://keystore-explorer.sourceforge.net/