api接口不再裸奔——签名认证

太过爱你忘了你带给我的痛 2022-03-19 15:37 302阅读 0赞

在第三方调用api接口的时候，可能会存在以下几个问题

*  请求身份是否合法？
 *  请求参数是否被篡改？
 *  请求是否唯一？

解决上述三个问题分为如下流程

1、合法性，通过请求许可来进行判断

为开发者分配**AccessKey**（开发者标识，确保唯一）和**SecretKey**（用于接口加密，确保不易被穷举，生成算法不易被猜测）

目前广泛使用token和AccessKey作用一样，都是第三方合法性的认证标示

2、防止被伪造，利用签名来解决

通常的做法利用参数名升序使用键值对+SecretKey+timestamp（后面将为什么要加时间戳）生成字符串sign，然后使用加密算法对sign进行加密（例如MD5），生成唯一的signkey，timestamp两个标示放到http请求的header中

3、请求的是否唯一性，以及时效性

此次也就是时间戳利用之处，为了防止同一个请求被长时间使用，利用时间戳解决使用时间范围区间的问题。利用带时间戳生成的signKey可以保证唯一性，而且通过失效时间范围可以提前阻拦一部分非法请求。如何解决在有效范围时间内请求唯一呢？

可以利用redis的expire，在合法的时间范围中将唯一的signKey存储到redis中，设置过期时间（防止存储内容过大），这样在合法范围时间中利用redis缓存，保证请求唯一一次的使用，可以防止暴力刷机的问题。

代码详情

public class SignHandlerInterceptor extends HandlerInterceptorAdapter implements IResponseWithJson {
        /**
         * 签名超时时长，默认时间为5分钟，ms
         */
        private int expiredTime = 5 * 60 * 1000;
    
        private String signKey = "sign";
    
        private static final String TIMESTAMP_KEY = "timestamp";
    
        private ICacheOperation cacheOperation;
    
        /**
         * 渠道类型
         */
        private Map<Integer, CheckChannelModel> channelModelMap = new HashMap<>();
    
        public SignHandlerInterceptor() {
        }
    
        public SignHandlerInterceptor(String expiredTime, String signKey, ICacheOperation cacheOperation, List<CheckChannelModel> channelModels) {
            if (CollectionUtil.isNotEmpty(channelModels)) {
                Map<Integer, List<CheckChannelModel>> tempMap = channelModels.stream()
                        .distinct()
                        .collect(Collectors.groupingBy(CheckChannelModel::getChannelCode));
                tempMap.forEach((code, checkChannelModels) -> {
                    this.channelModelMap.put(code, checkChannelModels.get(0));
                });
            }
            if (!Strings.isNullOrEmpty(signKey)) {
                this.signKey = signKey;
            }
            if (StringUtils.isNumeric(expiredTime)) {
                this.expiredTime = Integer.parseInt(expiredTime);
            }
            this.cacheOperation = cacheOperation;
        }
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            TokenUser tokenUser = RequestData.getTokenUser();
            //判断token为空，而且 开启签名认证，并且不存在白名单中
            String channelCode = request.getHeader("channel");
            if (tokenUser == null && CollectionUtil.isNotEmpty(channelModelMap)) {
                if (Strings.isNullOrEmpty(channelCode) || !channelModelMap.keySet().contains(Integer.parseInt(channelCode.trim()))) {
                    responseWithJson(request, response, JsonData.error("渠道不合法!"));
                    return false;
                } else if (channelModelMap.get(Integer.parseInt(channelCode.trim())).getOnOffSwitch() != 0) {
                    return true;
                } else {
                    //1、验证签名是否正确
                    String timestamp = request.getHeader(TIMESTAMP_KEY);
                    String sign = request.getHeader(this.signKey);
                    //2、判断时间戳是否符合格式要求
                    if (StringUtil.isEmpty(timestamp) || !StringUtil.isNumeric(timestamp)) {
                        responseWithJson(request, response, JsonData.error("请求时间戳不合法!"));
                        return false;
                    }
                    //3、判断时间戳是否在超时
                    long ts = Long.parseLong(timestamp);
                    if (System.currentTimeMillis() - ts > expiredTime) {
                        responseWithJson(request, response, JsonData.error("请求过期!"));
                        return false;
                    }
                    //4、判断签名是否存在
                    if (StringUtil.isEmpty(sign)) {
                        log.error("sign签名为空");
                        responseWithJson(request, response, JsonData.error("认证无法通过!"));
                        return false;
                    }
                    //5、判断签名是否正确
                    String secret = channelModelMap.get(Integer.parseInt(channelCode.trim())).getChannelSecret();
                    if (!verificationSign(request, secret, timestamp)) {
                        responseWithJson(request, response, JsonData.error("认证无法通过!"));
                        return false;
                    }
                    //6、判断认证是否被使用过,没有使用过则放入缓存中
                    byte[] signs = cacheOperation.get(sign.getBytes());
                    if (signs == null || signs.length == 0) {
                        cacheOperation.setnx(sign.getBytes(), expiredTime, "1".getBytes());
                    } else {
                        responseWithJson(request, response, JsonData.error("认证已失效!"));
                        return false;
                    }
                }
            }
            return true;
        }
    
        private boolean verificationSign(HttpServletRequest request, String accessSecret, String timestamp) throws IOException {
            Enumeration<?> pNames = request.getParameterNames();
            Map<String, Object> params = new HashMap<>();
            while (pNames.hasMoreElements()) {
                String pName = (String) pNames.nextElement();
                Object pValue = request.getParameter(pName);
                params.put(pName, pValue);
            }
            if (CollectionUtil.isEmpty(params)) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(request.getInputStream()));
                String body = IOUtils.read(reader);
                if (StringUtil.isNotEmpty(body)) {
                    params.put("body", body);
                }
    
            }
            String originSign = request.getHeader(signKey);
            String sign = createSign(params, accessSecret, timestamp);
            return sign.equals(originSign);
        }
    
        private String createSign(Map<String, Object> params, String accessSecret, String timestamp) {
            boolean append = false;
            StringBuilder temp = new StringBuilder();
            if (CollectionUtil.isNotEmpty(params)) {
                Set<String> keysSet = params.keySet();
                Object[] keys = keysSet.toArray();
                Arrays.sort(keys);
                for (Object key : keys) {
                    if (!append) {
                        append = true;
                    } else {
                        temp.append("&");
                    }
                    temp.append(key).append("=");
                    Object value = params.get(key);
                    String valueString = "";
                    if (null != value) {
                        valueString = String.valueOf(value);
                    }
                    temp.append(valueString);
                }
            }
            if (append) {
                temp.append("&");
            }
            temp.append(TIMESTAMP_KEY).append("=").append(timestamp);
            temp.append("&").append(signKey).append("=").append(accessSecret);
            return DigestUtils.md5Hex(temp.toString()).toUpperCase();
        }
    }

public interface IResponseWithJson {
        default void responseWithJson(HttpServletRequest request, HttpServletResponse response, Object responseObject) {
            String jsonpCallback = request.getParameter("callback");
            response.setCharacterEncoding("UTF-8");
            PrintWriter out;
            if (Strings.isNullOrEmpty(jsonpCallback)) {
                response.setContentType("application/json; charset=utf-8");
                out = null;
    
                try {
                    out = response.getWriter();
                    out.append(JSONObject.toJSONString(responseObject));
                } catch (IOException var18) {
                    var18.printStackTrace();
                } finally {
                    if (out != null) {
                        out.close();
                    }
    
                }
            } else {
                response.setContentType("text/plain");
                response.setHeader("Pragma", "No-cache");
                response.setHeader("Cache-Control", "no-cache");
                response.setDateHeader("Expires", 0L);
                out = null;
    
                try {
                    out = response.getWriter();
                    out.append(jsonpCallback + "(" + JSONObject.toJSONString(responseObject) + ")");
                } catch (IOException var17) {
                    var17.printStackTrace();
                } finally {
                    if (out != null) {
                        out.close();
                    }
    
                }
            }
        }
    }

备注：参考内容如下[《开放API接口签名验证，让你的接口从此不再裸奔》][API]

[API]: https://www.jianshu.com/p/ad410836587a