Spring Security 6.2 mTLS双向认证证书轮换无中断？X509CertRefresh与SSLContext重启

Spring Security 6.2 mTLS 双向认证证书轮换无中断方案：X509CertRefresh 与 SSLContext 重启

大家好，今天我们来探讨一个在生产环境中至关重要的话题：Spring Security 6.2 中 mTLS (Mutual TLS) 双向认证的证书轮换，并且要做到服务不中断。

mTLS 是一种安全机制，要求客户端和服务器端都必须提供有效的证书进行身份验证。这极大地增强了安全性，但也引入了一个复杂性：当证书过期或需要更新时，如何平滑地进行轮换，避免服务中断？

我们的目标是实现以下几点：

1. 证书自动刷新： 能够定期检查并加载新的证书。
2. 动态 SSLContext 更新： 在不重启应用的情况下，更新用于 mTLS 的 SSLContext。
3. 最小化中断： 在证书轮换期间，尽可能减少或消除对现有连接的影响。

为了实现这个目标，我们将采用以下关键技术：

• X509CertRefresh (自定义实现): 一个用于定期刷新 X.509 证书的类。
• SSLContext 重启: 动态更新服务器端使用的 SSLContext。
• Spring Security 配置: 利用 Spring Security 的配置，将刷新后的证书集成到 mTLS 认证流程中。

1. X509CertRefresh 的实现

首先，我们需要一个机制来定期检查并加载新的证书和密钥。 X509CertRefresh 类负责这个任务。 它会定期从指定的位置读取证书和密钥，并将其加载到 Java 的 KeyStore 和 TrustStore 中。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.TrustManagerFactory;
import lombok.extern.slf4j.Slf4j;

@Component
@Slf4j
public class X509CertRefresh {

    private static final String KEYSTORE_TYPE = "PKCS12";
    private static final String TRUSTSTORE_TYPE = "JKS";
    private static final String KEYSTORE_PASSWORD = "password"; // 生产环境需要更安全的密码
    private static final String TRUSTSTORE_PASSWORD = "password"; // 生产环境需要更安全的密码

    private String keystorePath = "path/to/keystore.p12";  // keystore 路径
    private String truststorePath = "path/to/truststore.jks";  // truststore 路径

    private KeyStore keyStore;
    private KeyStore trustStore;

    public X509CertRefresh() {
        try {
            loadKeyStore();
            loadTrustStore();
        } catch (Exception e) {
            log.error("Failed to load keystore or truststore during initialization", e);
            // 应用启动失败时，可以考虑抛出异常，阻止启动
            throw new RuntimeException("Failed to load keystore or truststore", e);
        }
    }

    @Scheduled(fixedRate = 60000) // 每分钟检查一次 (可配置)
    public void refreshCertificates() {
        try {
            log.info("Refreshing certificates...");
            loadKeyStore();
            loadTrustStore();
            log.info("Certificates refreshed successfully.");
        } catch (Exception e) {
            log.error("Failed to refresh certificates", e);
        }
    }

    private void loadKeyStore() throws KeyStoreException, IOException, CertificateException, NoSuchAlgorithmException {
        KeyStore ks = KeyStore.getInstance(KEYSTORE_TYPE);
        Path keyStoreFile = Paths.get(keystorePath);

        try (InputStream keyStoreStream = Files.newInputStream(keyStoreFile)) {
            ks.load(keyStoreStream, KEYSTORE_PASSWORD.toCharArray());
        } catch (IOException e) {
            log.error("Failed to load keystore from {}", keystorePath, e);
            throw e; // 重新抛出，确保刷新失败时能被捕获
        } catch (NoSuchAlgorithmException | CertificateException e) {
            log.error("Error loading keystore", e);
            throw e; // 重新抛出，确保刷新失败时能被捕获
        }

        this.keyStore = ks;
    }

    private void loadTrustStore() throws KeyStoreException, IOException, CertificateException, NoSuchAlgorithmException {
        KeyStore ts = KeyStore.getInstance(TRUSTSTORE_TYPE);
        Path trustStoreFile = Paths.get(truststorePath);

        try (InputStream trustStoreStream = Files.newInputStream(trustStoreFile)) {
            ts.load(trustStoreStream, TRUSTSTORE_PASSWORD.toCharArray());
        } catch (IOException e) {
            log.error("Failed to load truststore from {}", truststorePath, e);
            throw e; // 重新抛出，确保刷新失败时能被捕获
        } catch (NoSuchAlgorithmException | CertificateException e) {
            log.error("Error loading truststore", e);
            throw e; // 重新抛出，确保刷新失败时能被捕获
        }

        this.trustStore = ts;
    }

    public KeyStore getKeyStore() {
        return keyStore;
    }

    public KeyStore getTrustStore() {
        return trustStore;
    }
}

代码解释：

• @Component: 将该类标记为 Spring 组件，使其可以被 Spring 容器管理。
• @Slf4j: 使用 Lombok 自动生成 SLF4J Logger。
• @Scheduled(fixedRate = 60000): 使用 Spring 的 @Scheduled 注解，定义了一个定时任务，每分钟执行一次 refreshCertificates 方法。 这个时间间隔可以根据实际需求进行调整。
• loadKeyStore() 和 loadTrustStore(): 这两个方法负责从文件系统中加载 keystore 和 truststore。 它们使用 KeyStore.getInstance() 方法创建 KeyStore 对象，然后使用 ks.load() 方法从输入流中加载证书和密钥。 注意安全： keystore 密码应该存储在安全的地方，例如环境变量或配置管理工具中，而不是硬编码在代码中。
• getKeyStore() 和 getTrustStore(): 这两个方法返回加载的 KeyStore 和 TrustStore 对象。 这些对象将被用于创建 SSLContext。
• 异常处理: 代码包含详细的异常处理，确保在证书加载失败时能够记录错误信息并重新抛出异常。这对于诊断问题至关重要。
• 路径配置: keystorePath 和 truststorePath 变量定义了 keystore 和 truststore 文件的路径。 在实际部署中，这些路径应该通过配置文件进行配置。

2. 动态 SSLContext 更新

现在我们有了定期刷新证书的机制，接下来需要动态地更新用于 mTLS 的 SSLContext。 Spring Security 允许我们自定义 SSLContext，因此我们可以利用这一点来实现动态更新。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.KeyManagerFactory;

import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;

@Configuration
public class SSLContextConfig {

    @Autowired
    private X509CertRefresh x509CertRefresh;

    private SSLContext sslContext;

    @Bean
    public SSLContext sslContext() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        // 确保sslContext只被创建一次，后续的刷新通过更新其内部状态来实现。
        if (sslContext == null) {
            sslContext = createSSLContext();
        }
        return sslContext;
    }

    public SSLContext createSSLContext() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        KeyStore keyStore = x509CertRefresh.getKeyStore();
        KeyStore trustStore = x509CertRefresh.getTrustStore();

        // KeyManagerFactory
        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyManagerFactory.init(keyStore, "password".toCharArray()); // 使用你的 keystore 密码

        // TrustManagerFactory
        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustManagerFactory.init(trustStore);

        // SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        return sslContext;
    }

    // 在X509CertRefresh刷新证书后调用此方法来更新SSLContext。
    public void updateSSLContext() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        this.sslContext = createSSLContext();
    }

}

代码解释：

• @Configuration: 将该类标记为 Spring 配置类。
• @Autowired: 自动注入 X509CertRefresh 实例。
• sslContext(): 一个 @Bean 方法，用于创建和管理 SSLContext 实例。 关键点： 该方法使用了单例模式，确保只创建一次 SSLContext 实例。 后续的证书刷新操作将直接更新这个实例的内部状态，而不是创建新的实例。
• createSSLContext(): 该方法负责创建 SSLContext。 它从 X509CertRefresh 获取 KeyStore 和 TrustStore，然后使用 KeyManagerFactory 和 TrustManagerFactory 创建 KeyManagers 和 TrustManagers。 最后，它使用这些 Managers 初始化 SSLContext。
• updateSSLContext(): 此方法在 X509CertRefresh 刷新证书后被调用，用于更新 sslContext 实例。

3. Spring Security 配置集成

现在我们需要将动态更新的 SSLContext 集成到 Spring Security 的 mTLS 认证流程中。 这可以通过自定义 ServerHttpSecurity 来实现。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

import javax.net.ssl.SSLContext;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private SSLContext sslContext;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests(authorize -> authorize
                        .anyRequest().authenticated()
                )
                .x509(x509 -> x509
                        .subjectPrincipalRegex("CN=(.*?),")
                        .userDetailsService(userDetailsService())
                )
                .requiresChannel(channel -> channel
                        .anyRequest().requiresSecure() // 强制使用 HTTPS
                )
                .httpBasic().disable()
                .formLogin().disable();

        http.setSharedObject(SSLContext.class, sslContext); //  设置共享的 SSLContext

        return http.build();
    }

    @Bean
    public CustomUserDetailsService userDetailsService() {
        return new CustomUserDetailsService(); // 自定义 UserDetailsService
    }
}

代码解释：

• @EnableWebSecurity: 启用 Spring Security 的 Web 安全功能。
• filterChain(HttpSecurity http): 配置 HTTP 安全规则。
• x509(): 配置 X.509 客户端认证。
  • subjectPrincipalRegex(): 从客户端证书的 Subject Principal 中提取用户名。
  • userDetailsService(): 使用自定义的 UserDetailsService 来验证用户名。
• requiresChannel(): 强制所有请求使用 HTTPS。
• http.setSharedObject(SSLContext.class, sslContext): 关键点： 将我们动态更新的 SSLContext 设置为 HttpSecurity 的共享对象。 这样，Spring Security 就会使用这个 SSLContext 来进行 mTLS 握手。
• httpBasic().disable() 和 formLogin().disable(): 禁用了基本的 HTTP 认证和表单登录，只使用 mTLS 认证。
• CustomUserDetailsService: 一个自定义的 UserDetailsService，用于根据客户端证书中的信息加载用户信息。 你需要根据你的实际需求来实现这个类。

4. 协调刷新和更新：联动X509CertRefresh与SSLContextConfig

现在，我们需要确保在 X509CertRefresh 刷新证书后，SSLContextConfig 中的 SSLContext 能够得到更新。 这可以通过在 X509CertRefresh 中调用 SSLContextConfig 的 updateSSLContext() 方法来实现。

import org.springframework.beans.factory.annotation.Autowired;
// 省略其他 import
@Component
@Slf4j
public class X509CertRefresh {

    @Autowired
    private SSLContextConfig sslContextConfig; // 注入 SSLContextConfig

    // 省略其他代码

    @Scheduled(fixedRate = 60000)
    public void refreshCertificates() {
        try {
            log.info("Refreshing certificates...");
            loadKeyStore();
            loadTrustStore();
            sslContextConfig.updateSSLContext(); // 更新 SSLContext
            log.info("Certificates refreshed successfully.");
        } catch (Exception e) {
            log.error("Failed to refresh certificates", e);
        }
    }

    // 省略其他代码
}

代码解释：

• @Autowired: 自动注入 SSLContextConfig 实例。
• sslContextConfig.updateSSLContext(): 在 refreshCertificates() 方法中，在加载新的证书后，调用 SSLContextConfig 的 updateSSLContext() 方法来更新 SSLContext。

5. 自定义 UserDetailsService

CustomUserDetailsService 负责根据客户端证书中的信息加载用户信息。 你需要根据你的实际需求来实现这个类。 以下是一个简单的示例：

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.Collections;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //  根据客户端证书中的用户名加载用户信息。
        //  例如，你可以从数据库或配置文件中加载用户信息。
        //  这里只是一个简单的示例，直接创建一个 UserDetails 对象。

        if ("client".equals(username)) {
            return new User("client", "", Collections.emptyList()); // 用户名，密码（可以为空），权限列表
        } else {
            throw new UsernameNotFoundException("User not found: " + username);
        }
    }
}

代码解释：

• @Service: 将该类标记为 Spring 服务组件。
• loadUserByUsername(String username): 该方法根据用户名加载用户信息。 在这个示例中，如果用户名是 "client"，则创建一个 User 对象并返回。 否则，抛出一个 UsernameNotFoundException 异常。 你需要根据你的实际需求来实现这个方法。 例如，你可以从数据库或 LDAP 服务器中加载用户信息。

6. 测试与验证

完成以上配置后，你需要进行测试和验证，确保证书轮换能够正常工作，并且不会导致服务中断。

1. 准备测试证书： 创建两组证书，一组作为当前使用的证书，另一组作为即将轮换的证书。
2. 配置应用： 将当前使用的证书配置到应用程序中。
3. 模拟证书轮换： 将应用程序中的证书替换为即将轮换的证书。
4. 监控应用： 在证书轮换过程中，监控应用程序的连接和请求处理情况，确保没有出现中断或错误。
5. 验证新证书： 使用新的客户端证书连接到应用程序，确保可以成功进行 mTLS 认证。

7. 考虑事项与优化

• Keystore 密码安全: 绝对不要将 keystore 密码硬编码在代码中。 使用环境变量、配置文件或专门的密钥管理工具来存储密码。
• 证书存储位置: 选择一个安全且可靠的位置来存储证书文件。 考虑使用专门的证书管理系统。
• 监控和告警: 设置监控和告警系统，以便在证书即将过期或轮换失败时及时通知。
• 灰度发布: 在生产环境中进行证书轮换时，建议采用灰度发布的方式，逐步将流量切换到使用新证书的服务器。
• OCSP Stapling: 考虑启用 OCSP Stapling，以提高 mTLS 握手的性能。
• Session 管理: 确保Session可以正确的传递。
• 错误处理: 在生产环境中，需要更完善的错误处理机制，例如重试、回滚等。
• 日志记录: 记录详细的日志，方便排查问题。

代码示例总结

类名	描述	关键功能
X509CertRefresh	定时刷新 X.509 证书的组件	定期从文件系统加载 keystore 和 truststore，并使用 @Scheduled 注解触发刷新。提供 getKeyStore() 和 getTrustStore() 方法，供其他组件访问 KeyStore 和 TrustStore。
SSLContextConfig	配置和管理 SSLContext 的组件	创建和管理 SSLContext 实例，并使用 KeyManagerFactory 和 TrustManagerFactory 初始化 SSLContext。提供 updateSSLContext() 方法，用于在证书刷新后更新 SSLContext。
SecurityConfig	Spring Security 配置类	配置 HTTP 安全规则，启用 X.509 客户端认证，并强制使用 HTTPS。使用 http.setSharedObject(SSLContext.class, sslContext) 将动态更新的 SSLContext 设置为 HttpSecurity 的共享对象。
CustomUserDetailsService	自定义 UserDetailsService，用于加载用户信息	根据客户端证书中的信息加载用户信息。你需要根据你的实际需求来实现这个类，例如从数据库或 LDAP 服务器中加载用户信息。

一些值得注意的点

• 单例 SSLContext: 确保 SSLContext 只被创建一次，后续的刷新通过更新其内部状态来实现。
• 异常处理： 在生产环境中，需要完善的异常处理机制，例如重试、回滚等。
• 安全： Keystore 密码应该存储在安全的地方，而不是硬编码在代码中。

通过以上步骤，我们就可以实现 Spring Security 6.2 中 mTLS 双向认证的证书轮换，并且做到服务不中断。

关键在于维护一个单例的SSLContext实例，并通过定时任务更新其内部状态，同时确保Spring Security 使用这个单例实例。