当前位置:   article > 正文

【Java】AOP+注解实现前后端传参加解密_java使用aop对接口参数进行解密

java使用aop对接口参数进行解密

封装了一个前后端传参敏感数据加解密小工具,直接通过AOP+注解完成,在项目中亲测有效,特点包括:

  • 使用AES算法,密钥和偏移量基于token的md5加密,增加安全性;
  • 自定义方法注解,待加/解密字段全部放在注解中,不需要和其他任何注解组合使用,也不受其他任何注解的干扰;
  • 支持形参中的待解密对象为:自定义实体(实际加密实体中的指定字符串成员变量)、普通字符串、普通字符串列表;
  • 支持返回值的待加密对象为:单个自定义实体、自定义实体列表、自定义实体分页,实际加密的是实体中的字符串字段。

AES加解密工具类

import org.apache.commons.codec.binary.Base64;

import java.nio.charset.StandardCharsets;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import cn.hutool.core.text.CharSequenceUtil;
import lombok.CustomLog;

import static com.uih.uplus.mti.tm.biz.utils.errorcode.ServiceErrorCode.TM_ILLEGAL_PARAMETER;

/**
 * @author 
 * @description AES/CBC/PKCS5Padding加解密工具类
 * @date 2023/5/25 14:02
 */
@CustomLog
public class AesUtils {
    /**
     * 算法/模式/补码方式
     */
    private static final String MODE_METHOD = "AES/CBC/PKCS5Padding";
    /**
     * 算法
     */
    private static final String ALGORITHM_NAME = "AES";

    /**
     * AES算法加密明文
     *
     * @date: 2023/5/25 14:01
     * @author: 
     */
    public static String encryptAES(String data, String key, String iv) {
        //若字段为 null/"" 直接返回
        if (CharSequenceUtil.isEmpty(data)) {
            return data;
        }
        //加密
        try {
            SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), ALGORITHM_NAME);
            Cipher cipher = Cipher.getInstance(MODE_METHOD);
            //使用CBC模式,需要一个向量iv,可增加加密算法的强度
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec);
            byte[] encrypted = cipher.doFinal(data.getBytes());
            return encode(encrypted);
        } catch (Exception e) {
            throw new AppException(TM_ILLEGAL_PARAMETER);
        }
    }

    /**
     * AES算法解密密文
     *
     * @date: 2023/5/25 13:55
     * @author: 
     */
    public static String decryptAES(String data, String key, String iv) {
        //若字段为 null/"" 直接返回
        if (CharSequenceUtil.isEmpty(data)) {
            return data;
        }
        //解密
        try {
            Cipher cipher = Cipher.getInstance(MODE_METHOD);
            SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), ALGORITHM_NAME);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
            byte[] original = cipher.doFinal(decode(data));
            String originalString = new String(original);
            return originalString.trim();
        } catch (Exception e) {
            throw new AppException(TM_ILLEGAL_PARAMETER);
        }
    }

    /**
     * BASE64编码
     *
     * @date: 2023/5/25 13:54
     * @author: 
     */
    public static String encode(byte[] byteArray) {
        return Base64.encodeBase64String(byteArray);
    }

    /**
     * BASE64解码
     *
     * @date: 2023/5/25 13:54
     * @author: 
     */
    public static byte[] decode(String base64EncodedString) {
        return Base64.decodeBase64(base64EncodedString);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99

加解密注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @description: 针对方法是否开启加解密注解
 * 该注解是一个普通的自定义注解,不需要和其他任何注解组合使用,也不受其他任何注解的干扰
 * 该注解的主要功能是针对入参所有字段中,对与字符串数组decryptParams中同名的字段,尝试对该其进行解密操作
 * 针对出参的所有字段,对与字符串数组encryptParams中同名的字段,尝试对其进行加密操作
 * 注意:
 * 无论待加解密的对象被封装成自定义对象、分页类型、列表类型,AOP方法都会将其一层层剥离,最终仅针对具体的字符串字段做加解密操作
 * 待解密的字段前后端参数名称必须保持一致(即不能使用@RequestParam注解去处理前后端参数名称不一致的情况)
 * 若形参包括自定义类型对象,则该对象名称不能与类型中的成员变量重名
 * 若待解密/加密字段为空值,会直接忽略该字段不做解密/加密处理,后端不会抛出任何异常
 * 若在后端本因被解密的字段,前端传递过来却没有加密,后端不会抛异常,只会在控制台输出错误日志,并将其作为明文处理与使用(增加弹性)
 *
 * @date: 2023/4/1 14:52
 * @author: 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD})
public @interface EncryptMethod {
    /**
     * 从前端传递的参数中,需要解密的字段列表
     */
    String[] decryptParams() default {};

    /**
     * 向前端传递的参数中,需要加密的字段列表
     */
    String[] encryptParams() default {};
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

加解密切面类

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import com.uih.uplus.common.utils.result.Result;
import com.uih.uplus.mti.tm.biz.utils.AesUtils;
import com.uih.uplus.mti.tm.biz.utils.AppException;
import com.uih.uplus.mti.tm.biz.utils.TMPage;
import com.uih.uplus.mti.tm.biz.utils.annotation.encrypt.EncryptMethod;
import com.uih.uplus.mti.tm.biz.utils.uap.utils.TokenUtil;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletRequest;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.crypto.digest.MD5;
import lombok.CustomLog;

import static com.uih.uplus.mti.tm.biz.utils.errorcode.ServiceErrorCode.DECRYPT_FAILED;
import static com.uih.uplus.mti.tm.biz.utils.errorcode.ServiceErrorCode.ENCRYPT_FAILED;
import static com.uih.uplus.mti.tm.biz.utils.errorcode.ServiceErrorCode.NO_SUPPORT_DECRYPT_TYPE;

/**
 * @description: 入参解密/出参加密
 * 支持形参中的待解密对象为:自定义实体(实际解密实体中的指定字符串成员变量)、普通字符串、普通字符串列表
 * 支持返回值的待加密对象为:单个自定义实体、自定义实体列表、自定义实体分页,实际加密的是每个自定义实体中的指定字段
 * @date: 2023/5/16 14:42
 * @author: 
 */
@Component
@Aspect
@CustomLog
public class EncryptAop {
	//基于前端传递的token动态生成密钥和偏移量
    @Autowired
    private TokenUtil tokenUtil;

    /**
     * 切入点
     *
     * @date: 2023/5/17 20:13
     * @author: 
     */
    @Pointcut("@annotation(com.uih.uplus.mti.tm.biz.utils.annotation.encrypt.EncryptMethod)")
    public void pointCut() {
    }

    /**
     * 环绕通知
     *
     * @date: 2023/5/16 16:37
     * @author: 
     */
    @Around("pointCut()")
    public Object aroundEncrypt(ProceedingJoinPoint pjp) throws Throwable {
        //第一步:获取当前被@EncryptMethod注解的方法对象、注解对象
        MethodSignature signature = (MethodSignature)pjp.getSignature();
        Method method = pjp.getTarget().getClass().getMethod(signature.getName(), signature.getParameterTypes());
        EncryptMethod annotation = method.getAnnotation(EncryptMethod.class);

        //第二步:对入参敏感字段解密
        decrypt(pjp, method, annotation);

        //第三步:执行请求处理接口
        Object response = pjp.proceed(pjp.getArgs());

        //第四步:对出参敏感字段加密,并返回
        encrypt(annotation, response);
        return response;
    }

    /**
     * 对入参做解密
     * 支持对入参的自定义实体的字符串类型的成员变量、普通字符串形参的解密
     *
     * @date: 2023/5/17 20:13
     * @author: 
     */
    private void decrypt(ProceedingJoinPoint pjp, Method method, EncryptMethod annotation) {
        String key = MD5.create().digestHex(tokenUtil.getToken().jwtString);
        String iv = MD5.create().digestHex16(tokenUtil.getToken().jwtString);
        
        //获取注解的参数值
        List<String> decryptParam = Lists.newArrayList(annotation.decryptParams());
        ServletRequestAttributes sra = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        if (sra != null) {
            HttpServletRequest request = sra.getRequest();
            //获取请求参数
            try {
                Object[] args = pjp.getArgs();
                Parameter[] params = method.getParameters();
                for (int i = 0; i < args.length; i++) {
                    //判断当前形参是否是自定义实体类型,判断依据:
                    //针对自定义实体类型,接口参数的名称一般与Params或Body中的变量名称不一致
                    //而非自定义实体类型,一般接口参数的名称与Params或Body中的变量名称是一致的

                    //若该形参是自定义实体类
                    if (Boolean.FALSE.equals(getKey(request, params[i].getName()))) {
                        Field[] declaredFields = args[i].getClass().getDeclaredFields();
                        for (Field field : declaredFields) {
                            if (decryptParam.contains(field.getName())) {
                                field.setAccessible(true);
                                field.set(args[i], AesUtils.decryptAES((String)field.get(args[i]), key, iv));
                            }
                        }
                    } else {
                        //若该形参是非自定义实体
                        if (decryptParam.contains(params[i].getName())) {
                            //若该参数是字符串列表
                            if (args[i] instanceof List && Objects.nonNull(args[i]) && (CollUtil.isNotEmpty((List<?>)args[i])) &&
                                (((List<?>)args[i]).get(0) instanceof String)) {
                                args[i] = Convert.toList(String.class, args[i]).stream().map(x -> AesUtils.decryptAES(x, key, iv))
                                        .collect(Collectors.toList());
                            } else if (args[i] instanceof String) {
                                //若该参数是普通字符串
                                args[i] = AesUtils.decryptAES(pjp.getArgs()[i].toString(), key, iv);
                            } else {
                                //暂不支持其他类型形参的解密(如Map、Set、Long等)
                                throw new AppException(NO_SUPPORT_DECRYPT_TYPE);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                logger.error(e.getMessage());
                throw new AppException(DECRYPT_FAILED);
            }
        }
    }

    /**
     * 对出参对象的指定字段加密(仅支持分页、列表、自定义实体类型)
     *
     * @date: 2023/5/17 14:48
     * @author: 
     */
    private void encrypt(EncryptMethod annotation, Object response) {
        if (!Objects.isNull(response) && (response instanceof Result<?>)) {
            Result<?> result = (Result<?>)response;
            if (result.getData() instanceof TMPage<?>) {
                //若返回值为分页类型(TMPage是当前项目的分页类型,其他项目可能有自己的分页类型)
                TMPage<?> page = (TMPage<?>)result.getData();
                page.getRecords().forEach(x -> doEncryptObject(x, Lists.newArrayList(annotation.encryptParams())));
            } else if (result.getData() instanceof List<?>) {
                //若返回值为列表类型
                List<?> list = (List<?>)result.getData();
                list.forEach(x -> doEncryptObject(x, Lists.newArrayList(annotation.encryptParams())));
            } else {
                //其他(默认为自定义实体对象)
                doEncryptObject(result.getData(), Lists.newArrayList(annotation.encryptParams()));
            }
        }
    }

    /**
     * 仅针对自定义实体中的敏感字段加密
     *
     * @date: 2023/5/17 14:19
     * @author: 
     */
    private void doEncryptObject(Object object, List<String> encryptParam) {
        //若加密字段数组为空,直接返回,杜绝了返回值位Boolean的情况
        if (Objects.isNull(object) || CollUtil.isEmpty(encryptParam)) {
            return;
        }

        String key = MD5.create().digestHex(tokenUtil.getToken().jwtString);
        String iv = MD5.create().digestHex16(tokenUtil.getToken().jwtString);
        Field[] declaredFields = object.getClass().getDeclaredFields();
        HashMap<Object, Object> cipherMap = Maps.newHashMap();
        try {
            for (Field field : declaredFields) {
                if (encryptParam.contains(field.getName())) {
                    field.setAccessible(true);
                    String cipherText = (String)field.get(object);
                    cipherText = AesUtils.encryptAES(cipherText, key, iv);
                    cipherMap.put(field.getName(), cipherText);
                }
            }
            BeanUtil.copyProperties(cipherMap, object);
        } catch (Exception e) {
            logger.error(e.getMessage());
            throw new AppException(ENCRYPT_FAILED);
        }
    }

    /**
     * 根据前后端参数名称是否一致判断参数类型
     * 若名称一致则为非自定义类型
     * 若名称不一致则为自定义类型
     *
     * @date: 2023/5/16 15:34
     * @author: 
     */
    public Boolean getKey(HttpServletRequest request, String name) {
        Map<String, String[]> map = request.getParameterMap();

        for (Map.Entry<String, String[]> element : map.entrySet()) {
            if (element.getKey().equals(name)) {
                return true;
            }
        }
        return false;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224

用例

@RestController
@RequestMapping(value = "/app/patient")
public class AppPatientController {

    @Autowired
    private AppPatientService appPatientService;

    /**
     * 分页查询/患者列表信息
     *
     * @date: 2023/4/10 13:45
     * @author: 
     */
    @GetMapping("/page")
    @EncryptMethod(decryptParams = {"keyword"}, encryptParams = {"name", "patientIdNo"})
    public Result<TMPage<InpatientVO>> patientList(@Valid InpatientListDTO inpatientListDTO) {
        return RestResult.success(appPatientService.patientList(inpatientListDTO));
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

入参:

/**
 * @Description 患者列表分页查询请求参数
 * @Date 2022/10/19 10:53
 * @Author 
 */
@Data
public class InpatientListDTO {
    //查询类型:0最近访问 1本院急诊科  2全域患者
    private Integer queryType;
    //搜索关键字(App端使用): 支持身份证号码右模糊、门诊号右模糊、患者姓名全模糊
    private String keyword;
    ......
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

出参:

/**
 * @Description 查询患者住院信息返回对象
 * @Date 2022/10/19 10:53
 * @Author 
 */
@Data
public class InpatientVO {
    //患者治疗周期信息表ID
    private String patientPeriodId;
    //患者姓名
    private String name;
    //身份证号
    private String patientIdNo;
    ......
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

其实上面的整个加解密方法是有缺陷的,比如若存在类嵌套,敏感字段藏得比较深的话,上面的方法就不适用了。当然也有补救办法,就是如果嵌套的类对象中有敏感字段,就将该对象整体加解密,本文没有这样做的原因是项目中并不存在这种情况。
实质上AOP+注解实现前后端传参加解密的方式有很多种思路,根据不同的需求和考量,可以从以下几个方面着手:

  • 如果觉得单独去加解密模型对象中的一个字段比较麻烦,可以考虑暴力地将模型对象整体加解密,不用去剥洋葱找具体的敏感字段;
  • 也可以使用复合注解,不仅在方法上做注解,还需要在敏感字段上使用注解,这样就不需要将所有敏感字段像上面那样放在数组里面了
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/615741
推荐阅读
相关标签
  

闽ICP备14008679号