如何使用pfx、crt及key文件连接Java Spring Boot服务器

前提说明 #

你拿到的crt是服务器/客户端证书文件，pfx是包含证书链和私钥的PKCS12格式密钥库，key是单独的PEM格式私钥文件。以下提供两种常用实现方案，根据你的实际需求选择。

方案1：直接使用PFX文件构建SSL上下文 #

PFX文件已封装完整的证书和私钥，适合快速实现双向认证（服务器验证客户端证书）或单向认证（客户端信任服务器证书）。

代码实现 #

1. 工具类构建SSL上下文

import javax.net.ssl.SSLContext;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.security.KeyStore;

public class SSLContextBuilder {
    public static SSLContext buildFromPFX(String pfxFilePath, String pfxPassword) throws Exception {
        // 加载PFX密钥库
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(pfxFilePath)) {
            keyStore.load(fis, pfxPassword.toCharArray());
        }

        // 初始化密钥管理器（用于客户端身份认证）
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, pfxPassword.toCharArray());

        // 初始化信任管理器（信任服务器证书）
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(keyStore);

        // 创建并返回SSL上下文
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
        
        return sslContext;
    }
}

2. 在HTTP客户端中使用SSL上下文（以Spring RestTemplate为例）

import org.springframework.web.client.RestTemplate;
import org.springframework.http.client.SimpleClientHttpRequestFactory;

public class HttpsClient {
    public static void main(String[] args) throws Exception {
        // 替换为你的PFX路径和密码
        SSLContext sslContext = SSLContextBuilder.buildFromPFX("/opt/certs/client.pfx", "your-pfx-password");

        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setSslContext(sslContext);

        RestTemplate restTemplate = new RestTemplate(requestFactory);
        // 发起HTTPS请求
        String response = restTemplate.getForObject("https://your-spring-boot-server:443/api/test", String.class);
        System.out.println(response);
    }
}

方案2：使用CRT + KEY文件构建SSL上下文 #

若需单独使用证书和私钥文件，Java原生API不直接支持PEM格式的私钥加载，需借助BouncyCastle库转换处理。

步骤1：添加BouncyCastle依赖（Maven） #

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.70</version>
</dependency>

步骤2：工具类构建SSL上下文 #

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import javax.net.ssl.SSLContext;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileReader;
import java.security.KeyPair;
import java.security.KeyStore;
import java.security.Security;
import java.security.cert.X509Certificate;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
import org.bouncycastle.openssl.jcajce.JcaX509CertificateConverter;

public class PEMSSLContextBuilder {
    static {
        // 注册BouncyCastle安全提供者
        Security.addProvider(new BouncyCastleProvider());
    }

    public static SSLContext buildFromPEM(String crtFilePath, String keyFilePath, String keyPassword) throws Exception {
        // 加载CRT证书
        PEMParser certParser = new PEMParser(new FileReader(crtFilePath));
        X509Certificate certificate = new JcaX509CertificateConverter()
                .setProvider("BC")
                .getCertificate(certParser.readObject());
        certParser.close();

        // 加载KEY私钥
        PEMParser keyParser = new PEMParser(new FileReader(keyFilePath));
        KeyPair keyPair = new JcaPEMKeyConverter()
                .setProvider("BC")
                .getKeyPair(keyParser.readObject());
        keyParser.close();

        // 创建临时PKCS12密钥库，存入证书和私钥
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        keyStore.load(null, null);
        keyStore.setKeyEntry("client-alias", keyPair.getPrivate(), keyPassword.toCharArray(), new X509Certificate[]{certificate});

        // 初始化密钥管理器和信任管理器
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(keyStore, keyPassword.toCharArray());

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(keyStore);

        // 构建SSL上下文
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
        
        return sslContext;
    }
}

步骤3：在HTTP客户端中使用 #

和方案1的客户端代码一致，替换工具类方法即可。

额外配置与注意事项 #

1. 单向认证简化：如果仅需客户端信任服务器证书（无需服务器验证客户端），可跳过密钥管理器的初始化，仅配置信任管理器：

   sslContext.init(null, trustManagerFactory.getTrustManagers(), null);
   

2. Spring Boot应用配置：如果是在Spring Boot服务中配置HTTPS，可直接在application.properties中指定证书：

   server.ssl.key-store=classpath:client.pfx
   server.ssl.key-store-password=your-pfx-password
   server.ssl.key-store-type=PKCS12
   server.ssl.enabled=true
   

3. 生产环境注意：避免硬编码证书路径和密码，建议通过环境变量或配置中心读取；定期更新证书，确保文件权限安全（仅允许必要用户访问）。

内容的提问来源于stack exchange，提问作者nishchith rao