mTLS 双向 TLS#

import javax.net.ssl.*;
import java.security.*;
import java.security.cert.*;
import java.io.*;

public class MtlsServer {
    
    /**
     * 创建 mTLS 服务器 SSLContext
     */
    public SSLContext createServerSSLContext(
            String keyStorePath, 
            String keyStorePassword,
            String trustStorePath,
            String trustStorePassword) throws Exception {
        
        // 1. 创建 KeyManagerFactory
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(
            KeyManagerFactory.getDefaultAlgorithm());
        
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(keyStorePath)) {
            keyStore.load(fis, keyStorePassword.toCharArray());
        }
        kmf.init(keyStore, keyStorePassword.toCharArray());
        
        // 2. 创建 TrustManagerFactory
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        
        KeyStore trustStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(trustStorePath)) {
            trustStore.load(fis, trustStorePassword.toCharArray());
        }
        tmf.init(trustStore);
        
        // 3. 创建 SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), 
            new SecureRandom());
        
        return sslContext;
    }
    
    /**
     * 创建 mTLS HttpsURLConnection
     */
    public HttpsURLConnection createMtlsConnection(String url) throws Exception {
        SSLContext sslContext = createServerSSLContext(...);
        
        URL connectionUrl = new URL(url);
        HttpsURLConnection conn = (HttpsURLConnection) connectionUrl.openConnection();
        
        // 设置 SSL Socket Factory
        conn.setSSLSocketFactory(sslContext.getSocketFactory());
        
        // 启用客户端认证
        // （通过 SSLContext 配置自动完成）
        
        return conn;
    }
}

import javax.net.ssl.*;
import java.security.cert.*;
import java.security.*;
import java.net.*;

public class MtlsClient {
    
    /**
     * 创建 mTLS 客户端 SSLContext
     */
    public SSLContext createClientSSLContext(
            String clientKeyStorePath,
            String clientKeyPassword,
            String trustStorePath,
            String trustStorePassword) throws Exception {
        
        // 1. 加载客户端证书（用于认证）
        KeyManagerFactory kmf = KeyManagerFactory.getInstance("NewSunX509");
        KeyStore clientKeyStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(clientKeyStorePath)) {
            clientKeyStore.load(fis, clientKeyPassword.toCharArray());
        }
        kmf.init(clientKeyStore, clientKeyPassword.toCharArray());
        
        // 2. 加载受信任的 CA 证书（用于验证服务器）
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        KeyStore trustStore = KeyStore.getInstance("PKCS12");
        try (FileInputStream fis = new FileInputStream(trustStorePath)) {
            trustStore.load(fis, trustStorePassword.toCharArray());
        }
        tmf.init(trustStore);
        
        // 3. 初始化 SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
        
        return sslContext;
    }
    
    /**
     * 自定义 TrustManager（验证客户端证书）
     */
    public X509TrustManager createCustomTrustManager(
            X509Certificate... acceptedIssuers) {
        
        return new X509TrustManager() {
            
            @Override
            public void checkClientTrusted(X509Certificate[] chain, 
                    String authType) throws CertificateException {
                
                // 1. 验证证书链
                // 2. 验证证书有效期
                // 3. 验证证书用途
                // 4. 可选：检查吊销状态
                
                for (X509Certificate cert : chain) {
                    // 检查证书是否在有效期内
                    cert.checkValidity();
                    
                    // 检查证书是否由受信任的 CA 签发
                    // X500Principal issuer = cert.getIssuerX500Principal();
                    // ...
                }
            }
            
            @Override
            public void checkServerTrusted(X509Certificate[] chain, 
                    String authType) throws CertificateException {
                // 标准服务器证书验证
            }
            
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return acceptedIssuers;
            }
        };
    }
}

@Configuration
public class MtlsServerConfig {
    
    @Value("${server.ssl.key-store}")
    private String keyStorePath;
    
    @Value("${server.ssl.key-store-password}")
    private String keyStorePassword;
    
    @Value("${server.ssl.trust-store}")
    private String trustStorePath;
    
    @Value("${server.ssl.trust-store-password}")
    private String trustStorePassword;
    
    /**
     * 配置双向 TLS
     */
    @Bean
    public SSLContext sslContext() throws Exception {
        // 服务器密钥库（包含服务器证书和私钥）
        KeyStore serverKeyStore = KeyStore.getInstance("PKCS12");
        serverKeyStore.load(
            new FileInputStream(keyStorePath), 
            keyStorePassword.toCharArray()
        );
        
        // 服务器密钥管理器
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(
            KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(serverKeyStore, keyStorePassword.toCharArray());
        
        // 客户端信任库（包含受信任的客户端 CA）
        KeyStore trustStore = KeyStore.getInstance("PKCS12");
        trustStore.load(
            new FileInputStream(trustStorePath), 
            trustStorePassword.toCharArray()
        );
        
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(trustStore);
        
        // 创建 SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
        
        return sslContext;
    }
    
    @Bean
    public ServletWebServerFactory servletContainer() throws Exception {
        TomcatServletWebServerFactory factory = 
            new TomcatServletWebServerFactory();
        
        factory.setProtocol("org.apache.coyote.http11.Http11NioProtocol");
        factory.setSsl(sslContextProperties());
        
        return factory;
    }
    
    private Ssl sslContextProperties() {
        Ssl ssl = new Ssl();
        ssl.setEnabled(true);
        ssl.setKeyStore(keyStorePath);
        ssl.setKeyStorePassword(keyStorePassword);
        ssl.setTrustStore(trustStorePath);
        ssl.setTrustStorePassword(trustStorePassword);
        
        // 强制客户端认证
        ssl.setClientAuth(ClientAuth.NEED);
        
        // TLS 版本配置
        ssl.setEnabledProtocols(new String[]{"TLSv1.3", "TLSv1.2"});
        
        // 密码套件配置
        ssl.setCiphers(new String[]{
            "TLS_AES_256_GCM_SHA384",
            "TLS_AES_128_GCM_SHA256",
            "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"
        });
        
        return ssl;
    }
}

@RestController
@RequestMapping("/api")
public class ClientCertificateController {
    
    /**
     * 获取客户端证书信息
     * 用于业务逻辑中识别调用方
     */
    @GetMapping("/client-info")
    public ClientInfo getClientInfo(HttpServletRequest request) {
        
        X509Certificate[] clientCerts = 
            (X509Certificate[]) request.getAttribute(
                "jakarta.servlet.request.X509Certificate");
        
        if (clientCerts == null || clientCerts.length == 0) {
            throw new SecurityException("客户端证书未提供");
        }
        
        X509Certificate clientCert = clientCerts[0];
        
        return ClientInfo.builder()
            .subject(clientCert.getSubjectX500Principal().getName())
            .issuer(clientCert.getIssuerX500Principal().getName())
            .serialNumber(clientCert.getSerialNumber().toString())
            .validFrom(clientCert.getNotBefore())
            .validTo(clientCert.getNotAfter())
            .fingerprint(sha256Fingerprint(clientCert))
            .build();
    }
    
    /**
     * 验证客户端证书特定字段
     */
    @PostMapping("/secure-action")
    public ResponseEntity<?> secureAction(
            HttpServletRequest request,
            @RequestBody ActionRequest actionRequest) {
        
        X509Certificate[] clientCerts = 
            (X509Certificate[]) request.getAttribute(
                "jakarta.servlet.request.X509Certificate");
        
        X509Certificate clientCert = clientCerts[0];
        
        // 1. 验证证书序列号在白名单中
        if (!isCertificateAllowed(clientCert.getSerialNumber().toString())) {
            return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body("证书未授权");
        }
        
        // 2. 验证证书包含特定扩展（如 OID）
        if (!hasRequiredExtension(clientCert)) {
            return ResponseEntity.status(HttpStatus.FORBIDDEN)
                .body("证书缺少必要扩展");
        }
        
        // 3. 提取调用方身份
        String callerId = extractCallerId(clientCert);
        
        // 4. 执行业务逻辑
        return executeAction(callerId, actionRequest);
    }
    
    private String sha256Fingerprint(X509Certificate cert) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(cert.getEncoded());
            return Base64.getEncoder().encodeToString(digest);
        } catch (Exception e) {
            throw new RuntimeException("计算证书指纹失败", e);
        }
    }
}

public class PinnedCertificateTrustManager implements X509TrustManager {
    
    private final Set<String> pinnedPublicKeyHashes;
    private final X509TrustManager defaultTrustManager;
    
    public PinnedCertificateTrustManager(
            List<String> pinnedPublicKeyHashes,
            X509TrustManager defaultTrustManager) {
        this.pinnedPublicKeyHashes = new HashSet<>(pinnedPublicKeyHashes);
        this.defaultTrustManager = defaultTrustManager;
    }
    
    @Override
    public void checkServerTrusted(X509Certificate[] chain, String authType) 
            throws CertificateException {
        
        if (chain.length == 0) {
            throw new CertificateException("证书链为空");
        }
        
        // 1. 首先验证证书链的标准有效性
        defaultTrustManager.checkServerTrusted(chain, authType);
        
        // 2. 提取叶证书的公钥
        X509Certificate leafCert = chain[0];
        PublicKey publicKey = leafCert.getPublicKey();
        String publicKeyHash = sha256Base64(publicKey.getEncoded());
        
        // 3. 检查是否与固定值匹配
        if (!pinnedPublicKeyHashes.contains(publicKeyHash)) {
            // 固定不匹配，可能是中间人攻击
            throw new CertificateException(
                "服务器证书公钥与固定值不匹配，可能存在中间人攻击");
        }
    }
    
    @Override
    public void checkClientTrusted(X509Certificate[] chain, String authType) 
            throws CertificateException {
        defaultTrustManager.checkClientTrusted(chain, authType);
    }
    
    @Override
    public X509Certificate[] getAcceptedIssuers() {
        return defaultTrustManager.getAcceptedIssuers();
    }
    
    /**
     * 计算公钥的 SHA-256 哈希（Base64 编码）
     */
    private String sha256Base64(byte[] data) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(data);
            return Base64.getEncoder().encodeToString(hash);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("SHA-256 算法不可用", e);
        }
    }
}

@Service
@Slf4j
public class PinnedKeyManager {
    
    /**
     * 从配置文件加载固定值
     */
    @PostConstruct
    public void loadPinnedKeys() {
        String pinnedKeysConfig = environment.getProperty("security.pinned.keys");
        if (pinnedKeysConfig == null) {
            throw new IllegalStateException("未配置证书固定值");
        }
        
        // 解析固定值列表
        // 格式：公钥哈希，用逗号分隔
        String[] hashes = pinnedKeysConfig.split(",");
        for (String hash : hashes) {
            pinnedPublicKeyHashes.add(hash.trim());
        }
        
        log.info("已加载 {} 个证书固定值", pinnedPublicKeyHashes.size());
    }
    
    /**
     * 动态更新固定值（支持证书轮转）
     */
    public void updatePinnedKeys(List<String> newHashes) {
        log.info("更新证书固定值: {} -> {}", pinnedPublicKeyHashes, newHashes);
        pinnedPublicKeyHashes.clear();
        pinnedPublicKeyHashes.addAll(newHashes);
    }
}

@Configuration
public class MtlsSessionResumptionConfig {
    
    @Bean
    public SSLContext sslContext() throws Exception {
        // 配置会话恢复
        SSLContext sslContext = SSLContext.getInstance("TLSv1.3");
        
        // 设置会话缓存
        SSLSessionContext serverSessionContext = 
            sslContext.getServerSessionContext();
        serverSessionContext.setSessionCacheSize(10000);  // 缓存 10000 个会话
        serverSessionContext.setSessionTimeout(3600);   // 1 小时过期
        
        // 配置会话票据（0-RTT 恢复）
        // TLS 1.3 PSK 模式
        sslContext.init(...);
        
        return sslContext;
    }
}

@Service
@Slf4j
public class CertificateCacheService {
    
    private LoadingCache<String, X509Certificate> certCache;
    private LoadingCache<String, PublicKey> publicKeyCache;
    
    @PostConstruct
    public void initCaches() {
        // 证书缓存
        certCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(10))
            .build(cert -> loadCertificate(cert));
        
        // 公钥缓存
        publicKeyCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(10))
            .build(key -> loadPublicKey(key));
    }
    
    /**
     * 获取证书（带缓存）
     */
    public X509Certificate getCertificate(String serialNumber) {
        return certCache.get(serialNumber, this::loadCertificate);
    }
}

/**
 * 启用 OCSP Stapling 减少吊销检查延迟
 * 服务器在 TLS 握手时直接提供证书状态
 */
// Nginx 配置
// ssl_stapling on;
// ssl_stapling_verify on;
// ssl_trusted_certificate /path/to/ca.crt;