等保2.0下RSA+AES混合加密与防重放攻击实践

乱世佳人断佳话

1. 等保2.0背景与安全需求解析

在当前的网络安全环境下，单纯依赖传输层加密已经无法满足高安全等级系统的防护需求。等保2.0标准对数据传输提出了更高要求，主要体现在以下三个方面：

数据保密性：要求采用密码技术保证重要数据在传输过程中的保密性
数据完整性：要求采用校验技术或密码技术保证重要数据在传输过程中的完整性
防重放攻击：要求具备防止数据包被恶意重复利用的机制

提示：虽然HTTPS提供了传输层的加密，但应用层仍然需要额外的安全措施。这是因为：

服务器端的TLS终止可能导致数据在内部网络中明文传输

某些中间人攻击可能绕过TLS验证

需要防范内部人员的恶意行为

2. 技术方案设计与选型

2.1 混合加密机制：RSA + AES

我们采用非对称加密（RSA）与对称加密（AES）相结合的方案，充分发挥两种加密方式的优势：

RSA用于密钥交换（2048位）
- 客户端生成随机AES密钥
- 使用服务端公钥加密AES密钥
- 服务端用私钥解密获取AES密钥
AES用于数据加密（256位CBC模式）
- 加密效率高，适合大数据量
- 每次会话使用不同的密钥
- 添加IV（初始化向量）增强安全性

java复制// RSA密钥对生成示例
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
KeyPair keyPair = keyPairGenerator.generateKeyPair();

2.2 数字签名与验签流程

为确保数据完整性，我们采用SHA256withRSA签名算法：

签名生成：
- 对请求参数按字典序排序
- 拼接成待签名字符串
- 使用私钥进行签名
验签过程：
- 服务端按相同规则生成待验签字符串
- 使用公钥验证签名
- 签名不匹配则拒绝请求

2.3 防重放攻击设计

我们组合使用时间戳和随机Nonce来防止重放攻击：

时间戳校验：
- 请求必须包含当前时间戳
- 服务端校验时间差在允许范围内（默认5分钟）
Nonce机制：
- 每次请求生成唯一随机字符串
- 服务端缓存已使用的Nonce
- 重复Nonce直接拒绝

java复制// 防重放校验逻辑示例
public boolean checkReplayAttack(String nonce, long timestamp) {
    // 检查时间戳有效性
    if (Math.abs(System.currentTimeMillis() - timestamp) > TIME_TOLERANCE) {
        return false;
    }
    
    // 检查Nonce是否已使用
    if (nonceCache.contains(nonce)) {
        return false;
    }
    
    nonceCache.add(nonce);
    return true;
}

3. Spring Boot实现详解

3.1 项目结构与依赖配置

建议采用以下项目结构：

code复制src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── example/
│   │           ├── config/        # 安全配置类
│   │           ├── annotation/    # 自定义注解
│   │           ├── aspect/        # AOP切面
│   │           ├── util/          # 加密工具类
│   │           └── Application.java
│   └── resources/
│       └── application.yml

Maven依赖配置：

xml复制<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 加密相关 -->
    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.70</version>
    </dependency>
    
    <!-- 其他必要依赖... -->
</dependencies>

3.2 核心实现类解析

3.2.1 加密注解设计

java复制@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SecurityOperation {
    boolean encrypt() default true;  // 是否启用加密
    boolean sign() default true;     // 是否验签
    long timeTolerance() default 300L; // 允许的时间偏差(秒)
}

3.2.2 拦截器实现

java复制public class SecurityInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        
        // 1. 解析注解配置
        SecurityOperation securityConfig = getSecurityConfig(handler);
        
        // 2. 解密请求体
        if (securityConfig.encrypt()) {
            String encryptedData = request.getParameter("data");
            String aesKeyEncrypted = request.getParameter("key");
            
            // RSA解密获取AES密钥
            String aesKey = RSAUtil.decrypt(aesKeyEncrypted, privateKey);
            
            // AES解密数据
            String rawData = AESUtil.decrypt(encryptedData, aesKey);
            
            // 替换请求参数
            request.setAttribute("decryptedData", parseData(rawData));
        }
        
        // 3. 验签
        if (securityConfig.sign()) {
            String signature = request.getHeader("X-Signature");
            boolean valid = verifySignature(request, signature);
            if (!valid) {
                response.sendError(HttpStatus.FORBIDDEN.value(), "Invalid signature");
                return false;
            }
        }
        
        // 4. 防重放校验
        String nonce = request.getHeader("X-Nonce");
        long timestamp = Long.parseLong(request.getHeader("X-Timestamp"));
        if (!nonceService.checkAndRecord(nonce, timestamp, securityConfig.timeTolerance())) {
            response.sendError(HttpStatus.FORBIDDEN.value(), "Possible replay attack");
            return false;
        }
        
        return true;
    }
    
    // 其他辅助方法...
}

3.2.3 加密工具类实现

java复制public class AESUtil {
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
    
    public static String encrypt(String data, String key) throws Exception {
        // 生成随机IV
        byte[] iv = new byte[16];
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        
        // 初始化Cipher
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, 
                   new SecretKeySpec(key.getBytes(), "AES"),
                   new IvParameterSpec(iv));
        
        // 执行加密
        byte[] encrypted = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        
        // 组合IV和密文
        byte[] combined = new byte[iv.length + encrypted.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(encrypted, 0, combined, iv.length, encrypted.length);
        
        return Base64.getEncoder().encodeToString(combined);
    }
    
    // 解密方法类似...
}

4. 性能优化与安全加固

4.1 性能优化策略

RSA密钥缓存：
- 客户端缓存服务端公钥
- 服务端定期（如24小时）更换密钥对
- 旧密钥保留一段时间用于解密历史数据
AES会话复用：
- 同一会话复用AES密钥
- 设置合理的会话超时时间
- 关键操作强制更换密钥
异步处理：
- 加解密操作放入独立线程池
- 使用Spring的@Async注解

java复制@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("SecurityAsync-");
        executor.initialize();
        return executor;
    }
}

4.2 安全加固措施

密钥管理：
- 使用HSM（硬件安全模块）保护主密钥
- 实现密钥轮换机制
- 不同环境使用不同密钥
日志审计：
- 记录所有加解密操作
- 监控异常验签失败
- 告警重复Nonce尝试
防降级攻击：
- 强制使用安全算法
- 禁用弱密码套件
- 防止协议回退

java复制// 安全算法白名单示例
public class SecurityAlgorithmPolicy {
    private static final Set<String> ALLOWED_CIPHERS = Set.of(
        "AES/CBC/PKCS5Padding",
        "RSA/ECB/OAEPWithSHA-256AndMGF1Padding"
    );
    
    public static void checkAlgorithm(String algorithm) {
        if (!ALLOWED_CIPHERS.contains(algorithm)) {
            throw new SecurityException("Forbidden algorithm: " + algorithm);
        }
    }
}

5. 测试与验证方案

5.1 单元测试设计

加密解密测试：
- 验证加密后再解密能得到原始数据
- 测试不同长度的输入数据
- 验证篡改密文后解密失败

java复制@Test
public void testAESEncryptionDecryption() throws Exception {
    String original = "Test data 123";
    String key = "ThisIsATestKey123";
    
    String encrypted = AESUtil.encrypt(original, key);
    String decrypted = AESUtil.decrypt(encrypted, key);
    
    assertEquals(original, decrypted);
}

@Test(expected = BadPaddingException.class)
public void testTamperedCiphertext() throws Exception {
    String original = "Sensitive data";
    String key = "SecureKey12345678";
    
    String encrypted = AESUtil.encrypt(original, key);
    // 篡改密文
    String tampered = encrypted.substring(0, 10) + "XX" + encrypted.substring(12);
    
    AESUtil.decrypt(tampered, key); // 应该抛出异常
}

5.2 集成测试要点

端到端测试场景：
- 正常加密请求验证
- 缺失签名头测试
- 过期时间戳测试
- 重复Nonce测试
- 参数篡改测试
性能测试指标：
- 单次加解密耗时
- 并发请求处理能力
- 不同数据大小的吞吐量

5.3 等保合规检查项

必备检查项：
- [ ] 验证数据传输加密功能
- [ ] 验证数据完整性保护
- [ ] 验证防重放机制
- [ ] 检查密钥管理策略
- [ ] 审计日志完整性验证
建议补充项：
- [ ] 渗透测试验证
- [ ] 第三方安全审计
- [ ] 灾难恢复演练

6. 常见问题与解决方案

6.1 性能瓶颈问题

问题现象：高并发时系统响应变慢，CPU使用率高

排查步骤：

使用Profiler工具分析热点
检查加解密操作耗时
评估线程池配置

解决方案：

启用硬件加速（如Intel AES-NI）
调整线程池参数
考虑异步处理非关键路径

6.2 签名验证失败

常见原因：

客户端和服务端参数排序规则不一致
时间同步问题
密钥不匹配

排查流程：

mermaid复制graph TD
    A[签名失败] --> B{检查时间戳}
    B -->|有效| C[验证参数排序]
    B -->|无效| D[检查时钟同步]
    C --> E[验证密钥版本]
    E --> F[检查签名算法]

6.3 跨平台兼容性问题

典型场景：

其他语言实现的客户端无法解密
特殊字符处理不一致
编码方式差异

解决方案：

制定统一的接口规范文档
提供多语言SDK
建立兼容性测试套件

注意：在实际部署时，建议先在小范围环境验证，确保各系统间的兼容性后再全量上线。

7. 进阶扩展方向

7.1 国密算法支持

为满足等保对密码算法的要求，可以增加国密算法支持：

SM2：替换RSA用于非对称加密
SM3：替换SHA用于哈希运算
SM4：替换AES用于对称加密

java复制// SM4加密示例
public class SM4Util {
    private static final String ALGORITHM = "SM4/ECB/PKCS5Padding";
    
    public static String encrypt(String data, String key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, 
                   new SecretKeySpec(key.getBytes(), "SM4"));
        byte[] encrypted = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }
}