SpringBoot 如何保证接口安全？老鸟们都是这么玩的

红太狼 2023-10-09 23:37 18阅读 0赞

对于互联网来说，只要你系统的接口暴露在外网，就避免不了接口安全问题。如果你的接口在外网裸奔，只要让黑客知道接口的地址和参数就可以调用，那简直就是灾难。

举个例子：你的网站用户注册的时候，需要填写手机号，发送手机验证码，如果这个发送验证码的接口没有经过特殊安全处理，那这个短信接口早就被人盗刷不知道浪费多少钱了。

那如何保证接口安全呢？

一般来说，暴露在外网的api接口需要做到**防篡改**和**防重放**才能称之为安全的接口。

## 防篡改 ##

我们知道http 是一种无状态的协议，服务端并不知道客户端发送的请求是否合法，也并不知道请求中的参数是否正确。

举个例子, 现在有个充值的接口，调用后可以给用户增加对应的余额。

http://localhost/api/user/recharge?user_id=1001&amount=10

如果非法用户通过抓包获取到接口参数后，修改user\_id 或 amount的值就可以实现给任意账户添加余额的目的。

## 如何解决 ##

采用https协议可以将传输的明文进行加密，但是黑客仍然可以截获传输的数据包，进一步伪造请求进行重放攻击。如果黑客使用特殊手段让请求方设备使用了伪造的证书进行通信，那么https加密的内容也会被解密。

一般的做法有2种：

1.  采用https方式把接口的数据进行加密传输，即便是被黑客破解，黑客也花费大量的时间和精力去破解。
2.  接口后台对接口的请求参数进行验证，防止被黑客篡改；

![0b9bede8c70c4325b6f71883429b6deb.png][]

*  步骤1：客户端使用约定好的秘钥对传输的参数进行加密，得到签名值sign1，并且将签名值也放入请求的参数中，发送请求给服务端
 *  步骤2：服务端接收到客户端的请求，然后使用约定好的秘钥对请求的参数再次进行签名，得到签名值sign2。
 *  步骤3：服务端比对sign1和sign2的值，如果不一致，就认定为被篡改，非法请求。

## 防重放 ##

防重放也叫防复用。简单来说就是我获取到这个请求的信息之后什么也不改,，直接拿着接口的参数 重复请求这个充值的接口。此时我的请求是合法的, 因为所有参数都是跟合法请求一模一样的。  
重放攻击会造成两种后果：

1.  针对插入数据库接口：重放攻击，会出现大量重复数据，甚至垃圾数据会把数据库撑爆。
2.  针对查询的接口：黑客一般是重点攻击慢查询接口，例如一个慢查询接口1s，只要黑客发起重放攻击，就必然造成系统被拖垮，数据库查询被阻塞死。

对于重放攻击一般有两种做法：

## 基于timestamp的方案 ##

每次HTTP请求，都需要加上timestamp参数，然后把timestamp和其他参数一起进行数字签名。因为一次正常的HTTP请求，从发出到达服务器一般都不会超过60s，所以服务器收到HTTP请求之后，首先判断时间戳参数与当前时间比较，是否超过了60s，如果超过了则认为是非法请求。

一般情况下，黑客从抓包重放请求耗时远远超过了60s，所以此时请求中的timestamp参数已经失效了。如果黑客修改timestamp参数为当前的时间戳，则sign1参数对应的数字签名就会失效，因为黑客不知道签名秘钥，没有办法生成新的数字签名。

![71b7eb31a6f84d6aa8f633ada038b657.png][]

但是这种方式的漏洞也是显而易见，如果在60s之内进行重放攻击，那就没办法了，所以这种方式不能保证请求仅一次有效。

![86293ef502704896b2fa3d4c03420279.png][]

老鸟们一般会采取下面这种方案，既可以解决接口重放问题，又可以解决接口一次请求有效的问题。

## 基于nonce + timestamp 的方案 ##

nonce的意思是仅一次有效的随机字符串，要求每次请求时该参数要保证不同。实际使用用户信息+时间戳+随机数等信息做个哈希之后，作为nonce参数。

此时服务端的处理流程如下：

1.  去 redis 中查找是否有 key 为 nonce:\{nonce\} 的 string
2.  如果没有，则创建这个 key，把这个 key 失效的时间和验证 timestamp 失效的时间一致，比如是 60s。
3.  如果有，说明这个 key 在 60s 内已经被使用了，那么这个请求就可以判断为重放请求。

![b89ab31e2b38406cab81bb6caab2c280.png][]

这种方案nonce和timestamp参数都作为签名的一部分传到后端，基于timestamp方案可以让黑客只能在60s内进行重放攻击，加上nonce随机数以后可以保证接口只能被调用一次，可以很好的解决重放攻击问题。

## 代码实现 ##

接下来通过实际代码来看看如何实现接口的防篡改和防重放。

## 1、构建请求头对象 ##

@Data
    @Builder
    public class RequestHeader {
       private String sign ;
       private Long timestamp ;
       private String nonce;
    }

## 2、工具类从HttpServletRequest获取请求参数 ##

@Slf4j
    @UtilityClass
    public class HttpDataUtil {
        /**
         * post请求处理：获取 Body 参数，转换为SortedMap
         *
         * @param request
         */
        public  SortedMap<String, String> getBodyParams(final HttpServletRequest request) throws IOException {
            byte[] requestBody = StreamUtils.copyToByteArray(request.getInputStream());
            String body = new String(requestBody);
            return JsonUtil.json2Object(body, SortedMap.class);
        }
    
    
        /**
         * get请求处理：将URL请求参数转换成SortedMap
         */
        public static SortedMap<String, String> getUrlParams(HttpServletRequest request) {
            String param = "";
            SortedMap<String, String> result = new TreeMap<>();
    
            if (StringUtils.isEmpty(request.getQueryString())) {
                return result;
            }
    
            try {
                param = URLDecoder.decode(request.getQueryString(), "utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
            String[] params = param.split("&");
            for (String s : params) {
                String[] array=s.split("=");
                result.put(array[0], array[1]);
            }
            return result;
        }
    }

这里的参数放入SortedMap中对其进行字典排序，前端构建签名时同样需要对参数进行字典排序。

## 3、签名验证工具类 ##

@Slf4j
    @UtilityClass
    public class SignUtil {
        /**
         * 验证签名
         * 验证算法：把timestamp + JsonUtil.object2Json(SortedMap)合成字符串，然后MD5
         */
        @SneakyThrows
        public  boolean verifySign(SortedMap<String, String> map, RequestHeader requestHeader) {
            String params = requestHeader.getNonce() + requestHeader.getTimestamp() + JsonUtil.object2Json(map);
            return verifySign(params, requestHeader);
        }
    
        /**
         * 验证签名
         */
        public boolean verifySign(String params, RequestHeader requestHeader) {
            log.debug("客户端签名: {}", requestHeader.getSign());
            if (StringUtils.isEmpty(params)) {
                return false;
            }
            log.info("客户端上传内容: {}", params);
            String paramsSign = DigestUtils.md5DigestAsHex(params.getBytes()).toUpperCase();
            log.info("客户端上传内容加密后的签名结果: {}", paramsSign);
            return requestHeader.getSign().equals(paramsSign);
        }
    }

## 4、HttpServletRequest包装类 ##

public class SignRequestWrapper extends HttpServletRequestWrapper {
        //用于将流保存下来
        private byte[] requestBody = null;
    
        public SignRequestWrapper(HttpServletRequest request) throws IOException {
            super(request);
            requestBody = StreamUtils.copyToByteArray(request.getInputStream());
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);
    
            return new ServletInputStream() {
                @Override
                public boolean isFinished() {
                    return false;
                }
    
                @Override
                public boolean isReady() {
                    return false;
                }
    
                @Override
                public void setReadListener(ReadListener readListener) {
    
                }
    
                @Override
                public int read() throws IOException {
                    return bais.read();
                }
            };
    
        }
    
        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(getInputStream()));
        }
    }

防篡改和防重放我们会通过SpringBoot Filter来实现，而编写的filter过滤器需要读取request数据流，但是request数据流只能读取一次，需要自己实现HttpServletRequestWrapper对数据流包装，目的是将request流保存下来。

## 5、创建过滤器实现安全校验 ##

@Configuration
    public class SignFilterConfiguration {
        @Value("${sign.maxTime}")
        private String signMaxTime;
    
        //filter中的初始化参数
        private Map<String, String> initParametersMap =  new HashMap<>();
    
        @Bean
        public FilterRegistrationBean contextFilterRegistrationBean() {
            initParametersMap.put("signMaxTime",signMaxTime);
            FilterRegistrationBean registration = new FilterRegistrationBean();
            registration.setFilter(signFilter());
            registration.setInitParameters(initParametersMap);
            registration.addUrlPatterns("/sign/*");
            registration.setName("SignFilter");
            // 设置过滤器被调用的顺序
            registration.setOrder(1);
            return registration;
        }
    
        @Bean
        public Filter signFilter() {
            return new SignFilter();
        }
    }

@Slf4j
    public class SignFilter implements Filter {
        @Resource
        private RedisUtil redisUtil;
    
        //从fitler配置中获取sign过期时间
        private Long signMaxTime;
    
        private static final String NONCE_KEY = "x-nonce-";
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
            HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
    
            log.info("过滤URL:{}", httpRequest.getRequestURI());
    
            HttpServletRequestWrapper requestWrapper = new SignRequestWrapper(httpRequest);
            //构建请求头
            RequestHeader requestHeader = RequestHeader.builder()
                    .nonce(httpRequest.getHeader("x-Nonce"))
                    .timestamp(Long.parseLong(httpRequest.getHeader("X-Time")))
                    .sign(httpRequest.getHeader("X-Sign"))
                    .build();
    
            //验证请求头是否存在
            if(StringUtils.isEmpty(requestHeader.getSign()) || ObjectUtils.isEmpty(requestHeader.getTimestamp()) || StringUtils.isEmpty(requestHeader.getNonce())){
                responseFail(httpResponse, ReturnCode.ILLEGAL_HEADER);
                return;
            }
    
            /*
             * 1.重放验证
             * 判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。
             */
            long now = System.currentTimeMillis() / 1000;
    
            if (now - requestHeader.getTimestamp() > signMaxTime) {
                responseFail(httpResponse,ReturnCode.REPLAY_ERROR);
                return;
            }
    
            //2. 判断nonce
            boolean nonceExists = redisUtil.hasKey(NONCE_KEY + requestHeader.getNonce());
            if(nonceExists){
                //请求重复
                responseFail(httpResponse,ReturnCode.REPLAY_ERROR);
                return;
            }else {
                redisUtil.set(NONCE_KEY+requestHeader.getNonce(), requestHeader.getNonce(), signMaxTime);
            }
    
    
            boolean accept;
            SortedMap<String, String> paramMap;
            switch (httpRequest.getMethod()){
                case "GET":
                    paramMap = HttpDataUtil.getUrlParams(requestWrapper);
                    accept = SignUtil.verifySign(paramMap, requestHeader);
                    break;
                case "POST":
                    paramMap = HttpDataUtil.getBodyParams(requestWrapper);
                    accept = SignUtil.verifySign(paramMap, requestHeader);
                    break;
                default:
                    accept = true;
                    break;
            }
            if (accept) {
                filterChain.doFilter(requestWrapper, servletResponse);
            } else {
                responseFail(httpResponse,ReturnCode.ARGUMENT_ERROR);
                return;
            }
    
        }
    
        private void responseFail(HttpServletResponse httpResponse, ReturnCode returnCode)  {
            ResultData<Object> resultData = ResultData.fail(returnCode.getCode(), returnCode.getMessage());
            WebUtils.writeJson(httpResponse,resultData);
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            String signTime = filterConfig.getInitParameter("signMaxTime");
            signMaxTime = Long.parseLong(signTime);
        }
    }

## 6、Redis工具类 ##

@Component
    public class RedisUtil {
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return Boolean.TRUE.equals(redisTemplate.hasKey(key));
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 普通缓存放入并设置时间
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 普通缓存放入
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    }

[0b9bede8c70c4325b6f71883429b6deb.png]: https://img-blog.csdnimg.cn/0b9bede8c70c4325b6f71883429b6deb.png
[71b7eb31a6f84d6aa8f633ada038b657.png]: https://img-blog.csdnimg.cn/71b7eb31a6f84d6aa8f633ada038b657.png
[86293ef502704896b2fa3d4c03420279.png]: https://img-blog.csdnimg.cn/86293ef502704896b2fa3d4c03420279.png
[b89ab31e2b38406cab81bb6caab2c280.png]: https://img-blog.csdnimg.cn/b89ab31e2b38406cab81bb6caab2c280.png