it-swarm.com.de

Wie importiere ich ein vorhandenes x509-Zertifikat und einen privaten Schlüssel in den Java-Keystore, um ihn in SSL zu verwenden

Ich habe dies in 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 x509 cert und eine Schlüsseldatei

Wie importiere ich diese beiden, um sie in den SSL- und SSL-Stomp-Connectors zu verwenden? Alle Beispiele, die ich googeln konnte, 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 dazu 

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 zu verketten, habe aber das gleiche Ergebnis erhalten

Wie importiere ich den Schlüssel?

198

Ob Sie glauben oder nicht, keytool bietet keine grundlegenden Funktionen wie das Importieren eines privaten Schlüssels in den Keystore. Sie können diese Workaround versuchen, indem Sie die PKSC12-Datei mit dem privaten Schlüssel in einen Schlüsselspeicher einbinden. 

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

66
Matej

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

Schritt eins: Konvertieren von x509 Cert und Key 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: Vergewissern Sie sich, dass Sie ein Kennwort für die p12-Datei angeben. Andernfalls erhalten Sie eine Nullreferenz, wenn Sie versuchen, sie zu importieren. (Falls noch jemand diese Kopfschmerzen hatte). ( Danke Jocull! )

Hinweis 2: Möglicherweise möchten Sie die Option -chain hinzufügen, um die vollständige Zertifikatskette beizubehalten. ( Danke Mafuba )

Schritt zwei: Konvertieren Sie die pkcs12-Datei 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, selbstsigniertes Zertifikat erstellen

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!

478
reto

Keytool in Java 6 verfügt über diese Funktion: Importieren privater Schlüssel in einen Java-Keystore mithilfe von keytool

Hier sind die grundlegenden Details aus diesem Beitrag.

  1. Konvertieren Sie das vorhandene Zertifikat mithilfe von OpenSSL in ein PKCS12. Wenn Sie dazu aufgefordert werden, ist ein Passwort erforderlich, oder der 2. Schritt wird beschwert.

    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 das 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]
    
113
CoverosGene

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"
9
David Tonhofer

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

Zum Schluss ging ich mit der beschriebenen Lösung hier

In meinem Fall hatte ich eine PEM-Datei, die zwei Zertifikate und einen verschlüsselten privaten Schlüssel enthielt, der für die gegenseitige SSL-Authentifizierung verwendet werden sollte ..__ Also sah meine PEM-Datei 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, so dass 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 mithilfe von openssl und der folgenden Syntax in das DER-Format:

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

Wenn der private Schlüssel verschlüsselt ist, müssen Sie ein Kennwort eingeben (erfragen Sie es vom Hersteller der ursprünglichen Pem-Datei) Zum Konvertieren in das DER-Format werden Sie von Openssl nach dem Kennwort gefragt: " Geben Sie ein Passwort für pkey.pem ein: " 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, Certificate Fingerabdruck (SHA1): 2C: B8: ...

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

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

(optional) Testen Sie Ihre Zertifikate und Ihren privaten Schlüssel aus Ihrem neuen Schlüsselspeicher mit Ihrem SSL-Server: (Sie können das Debuggen als Option VM 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 schließlich Ihre Zertifikate bei HttpsURLConnection, wenn Sie sie 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);
6
Interkot

Zuerst in p12 umwandeln:

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

Neue JKS aus p12 erstellen:

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

Basierend auf den obigen Antworten können Sie einen brandneuen Keystore für Ihren Java-basierten Webserver erstellen, der aus einem unabhängig erstellten Comodo-Zertifikat und einem privaten Schlüssel mithilfe von keytool erstellt wird (erfordert JDK 1.6+).

  1. Geben Sie diesen Befehl aus und geben Sie bei der Kennworteingabeaufforderung Folgendes ein: somepass - '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 umzuwandeln: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Dann importieren Sie die anderen zwei Root/Intermediate-Certs, die Sie von Comodo erhalten haben:

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

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

5
Alex Fotios

Hier sind die Schritte, die ich befolgt habe, um den Schlüssel in einen vorhandenen Keystore zu importieren - kombinierte Anweisungen aus Antworten hier und an anderen Stellen, um diese Schritte zu erhalten, die für meinen Java-Keystore funktionieren: 

  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.) . Hier werden Sie nach dem Kennwort gefragt - Sie müssen das richtige Kennwort eingeben, andernfalls erhalten Sie eine Fehlermeldung (Überschriftenfehler oder Auffüllfehler usw.). 

  1. Sie werden aufgefordert, ein neues Passwort einzugeben. Sie müssen hier ein Passwort eingeben. Alles eingeben, aber nicht vergessen. (Nehmen wir an, Sie betreten Aragorn.) 
  2. Dadurch wird die server.p12-Datei im pkcs-Format erstellt. 
  3. Nun importieren Sie es in den *.jks-Dateilauf:

keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 - destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass vorhandenejavastorepassword -destkeypassest vorhandenejavastorepassword

(Sehr wichtig - lassen Sie den Deststorepass und die Destkeypass-Parameter nicht aus.)
5. Sie werden nach dem Kennwort für den Schlüsselspeicher von src gefragt. Geben Sie Aragorn ein und drücken Sie die Eingabetaste .. Das Zertifikat und der Schlüssel werden nun in Ihren vorhandenen Java-Keystore importiert. 

4
vanval

In früheren Antworten wird richtig darauf hingewiesen, dass Sie dies nur mit den Standard-JDK-Tools tun können, indem Sie die JKS-Datei zuerst in das PKCS # 12-Format konvertieren. Wenn Sie interessiert sind, habe ich ein kompaktes Dienstprogramm zusammengestellt, um von OpenSSL abgeleitete Schlüssel in einen JKS-formatierten Schlüsselspeicher zu importieren, 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 folgendermaßen verwenden:

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

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

$ 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
3
Joshua Davies

Wenn Sie eine PEM-Datei haben (z. B. server.pem), die Folgendes enthält:

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

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

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

2 ) Kopiere das cert aus der PEM-Datei in eine ASCII-Datei (z. B. server.crt)

3 ) Exportiere das cert 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 -CAfile-Option verwendet werden .
  • sie werden aufgefordert, ein Exportkennwort einzugeben.
  • wenn Sie dies in git bash tun, fügen Sie am Anfang des Befehls winpty 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 srcstorepass-Passwort sollte mit dem Export-Passwort aus Schritt 3 übereinstimmen.
2
Joman68

Was ich erreichen wollte, war, den bereits bereitgestellten privaten Schlüssel und das Zertifikat zum Signieren der Nachricht zu verwenden, um sicherzustellen, dass die Nachricht von mir stammt (private Schlüssel signieren, 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 eine .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 eine Zeichenfolge mit diesem Schlüssel 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 einen 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. Wie Zeichenfolge mit privatem Schlüssel signieren

Abschlussprogramm

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));
}
2
Mwa Joe

Verwenden von Let's Encrypt-Zertifikaten

Angenommen, Sie haben Ihre Zertifikate und privaten Schlüssel mit Let's Encrypt in /etc/letsencrypt/live/you.com erstellt:

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.pem und Ihren privaten Schlüssel privkey.pem in einer einzigen Datei, pkcs.p12.

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

Die Option export gibt an, dass eine PKCS # 12-Datei erstellt und nicht analysiert wird (from the manual ).

2. Erstellen Sie den Keystore Java

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

Wenn keystore.jks nicht existiert, wird es mit der oben erstellten pkcs.12 -Datei erstellt. Andernfalls importieren Sie pkcs.12 in den vorhandenen Keystore.


Diese Anweisungen stammen von diesem Blog-Beitrag .

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

1
Matthias Braun

in einem Fall von Elliptic Curve und beantworten Sie die Frage importieren Sie ein vorhandenes x509-Zertifikat und einen privaten Schlüssel im Java-Keystore , möchten Sie vielleicht auch einen Blick auf diesen Thread werfen Wie liest man den privaten EC-Schlüssel in Java? ist im .pem-Dateiformat

0
dilbertside

Erstellen Sie einfach einen PKCS12-Keystore, Java kann ihn jetzt direkt verwenden. Wenn Sie einen Java-Keystore auflisten, weist keytool Sie 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 Zertifikatsanbieter erhalten haben. Ich bin nicht sicher, was "-caname root" eigentlich bedeutet, aber es scheint so zu sein.

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

KeyStore.getInstance("PKCS12")

Ich habe dafür gesorgt, dass mein von comodo.com ausgestelltes SSL-Zertifikat in NanoHTTPD einwandfrei funktioniert.

0
Stefan Reich