接口鉴权扩展-从敏感数据的传递-看后端常规加密解密方式

迷南。 2022-12-02 01:28 279阅读 0赞

### 文章目录 ###

*   *  目标
     *  从敏感数据的传递 - 看后端常规加密解密方式
     *   *  查询接口
         *  提交接口
     *  脱敏工具类实践

## 目标 ##

*  了解常规后台加密方式
    
    参考：[谈谈数据脱敏][Link 1]
    
    [接口测试中验签与接口参数加密][Link 2]
    
    [java反射获取List泛型][java_List]
    
    [如何保证HTTP接口请求的安全呢？][HTTP]
    
    [Web安全测试中常见逻辑漏洞解析（实战篇）][Web]
    
    [解读接口常见的安全漏洞][Link 3]
    
    [Web安全测试常见漏洞解析(上)][Web 1]

> 也可以看看参考链接

## 从敏感数据的传递 - 看后端常规加密解密方式 ##

这里的敏感数据指的是，可以影响业务流程和结果的关键参数。

我们期望：

针对查询接口，不泄露敏感数据，防止越权查询。

针对提交接口，防止修改关键参数，影响业务流程和结果。

这些都跟项目的业务息息相关，每个项目有每个项目的做法，那么对于通常的一些情况，做下演示：

以下内容，不是技术规范，而是业务规范。

### 查询接口 ###

（1）不泄露敏感数据 - 将敏感数据脱敏，加密返回

场景： 查询用户信息的接口，期望返回用户数据是脱敏的，并且加密相关的关键参数和签名，以便于其他接口中使用。

思路： 返回用户信息的时候，将敏感数据脱敏，将身份证字段和手机号使用摘要算法（HMAC）加密，并返回使用对称加密算法（AES 、DES）加密后的身份证id

代码实践：

脱敏实现的代码参考：vjkit 唯品会提供的工具类，改造了一下 [日志脱敏][Link 4]

加密算法工具类参考：hutool

代码参考：[codecopy][] 下的 SecurityInterfaceController SecurityInterfaceService

controller

@ApiOperation(value = "针对查询接口，返回脱敏和需要加密的信息和签名字段", notes = "针对查询接口，返回脱敏和需要加密的信息和签名字段")
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/qryUserInfo")
        @ResponseBody
        public ReturnData qryUserInfo() { 
            // TODO 执行业务，返回数据
            ShowUserInfoVo showUserInfoVo = new ShowUserInfoVo();
            showUserInfoVo.setUserName("张三");
            showUserInfoVo.setAddress("北京市朝阳");
            showUserInfoVo.setBankCard("9559480089071474413");
            showUserInfoVo.setIdCard("410329188905068899");
            showUserInfoVo.setEmail("11640@qq.com");
            showUserInfoVo.setPhone("14535634523");
            // 加密 idCard 字段
            Optional<String> encrypt = AESUtils.encrypt(showUserInfoVo.getIdCard(), aeskey);
            showUserInfoVo.setIdkey(encrypt.orElse("error"));
            // 摘要信息，假如在其他接口，需要用到这个接口的返回信息，为了保证数据的完整性和正确性，将某几个字段组拼生成摘要，在下个接口中验证
            // 这里将 手机号 和 身份证id 加盐处理
            String sign = securityInterfaceService.signFields(SecurityInterfaceController.class.getName(), showUserInfoVo.getIdCard(), showUserInfoVo.getPhone());
            showUserInfoVo.setSignkey(sign);
            // 敏感数据的脱敏
            ShowUserInfoVo maskObj = (ShowUserInfoVo) BeanDataMaskUtils.maskObj(showUserInfoVo);
            ReturnData ret = ReturnData.newInstance();
            ret.setSuccess();
            ret.setMessage(maskObj);
            return ret;
        }

service

关注摘要加密算法实践：

HMAC，全称为“Hash Message Authentication Code”，中文名“散列消息鉴别码”，主要是利用哈希算法，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。一般的，消息鉴别码用于验证传输于两个共 同享有一个密钥的单位之间的消息。HMAC 可以与任何迭代散列函数捆绑使用。MD5 和 SHA-1 就是这种散列函数。HMAC 还可以使用一个用于计算和确认消息鉴别值的密钥。

做法：组拼参数，加盐，调用加密算法

/** * 返回字段签名 * * @param salt 盐 * @param fields 字段集合 * @return 摘要 */
        @Override
        public String signFields(String salt, String... fields) { 
            StringBuilder stringBuilder = new StringBuilder();
            Arrays.stream(fields).forEach(
                    field -> { 
                        stringBuilder.append("&" + field);
                    }
            );
            stringBuilder.append(salt);
            String param = stringBuilder.toString();
            byte[] key = hmacKey.getBytes();
            HMac mac = new HMac(HmacAlgorithm.HmacMD5, key);
            return mac.digestHex(param);
        }

脱敏实践

fun.gengzi.codecopy.utils.datamask 包下的代码

// 使用方式
    // 实体类 加上注解，写上脱敏的类型 和 脱敏显示的前缀位数和后缀位数
         @Sensitive(type = BeanDataMaskUtils.SensitiveType.IDCard, keepChars = { 5, 2})
        private String idCard;
     
    // 对象脱敏-新生成的对象属性已经是脱敏之后的了
    // 只支持 String String[] 的属性字段脱敏
        ShowUserInfoVo showUserInfoVo = new ShowUserInfoVo();
         showUserInfoVo.setIdCard("410329188905068899");
         ShowUserInfoVo maskObj = (ShowUserInfoVo) BeanDataMaskUtils.maskObj(showUserInfoVo);

运行结果：

{ 
    "userName": "*三",
    "phone": "145*****523",
    "email": "1***0@qq.com",
    "bankCard": "9559*************13",
    "address": "北****",
    "idCard": "41032***********99",   // 脱敏数据
    "idkey": "DYJjryX7Bv3iQ3CY/qGFhwHuBKjsrSCf6y0C84MLq8s=",   // 身份证id加密
    "signkey": "b87d8b5d855568b551aa5674af12fda9"    // 摘要算法得到的签名
    }

（2）防止越权查询- 某些关键参数，直接从后台直接限制。

不做代码演示了，说几种情况：

根据订单号，查询订单信息。应确保查询的订单信息，是本用户下的，不要查到别人的订单信息了。

根据地区信息，查询某个地区下的数据。应确保本用户是有对该地区查询权限的。

也就说，对于某些关键参数，一定要做校验，或者直接从后台获取。

### 提交接口 ###

限定关键参数值，防止因为修改导致影响业务流程和结果

对于提交接口，某些参数可以从session 、缓存或者数据库读取的，在不影响性能和业务规则的情况下，都从后端获取。如果这些提交参数，的确是用户需要提交的，请在后台加入跟前端的一样的校验规则。  
提交的数据，涉及关联用户之前的部分操作得到的数据，请做关联之前操作的数据正确性检查。

比如上传人脸照片接口，上传完毕，判断成功。在提交接口会把人脸返回的唯一id，再提交进来。  
请检查人脸返回的唯一id，是否存在，是否是当前用户提交的，是否是近期提交的。简单的理解，可以把 session 和人脸id 绑定。在后台加以判断。

场景演示：提交接口接收用户信息，保存用户数据。期望提交的用户数据，必须是之前查询接口返回的用户信息（其实我是找不到啥好例子了。。设计太复杂了，都是跟业务相关的，没有代表性）

思路：校验用户提交的身份证和手机号重新签名后，是否跟查询接口返回的签名一致。一致认为，可以保存用户信息。

代码实践：

controller

@ApiOperation(value = "提交接口，验证签名,解密数据", notes = "提交接口，验证签名，解密数据")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "ShowUserInfoVo", value = "ShowUserInfoVo", required = true)})
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/commitInfo")
        @ResponseBody
        public ReturnData commitInfo(@RequestBody ShowUserInfoVo showUserInfoVo) { 
            logger.info("ShowUserInfoVo ：{}", showUserInfoVo);
            ReturnData ret = ReturnData.newInstance();
            String signkey = showUserInfoVo.getSignkey();
            if (StringUtils.isBlank(signkey)) { 
                throw new RrException(RspCodeEnum.ERROR.getDesc(), RspCodeEnum.ERROR.getCode());
            }
            // 解密身份证数据
            String idkey = showUserInfoVo.getIdkey();
            Optional<String> decrypt = AESUtils.decrypt(idkey, aeskey);
            showUserInfoVo.setIdCard(decrypt.orElse("error"));
            logger.info("解密后的IdCard：{}",showUserInfoVo.getIdCard());
            // 验证签名
            boolean flag = securityInterfaceService.checkSignField(signkey, SecurityInterfaceController.class.getName(), showUserInfoVo.getIdCard(), showUserInfoVo.getPhone());
            if (!flag) { 
                ret.setFailure("参数校验失败，请重新尝试");
            }
            ret.setSuccess();
            ret.setMessage("校验成功，返回数据");
            return ret;
        }

service

/** * 校验字段签名 * * @param signKey 签名 * @param salt 盐 * @param fields 字段集合 * @return true 校验成功， false 校验失败 */
        @Override
        public boolean checkSignField(String signKey, String salt, String... fields) { 
            if (StringUtils.isAnyEmpty(signKey, salt)) { 
                throw new RrException("参数缺少！");
            }
            List<String> fieldsList = Arrays.asList(fields);
            if (fieldsList == null || fieldsList.isEmpty()) { 
                throw new RrException("待签名参数缺少！");
            }
            StringBuilder stringBuilder = new StringBuilder();
            Arrays.stream(fields).forEach(
                    field -> { 
                        stringBuilder.append("&" + field);
                    }
            );
            stringBuilder.append(salt);
            String param = stringBuilder.toString();
            byte[] key = hmacKey.getBytes();
            HMac mac = new HMac(HmacAlgorithm.HmacMD5, key);
            if (signKey.equals(mac.digestHex(param))) { 
                return true;
            }
            return false;
        }

## 脱敏工具类实践 ##

MaskStrategy 脱敏策略接口 提供了 PartMask NameMask DataMask EmailMask 策略

vjkit 只提供了对象转json脱敏 和 单个字段的脱敏，所以在这个基础了改造了一个对象脱敏

BeanDataMaskUtils

public static Object maskObj(Object value) { 
            if (null == value) { 
                return null;
            }
            try { 
                Class<?> aClass = value.getClass();
                Field[] declaredFields = aClass.getDeclaredFields();
                for (Field field : declaredFields) { 
                    if (field.getType() == String.class) { 
                        // 字符串处理
                        Sensitive sensitive = field.getAnnotation(Sensitive.class);
                        SensitiveType sensitiveType = getSensitiveType(field, sensitive);
                        boolean accessible = field.isAccessible();
                        // 修改访问控制权限
                        field.setAccessible(true);
                        Object o = field.get(value);
                        String newValue = mask((String) o, sensitive, sensitiveType);
                        field.set(value, newValue);
                        // 恢复访问控制权限
                        field.setAccessible(accessible);
                    } else if(field.getType() == String[].class){ 
                        // 字符串数组处理
                        Sensitive sensitive = field.getAnnotation(Sensitive.class);
                        SensitiveType sensitiveType = getSensitiveType(field, sensitive);
                        boolean accessible = field.isAccessible();
                        field.setAccessible(true);
                        String[] strArr= (String[]) field.get(value);
                        if(strArr != null){ 
                            for (int i = 0; i < strArr.length; i++) { 
                                strArr[i] = mask(strArr[i], sensitive, sensitiveType);
                            }
                            field.set(value, strArr);
                        }
                        field.setAccessible(accessible);
                    } else if (Collection.class.isAssignableFrom(field.getType())) { 
                        // 集合处理
                        boolean accessible = field.isAccessible();
                        field.setAccessible(true);
                        Collection collection = (Collection) field.get(value);
                        if (collection != null) { 
                            if (field.getGenericType() instanceof ParameterizedType) { 
                                ParameterizedType pt = (ParameterizedType) field.getGenericType();
                                Type[] listActualTypeArguments = pt.getActualTypeArguments();
                                logger.info("类型:{}", listActualTypeArguments[listActualTypeArguments.length - 1]);
                                collection.stream().forEach(obj -> { 
                                    maskObj(obj);
                                });
                                field.setAccessible(accessible);
                            }
                        }
                    }
                }
     
            } catch (Exception e) { 
                e.printStackTrace();
                return value;
            }
            return value;
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]

[Link 1]: https://www.jianshu.com/p/2e69ff5bb3cc
[Link 2]: https://www.cnblogs.com/bugoobird/p/13212496.html
[java_List]: https://blog.csdn.net/langwang1993/article/details/80536872
[HTTP]: https://www.jianshu.com/p/27c25c5978a3
[Web]: https://www.freebuf.com/vuls/112339.html
[Link 3]: https://www.sohu.com/a/364538856_472906
[Web 1]: https://blog.csdn.net/lujianhao_ios/article/details/79733833
[Link 4]: https://github.com/vipshop/vjtools/blob/master/vjkit/docs/data_masking.md
[codecopy]: https://github.com/gengzi/codecopy/tree/master/src/main/java/fun/gengzi/codecopy/business/authentication/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/7636912062b6461d8f804559aab04fa9.png