ओएसएसएसएसएस

Question

के साथ या बिना एसएसएल .pem को .p12 में कनवर्ट करें I बाहरी .pem फ़ाइलों को .p12 फ़ाइलों में परिवर्तित करने की आवश्यकता है - मैं प्रक्रिया में उपयोगकर्ता नाम और पासवर्ड जोड़ता हूं। (मैं यह करने के लिए किसी तीसरे पक्ष एपीआई का उपयोग करने की जरूरत है।)

openssl का उपयोग करना, आदेश है ...

openssl pkcs12 -export -in xxxx.pem -inkey xxxx.pem -out xxx.p12 -passout pas:newpassword -name "newname" 

मैं एक टर्मिनल सत्र से इस चला सकते हैं और यह पूरी तरह काम करता है।

हालांकि, मुझे अक्सर ऐसा करने की आवश्यकता होगी और जावा क्लास लिखा होगा जो इसे और अधिक संभालता है (मेरा आवेदन अधिकतर .jsp टॉमकैट और अपाचे के साथ है)। जब मैं Runtime.exec का उपयोग कर जावा से एक ही कमांड चलाने का प्रयास करता हूं, तो मुझे डरावना "यादृच्छिक स्थिति" त्रुटि (Using OpenSSL what does "unable to write 'random state'" mean?) में डरने में असमर्थ लगता है।

मुझे लगता है कि अंतर यह है कि, जब मैं जावा से चलाता हूं, तो उपयोगकर्ता "रूट" नहीं होता है।

तो, क्या कमांड लाइन प्रोग्राम (यानी openssl) निष्पादित करने के बजाए जावा लाइब्रेरी का उपयोग करके पेम से .p12 में कनवर्ट करने का एक बेहतर तरीका है?

अन्यथा, मुझे लगता है कि मुझे अपने सर्वर पर कुछ कॉन्फ़िगरेशन करने की आवश्यकता है। मुझे सर्वर पर कहीं भी .md फ़ाइल नहीं मिल रही है। केवल openssl.cnf फ़ाइल एक अजीब निर्देशिका में है (/etc/pki/tls)। क्या मुझे कहीं और openssl.cnf फ़ाइल बनाने की आवश्यकता है?

Answer 1

जावा में, Bouncycastle का उपयोग करें, लेकिन चेतावनी दी जाए, सीखना वक्र खड़ा है और दस्तावेज़ीकरण दुर्लभ है। मैं दृढ़ता से अनुशंसा करता हूं कि आप स्रोत वितरण

PemReader से प्रारंभ करें के उदाहरण के रूप में उपलब्ध उदाहरणों को देखें।

Answer 2

ऐसा करना चाहिए जो आप करना चाहते हैं (ऊपर दिए गए अनुसार बाउंसीकास्टल पीईएमआरडर का उपयोग करके) - एक पीईएम-एन्कोडेड निजी कुंजी + प्रमाणपत्र लें, और एक पीकेसीएस # 12 फ़ाइल आउटपुट करें। PKCS12 के लिए एक ही पासवर्ड का उपयोग करता है जिसका उपयोग निजी कुंजी की सुरक्षा के लिए किया गया था।

public static byte[] pemToPKCS12(final String keyFile, final String cerFile, final String password) throws Exception { 
    // Get the private key 
    FileReader reader = new FileReader(keyFile); 

    PEMReader pem = new PEMReader(reader, new PasswordFinder() { 
     @Override public char[] getPassword() { 
      return password.toCharArray(); 
     } 
    }); 

    PrivateKey key = ((KeyPair)pem.readObject()).getPrivate(); 

    pem.close(); 
    reader.close(); 

    // Get the certificate  
    reader = new FileReader(cerFile); 
    pem = new PEMReader(reader); 

    X509Certificate cert = (X509Certificate)pem.readObject(); 

    pem.close(); 
    reader.close(); 

    // Put them into a PKCS12 keystore and write it to a byte[] 
    ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
    KeyStore ks = KeyStore.getInstance("PKCS12"); 
    ks.load(null); 
    ks.setKeyEntry("alias", (Key)key, password.toCharArray(), new java.security.cert.Certificate[]{cert}); 
    ks.store(bos, password.toCharArray()); 
    bos.close(); 
    return bos.toByteArray(); 
} 

Answer 3

@MugglesMerriweather के जवाब के आधार पर, v1.51 के लिए एक अद्यतन संस्करण निम्नलिखित है:

public static byte[] convertPEMToPKCS12(final String keyFile, final String cerFile, 
     final String password) 
     throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException 
    { 
     // Get the private key 
     FileReader reader = new FileReader(keyFile); 

     PEMParser pem = new PEMParser(reader); 
     PEMKeyPair pemKeyPair = ((PEMKeyPair)pem.readObject()); 
     JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider("SC"); 
     KeyPair keyPair = jcaPEMKeyConverter.getKeyPair(pemKeyPair); 

     PrivateKey key = keyPair.getPrivate(); 

     pem.close(); 
     reader.close(); 

     // Get the certificate 
     reader = new FileReader(cerFile); 
     pem = new PEMParser(reader); 

     X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject(); 
     java.security.cert.Certificate X509Certificate = 
      new JcaX509CertificateConverter().setProvider("SC") 
       .getCertificate(certHolder); 

     pem.close(); 
     reader.close(); 

     // Put them into a PKCS12 keystore and write it to a byte[] 
     ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
     KeyStore ks = KeyStore.getInstance("PKCS12"); 
     ks.load(null); 
     ks.setKeyEntry("alias", (Key) key, password.toCharArray(), 
      new java.security.cert.Certificate[]{X509Certificate}); 
     ks.store(bos, password.toCharArray()); 
     bos.close(); 
     return bos.toByteArray(); 
    } 

Answer 4

जवाब मैं एक जावा 7 वर्ग है, जो एक बनाने के लिए सब कुछ संभालती बनाया के आधार पर वैध SSLContext। इसके अलावा यह आवश्यक श्रृंखला बनाता है। TODO: यदि आवश्यक हो तो ट्रस्टमैनगर।

public final class SSL_Context { 
    private static SSL_Context instance = new SSL_Context(); 

public static SSL_Context getInstance() { 
    return instance; 
} 

private SSLContext sslContext = null; 
private SSL_Context() { 
    try { 
     sslContext = generateSSLContext(); 
    } 
    catch (Exception e) 
    { 
     ErrorLogger.logException(e); 
    } 
} 

final private void dumpKeyStore(KeyStore keyStore) 
{ 
    try { 
     // List the aliases 
     Enumeration aliases = keyStore.aliases(); 
     for (; aliases.hasMoreElements();) { 
      String alias = (String) aliases.nextElement(); 

      // Does alias refer to a private key? 
      boolean a = keyStore.isKeyEntry(alias); 

      // Does alias refer to a trusted certificate? 
      boolean b = keyStore.isCertificateEntry(alias); 
      ErrorLogger.log(alias + " " + a + " " + b, 2); 
     } 
    } catch (Exception e) { 
     ErrorLogger.logException(e); 
    } 
} 


final private KeyStore convertPEMToPKCS12(final String keyAndPubFile, final String chainFile, final String password) { 
    try { 
     Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); 

     PrivateKey key; 
     Certificate pubCert; 

     try (FileReader reader = new FileReader(keyAndPubFile); 
      PEMParser pem = new PEMParser(reader)) { 
      PEMKeyPair pemKeyPair = ((PEMKeyPair) pem.readObject()); 
      JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider("BC"); 
      KeyPair keyPair = jcaPEMKeyConverter.getKeyPair(pemKeyPair); 
      key = keyPair.getPrivate(); 


      X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject(); 
      pubCert = new JcaX509CertificateConverter().setProvider("BC").getCertificate(certHolder); 
     } 

     // Get the certificates 
     try (FileReader reader = new FileReader(chainFile); 
      PEMParser pem = new PEMParser(reader)) { 

      //load all certs 
      LinkedList<Certificate> certsll = new LinkedList<>(); 
      X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject(); 
      do { 
       Certificate X509Certificate = new JcaX509CertificateConverter().setProvider("BC").getCertificate(certHolder); 
       certsll.add(X509Certificate); 
      } 
      while ((certHolder = (X509CertificateHolder) pem.readObject()) != null); 

      Certificate[] chain = new Certificate[certsll.size()+1]; 
      chain[0] = pubCert; 

      KeyStore ks = KeyStore.getInstance("PKCS12"); 
      ks.load(null); 

      int i = 1; 
      for (Certificate cert : certsll) { 
       ks.setCertificateEntry("chain" + i, cert); 
       chain[i] = ks.getCertificate("chain" + i); 
       i++; 
      } 

      ks.setKeyEntry("cert", key, password.toCharArray(), chain); 

      return ks; 
     } 
    } 
    catch (Exception e) 
    { 
     ErrorLogger.logException(e); 
    } 
    return null; 
} 

final private SSLContext generateSSLContext() 
{ 
    String keyStorePassword = ""; 
    try { 
     KeyStore keyStore = convertPEMToPKCS12("ssl/keyandcert.pem", "ssl/ca_bundle.crt", keyStorePassword); 
     SSLContext sslContext = SSLContext.getInstance("TLSv1"); 
     KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); 
     keyManagerFactory.init(keyStore, keyStorePassword.toCharArray()); 
     sslContext.init(keyManagerFactory.getKeyManagers(), null, new SecureRandom()); 
     return sslContext; 

    } catch (Exception e) { 
     ErrorLogger.logException(e); 
    } 
    return null; 
} 

final public SSLContext getContext() { 
    return sslContext; 
} 

final public static void main(String args[]) 
{ 
     getInstance().getContext(); 
} 

}