Java对外接口签名(Signature)实现方案

╰+哭是因爲堅強的太久メ 2023-09-28 13:34 21阅读 0赞

## 为什么要加密验签？ 防止报文明文传输 ##

数据在网络传输过程中，容易被抓包。如果使用的是HTTP协议的请求/响应(Request OR Response),它是明文传输的，都是可以被截获、篡改、重放(重发)的。所以需要进行数据的加密验签，所以需要考虑以下几点。

1.  防伪装攻击（案例：在公共网络环境中，第三方 有意或恶意 的调用我们的接口）
2.  防篡改攻击（案例：在公共网络环境中，请求头/查询字符串/内容 在传输过程被修改）
3.  防重放攻击（案例：在公共网络环境中，请求被截获，稍后被重放或多次重放）
4.  防数据信息泄漏（案例：截获用户登录请求，截获到账号、密码等）

## 实现方式 ##

常见的方式，就是对**关键字段**加密。比如查询订单接口，就可以对**订单号**进行加密。一般常用的加密算法**对称加密算法(如：AES****），**或者**哈希算法**处理(如：MD5)

> **对称加密**：加密和解密使用相同秘钥的加密算法

采用单钥[密码系统][Link 1]的加密方法，同一个[密钥][Link 2]可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。

> **非对称加密**：非对称加密算法需要两个密钥(公开密钥和私有密钥)。公钥和私钥是成对存在的，如果用公钥对数据加密，只有对应的私钥才能解密。 （非对称加密是更安全的做法，加密是算法RSA或SM2）

非对称加密算法需要两个[密钥][Link 2]来进行加密和解密，这两个密钥是[公开密钥][Link 3]（public key，简称公钥）和私有密钥（private key，简称私钥）。

> **加签验签**：使用Hash算法（如 MD5或者SHA-256）把原始请求参数生成报文摘要，然后用私钥对这个摘要进行加密，得到报文对应的sign

**加签**：用Hash函数把原始报文生成报文摘要，然后用私钥对这个摘要进行加密，就得到这个报文对应的数字签名。通常来说呢，请求方会把「数字签名和报文原文」一并发送给接收方。![1d588b9f46584ebfabde828a4b0eb3bf.png][]

**验签**：接收方拿到原始报文和数字签名后，用「同一个Hash函数」从报文中生成摘要A。另外，用对方提供的公钥对数字签名进行解密，得到摘要B，对比A和B是否相同，就可以得知报文有没有被篡改过。![047768049d05465992f465cd4454ce13.png][]

--------------------

### 客户端操作 ###

**请求参数**：

<table> 
 <tbody> 
 <tr> 
 <td> 字段 </td> 
 <td> 类型 </td> 
 <td> 必传 </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> sign </td> 
 <td> String </td> 
 <td> 是 </td> 
 <td> 接口签名，用户接口验证 </td> 
 </tr> 
 <tr> 
 <td> app_id </td> 
 <td> String </td> 
 <td> 是 </td> 
 <td> 开放平台的APP_ID，例如：1234 </td> 
 </tr> 
 <tr> 
 <td> date_time </td> 
 <td> String </td> 
 <td> 是 </td> 
 <td> 当前时间戳 </td> 
 </tr> 
 <tr> 
 <td> key </td> 
 <td> String </td> 
 <td> 是 </td> 
 <td> 开发平台的APP_KEY，例如：XA12#Da </td> 
 </tr> 
 <tr> 
 <td> name </td> 
 <td> String </td> 
 <td> 否 </td> 
 <td> 业务参数 </td> 
 </tr> 
 <tr> 
 <td> age </td> 
 <td> Integer </td> 
 <td> 否 </td> 
 <td> 业务参数 </td> 
 </tr> 
 </tbody> 
</table>

业务参数消息体数据格式：Content-Type 指定为 application/json

1.将请求参数中除sign外的多个键值对，根据键按照字典序排序，并按照"key1=value1&key2=value2..."的格式拼成一个字符串

String sortStr=" age=11&app_id=1234&date_time=1656926899731&name=xxx"

2.将key拼接在第一步中排序后的字符串后面得到待签名字符串

String sortStr ="age=11&app_id=1234&date_time=1656926899731&name=xxxkey=XA12#Da"

3.使用md5算法加密待加密字符串并转为大写即为sign

String sign ="57A132B7585F77B1948812275BE945B8"

4.将sign添加到请求参数中

https://www.baidu.com/test/get?age=11&app_id=1234&date_time=1656926899731&name=xxx&sign=57A132B7585F77B1948812275BE945B8

**需要注意以下重要规则**：

◆ 请求参数中有中文时，中文需要经过url编码，但计算签名时不需要；

◆ 请求参数的值为空则不参与签名；

◆ 参数名区分大小写；

◆ sign参数不参与签名；

### **服务端操作** ###

1.  接收到请求参数，转JSON格式
2.  验签
    
    1.  拿出用户签名
    2.  根据APP\_ID 拿去数据库中的KEY，使用该KEY进行重签参数
    3.  如果重签结果和用户签名一致则通过，否则返回签名错误
    4.  校验参数中的时间戳，如果时间戳 超过当前时间5分钟则签名失效
3.  如果c、d都通过则正常请求业务

--------------------

## 实现 ##

<dependency>
 <groupId>org.codehaus.groovy</groupId>
 <artifactId>groovy</artifactId>
 <version>3.0.6</version>
 </dependency>
 
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>fastjson</artifactId>
 <version>1.2.78</version>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

**服务端拦截器：**

package com.cykj.card.filter;
 
 import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.groovy.util.concurrent.concurrentlinkedhashmap.ConcurrentLinkedHashMap;
 import org.apache.groovy.util.concurrent.concurrentlinkedhashmap.Weighers;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Component;
 import org.springframework.util.DigestUtils;
 
 import javax.servlet.*;
 import javax.servlet.annotation.WebFilter;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.*;
 import java.nio.charset.Charset;
 import java.util.*;
 
 /**
 * @author 小影
 * @create 2022-07-04 10:59
 * @describe：
 */
 @Slf4j
 @Order(1)
 @WebFilter
 @Component
 public class ReqFilter implements Filter {
 // 热点缓存
 public static ConcurrentLinkedHashMap<String, String> cache = new ConcurrentLinkedHashMap.Builder<String, String>()
 .maximumWeightedCapacity(30).weigher(Weighers.singleton()).build();
 
 /**
 * 初始化
 *
 * @param filterConfig
 * @throws ServletException
 */
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {
 // key=APPID ,value=密钥 在数据库中加载出来,这里为了演示写死
 cache.put("1234", "XA12#Da");
 }
 
 /**
 * 签名验证时间（TIMES =分钟 * 秒 * 毫秒）
 * 当前设置为：5分钟有效期
 */
 protected static final Integer TIMES = 5 * 60 * 1000;
 
 @Override
 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
 HttpServletRequest request = (HttpServletRequest) req;
 HttpServletResponse response = (HttpServletResponse) res;
 // 判断请求方式
 String method = request.getMethod();
 if ("POST".equals(method)) {
 log.info("POST请求进入...");
 // 获取请求Body参数，需要使用 BodyReaderHttpServletRequestWrapper进行处理
 // 否则会出现异常：I/O error while reading input message； nested exception is java.io.IOException: Stream closed
 // 原因就是在拦截器已经读取了请求体中的内容，这时候Request请求的流中已经没有了数据
 // 解决流只能读取一次的问题：先读取流，然后在将流重新写进去就行了
 ServletRequest requestWrapper = new BodyReaderHttpServletRequestWrapper(request);
 String body = HttpHelper.getBodyString(requestWrapper);
 String bodyString = URLDecoder.decode(body, "utf-8");
 if (StrUtil.isEmpty(bodyString)) {
 Map<String, Object> map = new HashMap<>();
 response.setCharacterEncoding("utf-8");
 PrintWriter writer = response.getWriter();
 response.setHeader("Content-type", "application/json;charset=UTF-8");
 response.setCharacterEncoding("utf-8");
 map.put("code", 7000);
 map.put("msg", "请求参数不能为空");
 writer.print(JSONObject.toJSONString(map));
 writer.close();
 return;
 }
 // 解析参数转JSON格式
 // bodyString = "{" + bodyString.replace("&", "',").replace("=", ":'") + "'}";
 JSONObject jsonObject = JSONObject.parseObject(bodyString);
 // 验签
 boolean validation = validation(jsonObject, response);
 if (!validation) {
 return;
 }
 log.info("POST请求验签通过...");
 // 放行
 chain.doFilter(request, response);
 }
 if ("GET".equals(method)) {
 log.info("GET请求进入...");
 // 获取请求参数
 Map<String, String> allRequestParam = getAllRequestParam(request);
 Set<Map.Entry<String, String>> entries = allRequestParam.entrySet();
 // 参数转JSON格式
 JSONObject jsonObject = new JSONObject();
 entries.forEach(key -> {
 jsonObject.put(key.getKey(), key.getValue());
 });
 // 验签
 boolean validation = validation(jsonObject, response);
 if (!validation) {
 return;
 }
 log.info("GET请求验签通过...");
 // 放行
 chain.doFilter(request, response);
 
 }
 }
 
 /**
 * 验签
 *
 * @param body 请求参数
 * @param response
 * @return
 * @throws IOException
 */
 private boolean validation(JSONObject body, HttpServletResponse response) throws IOException {
 // 拿出请求签名
 String sign = body.getString("sign");
 body.remove("sign");
 // 根据APPID查询的密钥进行重签
 String sign1 = getSign(body);
 
 
 Map<String, Object> map = new HashMap<>();
 response.setCharacterEncoding("utf-8");
 PrintWriter writer = response.getWriter();
 response.setHeader("Content-type", "application/json;charset=UTF-8");
 response.setCharacterEncoding("utf-8");
 // 校验签名
 if (!StringUtils.equals(sign1, sign)) {// APPID查询的密钥进行签名 和 用户签名进行比对
 map.put("code", 10000);
 map.put("msg", "签名错误");
 writer.print(JSONObject.toJSONString(map));
 return false;
 }
 // 校验签名是否失效
 long thisTime = System.currentTimeMillis() - body.getLong("date_time");
 if (thisTime > TIMES) {// 比对时间是否失效
 map.put("code", 10000);
 map.put("msg", "签名失效");
 writer.print(JSONObject.toJSONString(map));
 return false;
 }
 return true;
 }
 
 /**
 * 计算签名
 *
 * @param params
 * @return
 */
 public static String getSign(JSONObject params) {
 // 从缓存中获取密钥
 String key = cache.get(params.getString("app_id"));
 if (StringUtils.isBlank(key)) {
 key = "XA12#Da";// 如果为nulll密钥就从DB中查询，这里演示就写死
 cache.put(params.getString("app_id"), key);// 放入缓存
 }
 // 参数进行字典排序
 String sortStr = getFormatParams(params);
 // 将密钥key拼接在字典排序后的参数字符串中,得到待签名字符串。
 sortStr += "key=" + key;
 // sortStr += "key=xxxxx";
 // 使用md5算法加密待加密字符串并转为大写即为sign
 String sign = SecureUtil.md5(sortStr).toUpperCase();
 return sign;
 }
 
 /**
 * 参数字典排序
 *
 * @param params
 * @return
 */
 private static String getFormatParams(Map<String, Object> params) {
 List<Map.Entry<String, Object>> infoIds = new ArrayList<Map.Entry<String, Object>>(params.entrySet());
 Collections.sort(infoIds, new Comparator<Map.Entry<String, Object>>() {
 public int compare(Map.Entry<String, Object> arg0, Map.Entry<String, Object> arg1) {
 return (arg0.getKey()).compareTo(arg1.getKey());
 }
 });
 String ret = "";
 for (Map.Entry<String, Object> entry : infoIds) {
 ret += entry.getKey();
 ret += "=";
 ret += entry.getValue();
 ret += "&";
 }
 return ret;
 }
 
 /**
 * 获取客户端GET请求中所有的请求参数
 *
 * @param request
 * @return
 */
 private Map<String, String> getAllRequestParam(final HttpServletRequest request) {
 Map<String, String> res = new HashMap<String, String>();
 Enumeration<?> temp = request.getParameterNames();
 if (null != temp) {
 while (temp.hasMoreElements()) {
 String en = (String) temp.nextElement();
 String value = request.getParameter(en);
 res.put(en, value);
 //如果字段的值为空，判断若值为空，则删除这个字段>
 if (null == res.get(en) || "".equals(res.get(en))) {
 res.remove(en);
 }
 }
 }
 return res;
 }
 }

**防止流丢失：**

package com.cykj.card.filter;
 
 import javax.servlet.ReadListener;
 import javax.servlet.ServletInputStream;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletRequestWrapper;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.nio.charset.Charset;
 import java.util.Enumeration;
 
 /**
 * @author 小影
 * @create 2022-07-04 10:59
 * @describe：
 */
 public class BodyReaderHttpServletRequestWrapper extends 
 HttpServletRequestWrapper { 
 
 private final byte[] body; 
 
 public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException { 
 super(request); 
 System.out.println("-------------------------------------------------"); 
 Enumeration e = request.getHeaderNames() ; 
 while(e.hasMoreElements()){ 
 String name = (String) e.nextElement(); 
 String value = request.getHeader(name); 
 System.out.println(name+" = "+value); 
 
 } 
 body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8")); 
 } 
 
 @Override 
 public BufferedReader getReader() throws IOException { 
 return new BufferedReader(new InputStreamReader(getInputStream())); 
 } 
 
 @Override 
 public ServletInputStream getInputStream() throws IOException { 
 
 final ByteArrayInputStream bais = new ByteArrayInputStream(body); 
 
 return new ServletInputStream() {
 @Override
 public boolean isFinished() {
 return false;
 }
 
 @Override
 public boolean isReady() {
 return false;
 }
 
 @Override
 public void setReadListener(ReadListener listener) {
 
 }
 
 @Override
 public int read() throws IOException { 
 return bais.read(); 
 } 
 }; 
 } 
 
 @Override 
 public String getHeader(String name) { 
 return super.getHeader(name); 
 } 
 
 @Override 
 public Enumeration<String> getHeaderNames() { 
 return super.getHeaderNames(); 
 } 
 
 @Override 
 public Enumeration<String> getHeaders(String name) { 
 return super.getHeaders(name); 
 } 
 
 }

**获取POST请求的Body中的参数：**

package com.cykj.card.filter;
    
    import javax.servlet.ServletRequest;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.nio.charset.Charset;
    /**
     * @author 小影
     * @create 2022-07-04 10:59
     * @describe：
     */
    public class HttpHelper {  
        /** 
         * 获取请求Body 
         * 
         * @param request 
         * @return 
         */  
        public static String getBodyString(ServletRequest request) {  
            StringBuilder sb = new StringBuilder();  
            InputStream inputStream = null;  
            BufferedReader reader = null;  
            try {  
                inputStream = request.getInputStream();  
                reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));  
                String line = "";  
                while ((line = reader.readLine()) != null) {  
                    sb.append(line);  
                }  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                if (inputStream != null) {  
                    try {  
                        inputStream.close();  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
                if (reader != null) {  
                    try {  
                        reader.close();  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }
            System.out.println("sb = " + sb);
            return sb.toString();  
        }  
    }

**客户端请求模拟：**

/**
 * @author 小影
 * @create 2022-07-04 17:01
 * @describe：
 */
 @SpringBootTest
 public class TestHttpReq {
 
 public static String secretKey = "XA12#Da";
 @Test
 public void testPost() {
 JSONObject data = new JSONObject();
 data.put("name", "xxx");
 data.put("age", "11");
 data.put("app_id", "1234");
 long dateTime = new Date().getTime();
 data.put("date_time", "1656926899731");
 String sign = getSign(data);
 //修改密钥为数据加密后加密串
 data.put("sign", sign);
 HttpResponse response = HttpRequest.post("localhost:8083/card/ss").form(data).contentType("application/json").execute();
 Object jsonObject = JSONObject.parse(response.body().trim());
 System.out.println("jsonObject = " + jsonObject);
 
 }
 
 @Test
 public void testGet() {
 String url = "localhost:8083/card/ss";
 long dateTime = new Date().getTime();
 //传入参数
 JSONObject data = new JSONObject();
 data.put("name", "123");
 data.put("age", "sss");
 data.put("app_id", "1234");
 data.put("date_time", dateTime);
 String sign = getSign(data);
 url = url + "?name=123&age=sss&appid=1234&dateTime=" + dateTime + "&sign=" + sign;
 HttpResponse response = HttpRequest.get(url).execute();
 System.out.println("response.body() = " + response.body().trim());
 
 }
 
 
 /**
 * 计算签名
 *
 * @param params
 * @return
 */
 public static String getSign(JSONObject params) {
 String sortStr = getFormatParams(params);
 System.out.println("sortStr = " + sortStr);
 //第二步：将tradeKey拼接在1中排序后的字符串后面得到待签名字符串。
 sortStr += "key="+ secretKey;
 System.out.println("sortStr = " + sortStr);
 //sortStr += "key=BF1BDE5A649724056F904A9335B1C1C9";
 //第三步：使用md5算法加密待加密字符串并转为大写即为sign
 String sign = DigestUtils.md5DigestAsHex(sortStr.getBytes()).toUpperCase();
 System.out.println("sign = " + sign);
 return sign;
 }
 
 
 /**
 * 字典排序
 * 获得参数格式化字符串
 * 参数名按字典排序，小写在后面
 */
 private static String getFormatParams(Map<String, Object> params) {
 List<Map.Entry<String, Object>> infoIds = new ArrayList<Map.Entry<String, Object>>(params.entrySet());
 Collections.sort(infoIds, new Comparator<Map.Entry<String, Object>>() {
 public int compare(Map.Entry<String, Object> arg0, Map.Entry<String, Object> arg1) {
 return (arg0.getKey()).compareTo(arg1.getKey());
 }
 });
 String ret = "";
 for (Map.Entry<String, Object> entry : infoIds) {
 ret += entry.getKey();
 ret += "=";
 ret += entry.getValue();
 ret += "&";
 }
 ret = ret.substring(0, ret.length() - 1);
 return ret;
 }
 }

这是小编在开发学习使用和总结的小Demo， 这中间或许也存在着不足，希望可以得到大家的理解和建议。如有侵权联系小编！

[Link 1]: https://baike.baidu.com/item/%E5%AF%86%E7%A0%81%E7%B3%BB%E7%BB%9F/5823651
[Link 2]: https://baike.baidu.com/item/%E5%AF%86%E9%92%A5/101144
[Link 3]: https://baike.baidu.com/item/%E5%85%AC%E5%BC%80%E5%AF%86%E9%92%A5/7453570
[1d588b9f46584ebfabde828a4b0eb3bf.png]: https://img-blog.csdnimg.cn/1d588b9f46584ebfabde828a4b0eb3bf.png
[047768049d05465992f465cd4454ce13.png]: https://img-blog.csdnimg.cn/047768049d05465992f465cd4454ce13.png