SSL'de kullanmak için Java anahtar deposunda mevcut bir X.509 sertifikası ve özel anahtarı nasıl içe aktarabilirim?


228

Bu bir ActiveMQ yapılandırmasında var:

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

Bir çift X.509 sertifikam ve bir anahtar dosyam var.

SSL ve SSL + stomp konektörlerinde kullanmak için bu ikisini nasıl içe aktarabilirim? Ben google tüm örnekleri her zaman anahtarı kendileri oluşturmak, ama zaten bir anahtar var.

denedim

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

ancak bu yalnızca sertifikayı içe aktarır, anahtar dosyasını değil

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.

Sertifikayı ve anahtarı bitiştirmeyi denedim ama aynı sonucu aldım.

Anahtarı nasıl alabilirim?


1
Bunu yapmak için aslında biraz kod yazmanız gerekir ve ayrıntılar içe aktarmaya çalıştığınız özel anahtarın biçimine bağlıdır. Anahtarınız ne biçim? Sahip olduğunuz anahtarı ve sertifikayı oluşturmak için kullandığınız araçları açıklayabilir misiniz?
erickson

Spring Boot ile iki yönlü SSL (istemci ve sunucu sertifikası) için bkz. Stackoverflow.com/a/59317888/548473
Grigory Kislin

Yanıtlar:


73

İster inanın ister inanmayın, keytool özel anahtarı anahtar deposuna almak gibi temel işlevleri sağlamaz. PKSC12 dosyasını özel anahtarla bir anahtar deposuna birleştirerek bu geçici çözümü deneyebilirsiniz .

Veya keytool.exe yerine anahtar deposu kullanımı için IBM'den daha kullanıcı dostu KeyMan kullanın.


11
CoverosGene'in cevap tuş takımına göre Java 6'dan beri destekliyor. Bu onun sağladığı bağlantı
Houtman

Değeri ne olursa olsun, bu konudaki tüm gürültü için en iyi bağlantı @ Matej'in
cloudsurfin

2
CoverosGene tarafından verilen cevabı takip ettim ve işe yaradı.
Robert3452

1
KeyMan benim için kullanıcı dostu görünmüyor.
Miscreant

15
Bozuk bağlantı. Lütfen çözümün ayrıntılarını doğrudan cevaba
ekleyin

536

Diğer cevaplarda yer alan yorumlarda / yayınlarda bulduğum aşağıdaki iki adımı kullandım:

Birinci adım: x.509 sertifikasını ve anahtarını bir pkcs12 dosyasına dönüştürün

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

Not: pkcs12 dosyasına bir şifre koyduğunuzdan emin olun - aksi takdirde içe aktarmaya çalıştığınızda boş bir işaretçi istisnası alırsınız. (Başkasının bu baş ağrısına sahip olması durumunda). ( Teşekkürler jocull! )

Not 2:-chain Tam sertifika zincirini koruma seçeneğini eklemek isteyebilirsiniz . ( Teşekkürler Mafuba )

İkinci adım: pkcs12 dosyasını bir Java anahtar deposuna dönüştürün

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

bitmiş

İSTEĞE BAĞLI Adım sıfır: Kendinden imzalı sertifika oluşturma

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

Şerefe!


12
P12 dosyasına bir şifre koyduğunuzdan emin olun - aksi takdirde içe aktarmaya çalıştığınızda boş bir referans istisnası alırsınız. (Vaka Başka birinin bu baş ağrısı vardı)
jocull

9
Benim durumumda birinci adımda seçenek -CAfile ca.crt -caname rootCA sertifikalarını doğru şekilde vermedi. Bunun yerine kullandım-certfile concatenedCAFiles.pem
dcernahoschi

11
-chainAnahtar deponuzda istiyorsanız, pfx / p12 dosyanıza tam sertifika zincirini dahil etmek için openssl ile argümanı kullanmayı unutmayın .
Mafuba

3
Bir Windows ortamında, pvk2pfx(VS cmdisteminde bulunan standart bir VS aracı ), a ile .pfxeşdeğer bir değer verir .p12. @ jocull'un tavsiyesi hala önemlidir; üzerine bir şifre koy. Gerek yok openssl.
Ben Mosher

9
Özellikle Tomcat için anahtar deposu ve anahtar parolalarının aynı olması şarttır . Bir içe aktardığınızda.p12 anahtarı.p12. aktardığınızda , orijinal Tomcat'in şifresi başarısız olur java.security.UnrecoverableKeyException: Cannot recover key. Başka bir deyişle: Eğer yürütmek gerekirse -deststorepass changeit -srcstorepass some-passwordile farklı şifreler, o zaman gerekir içerir -destkeypass changeit(aynı şifre ile -deststorepass)
Slav

127

Java 6'daki keytool şu özelliğe sahiptir: keytool kullanarak özel anahtarları Java anahtar deposuna içe aktarma

İşte bu yazının temel detayları.

  1. Varolan sertifikayı OpenSSL kullanarak PKCS12'ye dönüştürün. İstendiğinde bir şifre gerekir, aksi takdirde 2. adım şikayet edecektir.

    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. PKCS12'yi bir Java Anahtar Deposu Dosyasına dönüştürün.

    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]

4
@Reto tarafından verilen cevap bu bağlantının içeriğini içerir.
Mafuba

4
@Mafuba tarafından belirtildiği gibi, yine de openssl gibi java olmayan bir araçla ayrı bir pkcs12 anahtar deposu oluşturmanız gerekir - daha sonra bu, reto tarafından yanıtta belirtildiği gibi keytool tarafından bir jks mağazasına içe aktarılabilir.
Mister_Tom

Bunu iyi cevaplayan bir şey, giriş sertifikalarının parantez içinde açıkça belirtilmiş olmasıdır.
Mr.Budris

FWIW, 1. adımda çıktısı zaten (- Eğer sürece adım 2 gerekmeyebilir yüzden bir Java keystore'da olarak kullanılabilir olmalıdır yapmak bir içine sertifika + anahtarını almak için gereğini mevcut zaten @ jaco0646 tarafından bir önceki cevapta belirtildiği şekilde - keystore'da)
Janaka Bandara

9

Ve bir tane daha:

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

İlk önce p12'ye dönüştürün:

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

P12'den yeni JKS oluşturun:

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

7

Evet, tuş takımının özel bir anahtarı içe aktaracak işlevselliği olmadığı üzücü bir gerçektir.

Kayıt için, sonunda burada açıklanan çözümle gittim


6

Benim durumumda, iki sertifika içeren bir pem dosyası ve karşılıklı SSL kimlik doğrulamasında kullanılacak şifreli bir özel anahtarım vardı. Pem dosyam şöyle görünüyordu:

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

İşte yaptım:

Dosyayı üç ayrı dosyaya bölün, böylece her biri "--- BEGIN .." ile başlayıp "--- END .." satırlarıyla biten tek bir giriş içerir. Şimdi üç dosyamız olduğunu varsayalım: cert1.pem cert2.pem ve pkey.pem

Openssl ve aşağıdaki sözdizimini kullanarak pkey.pem dosyasını DER biçimine dönüştürün:

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

Özel anahtar şifrelenirse, DER biçimine dönüştürmek için bir şifre girmeniz (orijinal pem dosyasının sağlayıcısından edinmeniz) gerektiğini unutmayın, openssl sizden şu şifreyi soracaktır: "pkey için bir geçiş ifadesi girin .pem: "Dönüştürme başarılı olursa," pkey.der "adlı yeni bir dosya alırsınız

Yeni bir java anahtar deposu oluşturun ve özel anahtarı ve sertifikaları içe aktarın:

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

(isteğe bağlı) Yeni anahtar deponuzun içeriğini doğrulayın:

keytool -list -keystore mykeystore -storepass password

Anahtar deposu türü: JKS Anahtar deposu sağlayıcısı: SUN

Anahtar deponuz 3 giriş içeriyor

cn = ..., ou = ..., o = .., 2 Eyl 2014, güvenilirCertEntry, Sertifika parmak izi (SHA1): 2C: B8: ...

importkey, 2 Eyl 2014, PrivateKeyEntry, Sertifika parmak izi (SHA1): 9C: B0: ...

cn = ..., o = ...., 2 Eyl 2014, güvenilirCertEntry, Sertifika parmak izi (SHA1): 83:63: ...

(isteğe bağlı) Yeni anahtar deponuzdaki sertifikalarınızı ve özel anahtarınızı SSL sunucunuza karşı test edin: (Hata ayıklamayı VM seçeneği olarak etkinleştirmek isteyebilirsiniz: -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..

Son olarak, kullanmayı planlıyorsanız sertifikalarınızı HttpsURLConnection'a kaydedin:

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

Ancak Bruno bu ana bilgisayar adı doğrulayıcısının yanlış olduğunu belirtti: "Ana bilgisayar adı doğrulayıcınız yanlış, session.getPeerHost () sertifikadaki adı döndürmez, ancak bağlandığınız ad (yani urlHostName burada), bu yüzden her zaman Her zaman zaten doğruyorsun. - Bruno ". Ama benim için çalıştı, ama birileri bana iyi bir ana bilgisayar adı doğrulayıcı yazmak için gösterir eğer takdir ediyorum.
Interkot

1
Tabii ki sizin için "çalışacaktır", çünkü olması gerektiği zaman bile asla hata üretmeyecektir. HttpsURLConnectionKendinizinkini yazmaya çalışmak yerine varsayılan ana bilgisayar adı doğrulayıcısını bırakın . (Örneğinizle ilgili bir başka sorun da, her zaman iyi bir fikir olmayan bir anahtar deposu ve bir truststore ile aynı anahtar deposunu kullanmanızdır.)
Bruno

6

Let's Encrypt sertifikalarını kullanma

Let's Encrypt in ile sertifikalarınızı ve özel anahtarlarınızı oluşturduğunuz varsayılarak/etc/letsencrypt/live/you.com :

1. PKCS # 12 dosyası oluşturun

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

Bu, SSL sertifikanızı fullchain.pemve özel anahtarınızı privkey.pemtek bir dosyada birleştirir,pkcs.p12 .

İçin bir şifre girmeniz istenecek pkcs.p12 .

exportBir PKCS # 12 dosya oluşturulur ziyade (ayrıştırılan olacağını seçenek belirtir manuel ).

2. Java anahtar deposunu oluşturun

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

Eğer keystore.jksyoksa, o içeren oluşturulacak pkcs.12yukarıda oluşturulan dosyayı. Aksi takdirde, pkcs.12mevcut anahtar deposuna aktarırsınız .


Bu talimatlar bu blog yayınından türetilmiştir .

İşte farklı dosya türleri hakkında daha fazla bilgi /etc/letsencrypt/live/you.com/.


5

Yukarıdaki cevaplara dayanarak, bağımsız olarak oluşturulan bir Comodo sertifikası ve keytool kullanarak özel anahtardan java tabanlı web sunucunuz için nasıl yepyeni bir anahtar deposu oluşturacağınız aşağıda açıklanmıştır (JDK 1.6+ gerektirir)

  1. Bu komutu verin ve parola isteminde somepass girin - 'server.crt' sunucunuzun sertifikası ve 'server.key' CSR'yi vermek için kullandığınız özel anahtardır: 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. Ardından p12 anahtar deposunu bir jks anahtar deposuna dönüştürmek için keytool'u kullanın: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

Ardından Comodo'dan aldığınız diğer iki kök / ara sertifikayı içe aktarın:

  1. COMODORSAAddTrustCA.crt dosyasını içe aktarın: keytool -import -trustcacerts -alias cert1 -file COMODORSAAddTrustCA.crt -keystore keystore.jks

  2. COMODORSADomainValidationSecureServerCA.crt dosyasını içe aktarın: keytool -import -trustcacerts -alias cert2 -file COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks


4

Anahtarı mevcut bir anahtar deposuna almak için bu adımları kullanabilirsiniz. Talimatlar bu konudaki ve diğer sitelerdeki cevaplardan birleştirilmiştir. Bu talimatlar benim için çalıştı (java anahtar deposu):

  1. Çalıştırmak

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

(Gerekirse -chain seçeneğini koyun. Bu benim için başarısız oldu koymak). Bu parolayı soracaktır - doğru parolayı vermeniz gerekir, aksi takdirde bir hata alırsınız (başlık hatası veya dolgu hatası vb.).

  1. Sizden yeni bir şifre girmenizi isteyecektir - buraya bir şifre girmelisiniz - bir şey girin ama hatırlayın. (Aragorn'a girdiğinizi varsayalım).
  2. Bu, server.p12 dosyasını pkcs biçiminde oluşturur.
  3. Şimdi *.jksdosyayı çalıştırmak için:
    keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
    (Çok önemli - deststorepass ve destkeypass parametrelerini dışarıda bırakmayın.)
  4. Sizden src anahtar deposu şifresini soracaktır. Aragorn girin ve enter tuşuna basın. Sertifika ve anahtar şimdi mevcut java anahtar deponuza aktarıldı.

3

Önceki yanıtlar, JKS dosyasını önce PKCS # 12 formatına dönüştürerek bunu yalnızca standart JDK araçlarıyla yapabileceğinizi gösteriyor. İlgileniyorsanız, önce anahtar deposunu PKCS # 12'ye dönüştürmek zorunda kalmadan OpenSSL'den türetilen anahtarları JKS biçimli bir anahtar deposuna içe aktarmak için kompakt bir yardımcı program oluşturdum: http://commandlinefanatic.com/cgi-bin/showarticle. cgi? makale = art049

Bağlantılı yardımcı programı şu şekilde kullanırsınız:

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

(CSR'yi imzalayın, localhost.cer dosyasını geri alın)

$ 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

Sadece kendi kütüphanenize (veya yardımcı programınıza) bağlanmak iyi bir cevap değildir. Bağlantı kurmak, sorunu neden çözdüğünü açıklamak, bunu kullanarak kod sağlamak ve feragat etmek daha iyi bir yanıt verir. Bkz. Harici bir kaynağa topluluk dostu bir şekilde nasıl bağlanabilirim?
Mogsdad

"Feragat" ile ne demek istediğinizden emin değilim, ancak bir örnek ekledim.
Joshua Davies

Harika! Ret edilmesinin aracı Birlikte yaptığımız bağlantılı ürün veya hizmetin, kişiyle ilişkinizi bildirmek için "araya getirdiğim ..." - parçası geçerli değildi bu yüzden o, bir konserve açıklama var
Mogsdad

3

Aşağıdakileri server.pemiçeren bir PEM dosyanız varsa (örn. ):

  • güvenilir sertifika
  • özel anahtar

sonra sertifikayı ve anahtarı aşağıdaki gibi bir JKS anahtar deposuna aktarabilirsiniz:

1 ) Özel anahtarı PEM dosyasından bir ascii dosyasına kopyalayın (örn.server.key )

2 ) Sertifikayı PEM dosyasından bir ascii dosyasına kopyalayın (örn.server.crt )

3 ) Sertifikayı ve anahtarı bir PKCS12 dosyasına aktarın:

$ openssl pkcs12 -export -in server.crt -inkey server.key \
                 -out server.p12 -name [some-alias] -CAfile server.pem -caname root
  • PEM dosyası -CAfileseçeneğe argüman olarak kullanılabilir .
  • 'dışa aktar' şifresi girmeniz istenir.
  • bunu git bash içinde yapıyorsanız winpty, dışa aktarma şifresinin girilebilmesi için komutun başına ekleyin .

4 ) PKCS12 dosyasını bir JKS anahtar deposuna dönüştürün:

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit
  • srcstorepassşifre) 3. adımda ihracat şifresini aynı olmalıdır

3

Ne elde etmek çalışıyordum zaten iletinin benden geldiğinden emin olmak için gerekli bir yere gidiyor mesaj imzalamak için sağlanan özel anahtar ve sertifika kullanarak oldu (özel anahtarlar şifreleme sırasında özel anahtarlar işareti).

Eğer zaten bir .key ve .crt dosyanız varsa?

Bunu dene:

Adım 1: Anahtarı ve sertifikayı .p12 dosyasına dönüştürün

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

Adım 2: Anahtarı alın ve tek bir komutla bir .jsk dosyası oluşturun

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

Adım 3: Java'nızda:

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

Bu anahtarı kullanarak bazı dizeleri imzalamanız gerekiyorsa aşağıdakileri yapın:

Adım 1: Şifrelemek istediğiniz metni dönüştürün

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

Adım 2: Base64 kodlu özel anahtarı alın

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

Referanslar:

  1. SSL'de kullanmak için Java anahtar deposunda mevcut bir x509 sertifikası ve özel anahtarı nasıl içe aktarabilirim?
  2. http://tutorials.jenkov.com/java-cryptography/keystore.html
  3. http://www.java2s.com/Code/Java/Security/RetrievingaKeyPairfromaKeyStore.htm
  4. Özel anahtarla dize nasıl imzalanır

Final programı

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

1

Sadece bir PKCS12 anahtar deposu yapın, Java şimdi doğrudan kullanabilir. Aslında, Java tarzı bir anahtar deposunu listelerseniz, keytool'un kendisi PKCS12'nin artık tercih edilen format olduğu konusunda sizi uyarır.

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

Üç dosyayı da (server.crt, server.key, ca.crt) sertifika sağlayıcınızdan almış olmanız gerekir. "-Caname root" un gerçekten ne anlama geldiğinden emin değilim, ama bu şekilde belirtilmiş gibi görünüyor.

Java kodunda, doğru anahtar deposu türünü belirttiğinizden emin olun.

KeyStore.getInstance("PKCS12")

Comodo.com tarafından verilen SSL sertifikamın NanoHTTPD'de bu şekilde çalıştığını gördüm.


Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.