首页 文章

将PEM导入Java密钥库

提问于
浏览
107

我正在尝试连接到SSL服务器,这需要我对自己进行身份验证 . 为了在Apache MINA上使用SSL,我需要一个合适的JKS文件 . 但是,我只获得了一个.PEM文件 .

我如何从PEM文件创建JKS文件?

8 回答

  • 13

    首先,以DER格式转换证书:

    openssl x509 -outform der -in certificate.pem -out certificate.der
    

    之后,将其导入密钥库:

    keytool -import -alias your-alias -keystore cacerts -file certificate.der
    
  • 10

    如果您只想将PEM格式的证书导入密钥库,则keytool将完成以下任务:

    keytool -import -alias *alias* -keystore cacerts -file *cert.pem*
    
  • 7

    我开发了http://code.google.com/p/java-keyutil/,它直接将PEM证书导入Java密钥库 . 其主要目的是导入多部分PEM操作系统证书包,例如ca-bundle.crt . 这些通常包括keytool无法处理的标头

    </self promotion>
    
  • 44

    在我的情况下,我有一个pem文件,其中包含两个证书和一个用于相互SSL身份验证的加密私钥 . 所以我的pem文件看起来像这样:

    -----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.pemcert2.pempkey.pem .

    使用openssl和以下语法将 pkey.pem 转换为DER格式:

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

    请注意,如果私钥被加密,您需要提供密码(从原始pem文件的供应商处获取)以转换为DER格式, openssl 将要求您输入如下密码:“输入 pkey.pem 的密码: ” .

    如果转换成功,您将获得一个名为 pkey.der 的新文件 .

    创建一个新的Java密钥库并导入私钥和证书:

    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
    

    密钥库类型:JKS密钥库提供商:SUN

    您的密钥库包含3个条目:

    • cn = ...,ou = ...,o = ..,2014年9月2日,trustedCertEntry,证书指纹(SHA1):2C:B8:...

    • importkey,2014年9月2日,PrivateKeyEntry,证书指纹(SHA1):9C:B0:...

    • cn = ...,o = ....,2014年9月2日,trustedCertEntry,证书指纹(SHA1):83:63:...

    (可选)针对您的SSL服务器测试新密钥存储区中的证书和私钥:(您可能希望启用调试作为VM选项:-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..
    

    如果计划使用它,最后使用HttpsURLConnection注册您的证书:

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

    我总是忘记如何做到这一点,因为这是我偶尔会做的事情,这是一种可能的解决方案,它只是起作用:

    • 转到您喜欢的浏览器并从安全网站下载主证书 .

    • 执行以下两行代码:

    $ openssl x509 -outform der -in GlobalSignRootCA.crt -out GlobalSignRootCA.der
    $ keytool -import -alias GlobalSignRootCA -keystore GlobalSignRootCA.jks -file GlobalSignRootCA.der
    
    • 如果在Java SE环境中执行,请添加以下选项:
    $ java -Djavax.net.ssl.trustStore=GlobalSignRootCA.jks -Djavax.net.ssl.trustStorePassword=trustStorePassword -jar MyJar.jar
    
    • 或者将以下内容添加到java代码中:
    System.setProperty("javax.net.ssl.trustStore", "GlobalSignRootCA.jks");
    System.setProperty("javax.net.ssl.trustStorePassword","trustStorePassword");
    

    步骤2的另一个选项是仅使用 keytool 命令 . 贝娄是一个证书链的例子:

    $ keytool -import -file org.eu.crt -alias orgcrt -keystore globalsignrs.jks
    $ keytool -import -file GlobalSignOrganizationValidationCA-SHA256-G2.crt -alias globalsignorgvalca -keystore globalsignrs.jks
    $ keytool -import -file GlobalSignRootCA.crt -alias globalsignrootca -keystore globalsignrs.jks
    
  • 1

    如果您需要一种简单的方法来加载Java without having to deal with external tools (opensll, keytool) 中的PEM文件,这是我在 生产环境 中使用的代码:

    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.FileReader;
    import java.io.IOException;
    import java.security.KeyFactory;
    import java.security.KeyStore;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.PrivateKey;
    import java.security.cert.CertificateException;
    import java.security.cert.CertificateFactory;
    import java.security.cert.X509Certificate;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.net.ssl.KeyManager;
    import javax.net.ssl.KeyManagerFactory;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLServerSocketFactory;
    import javax.xml.bind.DatatypeConverter;
    
    public class PEMImporter {
    
        public static SSLServerSocketFactory createSSLFactory(File privateKeyPem, File certificatePem, String password) throws Exception {
            final SSLContext context = SSLContext.getInstance("TLS");
            final KeyStore keystore = createKeyStore(privateKeyPem, certificatePem, password);
            final KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            kmf.init(keystore, password.toCharArray());
            final KeyManager[] km = kmf.getKeyManagers();
            context.init(km, null, null);
            return context.getServerSocketFactory();
        }
    
        /**
         * Create a KeyStore from standard PEM files
         * 
         * @param privateKeyPem the private key PEM file
         * @param certificatePem the certificate(s) PEM file
         * @param the password to set to protect the private key
         */
        public static KeyStore createKeyStore(File privateKeyPem, File certificatePem, final String password)
                throws Exception, KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException {
            final X509Certificate[] cert = createCertificates(certificatePem);
            final KeyStore keystore = KeyStore.getInstance("JKS");
            keystore.load(null);
            // Import private key
            final PrivateKey key = createPrivateKey(privateKeyPem);
            keystore.setKeyEntry(privateKeyPem.getName(), key, password.toCharArray(), cert);
            return keystore;
        }
    
        private static PrivateKey createPrivateKey(File privateKeyPem) throws Exception {
            final BufferedReader r = new BufferedReader(new FileReader(privateKeyPem));
            String s = r.readLine();
            if (s == null || !s.contains("BEGIN PRIVATE KEY")) {
                r.close();
                throw new IllegalArgumentException("No PRIVATE KEY found");
            }
            final StringBuilder b = new StringBuilder();
            s = "";
            while (s != null) {
                if (s.contains("END PRIVATE KEY")) {
                    break;
                }
                b.append(s);
                s = r.readLine();
            }
            r.close();
            final String hexString = b.toString();
            final byte[] bytes = DatatypeConverter.parseBase64Binary(hexString);
            return generatePrivateKeyFromDER(bytes);
        }
    
        private static X509Certificate[] createCertificates(File certificatePem) throws Exception {
            final List<X509Certificate> result = new ArrayList<X509Certificate>();
            final BufferedReader r = new BufferedReader(new FileReader(certificatePem));
            String s = r.readLine();
            if (s == null || !s.contains("BEGIN CERTIFICATE")) {
                r.close();
                throw new IllegalArgumentException("No CERTIFICATE found");
            }
            StringBuilder b = new StringBuilder();
            while (s != null) {
                if (s.contains("END CERTIFICATE")) {
                    String hexString = b.toString();
                    final byte[] bytes = DatatypeConverter.parseBase64Binary(hexString);
                    X509Certificate cert = generateCertificateFromDER(bytes);
                    result.add(cert);
                    b = new StringBuilder();
                } else {
                    if (!s.startsWith("----")) {
                        b.append(s);
                    }
                }
                s = r.readLine();
            }
            r.close();
    
            return result.toArray(new X509Certificate[result.size()]);
        }
    
        private static RSAPrivateKey generatePrivateKeyFromDER(byte[] keyBytes) throws InvalidKeySpecException, NoSuchAlgorithmException {
            final PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
            final KeyFactory factory = KeyFactory.getInstance("RSA");
            return (RSAPrivateKey) factory.generatePrivate(spec);
        }
    
        private static X509Certificate generateCertificateFromDER(byte[] certBytes) throws CertificateException {
            final CertificateFactory factory = CertificateFactory.getInstance("X.509");
            return (X509Certificate) factory.generateCertificate(new ByteArrayInputStream(certBytes));
        }
    
    }
    

    玩得开心 .

  • 180

    还有一个GUI工具,允许可视化JKS创建和证书导入 .

    http://portecle.sourceforge.net/

    Portecle是一个用户友好的GUI应用程序,用于创建,管理和检查密钥库,密钥,证书,证书请求,证书撤销列表等 .

  • 3

    我是从网上得到的 . 它适用于包含多个条目的pem文件 .

    #!/bin/bash
    pemToJks()
    {
            # number of certs in the PEM file
            pemCerts=$1
            certPass=$2
            newCert=$(basename "$pemCerts")
            newCert="${newCert%%.*}"
            newCert="${newCert}"".JKS"
            ##echo $newCert $pemCerts $certPass
            CERTS=$(grep 'END CERTIFICATE' $pemCerts| wc -l)
            echo $CERTS
            # For every cert in the PEM file, extract it and import into the JKS keystore
            # awk command: step 1, if line is in the desired cert, print the line
            #              step 2, increment counter when last line of cert is found
            for N in $(seq 0 $(($CERTS - 1))); do
              ALIAS="${pemCerts%.*}-$N"
              cat $pemCerts |
                    awk "n==$N { print }; /END CERTIFICATE/ { n++ }" |
                    $KEYTOOLCMD -noprompt -import -trustcacerts \
                                    -alias $ALIAS -keystore $newCert -storepass $certPass
            done
    }
    pemToJks <pem to import> <pass for new jks>
    

相关问题