从攻击者视角看接口加密：基于 Spring Boot 的接口安全防护实践

2024年10月20日 818点热度 0人点赞 0条评论

引言

在现代分布式系统中，接口不仅是功能实现的枢纽，还肩负着数据交互的重任。然而，开放接口的同时也意味着暴露了一定程度的安全风险。随着网络攻击技术的不断演进，识别和防范接口的薄弱点成为每个开发者必须重视的内容。本文旨在深入探讨接口加密的必要性，通过分析攻击者如何利用这些薄弱点，并对防御策略进行探讨。

1. 从攻击者角度看接口的薄弱点

接口的设计原则通常倾向于开放和灵活，但这也成为攻击者的潜在攻击路径。探索这些薄弱点能帮助我们更好地理解如何构筑稳固的防御体系。

1.1 数据窃取

数据窃取是网络安全领域中一种古老但依然有效的攻击手段。未加密的数据在传输过程中极易被拦截，尤其是在分布式架构中，接口调用频繁且复杂，难以全面监控。攻击者通过流量分析、信道监听等技术手段，可以获取明文数据，涉及用户身份信息、商业秘密甚至系统配置。数据一旦泄露，不仅对个体构成直接威胁，企业的竞争力和市场声誉也将受到不可逆的影响。因此，数据窃取问题的解决方案并不仅仅在于简单地加密数据，而是要求我们在架构设计层面就考虑数据保护和生命周期管理。

1.2 数据篡改

在未采取一致性和完整性保护的系统中，数据篡改是一个不可忽视的威胁。它不仅涉及数据被恶意修改的问题，同时也考验系统对异常数据处理的鲁棒性。在接口通信中，通过篡改请求参数或响应内容，攻击者能够实现业务权限提升、数据欺诈等攻击行为。这种操作通常隐藏在合法请求的外衣下，使得传统的防护措施难以察觉。因此，如何确保数据在传输过程中的完整性，以及在意外修改中迅速恢复是我们需要深入探讨的问题。

1.3 重放攻击

重放攻击利用系统对相同请求的短期信任，截取并重发合法请求，导致系统执行重复或非法操作。这种攻击强调对时间性和唯一性的利用，通过反复发送请求扰乱系统运行或绕过重要业务检查流程。在缺乏时效性验证或请求唯一性鉴别的情况下，系统将面临不可预知的使用风险和安全漏洞。防御重放攻击需要设计以时间戳、唯一请求标识符或一次性令牌为基础的机制，同时也意味着开发者需要在安全和性能之间做出复杂的权衡。

2. 防守策略的构建：接口安全的实践

为了对抗上述风险，不仅需要理解攻击者视角的手段，更要深入部署多层防御策略，确保接口的安全性：

2.1 端到端加密

实施传输层安全（如 TLS/SSL）为最基本的安全措施，确保在网络传输期间，数据是加密的。此外，应用层加密可以在服务器和数据存储期间继续保护敏感信息。

2.2 数据完整性与认证

利用消息鉴别码（MAC）和数字签名技术，强制确保数据的一致性，防止传输过程中数据被篡改。通过加密签名和检验机制，保证信息来源的可信性及其在链路上的完整性。

2.3 防重放机制

纳入时间戳和一次性密码（OTP）的请求管理，以确保每个接口调用具有唯一性和时间效力。这种机制能有效地避免攻击者通过重发请求来实施攻击。

2.4 综合监测和响应控制

部署细粒度权限管理和多因子身份验证以加强用户验证，结合实时监控系统以检测并响应异常操作。自动化安全防护措施将减少人为响应时间，更快地应对潜在或正在进行的攻击。

3. 利用 Spring Boot 提供安全接口：基于公钥获取与加密操作

在网络中传输敏感数据时，我们希望确保数据的完整性、机密性和发送者的真实性。这可以通过以下方式实现：

公钥加密：使用公钥加密的策略确保数据只能被拥有相应私钥的服务器解锁。这使得即便数据在传输过程中被截获也无法被解密。
数字签名和哈希：签名和哈希确保数据完整性和传输真实性。客户端在发送数据之前，利用私钥对数据哈希生成签名，从而可以让服务器验证身份。
时间戳和随机数：添加时间戳和随机数以抵御重放攻击。每个请求都有唯一的标识符和生存期限，保证请求的时间敏感性。

3.1 理论概述

获取公钥接口：首先，提供一个专用端点，让客户端获取服务器的公钥。这一过程通常使用 HTTPS 确保传输安全。
构建请求：客户端在发送请求时，附加公钥的哈希、生成的签名、随机数和时间戳，并使用公钥加密实际的请求数据。
后端验证：服务器接受请求后，通过公钥验证签名、检查时间戳和随机数，再使用私钥解密数据内容。

3.2 接口与请求实现

以下是如何在 Spring Boot 中实现一个获取公钥的接口，以及一个验证客户端请求的过滤器。

//这是一个获取公钥的接口实例
@RestController
@RequestMapping("/api")
@Slf4j
public class PublicApiController {
    @Autowired
    private RedisUtil redisUtil;

    @GetMapping("/noauth/getPublicKey")
    public Result getPublicKey() throws NoSuchAlgorithmException {
        //这里使用redis存储密钥对的原因是可以自定义的控制过期的时间
        KeyPairContainer keyPairContainer = (KeyPairContainer) redisUtil.get("RSA");
        if (Objects.nonNull(keyPairContainer)) {
            return Result.OK(Base64.getEncoder().encodeToString(keyPairContainer.getPublicKey()));
        }
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        keyPairContainer = new KeyPairContainer(
                keyPair.getPublic().getEncoded(),
                keyPair.getPrivate().getEncoded()
        );
        redisUtil.set("RSA", keyPairContainer, 60 * 60 * 12);
        return Result.OK(Base64.getEncoder().encodeToString(keyPairContainer.getPublicKey()));
    }
}

//放到redis里的密钥对对象
@Data
@AllArgsConstructor
@NoArgsConstructor
public class KeyPairContainer implements Serializable {
    private byte[] publicKey;
    private byte[] privateKey;
}

@Slf4j
@Component
@AllArgsConstructor
public class SignInterceptor implements Filter {

    // 注入 RequestMappingHandlerMapping 和 RedisUtil 以便在请求处理中使用
    private final RequestMappingHandlerMapping requestMappingHandlerMapping;
    private final RedisUtil redisUtil;
    private final String requestrandomKey = "requestrandom";

    // 静态代码块，添加 BouncyCastle 加密提供者
    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HandlerExecutionChain handlerExecutionChain = null;
        try {
            // 获取处理当前请求的 Handler
            handlerExecutionChain = requestMappingHandlerMapping.getHandler((HttpServletRequest) servletRequest);
            if (Objects.isNull(handlerExecutionChain)) {
                // 如果没有找到处理器，直接继续过滤链
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
        } catch (Exception e) {
            // 发生异常时直接继续过滤链
            filterChain.doFilter(servletRequest, servletResponse);
            return;
        }

        // 获取处理器
        Object handler = handlerExecutionChain.getHandler();
        if (handler instanceof HandlerMethod) {
            //如果 handler 是 HandlerMethod，检查是否有 DecryptRequest 注解
            //这里使用注解的方式可以更加灵活的控制哪些敏感接口需要加密的数据
            DecryptRequest decryptRequest = ((HandlerMethod) handler).getMethodAnnotation(DecryptRequest.class);
            if (Objects.nonNull(decryptRequest)) {
                // 获取请求体
                String requestBody = servletRequest.getReader().lines().collect(Collectors.joining(System.lineSeparator()));
                if (StringUtils.isEmpty(requestBody)) {
                    // 请求体为空，返回错误响应
                    ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                    servletResponse.setContentType("application/json; charset=utf-8");
                    servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420005, "请求体为空")));
                    return;
                }
                log.info("加密的请求体:{}", requestBody);

                // 解析 JSON 请求体
                JSONObject jsonObject = JSONObject.parseObject(requestBody);
                if (decryptRequest.sign()) {
                    // 获取随机数、时间戳、加密数据、用户UID和签名
                    String random = jsonObject.getString("random");
                    String timestamp = jsonObject.getString("timestamp");
                    String data = jsonObject.getString("data");
                    String uid = getUserId(((HttpServletRequest) servletRequest).getHeader("Token"));
                    String sign = jsonObject.getString("sign");

                    // 重复请求校验
                    if (Objects.nonNull(redisUtil.get(String.format("%s::%s", requestrandomKey, random)))) {
                        // 返回重复请求错误
                        ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                        servletResponse.setContentType("application/json; charset=utf-8");
                        servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420000, "重复请求")));
                        return;
                    }
                    // 将随机数存入 Redis，设置过期时间
                    redisUtil.set(String.format("%s::%s", requestrandomKey, random), null, 60 * 60 * 10);

                    // 验证签名
                    if (!verifySignature(data, uid, random, timestamp, sign)) {
                        // 返回验签失败错误
                        ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                        servletResponse.setContentType("application/json; charset=utf-8");
                        servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420001, "验签失败")));
                        return;
                    }
                }
                // 获取公钥
                String publicKey = jsonObject.getString("publicKey");
                KeyPairContainer keyPairContainer = (KeyPairContainer) redisUtil.get("RSA");
                if (Objects.isNull(keyPairContainer)) {
                    // 返回公钥过期错误
                    ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                    servletResponse.setContentType("application/json; charset=utf-8");
                    servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420002, "公钥过期")));
                    return;
                }
                // 校验公钥是否匹配
                String publicKeyLocal = DigestUtils.sha256Hex(Base64.getEncoder().encodeToString(keyPairContainer.getPublicKey()));
                if (!Objects.equals(publicKeyLocal, publicKey)) {
                    // 返回公钥不匹配错误
                    ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                    servletResponse.setContentType("application/json; charset=utf-8");
                    servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420003, "公钥不匹配")));
                    return;
                }
                // 解密请求体
                try {
                    String decrypt = decrypt(jsonObject.getString("data"));
                    log.info("解密的请求体:{}", decrypt);
                    // 使用解密后的数据替换原请求体
                    filterChain.doFilter(new BodyReaderHttpServletRequestWrapper((HttpServletRequest) servletRequest, decrypt), servletResponse);
                    return;
                } catch (Exception e) {
                    // 返回解密失败错误
                    e.printStackTrace();
                    ((HttpServletResponse) servletResponse).setStatus(HttpStatus.OK.value());
                    servletResponse.setContentType("application/json; charset=utf-8");
                    servletResponse.getWriter().write(JSONObject.toJSONString(Result.error(420004, "解密失败")));
                    return;
                }
            }
        }
        // 如果没有加解密逻辑，继续过滤链
        filterChain.doFilter(servletRequest, servletResponse);
    }

    // 实际的解密逻辑
    private String decrypt(String encryptedRequestBody) throws Exception {
        KeyPairContainer keyPairContainer = (KeyPairContainer) redisUtil.get("RSA");
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(keyPairContainer.getPrivateKey()));
        // 使用私钥解密
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedRequestBody));
        return new String(decryptedData);
    }

    // 验证签名
    // 签名的规则可以自定义,我的规则是sha256(加密的数据+用户的id+随机数+时间戳)
    private Boolean verifySignature(String data, String uid, String random, String timestamp, String sign) {
        String localSign = DigestUtils.sha256Hex(data + uid + random + timestamp).toLowerCase();
        boolean equals = Objects.equals(sign, localSign);
        if (!equals) {
            log.info("验签失败");
            log.info("等签名字符串:{}", data + uid + random + timestamp);
            log.info("localSign:{},sign:{}", localSign, sign);
        }
        return equals;
    }
}

通过引入公钥加密与数字签名的机制，我们有效地提升了接口的安全保障。本文所探讨的解决方案不仅保护了数据的保密性和完整性，还抵御了重放攻击等常见的安全威胁。利用 Spring Boot 强大的整合能力，实现从公钥分发到请求验证的整个闭环流程，确保了安全的同时未显著影响系统性能。

在实现中，公钥与私钥的生命周期管理是关键，其安全性直接关系到系统整体的信任链。因此，借助 Redis 等缓存技术来控制其有效期和更新频率，进一步增强了方案的实用性和稳健性。

未来，我们可以继续完善这套机制，考虑引入更高级的加密算法或者进一步优化签名与验证的流程。同时，与应用层面的全面安全策略结合，形成一套综合性防御体系，以应对不断变化与升级的安全挑战。通过持续的检测与改进，该解决方案能够保障系统在复杂网络环境下的安全性和可靠性。

通过这篇文章，希望能够为有类似需求的开发者提供一些思路和实践建议，使得大家在接口安全设计上有更多的参考和创新。

如果您对本文的内容有任何建议或进一步讨论的兴趣，欢迎随时交流！

本作品采用知识共享署名 4.0 国际许可协议进行许可