API横向越权修复之ID加密

• 横向越权

横向越权一般发生在应用系统做了【认证】，但没有做【鉴权】的情况下，也是最常见的漏洞之一。

• 认证：即识别是否有权限访问系统；
• 鉴权：即识别在系统中的权限是什么；

例如：

// 访问某数据查询接口,接口返回ID为123的数据信息

POST : https://xxxx/iservice/queryInfo?detail_id=123 

请求接口时一般都会要求携带TOKEN，无论是JWT还是RSA的，至少不会是裸奔。这里的TOKEN就是【认证】信息，接口通过TOKEN去判断当前用户是否有请求接口的权限。但如果接口中没有做【鉴权】则会发生横向越权，用户通过修改detail_id的值就可以遍历DB中的所有记录。

解决的思路：

• 建立数据权限：常见的有：【RBAC：role based access control】, 基于角色的权限控制，一般用户不被直接授予权限，而是通过Role去获取权限。将数据的访问权限与角色绑定，用户拥有什么角色才能看到什么数据，这样即使遍历接口也只能查询到当前用户自己的数据；
• ID加密：如例子中的detail_id，如果我们换成uuid，或其他无规则的值，也可以降低被遍历的可能性；

建立完善的权限策略是控制越权最合适的方法，但很多系统已经维护了很多年，里面的功能很庞大，往里面集成权限策略难度较大，需要去定义角色，梳理业务数据与角色的关系，然后开发权限管理功能，再挨个功能去添加鉴权；这里提供ID加密的方式去处理横向越权。

• 目的：

    1、对原代码（业务）入侵小；
    2、降低数据遍历风险；
    3、投入人天小；
  

• 代码实现思路

通过全局拦截API入参与返回值，对可遍历字段进行加解密。无需前端参与，后端返回数据时，对字段进行加密，加密算法保存在后端，前端使用加密字段进行后续业务处理，后端接口入参接收时进行解密。

用户选择查看序号1的行时，请求后端返回详细数据，接口如下：

https://xxxx/iservice/queryInfo?detail_id=wMul8LwP

此时如果要恶意遍历接口的话，难度相对较高，还可以将ID的加密强度提升来提供安全性。

• 代码实现

以下均基于JAVA语言+springboot框架实现。通过反射，在拦截中判断字段是否有加密或解密注解，进行对应的加解密操作后流转。

• 自定义注解

/**
 * 字段解密
 * @author lu
 */
@Target({
   ElementType.FIELD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface Decrypt {
   

}

	解密在接口入参中使用，一般为RO对象，或者是基础类型的参数，所以作用域为FIELD或PARAMETER

/**
 * 字段加密
 * @author lu
 */
@Target({
   ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Encrypt {
   

}

	加密在返回值（VO）中使用，一般都为对象，所以注解作用域为FIELD；

• 加密算法

  加密强度自己选择，这里以DES加密为例

/**
 * 加解密
 * @author lu
 */
@Slf4j
public class DesUtil {
   

    public static final String SECURITY_KEY = "IxDQ4e5bCEY";
    public static String encrypt(String info) {
   
        byte[] key = new byte[0];
        try {
   
            key = new BASE64Decoder().decodeBuffer(SECURITY_KEY);
        } catch (IOException e) {
   
            log.error("加密失败",e);
        }
        DES des = SecureUtil.des(key);
        String encrypt = des.encryptHex(info);
        return encrypt;
    }

    public static String decode(String encrypt) {
   
        byte[] key = new byte[0];
        try {
   
            key = new BASE64Decoder().decodeBuffer(SECURITY_KEY);
        } catch (IOException e) {
   
            log.error("解密失败",e);
        }
        DES des = SecureUtil.des(key);
        return des.decryptStr(encrypt);
    }
}

• 接口返回值加密

    responseBodyAdvice —— 响应体的统一处理器，一般用来统一返回值使用。这里用于返回值字段加密。
  

/**
 * 返回值字段加密
 * @author lu
 */
@Slf4j
@RestControllerAdvice
public class ResponseEncryptAdvice implements ResponseBodyAdvice {
   

    /** 此处如果返回false , 则不执行当前Advice的业务 */
    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
   
        return true;
    }

    /**
     * @title 写返回值前执行
     *
     * */
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
   
        try {
   
            // 获取data类型
            Class clazz = body.getClass();
            // 是否是集合
            boolean isCollectionType = Collection.class.isAssignableFrom(clazz);
            if(isCollectionType){
   
                return encodeList(body);
            }else{
   
                return encode(body);
            }
        }catch (Exception e){
   
            log.error("请求后置处理异常",e);
        }
        return body;
    }

    /**
     * 递归加密
     */
    private JSONObject encode(Object object) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
   
        // 获取data类型
        Class clazz = object.getClass();
        // 转成JSON处理，字段加密后数据类型会变，原类无法处理
        JSONObject jsonObject = (JSONObject) JSONObject.toJSON(object);
        // 递归遍历类里及父类所有属性，找到所有带加密注解的字段
        Field[] fields = FieldsUtils.getClassAllFields(clazz);
        for (Field field : fields) {
   
            // 获取字段值
            field.setAccessible(true);
            Object val = field.get(object);
            if(val==null){
   
                // 空值不处理
                continue;
            }
            // final 修饰的跳过！！！，避免出现递归死循环的问题，例如：PageInfo
            int modify = field.getModifiers();
            if(Modifier.isFinal(modify)){
   
                continue;
            }
            // 字段类型
            Class valClass = val.getClass();
            // 是否是集合
            boolean isCollectionType = Collection.class.isAssignableFrom(valClass);
            // 是否是对象，排除掉基础数据类型与包装类
            boolean isObject = isJsonObject(val);
            // 如果是带加密注解的字段，不管什么类型，直接转String加密
            if(field.isAnnotationPresent(Encrypt.class)){
   
                // 字段加密
                jsonObject.put(field.getName(), DesUtil.encrypt(val.toString()));
            }
            // 如果是集合类型
            else if(isCollectionType){
   
                JSONArray jsonArray = encodeList(val);
                jsonObject.put(field.getName(),jsonArray);
            }
            // 基础数据类型
            else if(!isObject){
   
                // 基础数据类型且没有注解，直接放过
                continue;
            }
            // 如果是自定义的类，则继续下沉找是否有加密字段
            else /*if (valClass.getPackage().getName().startsWith("com.lu.test"))*/{
   
                jsonObject.put(field.getName(),encode(val));
            }
            /*// 其他接口带泛型的，例如：Ipage , PageInfo
            else if(valClass.equals(IPage.class)){
                // 调用获取行数据的方法
                Method method = valClass.getMethod("size");
            }else if(valClass.equals(PageInfo.class)){
                // 把PageInfo转成JSON处理
                JSONObject jsonObject = (JSONObject) JSONObject.toJSON(object);
                // 调用获取行数据的方法
                Method method = valClass.getMethod("getList");
                // 获取行数据
                Object rows = method.invoke(val);
            }*/
        }
        return jsonObject;
    }

    /**
     * 集合
     * @param object
     * @return
     */
    private JSONArray encodeList(Object object) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
   
        // 以JSONARRAY存储
        JSONArray jsonArray =  new JSONArray();
        Class clazz = object.getClass();
        // 遍历集合
        Method sizeMethod = clazz.getMethod("size");
        // 调用List的size()方法获取元素数量
        int size = (int)sizeMethod.invoke(object);
        // 获取元素
        Method toArrayMethod = clazz.getMethod("toArray");
        Object[] elementArr = (Object[]) toArrayMethod.invoke(object);
        for (int i = 0; i < size; i++) {
   
            // 获取元素属性
            //Field listField = clazz.getDeclaredField("elementData");
            // 设置访问权限
            //listField.setAccessible(true);
            // 获取元素
            Object element = elementArr[i];
            // 丢进去递归
            jsonArray.add(encode(element));
        }
        return jsonArray;
    }

    /**
     * 判断是否是JSON字符串
     * @param object
     * @return
     */
    private static boolean isJsonObject(Object object) {
   
        try {
   
            JSONObject jsonObject = (JSONObject) JSONObject.toJSON(object);
            return true;
        } catch (Exception e) {
   
            return false;
        }
    }
}

适用于常见的返回值类型List<> ,Ipage , PageInfo, 以及自定义返回对象 。

• 接口入参解密 （POST / JSON）

    入参的处理相对麻烦，因为参数的位置（contentType）多样性.
  

/**
 * 入参解密
 * @author lu
 */
@Slf4j
@RestControllerAdvice
public class RequestJsonBodyDecryptAdvice implements RequestBodyAdvice {
   

    /** 此处如果返回false , 则不执行当前Advice的业务 */
    @Override
    public boolean supports(MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
   
        return true;
    }

    /**
     * @title 读取参数前执行
     * @description 在此做些编码 / 解密 / 封装参数为对象的操作
     *
     * POST 请求 JSON格式入参会进入这里
     *
     * */
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) throws IOException {
   
        try{
   
            // 当前接口方法
            Method method = methodParameter.getMethod();
            // 获取参数集合 @RequestBody 只有一个参数
            Parameter[] parameters = method.getParameters();
            if(ArrayUtils.isNotEmpty(parameters)){
   
                for (Parameter parameter : parameters) {
   
                    if(parameter.isAnnotationPresent(RequestBody.class)){
   
                        Class bodyType = parameter.getType();
                        return  new DecryptHttpInputMessage(httpInputMessage,type,bodyType);
                    }
                }
            }
        }catch (Exception e){
   
            log.error("请求参数解密失败",e);
            throw new BusinessException("请求参数错误！");
        }
        return httpInputMessage;
    }

    /**
     * @title 读取参数后执行
     * @author Xingbz
     */
    @Override
    public Object afterBodyRead(Object body, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
   
        return body;
    }

    /**
     * @title 无请求参数时的处理
     */
    @Override
    public Object handleEmptyBody(Object body, HttpInputMessage httpInputMessage, MethodParameter methodParameter, Type type, Class<? extends HttpMessageConverter<?>> aClass) {
   
        return body;
    }


    /**
     * 解密-使用解密后的数据，构造新的读取流
     */
    class DecryptHttpInputMessage implements HttpInputMessage {
   
        private HttpHeaders headers;

        private InputStream body;

        public DecryptHttpInputMessage(HttpInputMessage inputMessage, Type type,Class bodyType) throws Exception {
   
            // 转存请求头
            this.headers = inputMessage.getHeaders();
            // 请求JSON
            String bodyStr = StringUtils.defaultString(IOUtils.toString(inputMessage.getBody(), "UTF-8"));
            log.info("headers:{},body:{}",headers,bodyStr);
            try {
   
                // 有些保存接口是LIST，需要特殊处理
                if(bodyType.equals(List.class)){
   
                    // 获取LIST的内部泛型类
                    JSONArray jsonArray = JSONObject.parseArray(bodyStr);
                    JSONArray decryptArray = new JSONArray();
                    if (ObjectUtils.isEmpty(type)){
   
                        this.body = IOUtils.toInputStream(jsonArray.toJSONString(), "UTF-8");
                        return;
                    }
                    ParameterizedType parameterizedType = (ParameterizedType) type;
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    Class<?> elementType = (Class<?>) actualTypeArguments[0];
                    for (Object o : jsonArray) {
   
                        decryptArray.add(decode(JSONObject.parseObject(JSONObject.toJSONString(o)),elementType));
                    }
                    // 传递到接口
                    this.body = IOUtils.toInputStream(decryptArray.toJSONString(), "UTF-8");
                }else {
   
                    // 先转成JSON对象
                    JSONObject jsonObject = JSONObject.parseObject(bodyStr);
                    // 解密
                    JSONObject finObject = decode(jsonObject, bodyType);
                    // 传递到接口
                    this.body = IOUtils.toInputStream(finObject.toJSONString(), "UTF-8");
                }
            } catch (Exception e) {
   
                log.error("加密参数【{}】解密失败：{}", bodyStr, e.getMessage(), e);
                // 传递到接口
                this.body = IOUtils.toInputStream(bodyStr, "UTF-8");
            }
        }

        @Override
        public InputStream getBody() {
   
            return body;
        }

        @Override
        public HttpHeaders getHeaders() {
   
            return headers;
        }

    }

    /**
     * 递归解密
     */
    private JSONObject decode(JSONObject jsonObject,Class type) throws IllegalAccessException, NoSuchMethodException, NoSuchFieldException {
   
        // 取对象里的属性
        Set<String> keys = jsonObject.keySet();
        // 取接受入参里的所有属性
        Field[] fields = FieldsUtils.getClassAllFields(type);
        // 匹配两者，解密、字段类型转换
        for (Field field : fields) {
   
            field.setAccessible(true);
            // 字段名
            String fieldName = field.getName();
            // 字段类型
            Class fieldType = field.getType();
            // 如果JSON中没有，则直接跳过
            if(!keys.contains(fieldName)){
   
                continue;
            }
            // 是否是集合
            boolean isCollectionType = Collection.class.isAssignableFrom(fieldType);
            // 当前字段是否带有解密注解
            if(field.isAnnotationPresent(Decrypt.class)){
   
                // 需要解密,一定是要String类型
                String val = jsonObject.getString(fieldName);
                // 解
                String finVal = DesUtil.decode(val);
                // 判断原来是什么类型
                //log.info("fileType:{}",fieldType);

                if(ClassUtils.isPrimitiveOrWrapper(fieldType)){
   
                    // 基础数据类型 直接替换
                    jsonObject.put(fieldName,finVal);
                }else if(fieldType.equals(List.class)){
   
                    // LIST集合，用array的接口换成LIST去接收
                    jsonObject.put(fieldName,JSONObject.parseArray(finVal));
                }else{
   
                    if(isJsonString(finVal)) {
   
                        jsonObject.put(fieldName,JSONObject.parseObject(finVal));
                    }else{
   
                        // 还存在一些BigDecimal类似的，无法被判断为基础数据类型，回到这里
                        jsonObject.put(fieldName,finVal);
                    }
                }
            }else if(fieldType.getPackage().getName().startsWith("com.lu.test")){
   
                // 如果是com.lu.test这个根包下的自定义对象，则递归向下找
                jsonObject.put(fieldName,decode(jsonObject.getJSONObject(fieldName),fieldType));
            }else if(isCollectionType){
   
                // 以JSONARRAY存储
                JSONArray jsonArray =  jsonObject.getJSONArray(fieldName);
                JSONArray decodeArray = new JSONArray();
                // 获取LIST中的泛型集合
                Type listType = field.getGenericType();
                ParameterizedType parameterizedType = (ParameterizedType) listType;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                Class<?> elementType = (Class<?>) actualTypeArguments[0];
                // 遍历集合
                for (Object o : jsonArray) {
   
                    // 获取元素属性
                    decodeArray.add(decode(JSONObject.parseObject(JSON.toJSONString(o)),elementType));
                }
                jsonObject.put(field.getName(),decodeArray);
            }
        }
        return jsonObject;
    }


    /**
     * 判断是否是JSON字符串
     * @param jsonString
     * @return
     */
    private static boolean isJsonString(String jsonString) {
   
        try {
   
            JSONObject.parseObject(jsonString);
            return true;
        } catch (Exception e) {
   
            return false;
        }
    }
}

• 接口入参解密 （GET & POST FORM-DATA | URL）

/**
 * 入参解密
 *
 * @author lu
 */
@Slf4j
@Component
public class RequestParamDecryptAdvice implements HandlerInterceptor {
   

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
   
        //部分get请求不会带Content-Type
        /*if (ObjectUtils.isEmpty(request.getContentType())){
            return true;
        }*/
        // application/json 直接放过
        if(ObjectUtils.isNotEmpty(request.getContentType()) && request.getContentType().toLowerCase().contains("application/json")){
   
            return true;
        }
        if (ObjectUtils.isEmpty(request.getContentType())){
   
            log.warn("当前请求 contentType 为空!");
        }
        // 请求头里获取解密标识
        String flag = request.getHeader(DecryptRequestWrapper.DECRYPT_FLAG);
        if (StringUtils.isEmpty(flag)) {
   
            // 生成包装类
            DecryptRequestWrapper decryptRequest = new DecryptRequestWrapper(request);
            // 判断是否需要解密
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            //获取参数名集合
            String[] parameterNames = ParameterUtil.getParameterNames(method);
            // 获取参数集合
            Parameter[] parameters = method.getParameters();
            if (ArrayUtils.isNotEmpty(parameters)) {
   
                try {
   
                    // 遍历参数
                    int i=0;
                    for (Parameter parameter : parameters) {
   
                        // 获取参数类型
                        Class paramterType = parameter.getType();
                        // 断参数是否是基本数据类型以及包装类 && 带有解密注解
                        if (ClassUtils.isPrimitiveOrWrapper(paramterType) && parameter.isAnnotationPresent(Decrypt.class)) {
   
                            // 获取密文
                            //JDK版本必须是1.8及以上
                            //编译时候必须有编译选项：javac -parameters打开，默认是关闭的
                            // 否则这里parameter.getName()拿不到真实的参数名字
                            if (i>parameters.length-1) {
   
                                return true ;
                            }
                            String orginVal = request.getParameter(parameterNames[i]);
                            // 空值不处理
                            if (StringUtils.isEmpty(orginVal)) {
   
                                log.warn("形参：{}未从入参中获取到值", parameterNames[i]);
                                continue;
                            }
                            // 非空解密 覆盖
                            decryptRequest.setParameter(parameterNames[i], DesUtil.decode(orginVal));

                        }
                        // 自动以RO处理
                        else if (paramterType.getPackage().getName().startsWith("com.lu.test")) {
   
                            // 获取所有字段
                            Field[] fields = paramterType.getDeclaredFields();
                            // 是否带解密注解（这里不递归，不考虑RO里还玩嵌套的,不是JSON格式的应该不存在这种情况）
                            for (Field field : fields) {
   
                                if (ClassUtils.isPrimitiveOrWrapper(field.getType()) && field.isAnnotationPresent(Decrypt.class)) {
   
                                    // 获取密文
                                    String orginVal = request.getParameter(field.getName());
                                    // 空值不处理
                                    if (StringUtils.isEmpty(orginVal)) {
   
                                        log.warn("形参：{}未从入参中获取到值", field.getName());
                                        continue;
                                    }
                                    // 非空解密 覆盖
                                    decryptRequest.setParameter(field.getName(), DesUtil.decode(orginVal));
                                }
                            }
                        }
                        i++;
                        // 其他常见的 request/response对象这些都不处理
                    }
                } catch (Exception e) {
   
                    log.error("字段解密异常！", e);
                }
            }
            String uri = request.getRequestURI().replace(request.getContextPath(), "");
            request.getRequestDispatcher(uri).forward(decryptRequest, response);
            return false;
        }
        // 已经解密的
        return true;
    }


    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
   
    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
   
    }
}

	HandlerInterceptor 需要结合WebMvcConfigurer才能生效

/**
 * @author lu
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
   

    @Autowired
    RequestParamDecryptAdvice requestParamDecryptAdvice;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
   
        registry.addInterceptor(requestParamDecryptAdvice);
    }
}

• 反射参数获取工具

/**
 * 自 java8 开始，可以通过反射得到方法的参数名，不过这有个条件：你必须手动在编译时开启-parameters 参数
 * 部署项目时不可能设置这种东西，
 */
public class ParameterUtil {
   
    /**
     * Spring自带的参数提取工具类
     */
    private static final DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();

    /**
     * 获取参数名
     *
     * @param method 方法
     * @return 参数名
     */
    @Nullable
    public static String[] getParameterNames(Method method) {
   
        return discoverer.getParameterNames(method);
    }

    /**
     * 获取参数名
     *
     * @param ctor 构造函数
     * @return 参数名
     */
    @Nullable
    public static String[] getParameterNames(Constructor<?> ctor) {
   
        return discoverer.getParameterNames(ctor);
    }
}

• 应用场景

    // ResponseResult 为自定义的统一返回值
    @PostMapping("/query1")
    public ResponseResult<SupErpVo> querySup(@RequestBody SupErpRo ro) {
   
        return supService.querySup(ro);
    }

	// ResponseResult 为自定义的统一返回值
	// IPage 为分页插件返回值
    @GetMapping("/query2")
    public ResponseResult<IPage<SupErpVo>> querySup(@RequestParam @Decrypt Long headId) {
   
        return supService.querySup(headId);
    }

	@Data
	public class SupErpVo {
   
	    
	    // 可遍历字段加密
	    @Encrypt
	    private Long id;
	
	    private String supName;
	    
	    private String supDep;
	}

	@Data
	public class SupErpRo {
   
	    
	    // 加密字段解密
	    @Decrypt
	    private Long id;
	
	    private String supName;
	    
	}