दिलचस्प पोस्ट
दृश्य स्टूडियो में निर्माण करते समय सशर्त 32/64 बिट संदर्भ का उपयोग करें खोज आदेश के साथ regex का उपयोग कैसे करें? किसी सामग्री स्क्रिप्ट का उपयोग करके पृष्ठ संदर्भ में कोड डालें ईएक्स के उच्च बाइट्स में एक रजिस्टर क्यों नहीं है? <<से अधिक <<है? जावा में फंक्शन पॉइंटर MySQL में दो डेटासेट के बीच अंतर की गणना करें स्विफ्ट 2: कॉल फेंक सकता है, लेकिन यह 'कोशिश' के साथ चिह्नित नहीं है और त्रुटि का संचालन नहीं किया गया है Array.prototype और Object.prototype पर जावास्क्रिप्ट में विधि को परिभाषित करने के लिए कैसे करें ताकि यह लूप में दिखाई न दें `+:` और `-:` क्या है? क्या आप कॉन्फ़िग फ़ाइल का उपयोग करने के बजाय कोड में लॉग 4नेट को कॉन्फ़िगर कर सकते हैं? URL पैरामीटर बदलें मुख्य () में कॉलिंग मुख्य () में सी में HTML ईमेल में एक बेस 64 चित्र भेजें GET पैरामीटर का उपयोग किए बिना @ViewScoped सेम के बीच किसी वस्तु को पास करें

SSL में उपयोग करने के लिए जावा कीस्टोर में मौजूदा x509 प्रमाणपत्र और निजी कुंजी को कैसे आयात करें?

मेरे पास यह activemq config में है

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

मेरे पास x509 सर्ट और एक महत्वपूर्ण फ़ाइल है

मैं उन दोनों को एसएसएल और एसएसएल + स्टॉम्प कनेक्टर्स में कैसे उपयोग करूँ? सभी उदाहरणों से मैं हमेशा अपने आप को कुंजी उत्पन्न कर सकता हूं, लेकिन मेरे पास पहले से ही एक कुंजी है

मैं प्रयास कर चुका हूं

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

लेकिन यह केवल प्रमाणपत्र को आयात करता है, न कि कुंजी फ़ाइल और इसके परिणामस्वरूप

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.

मैंने प्रमाण और चाबी को जोड़ने की कोशिश की है लेकिन मुझे उसी परिणाम मिला है

मैं कुंजी कैसे आयात करूँ?

वेब के समाधान से एकत्रित समाधान "SSL में उपयोग करने के लिए जावा कीस्टोर में मौजूदा x509 प्रमाणपत्र और निजी कुंजी को कैसे आयात करें?"

मानो या नहीं, keytool ऐसी बुनियादी कार्यक्षमता प्रदान नहीं करता है जैसे कि कीस्टोर को निजी कुंजी आयात करना। आप PKSC12 फ़ाइल को एक कुंजीस्टोर में निजी कुंजी के साथ मर्ज करने के साथ इस समाधान को आज़मा सकते हैं।

या सिर्फ keytool.exe के बजाय keystore हैंडलिंग के लिए आईबीएम से अधिक उपयोगकर्ता-अनुकूल कुंजीमेन का उपयोग करें।

मैंने निम्नलिखित दो चरणों का इस्तेमाल किया जो मुझे अन्य उत्तरों में लिखे गए टिप्पणियों / पदों में मिला:

एक कदम: एक pkcs12 फ़ाइल में x509 सर्ट और कुंजी कन्वर्ट करें

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

नोट: सुनिश्चित करें कि आप p12 फ़ाइल पर एक पासवर्ड डालते हैं – अन्यथा जब आप इसे आयात करने का प्रयास करते हैं तो आपको एक रिक्त संदर्भ अपवाद मिलेगा (मामले में किसी और के लिए यह सिरदर्द था)। ( धन्यवाद जेक! )

नोट 2: आप पूर्ण प्रमाणपत्र श्रृंखला को संरक्षित करने के लिए- -chain विकल्प जोड़ना चाह सकते हैं। ( धन्यवाद मफुबा )

चरण दो: pkcs12 फ़ाइल को एक जावा कीस्टोर में कनवर्ट करें

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

ख़त्म होना

वैकल्पिक चरण शून्य, स्व-हस्ताक्षरित प्रमाणपत्र बनाएं

 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 

चीयर्स!

जावा 6 में कीटोलोल में यह क्षमता होती है: कुंजी टोल का उपयोग करके जावा कीस्टोर में निजी कुंजी को आयात करना

यहां उस पोस्ट से मूल विवरण दिए गए हैं

  1. OpenSSL का उपयोग करके मौजूदा प्रमाणपत्र को पीकेएसीएसए 12 में परिवर्तित करें। पूछे जाने पर पासवर्ड की आवश्यकता होती है या दूसरा चरण शिकायत करेगा।

    openssl pkcs12 -export -in [my_certificate.crt] -किनी [my_key.key] -out [keystore.p12] -नाम [new_alias] -कफ़ाइल [my_ca_bundle.crt] -केनाम रूट

  2. पीकेसीएस 12 को जावा कीस्टोर फाइल में कनवर्ट करें

    keytool -importkeystore -deststorepass [new_keystore_pass] -destkeypass [new_key_pass] -destkeystore [keystore.jks] -srckeystore [keystore.p12] -srcstoretype पीकेसीएस 12 -एसआरसीस्टोरपास [pass_used_in_p12_keystore] -alias [alias_used_in_p12_keystore]

एक और:

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

हां, यह वास्तव में एक दुखद तथ्य है कि कुंजी टोल के पास निजी कुंजी आयात करने की कोई कार्यक्षमता नहीं है।

रिकॉर्ड के लिए, अंत में मैं यहाँ वर्णित समाधान के साथ गया था

मेरे मामले में मेरे पास एक पेम फ़ाइल थी जिसमें पारस्परिक SSL प्रमाणीकरण में दो प्रमाण पत्र और एन्क्रिप्टेड निजी कुंजी का उपयोग किया गया था। तो मेरी पीम फ़ाइल इस तरह दिखती है:

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

मैंने जो किया था यह रहा:

फ़ाइल को तीन अलग-अलग फ़ाइलों में विभाजित करें, ताकि "— BEGIN" से शुरु होने और "— END .." लाइनों के साथ समाप्त होने पर प्रत्येक में केवल एक प्रविष्टि हो। मान लें कि हमारे पास अब तीन फाइलें हैं: cert1.pem cert2.pem और pkey.pem

पीईसीपीईम को डीईआर प्रारूप में एक्सप्लॉम्सएल और निम्न सिंटैक्स का उपयोग कर कनवर्ट करें:

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

ध्यान दें, यदि निजी कुंजी को एन्क्रिप्ट किया गया है, तो आपको डीईआर प्रारूप में कनवर्ट करने के लिए पासवर्ड (मूल पेम फ़ाइल के सप्लायर से प्राप्त करें) की आवश्यकता है, openssl आपको इस तरह से पासवर्ड के लिए कहता है: "पाकी के लिए एक पास फ़्राज़ दर्ज करें .पीम: "यदि रूपांतरण सफल हुआ है, तो आपको" पाकी.डर "नामक एक नई फ़ाइल मिलेगी।

एक नया जावा कुंजी स्टोर बनाएं और निजी कुंजी और प्रमाणपत्र आयात करें:

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

(वैकल्पिक) अपनी नई कुंजी स्टोर की सामग्री को सत्यापित करें:

keytool -list -keystore mykeystore -storepass password

कीस्टोर प्रकार: जेकेएस कीस्टॉर प्रदाता: एसएनआई

आपके keystore में 3 प्रविष्टियां हैं

cn = …, ou = …, o = .., 2 सितंबर, 2014, विश्वसनीय क्रिस्टेंट, प्रमाणपत्र फिंगरप्रिंट (एसएचए 1): 2 सी: बी 8: …

importkey, 2 सितंबर, 2014, निजीकिएन्ट्री, प्रमाणपत्र फ़िंगरप्रिंट (एसएचए 1): 9 सी: बी 0: …

सीएन = …, ओ = …., 2 सितंबर, 2014, विश्वसनीय क्रर्ट एंटर, प्रमाणपत्र फिंगरप्रिंट (एसएचए 1): 83:63: …

(वैकल्पिक) अपने SSL सर्वर से अपनी नई कुंजी स्टोर से अपने प्रमाण पत्र और निजी कुंजी का परीक्षण करें: (आप वीएम विकल्प के रूप में डीबगिंग को सक्षम करना चाहें: -Djavax.net.debug = सभी)

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

आखिरकार अपने प्रमाण पत्र को एचटीपीएसयूआरएल कनेक्शन के साथ रजिस्टर करें यदि इसका इस्तेमाल करने की योजना है:

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

ऊपर दिए गए उत्तरों के आधार पर, यहां अपने जावा आधारित वेब सर्वर के लिए एक नया कीस्टोर बनाने का तरीका बताया गया है, जो एक स्वतंत्र रूप से निर्मित कॉमोडो प्रमाणपत्र और निजी कुंजी का उपयोग करके कीटोल (जेडीके 1.6+ की आवश्यकता है)

  1. इस आदेश को जारी करें और पासवर्ड प्रॉम्प्ट पर कुछ पाई दर्ज करें – 'server.crt' आपके सर्वर का प्रमाण है और 'server.key' निजी कुंजी है जिसे आपने सीएसआर जारी करने के लिए उपयोग किया था: openssl pkcs12 -export -in server.crt -inkey सर्वर कुंजी-आउट सर्वर.p12 -name http://www.yourdomain.com -एफ़ाफ़ाइल AddTrustExternalCARoot.crt -किंवा "अतिरिक्त विदेशी सीए रूट"

  2. फिर जेएम कीस्टस्टोर में पी 12 कीस्टस्टोर को कन्वर्ट करने के लिए मुख्य टोल का उपयोग करें : मुख्य टोल -इमपोर्टकीस्टोर-डिस्टस्टोरपास एपरेस्ट -डस्टकैपस एपपास -डेस्टस्टोरस्टोर keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

फिर कॉमोडो से प्राप्त अन्य दो रूट / मध्यवर्ती नोटिस आयात करें:

  1. keytool -import -trustcacerts -alias cert1-फ़ाइल COMODORSAAddTrustCA.crt -keystore keystore.jks

  2. keytool -import -trustcacerts -alias cert2 -फ़ाइल COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks

पिछली उत्तर सही ढंग से इंगित करते हैं कि आप जेकेडीके फ़ाइल को केवल पीकेसीएस # 12 प्रारूप में पहली बार परिवर्तित करके मानक जेडीके उपकरण के साथ ही कर सकते हैं। यदि आप रुचि रखते हैं, तो मैं एक साथ जेएस-प्रारूपित कीस्टोर में ओपनएसएसएल-व्युत्पन्न कुंजियों को आयात करने के लिए एक कॉम्पैक्ट उपयोगिता रखता हूं, बिना कीस्टोर को पीकेसीएस # 12 में परिवर्तित करने के लिए: http://commandlinefanatic.com/cgi-bin/showarticle cgi? लेख = art049

आप इस तरह से लिंक्ड उपयोगिता का उपयोग करेंगे:

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

(सीएसआर पर हस्ताक्षर करें, वापस स्थानीयहोस्ट करें।)

 $ 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 

पहले p12 में परिवर्तित करें:

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

पी 12 से नया जेएसके बनाएं:

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

यहाँ एक मौजूदा कुंजीस्टोर की कुंजी को आयात करने के लिए मैंने जो कदम उठाए हैं – यहां दिए गए उत्तर और अन्य स्थानों से संयुक्त निर्देशों से ये कदम उठाए गए हैं जो मेरे जावा कीस्टस्टोर के लिए काम करते हैं:

  1. रन

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

(यदि आवश्यक हो तो-चेन विकल्प डाल दिया। मेरे लिए असफल रहने के लिए)। यह पासवर्ड के लिए पूछेगा – आपको सही पासवर्ड देना होगा आपको एक त्रुटि मिल जाएगी (शीर्ष त्रुटि या पैडिंग त्रुटि आदि)

  1. यह आपको एक नया पासवर्ड दर्ज करने के लिए कहेंगे – आपको यहां एक पासवर्ड दर्ज करना होगा – कुछ भी दर्ज करें लेकिन इसे याद रखें। (हमें लगता है कि आप Aragorn दर्ज करें)।
  2. यह pkcs प्रारूप में server.p12 फ़ाइल बनाएगा।
  3. अब इसे *.jks फ़ाइल चलाने में आयात करने के लिए:

keytool -importkeystore -srckeystore server.p12 -srcstoretype pkcs12 -destkeystore yourexistingjavakeystore.jks- डिस्टस्टोरप्रकार jks- मौजूदास्टाइलस्टस्टोरपासजवासस्टोर पासवर्ड -destkeypass मौजूदा javastorepassword

(बहुत ज़रूरी – डेस्टॉरेऔर और डिस्टैपर पैरामीटर नहीं छोड़ें।)
5. यह आपको एसआरसी कुंजी स्टोर पासवर्ड के लिए पूछेगा। एग्रॉर्न दर्ज करें और दर्ज करें दबाएं प्रमाणपत्र और कुंजी अब आपके मौजूदा जावा कीस्टोर में आयात की जाती है