再谈前后端API签名安全？

上次《前后端API交互如何保证数据安全性?》文章中，我们介绍了如何在Spring Boot框架中去统一处理数据的加解密。对于请求的加密也只做了POST请求的自动加密，今天接着上文来继续介绍GET请求的安全性如何保证?

网站建设哪家好，找创新互联公司！专注于网页设计、网站建设、微信开发、微信小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了横峰免费建站欢迎大家使用！

首先我们来看一个简单的GET请求：

  • http://cxytiandi.com/user?name=yinjihuan

首先很明显的是我们可以看到name参数是明文的，如果对安全性要求很高，建议查询也用POST请求，前面我们对所有POST请求的参数都做了加密操作。

无论是GET还是POST都可以做签名

明文没关系，关键是这个请求我复制到浏览器中打开，把name改成别的值，如果真的存在的话也是能返回结果的。问题就在这，参数被修改了，后端无法识别，这是***个问题。

第二个问题是这个请求可以***的使用，就是你明天去请求这个地址它还能返回结果，这个其实也需要控制下，当然控制的方式有很多种，今天我们会介绍一种比较简单的方式来控制。

***种方式

参数中加签名，前后端约定一个key,将参数按照字母排序拼接成一个字符串，然后拼接上key,***用MD5或者SHA进行加密，***得到一个加密的签名，作为参数传到后端进行验证。

比如：

 
 
 
    
  
  
  
  1. name=yinjihuan&sign=MD5(name=yinjihuan+key) 
    2.

后端我们可以统一在过滤器中进行验证，取得参数sign的值，取得请求的所有参数，同时也按照前端生成sign的方式生成一个新的sign,对两个sign进行比较，如果相等，就证明参数没有被篡改。

为了防止一个请求被多次使用，我们通常会再sign中加上请求那刻的时间戳，服务器这边会判断时间差，如果在10分钟内可以让它继续执行，当然这个10分钟你可以自己去调整，长一点主要是为了方式客户端和服务器时间不一样的问题，当然这种情况不能完全避免。

第二种方式

第二种方式比较简单，因为我们前面讲过了请求的数据加解密，既然我们有了加密的key和加密算法，其实完全可以将签名的内容用我们的加密算法进行加密，上面用的md5方式不是很安全，md5是可以被破解的。

同时因为我这边用的axios来请求数据，可以使用请求拦截器，在请求之前统一对请求进行签名操作，不用在每个地方单独去处理。

在使用get请求时，我们用下面的方式：

 
 
 
    
  
  
  
  1. axios.get('/user', { 
    2.   
  
  
  2.     params: { 
    3.   
  
  
  3.       ID: 12345 
    4.   
  
  
  4.     } 
    5.   
  
  
  5. }) 
    6.   
  
  
  6. .then(function (response) { 
    7.   
  
  
  7.     console.log(response); 
    8.   
  
  
  8.   }) 
    9.   
  
  
  9.  .catch(function (error) { 
    10.   
  
  
  10.     console.log(error); 
    11.   
  
  
  11. }); 
    12.

然后在请求拦截器中我们可以通过params就可以获取当前请求的所有参数信息，这边我们不采用拼接的方式，直接往params中添加一个signTime(签名时间)，然后用对整个params进行加密得到一个sign,通过请求头传递到后台。

此时到后台的数据就是参数信息+签名时间，比如：{name:"yjh",signTime:19210212121212}, 签名就是{name:"yjh",signTime:19210212121212}加密的内容。

 
 
 
    
  
  
  
  1. // 添加请求拦截器 
    2.   
  
  
  2. axios.interceptors.request.use(function (config) { 
    3.   
  
  
  3.      // 在发送请求之前做些什么 
    4.   
  
  
  4.     if (config.method == "get"){ 
    5.   
  
  
  5.        var newParams = config.params; 
    6.   
  
  
  6.        console.log(newParams); 
    7.   
  
  
  7.        if (newParams == undefined) { 
    8.   
  
  
  8.            newParams = new Object(); 
    9.   
  
  
  9.        } 
    10.   
  
  
  10.        newParams.signTime = new Date().getTime(); 
    11.   
  
  
  11.        config.headers.sign = EncryptData(JSON.stringify(newParams)); 
    12.   
  
  
  12.        console.log(JSON.stringify(config)); 
    13.   
  
  
  13.     } 
    14.   
  
  
  14.     if (config.method == "post"){ 
    15.   
  
  
  15.        var newParams = new Object(); 
    16.   
  
  
  16.        newParams.signTime = new Date().getTime(); 
    17.   
  
  
  17.        config.headers.sign = EncryptData(JSON.stringify(newParams)); 
    18.   
  
  
  18.     } 
    19.   
  
  
  19.     return config; 
    20.   
  
  
  20.   }, function (error) { 
    21.   
  
  
  21.     // 对请求错误做些什么 
    22.   
  
  
  22.     return Promise.reject(error); 
    23.   
  
  
  23.  }); 
    24.

后端可以在过滤器中进行签名校验，代码如下：

 
 
 
    
  
  
  
  1. /** 
    2.   
  
  
  2.  * 请求签名验证过滤器
     
    3.   
  
  
  3.  *  
    4.   
  
  
  4.  * 请求头中获取sign进行校验，判断合法性和是否过期
     
    5.   
  
  
  5.  *  
    6.   
  
  
  6.  * sign=加密({参数：值, 参数2：值2, signTime:签名时间戳}) 
    7.   
  
  
  7.  * @author yinjihuan 
    8.   
  
  
  8.  *  
    9.   
  
  
  9.  * @about http://cxytiandi.com/about 
    10.   
  
  
  10.  * 
    11.   
  
  
  11.  */ 
    12.   
  
  
  12. public class SignAuthFilter implements Filter { 
    13.   
  
  
  13.  
    14.   
  
  
  14.     private EncryptProperties encryptProperties; 
    15.   
  
  
  15.  
    16.   
  
  
  16.     @Override 
    17.   
  
  
  17.     public void init(FilterConfig filterConfig) throws ServletException { 
    18.   
  
  
  18.         ServletContext context = filterConfig.getServletContext();   
    19.   
  
  
  19.         ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(context); 
    20.   
  
  
  20.         encryptProperties = ctx.getBean(EncryptProperties.class); 
    21.   
  
  
  21.     } 
    22.   
  
  
  22.  
    23.   
  
  
  23.     @SuppressWarnings("unchecked") 
    24.   
  
  
  24.     @Override 
    25.   
  
  
  25.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
    26.   
  
  
  26.             throws IOException, ServletException { 
    27.   
  
  
  27.         HttpServletRequest req = (HttpServletRequest) request; 
    28.   
  
  
  28.         HttpServletResponse resp = (HttpServletResponse) response; 
    29.   
  
  
  29.         if (req.getMethod().equals("OPTIONS")) { 
    30.   
  
  
  30.             chain.doFilter(request, response); 
    31.   
  
  
  31.             return; 
    32.   
  
  
  32.         } 
    33.   
  
  
  33.         resp.setCharacterEncoding("UTF-8"); 
    34.   
  
  
  34.         String sign = req.getHeader("sign"); 
    35.   
  
  
  35.         if (!StringUtils.hasText(sign)) { 
    36.   
  
  
  36.             PrintWriter print = resp.getWriter(); 
    37.   
  
  
  37.             print.write("非法请求:缺少签名信息"); 
    38.   
  
  
  38.             return; 
    39.   
  
  
  39.         } 
    40.   
  
  
  40.         try { 
    41.   
  
  
  41.             String decryptBody = AesEncryptUtils.aesDecrypt(sign, encryptProperties.getKey()); 
    42.   
  
  
  42.             Map signInfo = JsonUtils.getMapper().readValue(decryptBody, Map.class); 
    43.   
  
  
  43.             Long signTime = (Long) signInfo.get("signTime"); 
    44.   
  
  
  44.  
    45.   
  
  
  45.             // 签名时间和服务器时间相差10分钟以上则认为是过期请求，此时间可以配置 
    46.   
  
  
  46.             if ((System.currentTimeMillis() - signTime) > encryptProperties.getSignExpireTime() * 60000) { 
    47.   
  
  
  47.                 PrintWriter print = resp.getWriter(); 
    48.   
  
  
  48.                 print.write("非法请求:已过期"); 
    49.   
  
  
  49.                 return; 
    50.   
  
  
  50.             } 
    51.   
  
  
  51.  
    52.   
  
  
  52.             // POST请求只处理时间 
    53.   
  
  
  53.             // GET请求处理参数和时间 
    54.   
  
  
  54.             if(req.getMethod().equals(HttpMethod.GET.name())) { 
    55.   
  
  
  55.                 Set paramsSet = signInfo.keySet(); 
    56.   
  
  
  56.                 for (String key : paramsSet) { 
    57.   
  
  
  57.                     if (!"signTime".equals(key)) { 
    58.   
  
  
  58.                         String signValue = signInfo.get(key).toString(); 
    59.   
  
  
  59.                         String reqValue = req.getParameter(key).toString(); 
    60.   
  
  
  60.                         if (!signValue.equals(reqValue)) { 
    61.   
  
  
  61.                             PrintWriter print = resp.getWriter(); 
    62.   
  
  
  62.                             print.write("非法请求:参数被篡改"); 
    63.   
  
  
  63.                             return; 
    64.   
  
  
  64.                         } 
    65.   
  
  
  65.                     } 
    66.   
  
  
  66.                 } 
    67.   
  
  
  67.             } 
    68.   
  
  
  68.         } catch (Exception e) { 
    69.   
  
  
  69.             PrintWriter print = resp.getWriter(); 
    70.   
  
  
  70.             print.write("非法请求:" + e.getMessage()); 
    71.   
  
  
  71.             return; 
    72.   
  
  
  72.         } 
    73.   
  
  
  73.         chain.doFilter(request, response); 
    74.   
  
  
  74.     } 
    75.   
  
  
  75.  
    76.   
  
  
  76.     @Override 
    77.   
  
  
  77.     public void destroy() { 
    78.   
  
  
  78.  
    79.   
  
  
  79.     } 
    80.   
  
  
  80.  
    81.   
  
  
  81. } 
    82.

首先我们会对签名信息进行判断，没有则拦截掉，然后进行解密操作，得到签名时间，判断有效期，***再根据解密得到的参数信息，循环去和当前请求中的参数进行比较，只要有一个对不上，那就是参数被篡改了，这边我做的比较简单，对值的判断都转成字符串来比较，不确定在一些特殊数据类型是否有问题，大家可以自己去改。

验证的代码我也封装到了我的那个spring-boot-starter-encrypt中(欢迎Star)：https://github.com/yinjihuan/spring-boot-starter-encrypt

只需要配置过滤器即可：

 
 
 
    
  
  
  
  1. /** 
    2.   
  
  
  2.  * 注册签名验证过滤器 
    3.   
  
  
  3.  * @return 
    4.   
  
  
  4.  */ 
    5.   
  
  
  5. @Bean   
    6.   
  
  
  6. public FilterRegistrationBean signAuthFilter() {   
    7.   
  
  
  7.     FilterRegistrationBean registrationBean = new FilterRegistrationBean();   
    8.   
  
  
  8.     registrationBean.setFilter(new SignAuthFilter());   
    9.   
  
  
  9.     registrationBean.setUrlPatterns(Arrays.asList("/rest/*"));   
    10.   
  
  
  10.     return registrationBean;   
    11.   
  
  
  11. } 
    12.

以上代码大家不一定能用到，我个人认为没必要复制我的代码去实验，理解思路才是你***的选择。简单分享，勿喷哈。。。。。。。。。。。

本文题目：再谈前后端API签名安全？
文章源于：http://www.mswzjz.com/qtweb/news14/184414.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站建设知识

分类信息网站

吉安网站建设　　 　成都企业网站建设公司　　 　定制网站设计　　 　丹棱网站建设　　 　响应式网站设计方案　　 　铁科精智测控　　 　小程序开发　　 　成都主机托管　　 　兴发搬家　　 　网站托管运营　　 　Android开发　　 　传美奇电气　　 　成都全网营销　　 　成都恒翔机电维修　　 　成都网站建设　　 　网站方案　　 　电信内江机房　　 　合江网站建设　　 　温江网站制作　　 　成都小程序制作