如何从PEM证书和密钥构建SSLSocketFactory而无需转换为密钥库？

Question

我得到了一个自签名的客户端证书套件，用于通过HTTPS访问服务器。该套件由以下PEM文件组成：

1. client.crt（客户端证书）
2. client.key（客户端私钥）
3. ca.crt（CA证书）

解决此任务的一种方法是生成Java keystore：

1. 使用openssl将客户端证书和密钥转换为PKCS12 keystore
2. 使用keytool将CA证书导入存储库

然后使用以下类似代码来构建SSLSocketFactory实例：

InputStream stream = new ByteArrayInputStream(pksData);         
KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(stream, password);

KeyManagerFactory kmf = KeyManagerFactory.getInstance(
    KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keyStore, password.toCharArray());
KeyManager[] keyManagers = kmf.getKeyManagers();

TrustManagerFactory tmfactory = TrustManagerFactory.getInstance(
    TrustManagerFactory.getDefaultAlgorithm());
tmfactory.init(keyStore);
TrustManager[] trustManagers = tmfactory.getTrustManagers();

SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(keyManagers, trustManagers, null);
sslSocketFactory = sslContext.getSocketFactory();

... 这将在后面用于初始化 http 库。

所以我们获取一个 KeyStore，然后借助它来初始化 KeyManagers 和 TrustManagers，最后使用它们构建 SSLSocketFactory 实例。

问题是：是否有一种方法可以避免创建 keystore 文件，并且以某种方式使用 PublicKey 和 Certificate 实例构建 SSLSocketFactory（例如，可以使用 bouncycastle 的 PemReader 从 PEM 文件中获取）？

- Roman Puchkovskiy

---

不行。你必须构建一个PKCS#12或JKS密钥库。但是你不应该被给予私钥。你应该自己生成它。这里存在严重的安全问题。你的私钥不是私有的，所以谁给了你私钥就可以在法律意义上冒充你。不要这样做。 - user207421

是的，谢谢，我们知道应该自己生成私钥。但是我们在这里工作的机构规定了他们自己生成所有密钥并不听取任何人的意见：尽管这不是技术问题。 - Roman Puchkovskiy

Answer 1

结果发现仍需要构建KeyStore实例，但可以在内存中完成（从PEM文件作为输入开始），而无需使用通过keytool构建的中间密钥库文件。

要构建内存中的KeyStore，可以使用以下类似代码：

private static final String TEMPORARY_KEY_PASSWORD = "changeit";

private KeyStore getKeyStore() throws ConfigurationException {
    try {
        Certificate clientCertificate = loadCertificate(certificatePem);
        PrivateKey privateKey = loadPrivateKey(privateKeyPem);
        Certificate caCertificate = loadCertificate(caPem);

        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(null, null);
        keyStore.setCertificateEntry("ca-cert", caCertificate);
        keyStore.setCertificateEntry("client-cert", clientCertificate);
        keyStore.setKeyEntry("client-key", privateKey, TEMPORARY_KEY_PASSWORD.toCharArray(), new Certificate[]{clientCertificate});
        return keyStore;
    } catch (GeneralSecurityException | IOException e) {
        throw new ConfigurationException("Cannot build keystore", e);
    }
}

private Certificate loadCertificate(String certificatePem) throws IOException, GeneralSecurityException {
    CertificateFactory certificateFactory = CertificateFactory.getInstance("X509");
    final byte[] content = readPemContent(certificatePem);
    return certificateFactory.generateCertificate(new ByteArrayInputStream(content));
}

private PrivateKey loadPrivateKey(String privateKeyPem) throws IOException, GeneralSecurityException {
    return pemLoadPrivateKeyPkcs1OrPkcs8Encoded(privateKeyPem);
}

private byte[] readPemContent(String pem) throws IOException {
    final byte[] content;
    try (PemReader pemReader = new PemReader(new StringReader(pem))) {
        final PemObject pemObject = pemReader.readPemObject();
        content = pemObject.getContent();
    }
    return content;
}

private static PrivateKey pemLoadPrivateKeyPkcs1OrPkcs8Encoded(
        String privateKeyPem) throws GeneralSecurityException, IOException {
    // PKCS#8 format
    final String PEM_PRIVATE_START = "-----BEGIN PRIVATE KEY-----";
    final String PEM_PRIVATE_END = "-----END PRIVATE KEY-----";

    // PKCS#1 format
    final String PEM_RSA_PRIVATE_START = "-----BEGIN RSA PRIVATE KEY-----";
    final String PEM_RSA_PRIVATE_END = "-----END RSA PRIVATE KEY-----";

    if (privateKeyPem.contains(PEM_PRIVATE_START)) { // PKCS#8 format
        privateKeyPem = privateKeyPem.replace(PEM_PRIVATE_START, "").replace(PEM_PRIVATE_END, "");
        privateKeyPem = privateKeyPem.replaceAll("\\s", "");

        byte[] pkcs8EncodedKey = Base64.getDecoder().decode(privateKeyPem);

        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(new PKCS8EncodedKeySpec(pkcs8EncodedKey));

    } else if (privateKeyPem.contains(PEM_RSA_PRIVATE_START)) {  // PKCS#1 format

        privateKeyPem = privateKeyPem.replace(PEM_RSA_PRIVATE_START, "").replace(PEM_RSA_PRIVATE_END, "");
        privateKeyPem = privateKeyPem.replaceAll("\\s", "");

        DerInputStream derReader = new DerInputStream(Base64.getDecoder().decode(privateKeyPem));

        DerValue[] seq = derReader.getSequence(0);

        if (seq.length < 9) {
            throw new GeneralSecurityException("Could not parse a PKCS1 private key.");
        }

        // skip version seq[0];
        BigInteger modulus = seq[1].getBigInteger();
        BigInteger publicExp = seq[2].getBigInteger();
        BigInteger privateExp = seq[3].getBigInteger();
        BigInteger prime1 = seq[4].getBigInteger();
        BigInteger prime2 = seq[5].getBigInteger();
        BigInteger exp1 = seq[6].getBigInteger();
        BigInteger exp2 = seq[7].getBigInteger();
        BigInteger crtCoef = seq[8].getBigInteger();

        RSAPrivateCrtKeySpec keySpec = new RSAPrivateCrtKeySpec(modulus, publicExp, privateExp, prime1, prime2,
                exp1, exp2, crtCoef);

        KeyFactory factory = KeyFactory.getInstance("RSA");

        return factory.generatePrivate(keySpec);
    }

    throw new GeneralSecurityException("Not supported format of a private key");
}

这个想法来自于Programmatically Obtain KeyStore from PEM

- Roman Puchkovskiy

---

谢谢，这个解决方案适用于Java 8，但是在Java 11中，DerInputStream和DerValue不再可用。有没有什么合适的替代方法来解析“-----BEGIN RSA PRIVATE KEY----- * -----END RSA PRIVATE KEY-----”的内容？ - Hakan54

@Hakan54 我不确定这在法律上是否可以，但从技术上讲，您可以将整个 sun.security.util 包从 Java 8 复制到您自己的包中。此外，还有 https://github.com/AdoptOpenJDK/openjdk-jdk11/blob/master/src/java.base/share/classes/sun/security/util/DerInputStream.java，您可以从那里复制代码（或者使用 AdoptOpenJDK，可能会更好？） - Roman Puchkovskiy

Answer 2

我之前在面对类似的挑战时，在你的回答下留了个评论，现在我回来提供一个加载pem文件的替代方案。我已经将其制作成一个库，以便于我自己和其他人使用，详情请见：GitHub - SSLContext Kickstart 希望你会喜欢它 :)

添加以下依赖项：

<dependency>
    <groupId>io.github.hakky54</groupId>
    <artifactId>sslcontext-kickstart-for-pem</artifactId>
    <version>8.0.0</version>
</dependency>

pem文件可以使用以下代码片段加载：

var keyManager = PemUtils.loadIdentityMaterial("certificate-chain.pem", "private-key.pem");
var trustManager = PemUtils.loadTrustMaterial("some-trusted-certificate.pem");

var sslFactory = SSLFactory.builder()
          .withIdentityMaterial(keyManager)
          .withTrustMaterial(trustManager)
          .build();

var sslContext = sslFactory.getSslContext();
var sslSocketFactory = sslFactory.getSslSocketFactory();

回到你的主要问题，我也发现没有KeyStores是无法创建SSLSocketFactory的。而且，像你建议的那样，一个内存中的KeyStore对于这种情况非常适用。

- Hakan54