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

我们好，我是飘渺。 今天给我们带来SpringBoot老鸟系列的第11篇，怎么确保接口安全！

为什么要确保接口安全

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

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

那怎么确保接口安全呢？

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

防篡改

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

举个比如, 现在有个充值的接口，调用后能够给用户增加对应的余额。

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

假如非法用户经过抓包获取到接口参数后，修正user_id 或 amount的值就能够完成给恣意账户添加余额的意图。

怎么处理

选用https协议能够将传输的明文进行加密，可是黑客依然能够截获传输的数据包，进一步假造恳求进行重放进犯。假如黑客运用特殊手段让恳求方设备运用了假造的证书进行通信，那么https加密的内容也会被解密。

一般的做法有2种：

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

• 过程1：客户端运用约定好的秘钥对传输的参数进行加密，得到签名值sign1，并且将签名值也放入恳求的参数中，发送恳求给服务端
• 过程2：服务端接收到客户端的恳求，然后运用约定好的秘钥对恳求的参数再次进行签名，得到签名值sign2。
• 过程3：服务端比对sign1和sign2的值，假如不共同，就认定为被篡改，非法恳求。

防重放

防重放也叫防复用。简略来说便是我获取到这个恳求的信息之后什么也不改,，直接拿着接口的参数去 重复恳求这个充值的接口。此刻我的恳求是合法的, 由于一切参数都是跟合法恳求一模一样的。重放进犯会形成两种后果：

0. 针对插入数据库接口：重放进犯，会呈现很多重复数据，甚至垃圾数据会把数据库撑爆。
1. 针对查询的接口：黑客一般是重点进犯慢查询接口，例如一个慢查询接口1s，只要黑客建议重放进犯，就必定形成系统被拖垮，数据库查询被阻塞死。

关于重放进犯一般有两种做法：

依据timestamp的计划

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

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

可是这种方式的漏洞也是显而易见，假如在60s之内进行重放进犯，那就没办法了，所以这种方式不能确保恳求仅一次有用。

老鸟们一般会采纳下面这种计划，既能够处理接口重放问题，又能够处理一次恳求有用的问题。

依据nonce + timestamp 的计划

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

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

0. 去 redis 中查找是否有 key 为 nonce:{nonce} 的 string
1. 假如没有，则创立这个 key，把这个 key 失效的时刻和验证 timestamp 失效的时刻共同，比如是 60s。
2. 假如有，说明这个 key 在 60s 内已经被运用了，那么这个恳求就能够判别为重放恳求。

这种计划nonce和timestamp参数都作为签名的一部分传到后端，依据timestamp计划能够让黑客只能在60s内进行重放进犯，加上nonce随机数以后能够确保接口只能被调用一次，能够很好的处理重放进犯问题。

代码完成

接下来以SpringBoot项目为例看看怎么完成接口的防篡改和防重放功能。

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;
     }
   }
​
}

老鸟系列源码已经上传至GitHub，需求的在公号【JAVA日知录】回复关键字0923获取源码地址。