为什么要保障接口平安
对于互联网来说，只有你零碎的接口裸露在外网，就防止不了接口平安问题。如果你的接口在外网裸奔，只有让黑客晓得接口的地址和参数就能够调用，那几乎就是劫难。
举个例子：你的网站用户注册的时候，须要填写手机号，发送手机验证码，如果这个发送验证码的接口没有通过非凡平安解决，那这个短信接口早就被人盗刷不晓得节约多少钱了。
那如何保障接口平安呢？
一般来说，裸露在外网的 api 接口须要做到防篡改和防重放能力称之为平安的接口。
防篡改
咱们晓得 http 是一种无状态的协定，服务端并不知道客户端发送的申请是否非法，也并不知道申请中的参数是否正确。
举个例子, 当初有个充值的接口，调用后能够给用户减少对应的余额。
http://localhost/api/user/recharge?user_id=1001&amount=10
复制代码
如果非法用户通过抓包获取到接口参数后，批改 user_id 或 amount 的值就能够实现给任意账户增加余额的目标。
如何解决
采纳 https 协定能够将传输的明文进行加密，然而黑客依然能够截获传输的数据包，进一步伪造申请进行重放攻打。如果黑客应用非凡伎俩让申请方设施应用了伪造的证书进行通信，那么 https 加密的内容也会被解密。
个别的做法有 2 种：
采纳 https 形式把接口的数据进行加密传输，即使是被黑客破解，黑客也破费大量的工夫和精力去破解。
接口后盾对接口的申请参数进行验证，避免被黑客篡改；
步骤 1：客户端应用约定好的秘钥对传输的参数进行加密，失去签名值 sign1，并且将签名值也放入申请的参数中，发送申请给服务端
步骤 2：服务端接管到客户端的申请，而后应用约定好的秘钥对申请的参数再次进行签名，失去签名值 sign2。
步骤 3：服务端比对 sign1 和 sign2 的值，如果不统一，就认定为被篡改，非法申请。
防重放
防重放也叫防复用。简略来说就是我获取到这个申请的信息之后什么也不改,，间接拿着接口的参数去 反复申请这个充值的接口。此时我的申请是非法的, 因为所有参数都是跟非法申请截然不同的。重放攻打会造成两种结果：
针对插入数据库接口：重放攻打，会呈现大量反复数据，甚至垃圾数据会把数据库撑爆。
针对查问的接口：黑客个别是重点攻打慢查问接口，例如一个慢查问接口 1s，只有黑客发动重放攻打，就必然造成零碎被拖垮，数据库查问被阻塞死。
对于重放攻打个别有两种做法：
基于 timestamp 的计划
每次 HTTP 申请，都须要加上 timestamp 参数，而后把 timestamp 和其余参数一起进行数字签名。因为一次失常的 HTTP 申请，从收回达到服务器个别都不会超过 60s，所以服务器收到 HTTP 申请之后，首先判断工夫戳参数与以后工夫比拟，是否超过了 60s，如果超过了则认为是非法申请。
个别状况下，黑客从抓包重放申请耗时远远超过了 60s，所以此时申请中的 timestamp 参数曾经生效了。如果黑客批改 timestamp 参数为以后的工夫戳，则 sign1 参数对应的数字签名就会生效，因为黑客不晓得签名秘钥，没有方法生成新的数字签名。
然而这种形式的破绽也是不言而喻，如果在 60s 之内进行重放攻打，那就没方法了，所以这种形式不能保障申请仅一次无效。
老鸟们个别会采取上面这种计划，既能够解决接口重放问题，又能够解决一次申请无效的问题。
基于 nonce + timestamp 的计划
nonce 的意思是仅一次无效的随机字符串，要求每次申请时该参数要保障不同。理论应用用户信息 + 工夫戳 + 随机数等信息做个哈希之后，作为 nonce 参数。
此时服务端的解决流程如下：
去 redis 中查找是否有 key 为 nonce:{nonce} 的 string
如果没有，则创立这个 key，把这个 key 生效的工夫和验证 timestamp 生效的工夫统一，比方是 60s。
如果有，阐明这个 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;
}
}
}