Wie ein bestehendes X.509-Zertifikat und ein privaten Schlüssel in Java-Schlüsselspeicher importieren in SSL verwenden?

StackOverflow https://stackoverflow.com/questions/906402

  •  05-09-2019
  •  | 
  •  

Frage

Ich habe dies in einer ActiveMQ config: 

<sslContext>
        <sslContext keyStore="file:/home/alex/work/amq/broker.ks"  
 keyStorePassword="password" trustStore="file:${activemq.base}/conf/broker.ts" 
 trustStorePassword="password"/>
</sslContext>

Ich habe ein Paar von X.509-Zertifikat und eine Schlüsseldatei.

Wie importiere ich die beiden, um sie in SSL und SSL + stampfen Anschlüsse zu benutzen? Alle Beispiele könnte ich google immer den Schlüssel selbst erzeugen, aber ich habe bereits einen Schlüssel.

Ich habe versucht, 

keytool -import  -keystore ./broker.ks -file mycert.crt

aber diese importiert nur das Zertifikat und nicht die Schlüsseldatei und die Ergebnisse in 

2009-05-25 13:16:24,270 [localhost:61612] ERROR TransportConnector - Could not accept connection : No available certificate or key corresponds to the SSL cipher suites which are enabled.

Ich habe versucht, das CERT und den Schlüssel verketten bekam aber das gleiche Ergebnis.

Wie importiere ich den Schlüssel?

War es hilfreich?

Lösung

glauben oder nicht, keytool nicht solche grundlegenden Funktionen bietet wie private Schlüssel zum Schlüsselspeicher zu importieren. Sie können versuchen, diese Abhilfe mit PKSC12 Datei mit einem privaten Schlüssel zu einem Schlüsselspeicher zu verschmelzen.

Oder benutzen Sie einfach benutzerfreundlicher KeyMan von IBM für Schlüsselspeicher statt keytool.exe Handhabung.

Andere Tipps

Ich habe die folgenden zwei Schritte, die ich in den Kommentaren / Einträge gefunden in den anderen Antworten verknüpft:

Erster Schritt: Konvertieren Sie das X.509-Zertifikat und Schlüssel zu einer pkcs12 Datei 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root

Hinweis: Vergewissern Sie sich ein Passwort auf der pkcs12 Datei setzen - sonst werden Sie eine Null-Zeiger Ausnahme erhalten, wenn Sie versuchen, es zu importieren. (Falls jemand anderes hatte diese Kopfschmerzen). ( Dank jocull! )

Hinweis 2: Sie möchten vielleicht die -chain Option hinzufügen, um die vollständige Zertifikatkette zu bewahren. ( Dank Mafuba )

Schritt zwei: Konvertieren Sie die pkcs12-Datei in einem Java-Schlüsselspeicher 

keytool -importkeystore \
        -deststorepass [changeit] -destkeypass [changeit] -destkeystore server.keystore \
        -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass some-password \
        -alias [some-alias]

Fertig

fakultativer Schritt Null: Erstellen Sie selbst signiertes Zertifikat 

openssl genrsa -out server.key 2048
openssl req -new -out server.csr -key server.key
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Cheers!

Keytool in Java 6 hat diese Fähigkeit: Importieren von privaten Schlüsseln in eine Java-Schlüsselspeicher mit keytool

Hier sind die grundlegenden Details von dieser Stelle.

  1. Konvertieren Sie die vorhandenen cert in eine PKCS12 OpenSSL. Ein Passwort ist erforderlich, wenn gefragt oder der zweiten Stufe wird sich beschweren. 

    openssl pkcs12 -export -in [my_certificate.crt] -inkey [my_key.key] -out [keystore.p12] -name [new_alias] -CAfile [my_ca_bundle.crt] -caname root

  2. Konvertieren Sie die PKCS12 auf eine Java-Schlüsselspeicherdatei. 

    keytool -importkeystore -deststorepass [new_keystore_pass] -destkeypass [new_key_pass] -destkeystore [keystore.jks] -srckeystore [keystore.p12] -srcstoretype PKCS12 -srcstorepass [pass_used_in_p12_keystore] -alias [alias_used_in_p12_keystore]

Und noch ein: 

#!/bin/bash

# We have:
#
# 1) $KEY : Secret key in PEM format ("-----BEGIN RSA PRIVATE KEY-----") 
# 2) $LEAFCERT : Certificate for secret key obtained from some
#    certification outfit, also in PEM format ("-----BEGIN CERTIFICATE-----")   
# 3) $CHAINCERT : Intermediate certificate linking $LEAFCERT to a trusted
#    Self-Signed Root CA Certificate 
#
# We want to create a fresh Java "keystore" $TARGET_KEYSTORE with the
# password $TARGET_STOREPW, to be used by Tomcat for HTTPS Connector.
#
# The keystore must contain: $KEY, $LEAFCERT, $CHAINCERT
# The Self-Signed Root CA Certificate is obtained by Tomcat from the
# JDK's truststore in /etc/pki/java/cacerts

# The non-APR HTTPS connector (APR uses OpenSSL-like configuration, much
# easier than this) in server.xml looks like this 
# (See: https://tomcat.apache.org/tomcat-6.0-doc/ssl-howto.html):
#
#  <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
#                SSLEnabled="true"
#                maxThreads="150" scheme="https" secure="true"
#                clientAuth="false" sslProtocol="TLS"
#                keystoreFile="/etc/tomcat6/etl-web.keystore.jks"
#                keystorePass="changeit" />
#

# Let's roll:    

TARGET_KEYSTORE=/etc/tomcat6/foo-server.keystore.jks
TARGET_STOREPW=changeit

TLS=/etc/pki/tls

KEY=$TLS/private/httpd/foo-server.example.com.key
LEAFCERT=$TLS/certs/httpd/foo-server.example.com.pem
CHAINCERT=$TLS/certs/httpd/chain.cert.pem

# ----
# Create PKCS#12 file to import using keytool later
# ----

# From https://www.sslshopper.com/ssl-converter.html:
# The PKCS#12 or PFX format is a binary format for storing the server certificate,
# any intermediate certificates, and the private key in one encryptable file. PFX
# files usually have extensions such as .pfx and .p12. PFX files are typically used 
# on Windows machines to import and export certificates and private keys.

TMPPW=$$ # Some random password

PKCS12FILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary PKCS12 file failed -- exiting" >&2; exit 1
fi

TRANSITFILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary transit file failed -- exiting" >&2; exit 1
fi

cat "$KEY" "$LEAFCERT" > "$TRANSITFILE"

openssl pkcs12 -export -passout "pass:$TMPPW" -in "$TRANSITFILE" -name etl-web > "$PKCS12FILE"

/bin/rm "$TRANSITFILE"

# Print out result for fun! Bug in doc (I think): "-pass " arg does not work, need "-passin"

openssl pkcs12 -passin "pass:$TMPPW" -passout "pass:$TMPPW" -in "$PKCS12FILE" -info

# ----
# Import contents of PKCS12FILE into a Java keystore. WTF, Sun, what were you thinking?
# ----

if [[ -f "$TARGET_KEYSTORE" ]]; then
  /bin/rm "$TARGET_KEYSTORE"
fi

keytool -importkeystore \
   -deststorepass  "$TARGET_STOREPW" \
   -destkeypass    "$TARGET_STOREPW" \
   -destkeystore   "$TARGET_KEYSTORE" \
   -srckeystore    "$PKCS12FILE" \
   -srcstoretype  PKCS12 \
   -srcstorepass  "$TMPPW" \
   -alias foo-the-server

/bin/rm "$PKCS12FILE"

# ----
# Import the chain certificate. This works empirically, it is not at all clear from the doc whether this is correct
# ----

echo "Importing chain"

TT=-trustcacerts

keytool -import $TT -storepass "$TARGET_STOREPW" -file "$CHAINCERT" -keystore "$TARGET_KEYSTORE" -alias chain

# ----
# Print contents
# ----

echo "Listing result"

keytool -list -storepass "$TARGET_STOREPW" -keystore "$TARGET_KEYSTORE"

Ja, es ist in der Tat eine traurige Tatsache, dass keytool keine Funktionalität hat einen privaten Schlüssel zu importieren.

Für die Aufzeichnung am Ende ich mit der Lösung ging beschrieben hier

Zuerst konvertieren p12: 

openssl pkcs12 -export -in [filename-certificate] -inkey [filename-key] -name [host] -out [filename-new-PKCS-12.p12]

Neue JKS von p12: 

keytool -importkeystore -deststorepass [password] -destkeystore [filename-new-keystore.jks] -srckeystore [filename-new-PKCS-12.p12] -srcstoretype PKCS12

In meinem Fall hatte ich eine pem-Datei, die zwei Zertifikate enthalten und einen verschlüsselten privaten Schlüssel in der gegenseitigen SSL-Authentifizierung verwendet werden. Also meine pem-Datei sah wie folgt aus: 

-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,C8BF220FC76AA5F9
...
-----END RSA PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

Hier ist, was ich getan habe:

Sie die Datei in drei separate Dateien aufgeteilt, so dass jeder nur einen Eintrag enthält, beginnend mit "--- BEGIN .." und endend mit "--- END .." Linien. Nehmen wir an, wir haben jetzt drei Dateien: Datei cert1.pem cert2.pem und pkey.pem

Konvertieren pkey.pem in DAS-Format mit OpenSSL und die folgende Syntax:

openssl pkcs8 -topk8 -nocrypt -in pkey.pem -inform PEM -out pkey.der -outform DER

Beachten Sie, dass, wenn der private Schlüssel verschlüsselt ist, benötigen Sie ein Passwort angeben (erhalten sie vom Lieferanten der ursprünglichen pem-Datei) konvertieren zu DEM-Format, openssl werden Sie nach dem Passwort wie folgt fragen: „einen Pass Phraze für pkey.pem eingeben:“ Wenn die Konvertierung erfolgreich ist, werden Sie eine neue Datei mit dem Namen „pkey.der“ get

Erstellen

einen neuen Java-Schlüsselspeicher und importieren Sie die privaten Schlüssel und die Zertifikate: 

String keypass = "password";  // this is a new password, you need to come up with to protect your java key store file
String defaultalias = "importkey";
KeyStore ks = KeyStore.getInstance("JKS", "SUN");

// this section does not make much sense to me, 
// but I will leave it intact as this is how it was in the original example I found on internet:   
ks.load( null, keypass.toCharArray());
ks.store( new FileOutputStream ( "mykeystore"  ), keypass.toCharArray());
ks.load( new FileInputStream ( "mykeystore" ),    keypass.toCharArray());
// end of section..


// read the key file from disk and create a PrivateKey

FileInputStream fis = new FileInputStream("pkey.der");
DataInputStream dis = new DataInputStream(fis);
byte[] bytes = new byte[dis.available()];
dis.readFully(bytes);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

byte[] key = new byte[bais.available()];
KeyFactory kf = KeyFactory.getInstance("RSA");
bais.read(key, 0, bais.available());
bais.close();

PKCS8EncodedKeySpec keysp = new PKCS8EncodedKeySpec ( key );
PrivateKey ff = kf.generatePrivate (keysp);


// read the certificates from the files and load them into the key store:

Collection  col_crt1 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert1.pem"));
Collection  col_crt2 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert2.pem"));

Certificate crt1 = (Certificate) col_crt1.iterator().next();
Certificate crt2 = (Certificate) col_crt2.iterator().next();
Certificate[] chain = new Certificate[] { crt1, crt2 };

String alias1 = ((X509Certificate) crt1).getSubjectX500Principal().getName();
String alias2 = ((X509Certificate) crt2).getSubjectX500Principal().getName();

ks.setCertificateEntry(alias1, crt1);
ks.setCertificateEntry(alias2, crt2);

// store the private key
ks.setKeyEntry(defaultalias, ff, keypass.toCharArray(), chain );

// save the key store to a file         
ks.store(new FileOutputStream ( "mykeystore" ),keypass.toCharArray());

(optional) Überprüfen Sie den Inhalt des neuen Schlüsselspeicher:

keytool -list -keystore mykeystore -storepass password

  

Schlüsselspeichertyp: JKS-Keystore-Anbieter: SUN

     

Ihr Schlüsselspeicher enthält 3 Einträge

     

cn = ..., ou = ..., o = .., 2. September 2014, trustedCertEntry, Zertifikat   Fingerabdruck (SHA1): 2C: B8: ...

     

importkey, 2. September 2014, PrivateKeyEntry, Zertifikat Fingerabdruck   (SHA1): 9C: B0: ...

     

cn = ..., o = ...., 2. September 2014, trustedCertEntry, Zertifikat Fingerabdruck   (SHA1): 83:63: ...

(optional) Testen Sie Ihre Zertifikate und private Schlüssel von Ihrem neuen Schlüsselspeicher gegen den SSL-Server: (Sie können das Debuggen als VM-Option aktiviert werden soll: -Djavax.net.debug = alle) 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        SSLSocketFactory factory = sclx.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket( "192.168.1.111", 443 );
        socket.startHandshake();

        //if no exceptions are thrown in the startHandshake method, then everything is fine..

Schließlich Ihre Zertifikate mit HttpsURLConnection registrieren, wenn Plan, es zu benutzen: 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        HostnameVerifier hv = new HostnameVerifier()
        {
            public boolean verify(String urlHostName, SSLSession session)
            {
                if (!urlHostName.equalsIgnoreCase(session.getPeerHost()))
                {
                    System.out.println("Warning: URL host '" + urlHostName + "' is different to SSLSession host '" + session.getPeerHost() + "'.");
                }
                return true;
            }
        };

        HttpsURLConnection.setDefaultSSLSocketFactory( sclx.getSocketFactory() );
        HttpsURLConnection.setDefaultHostnameVerifier(hv);

Basierend auf den Antworten oben, hier ist, wie ein brandneuen Schlüsselspeicher für Ihren Java-basierten Web-Server zu erstellen, aus einer unabhängig geschaffenen Comodo cert und privaten Schlüssel keytool (erfordert JDK 1.6 +)

  1. Geben Sie diesen Befehl und an der Kennwort-Eingabeaufforderung eingeben somepass - ‚server.crt‘ ist cert Ihres Servers und ‚server.key‘ wird mit dem privaten Schlüssel Sie für die Ausstellung des CSR verwendet: openssl pkcs12 -export -in server.crt -inkey server.key -out server.p12 -name www.yourdomain.com -CAfile AddTrustExternalCARoot.crt -caname "AddTrust External CA Root"

  2. Dann keytool verwenden, um den p12-Schlüsselspeicher in einen jks Schlüsselspeicher zu konvertieren: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Dann importieren Sie die anderen beiden root / Zwischen Zert Sie von Comodo erhalten:

  1. Import COMODORSAAddTrustCA.crt: keytool -import -trustcacerts -alias cert1 -file COMODORSAAddTrustCA.crt -keystore keystore.jks

  2. Import COMODORSADomainValidationSecureServerCA.crt: keytool -import -trustcacerts -alias cert2 -file COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks

Sie können diese Schritte verwenden, um die Schlüssel zu einem vorhandenen Schlüsselspeicher zu importieren. Die Anweisungen werden von Antworten in diesem Thread und anderen Seiten kombiniert. Diese Anweisungen arbeiten für mich (Java-Schlüsselspeicher):

  1. Ausführen

openssl pkcs12 -export -in yourserver.crt -inkey yourkey.key -out server.p12 -name somename -certfile yourca.crt -caname root

(Wenn die -Kette Put-Option erforderlich. Putting das für mich nicht). Dies wird nach dem Passwort fragen - Sie müssen das richtige Passwort geben sonst wird eine Fehlermeldung angezeigt (Kursfehler oder padding Fehler usw.).

  1. Sie werden aufgefordert, ein neues Passwort eingeben - Sie hier ein Kennwort eingeben muss - geben Sie etwas aber nicht vergessen, es. (Lassen Sie uns annehmen, dass Sie Aragorn eingeben).
  2. Das wird die server.p12 Datei im PKCS-Format erstellen.
  3. Geben Sie nun in die *.jks Datei laufen zu importieren:
    keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
    (Sehr wichtig -. Nicht die deststorepass auslassen und die destkeypass Parameter)
  4. Es wird Sie für den src Schlüsselspeicher Passwort fragen. Geben Sie Aragorn und drücken Sie die Eingabetaste. Das Zertifikat und der Schlüssel wird jetzt in Ihren bestehenden Java-Schlüsselspeicher importiert.

Vorherige Antworten weisen darauf hin, richtig, dass Sie nur diese mit den Standard-JDK-Tool tun können, indem die JKS-Datei in PKCS # 12-Format zuerst konvertieren. Wenn Sie interessiert sind, habe ich zusammen ein kompaktes Programm zu importieren OpenSSL-abgeleiteten Schlüssel in einen JKS-Format Schlüsselspeicher, ohne die Schlüsselspeicher zu PKCS # 12 zuerst zu konvertieren: http://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art049

Sie würden das verknüpfte Dienstprogramm wie folgt verwenden: 

$ openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.csr -subj "/CN=localhost"

(die CSR unterzeichnen, erhalten zurück localhost.cer) 

$ openssl rsa -in localhost.key -out localhost.rsa
Enter pass phrase for localhost.key:
writing RSA key
$ java -classpath . KeyImport -keyFile localhost.rsa -alias localhost -certificateFile localhost.cer -keystore localhost.jks -keystorePassword changeit -keystoreType JKS -keyPassword changeit

Wenn Sie eine PEM-Datei (zum Beispiel server.pem) enthält:

  • das vertrauenswürdige Zertifikat
  • der private Schlüssel

, dann können Sie das Zertifikat und den Schlüssel in ein JKS Schlüsselspeicher wie folgt importieren:

1 ) Kopieren Sie die privaten Schlüssel aus der PEM-Datei in eine ASCII-Datei (z server.key)

2 ) Kopieren Sie die cert aus der PEM-Datei in eine ASCII-Datei (z server.crt)

3 ), um die cert und Schlüssel in eine PKCS12-Datei exportieren: 

$ openssl pkcs12 -export -in server.crt -inkey server.key \
                 -out server.p12 -name [some-alias] -CAfile server.pem -caname root
  • die PEM-Datei kann als Argument für die -CAfile Option verwendet werden .
  • Sie sind für ein 'Export' Passwort gefragt.
  • , wenn diese in git tut bash dann winpty zu Beginn des Befehls hinzufügen, so kann das Export-Passwort eingegeben werden.

4 ) Konvertieren Sie die PKCS12-Datei in einem JKS Schlüsselspeicher: 

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit
  • sollte das srcstorepass Passwort das Export Passwort aus Schritt 3)
    • entspricht

Was ich versuche, bereits zur Verfügung gestellt private Schlüssel und das Zertifikat zu erreichen, wurde unter Verwendung von Nachricht zu signieren, die irgendwo würde, die sicher zu machen brauchten, dass die Nachricht von mir kommen werde (private Schlüssel signieren, während Öffentliche Schlüssel verschlüsseln).

Wenn Sie also bereits eine .key-Datei und eine CRT-Datei?

Versuchen Sie folgendes:

Schritt 1: Konvertieren Sie die Schlüssel und cert-Datei als .p12 

openssl pkcs12 -export -in certificate.crt -inkey privateKey.key -name alias -out yourconvertedfile.p12

Schritt 2: den Schlüssel importieren und eine .jsk Datei mit einem einzigen Befehl erstellen 

keytool -importkeystore -deststorepass changeit -destkeystore keystore.jks -srckeystore umeme.p12 -srcstoretype PKCS12

Schritt 3: in der Java: 

char[] keyPassword = "changeit".toCharArray();

KeyStore keyStore = KeyStore.getInstance("JKS");
InputStream keyStoreData = new FileInputStream("keystore.jks");

keyStore.load(keyStoreData, keyPassword);
KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(keyPassword);
KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry("alias", entryPassword);

System.out.println(privateKeyEntry.toString());

Wenn Sie eine Zeichenfolge mit diesem Schlüssel zu unterschreiben Sie wie folgt vor:

Schritt 1: Konvertieren Sie den Text möchten Sie verschlüsseln 

byte[] data = "test".getBytes("UTF8");

Schritt 2: Get base64 private Schlüssel verschlüsselt 

keyStore.load(keyStoreData, keyPassword);

//get cert, pubkey and private key from the store by alias
Certificate cert = keyStore.getCertificate("localhost");
PublicKey publicKey = cert.getPublicKey();
KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

//sign with this alg
Signature sig = Signature.getInstance("SHA1WithRSA");
sig.initSign(keyPair.getPrivate());
sig.update(data);
byte[] signatureBytes = sig.sign();
System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

sig.initVerify(keyPair.getPublic());
sig.update(data);

System.out.println(sig.verify(signatureBytes));

Referenzen:

  1. Wie ein vorhandenes x509 Zertifikat und einen privaten Schlüssel in Java-Schlüsselspeicher importieren, in die Verwendung von SSL?
  2. http://tutorials.jenkov.com/java-cryptography/keystore.html
  3. http://www.java2s.com/Code/Java/Security /RetrievingaKeyPairfromaKeyStore.htm
  4. Wie String mit einem privaten Schlüssel unterzeichnen

Endgültiges Programm 

public static void main(String[] args) throws Exception {

    byte[] data = "test".getBytes("UTF8");

    // load keystore
    char[] keyPassword = "changeit".toCharArray();

    KeyStore keyStore = KeyStore.getInstance("JKS");
    //System.getProperty("user.dir") + "" < for a file in particular path 
    InputStream keyStoreData = new FileInputStream("keystore.jks");
    keyStore.load(keyStoreData, keyPassword);

    Key key = keyStore.getKey("localhost", keyPassword);

    Certificate cert = keyStore.getCertificate("localhost");

    PublicKey publicKey = cert.getPublicKey();

    KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

    Signature sig = Signature.getInstance("SHA1WithRSA");

    sig.initSign(keyPair.getPrivate());
    sig.update(data);
    byte[] signatureBytes = sig.sign();
    System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

    sig.initVerify(keyPair.getPublic());
    sig.update(data);

    System.out.println(sig.verify(signatureBytes));
}

Nur ein PKCS12 Keystor machen, Java kann nun direkt verwenden. In der Tat, wenn Sie einen Java-Stil Schlüsselspeichern Liste keytool selbst weist auf die Tatsache, dass PKCS12 ist jetzt das bevorzugte Format. 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root -chain

Sie sollten alle drei Dateien (server.crt, server.key, ca.crt) von Ihrem Zertifikat Provider erhalten haben. Ich bin nicht sicher, was „-caname root“ eigentlich bedeutet, aber es scheint zu sein, um auf diese Weise festgelegt werden.

In dem Java-Code, stellen Sie sicher den richtigen Schlüsselspeichertyp angeben. 

KeyStore.getInstance("PKCS12")

Ich habe meine comodo.com ausgestellten SSL-Zertifikat in NanoHTTPD adaequat auf diese Weise.

Mit Lassen Sie uns Encrypt Zertifikate

Angenommen, Sie Ihre Zertifikate und private Schlüssel mit Lasst uns Verschlüsseln in /etc/letsencrypt/live/you.com:

1. Erstellen Sie eine PKCS # 12 Datei 

openssl pkcs12 -export -in fullchain.pem -inkey privkey.pem -out pkcs.p12 \
        -name letsencrypt

Dies kombiniert die SSL-Zertifikat fullchain.pem und Ihre privaten Schlüssel privkey.pem in eine einzige Datei, pkcs.p12.

Sie werden nach einem Passwort für pkcs.p12 gefragt.

Die export Option gibt an, dass eine PKCS # 12-Datei nicht erstellt wird, als analysiert (von der Handbuch ).

2. Erstellen Sie den Java-Schlüssel 

keytool -importkeystore -destkeystore keystore.jks -srckeystore pkcs.p12 \
        -srcstoretype PKCS12 -alias letsencrypt

Wenn keystore.jks nicht existiert, wird es die pkcs.12 Datei oben, erstellt werden enthalten. Andernfalls werden Sie pkcs.12 in die vorhandenen Schlüsselspeicher importieren.

Diese Anweisungen sind abgeleitet von dieses Blog-Post .

Hier mehr auf der anderen Art Dateien in /etc/letsencrypt/live/you.com/.

in einem Fall von Elliptic Curve und die Frage beantworten, importieren Sie eine vorhandene x509-Zertifikat und einen privaten Schlüssel in Java-Schlüsselspeicher , können Sie einen Blick auch auf diesen Thread wollen Wie EC private Schlüssel in Java zu lesen, die in .pem-Datei-Format ist

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top