Ich habe dies in einer ActiveMQ-Konfiguration:

<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 X.509-Zertifikat und eine Schlüsseldatei.

Wie importiere ich diese beiden, um sie in SSL- und SSL + -Stomp-Connectors zu verwenden? Alle Beispiele, die ich googeln könnte, generieren den Schlüssel immer selbst, aber ich habe bereits einen Schlüssel.

Ich habe versucht

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

Dies importiert jedoch nur das Zertifikat und nicht die Schlüsseldatei und führt zu

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 Zertifikat und den Schlüssel zu verketten, habe aber das gleiche Ergebnis erzielt.

Wie importiere ich den Schlüssel?

Ob Sie es glauben oder nicht, Keytool bietet keine grundlegenden Funktionen wie das Importieren eines privaten Schlüssels in den Keystore. Sie können diese Problemumgehung ausprobieren mit PKSC12 Datei mit einem privaten Schlüssel zu einem Schlüsselspeicher zu verschmelzen.

Oder verwenden Sie einfach den benutzerfreundlicheren KeyMan von IBM für die Keystore-Behandlung anstelle von keytool.exe.

Ich habe die folgenden zwei Schritte verwendet, die ich in den Kommentaren / Beiträgen gefunden habe, die in den anderen Antworten verlinkt sind:

Schritt eins: Konvertieren Sie das x.509-Zertifikat und den Schlüssel in eine pkcs12-Datei

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

Hinweis: Stellen Sie sicher, dass Sie ein Kennwort für die Datei pkcs12 eingeben. Andernfalls wird beim Importieren eine Nullzeigerausnahme angezeigt. (Falls jemand anderes diese Kopfschmerzen hatte). ( Danke Jocull! )

Anmerkung 2: Möglicherweise möchten Sie die -chainOption hinzufügen , um die vollständige Zertifikatkette beizubehalten. ( Danke Mafuba )

Schritt zwei: Konvertieren Sie die Datei pkcs12 in einen Java-Keystore

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

Fertig

OPTIONAL Schritt Null: Erstellen Sie ein selbstsigniertes 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

Prost!

Keytool in Java 6 bietet folgende Funktionen: Importieren von privaten Schlüsseln in einen Java-Keystore mithilfe von Keytool

Hier sind die grundlegenden Details aus diesem Beitrag.

1. Konvertieren Sie das vorhandene Zertifikat mit OpenSSL in ein PKCS12. Ein Passwort ist erforderlich, wenn Sie gefragt werden, oder der zweite Schritt 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 den PKCS12 in eine Java-Keystore-Datei.

   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 einer mehr:

#!/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"

Zuerst auf p12 konvertieren:

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

Erstellen Sie neue JKS ab Seite 12:

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

Ja, es ist in der Tat eine traurige Tatsache, dass Keytool keine Funktionalität zum Importieren eines privaten Schlüssels hat.

Am Ende habe ich mich für die hier beschriebene Lösung entschieden

In meinem Fall hatte ich eine PEM-Datei, die zwei Zertifikate und einen verschlüsselten privaten Schlüssel zur gegenseitigen SSL-Authentifizierung enthielt. Meine PEM-Datei sah also so 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-----

Folgendes habe ich getan:

Teilen Sie die Datei in drei separate Dateien auf, sodass jede nur einen Eintrag enthält, beginnend mit "--- BEGIN .." und endend mit "--- END ..". Nehmen wir an, wir haben jetzt drei Dateien: cert1.pem cert2.pem und pkey.pem

Konvertieren Sie pkey.pem mit openssl und der folgenden Syntax in das DER-Format:

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, Sie ein Passwort angeben müssen (erhalten Sie es vom Lieferanten der ursprünglichen PEM-Datei), um es in das DER-Format zu konvertieren. OpenSL fragt Sie nach dem Passwort wie folgt: "Geben Sie eine Pass-Phraze für pkey ein .pem: "Wenn die Konvertierung erfolgreich ist, erhalten Sie eine neue Datei mit dem Namen" pkey.der ".

Erstellen Sie einen neuen Java-Schlüsselspeicher und importieren Sie den 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 Ihres neuen Schlüsselspeichers:

keytool -list -keystore mykeystore -storepass password

Keystore-Typ: JKS Keystore-Anbieter: SUN

Ihr Keystore enthält 3 Einträge

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

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

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

(optional) Testen Sie Ihre Zertifikate und Ihren privaten Schlüssel aus Ihrem neuen Schlüsselspeicher mit Ihrem SSL-Server: (Möglicherweise möchten Sie das Debuggen als VM-Option aktivieren: -Djavax.net.debug = all)

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

Registrieren Sie abschließend Ihre Zertifikate bei HttpsURLConnection, wenn Sie diese verwenden möchten:

        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 obigen Antworten erfahren Sie hier, wie Sie einen brandneuen Keystore für Ihren Java-basierten Webserver aus einem unabhängig erstellten Comodo-Zertifikat und einem privaten Schlüssel mit keytool erstellen (JDK 1.6+ erforderlich).

1. Geben Sie diesen Befehl ein und geben Sie an der Kennwortabfrage einen Pass ein. 'Server.crt' ist das Zertifikat Ihres Servers und 'server.key' ist der private Schlüssel, den Sie für die Ausgabe des CSR verwendet haben: 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. Verwenden Sie dann Keytool, um den p12-Keystore in einen jks-Keystore zu konvertieren: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Importieren Sie dann die beiden anderen Root- / Intermediate-Zertifikate, die Sie von Comodo erhalten haben:

3. Importieren Sie COMODORSAAddTrustCA.crt: keytool -import -trustcacerts -alias cert1 -file COMODORSAAddTrustCA.crt -keystore keystore.jks

4. Importieren Sie COMODORSADomainValidationSecureServerCA.crt: keytool -import -trustcacerts -alias cert2 -file COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks

Verwenden von Let's Encrypt-Zertifikaten

Angenommen, Sie haben Ihre Zertifikate und privaten Schlüssel mit Let's Encrypt erstellt 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 Ihr SSL-Zertifikat fullchain.pemund Ihren privaten Schlüssel privkey.pemin einer einzigen Datei pkcs.p12.

Sie werden aufgefordert, ein Passwort für einzugeben pkcs.p12.

Die exportOption gibt an, dass eine PKCS # 12-Datei erstellt und nicht analysiert wird (aus dem Handbuch ).

2. Erstellen Sie den Java-Keystore

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

Wenn keystore.jkses nicht vorhanden ist, wird es mit der pkcs.12oben erstellten Datei erstellt. Andernfalls importieren Sie pkcs.12in den vorhandenen Schlüsselspeicher.

Diese Anweisungen stammen aus diesem Blog-Beitrag .

Hier erfahren Sie mehr über die verschiedenen Arten von Dateien in /etc/letsencrypt/live/you.com/.

Mit diesen Schritten können Sie den Schlüssel in einen vorhandenen Schlüsselspeicher importieren. Die Anweisungen werden aus den Antworten in diesem Thread und anderen Websites kombiniert. Diese Anleitung hat bei mir funktioniert (der Java Keystore):

1. Lauf

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

(Falls erforderlich, setzen Sie die Option -chain. Das Setzen ist für mich fehlgeschlagen.) Dies fragt nach dem Passwort - Sie müssen das richtige Passwort eingeben, sonst erhalten Sie einen Fehler (Überschriftenfehler oder Auffüllfehler usw.).

2. Sie werden aufgefordert, ein neues Passwort einzugeben. Sie müssen hier ein Passwort eingeben. Geben Sie etwas anderes ein, als sich daran zu erinnern. (Nehmen wir an, Sie betreten Aragorn).
3. Dadurch wird die Datei server.p12 im pkcs-Format erstellt.
4. Um es nun in die *.jksDatei zu importieren, führen Sie Folgendes aus:
   keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
   den Dateilauf (Sehr wichtig - lassen Sie die Parameter deststorepass und destkeypass nicht aus.)
5. Sie werden nach dem Kennwort für den src-Schlüsselspeicher gefragt. Geben Sie Aragorn ein und drücken Sie die Eingabetaste. Das Zertifikat und der Schlüssel werden jetzt in Ihren vorhandenen Java-Keystore importiert.

Frühere Antworten weisen richtig darauf hin, dass Sie dies nur mit den Standard-JDK-Tools tun können, indem Sie zuerst die JKS-Datei in das PKCS # 12-Format konvertieren. Wenn Sie interessiert sind, habe ich ein kompaktes Dienstprogramm zum Importieren von OpenSSL-abgeleiteten Schlüsseln in einen JKS-formatierten Schlüsselspeicher zusammengestellt, ohne den Schlüsselspeicher zuerst in PKCS # 12 konvertieren zu müssen: 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"

(CSR unterschreiben, localhost.cer zurückholen)

$ 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 (z. B. server.pem) haben, die Folgendes enthält:

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

Anschließend können Sie das Zertifikat und den Schlüssel wie folgt in einen JKS-Keystore importieren:

1 ) Kopieren Sie den privaten Schlüssel aus der PEM-Datei in eine ASCII-Datei (zserver.key )

2 ) Kopieren Sie das Zertifikat aus der PEM-Datei in eine ASCII-Datei (zserver.crt )

3 ) Exportieren Sie das Zertifikat und den Schlüssel in eine PKCS12-Datei:

$ 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 -CAfileOption verwendet werden .
• Sie werden aufgefordert, ein 'Export'-Passwort einzugeben.
• Wenn Sie dies in git bash tun, fügen Sie winptyes am Anfang des Befehls hinzu, damit das Exportkennwort eingegeben werden kann.

4 ) Konvertieren Sie die PKCS12-Datei in einen JKS-Keystore:

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit

• Das srcstorepassPasswort sollte mit dem Exportpasswort aus Schritt 3) übereinstimmen.

Was ich erreichen wollte, war die Verwendung des bereits bereitgestellten privaten Schlüssels und Zertifikats zum Signieren einer Nachricht, die an einen Ort ging, an dem sichergestellt werden musste, dass die Nachricht von mir kam (privates Schlüsselzeichen, während öffentliche Schlüssel verschlüsseln).

Also, wenn Sie bereits eine .key-Datei und eine .crt-Datei haben?

Versuche dies:

Schritt 1: Konvertieren Sie den Schlüssel und das Zertifikat in die P12-Datei

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

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

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

Schritt 3: In Ihrem 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 mit diesem Schlüssel eine Zeichenfolge signieren müssen, gehen Sie wie folgt vor:

Schritt 1: Konvertieren Sie den zu verschlüsselnden Text

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

Schritt 2: Holen Sie sich den Base64-codierten privaten Schlüssel

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

Verweise:

1. Wie importiere ich ein vorhandenes x509-Zertifikat und einen privaten Schlüssel in den Java-Keystore, um sie in SSL zu verwenden?
2. http://tutorials.jenkov.com/java-cryptography/keystore.html
3. http://www.java2s.com/Code/Java/Security/RetrievingaKeyPairfromaKeyStore.htm
4. So signieren Sie eine Zeichenfolge mit einem privaten Schlüssel

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

Erstellen Sie einfach einen PKCS12-Keystore, Java kann ihn jetzt direkt verwenden. Wenn Sie einen Keystore im Java-Stil auflisten, weist Sie das Keytool selbst darauf hin, dass PKCS12 jetzt das bevorzugte Format ist.

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 Zertifikatanbieter erhalten haben. Ich bin nicht sicher, was "-caname root" eigentlich bedeutet, aber es scheint so spezifiziert werden zu müssen.

Stellen Sie im Java-Code sicher, dass Sie den richtigen Keystore-Typ angeben.

KeyStore.getInstance("PKCS12")

Auf diese Weise funktioniert mein von comodo.com ausgestelltes SSL-Zertifikat in NanoHTTPD einwandfrei.

In einem Fall von Elliptic Curve und Beantwortung der Frage zum Importieren eines vorhandenen x509-Zertifikats und eines privaten Schlüssels im Java-Keystore möchten Sie möglicherweise auch einen Blick auf diesen Thread werfen. So lesen Sie den privaten EC-Schlüssel in Java im PEM-Dateiformat