devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot中的后端接口加密解密_springboot @encrypt

作者：2023面试高手 | 2024-05-24 20:16:19

赞

踩

springboot @encrypt

近期在项目中因为安全红线要求需要进行接口加解密，在此记录一下。

通过@ControllerAdvice扫描所有接口进行接口加密以及接口解密，本文选择的是AES加密，通过密匙及偏移量加密接口数据。

一.结构：

//加密方法，通过@ControllerAdvice扫描所有接口，对含有@EncryptResponse注解的类或者方法进行加密

  1. /**
  2.  * 请求响应处理类
  3.  * 对加了@Encrypt的方法的数据进行加密操作
  4.  *
  5.  * @author gzy
  6.  */
  7. @ControllerAdvice
  8. @Slf4j
  9. public class EncryptResponseBodyAdvice implements ResponseBodyAdvice<Object> {
  10.  
  11.     @Override
  12.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
  13.         //在这里调用needEncrypet方法判断是否需要加密
  14.         return new NeedCrypto().needEncrypt(returnType);
  15.     }
  16.     
  17.     //这个方法截取了接口中返回的对象，在对对象加密后返回
  18.     @Override
  19.     public Object beforeBodyWrite(Object obj, MethodParameter returnType, MediaType selectedContentType,
  20.                                   Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest serverHttpRequest,
  21.                                   ServerHttpResponse serverHttpResponse) {
  22.         // 通过 ServerHttpRequest的实现类ServletServerHttpRequest 获得HttpServletRequest
  23.         ServletServerHttpRequest sshr = (ServletServerHttpRequest) serverHttpRequest;
  24.         // 此处获取到request 是为了取到在拦截器里面设置的一个对象 是我项目需要,可以忽略
  25.         HttpServletRequest request = sshr.getServletRequest();
  26.  
  27.         String returnData;
  28.         String realData = "";
  29.         JSONObject data = new JSONObject();
  30.         try {
  31.             data = (JSONObject) JSONObject.toJSON(obj);
  32.             if(!data.get("data").toString().isEmpty()){
  33.                 realData = data.get("data").toString();
  34.             }
  35.             // 添加encry header，告诉前端数据已加密
  36.             serverHttpResponse.getHeaders().add("encrypt", "true");
  37.             // 加密
  38.             returnData = AESOperator.replace(AESUtil.encrypt(realData));
  39.  
  40.             log.debug("接口={},原始数据={},加密后数据={}", request.getRequestURI(), realData, returnData);
  41.             data.put("data", returnData);
  42.         } catch (Exception e) {
  43.             log.error("异常！", e);
  44.         }
  45.         return data;
  46.     }
  47. }

//解密方法，通过@ControllerAdvice扫描所有接口，对含有@DecryptRequest注解的类或者方法进行解密

  1. /**
  2.  * 请求数据接收处理类
  3.  * 对加了@Decrypt的方法的数据进行解密操作
  4.  *
  5.  * @author gzy
  6.  */
  7. @ControllerAdvice
  8. @Slf4j
  9. public class DecryptRequestBodyAdvice implements RequestBodyAdvice {
  10.     
  11.     //needDecrypt判断是否需要解密
  12.     @Override
  13.     public boolean supports(MethodParameter methodParameter, Type targetType,
  14.                             Class<? extends HttpMessageConverter<?>> converterType) {
  15.         return new NeedCrypto().needDecrypt(methodParameter);
  16.     }
  17.  
  18.     @Override
  19.     public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter,
  20.                                   Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
  21.         return body;
  22.     }
  23.  
  24.     @Override
  25.     public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
  26.                                            Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
  27.         return inputMessage;
  28.     }
  29.     
  30.     //拦截接口中的入参，对入参进行解密后返回
  31.     @Override
  32.     public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType,
  33.                                 Class<? extends HttpMessageConverter<?>> converterType) {
  34.         JSONObject dealData = new JSONObject();
  35.         try {
  36.             // 解密操作
  37.             JSONObject encryptObject = (JSONObject) JSONObject.toJSON(body);
  38.             String srcData = String.valueOf(encryptObject.get("encryptData"));
  39.             String decryptData = AESUtil.decrypt(srcData);
  40.             dealData = JSON.parseObject(decryptData);
  41.         } catch (Exception e) {
  42.             log.error("请求body参数格式解析异常！", e);
  43.         }
  44.         return dealData;
  45.     }
  46. }

//NeedCrypto类，判断是否需要进行加解密，类中是否需要加解密的逻辑可以根据需要进行修改，

目前代码中的逻辑为：注解在类上加密解密整个类，在方法是加密解密单个方法

  1. /**
  2.  * 判断是否需要加解密
  3.  *
  4.  * @author gzy
  5.  * @date 2021/09/03
  6.  */
  7. @Configuration
  8. @Log4j2
  9. public class NeedCrypto {
  10.     
  11.     //开关变量，在配置文件中配置是否开启加解密功能，不需要可以去掉
  12.     @Value("${encrypt.api.flag}")
  13.     private boolean encryptApiFlag;
  14.  
  15.     private static boolean flag = false;
  16.  
  17.     @PostConstruct
  18.     public void NeedCrypto() {
  19.         flag = encryptApiFlag;
  20.     }
  21.  
  22.     /**
  23.      * 是否需要对结果加密
  24.      * 1.类上标注或者方法上标注,并且都为true
  25.      * 2.有一个标注为false就不需要加密
  26.      */
  27.     public boolean needEncrypt(MethodParameter returnType) {
  28.         boolean encrypt = false;
  29.         if (flag) {
  30.             boolean classPresentAnno = returnType.getContainingClass().isAnnotationPresent(EncryptResponse.class);
  31.             boolean methodPresentAnno = returnType.getMethod().isAnnotationPresent(EncryptResponse.class);
  32.  
  33.             if (classPresentAnno) {
  34.                 //类上标注的是否需要加密
  35.                 encrypt = returnType.getContainingClass().getAnnotation(EncryptResponse.class).value();
  36.                 if (encrypt) {
  37.                     return encrypt;
  38.                 }
  39.                 //类不加密，所有都不加密
  40.                 /**if(!encrypt){
  41.                  return false;
  42.                  }*/
  43.             }
  44.             if (methodPresentAnno) {
  45.                 //方法上标注的是否需要加密
  46.                 encrypt = returnType.getMethod().getAnnotation(EncryptResponse.class).value();
  47.             }
  48.         }
  49.         return encrypt;
  50.     }
  51.  
  52.     /**
  53.      * 是否需要参数解密
  54.      * 1.类上标注或者方法上标注,并且都为true
  55.      * 2.有一个标注为false就不需要解密
  56.      */
  57.     public boolean needDecrypt(MethodParameter parameter) {
  58.         boolean encrypt = false;
  59.         if (flag) {
  60.             boolean classPresentAnno = parameter.getContainingClass().isAnnotationPresent(DecryptRequest.class);
  61.             boolean methodPresentAnno = parameter.getMethod().isAnnotationPresent(DecryptRequest.class);
  62.  
  63.             if (classPresentAnno) {
  64.                 //类上标注的是否需要解密
  65.                 encrypt = parameter.getContainingClass().getAnnotation(DecryptRequest.class).value();
  66.                 if (encrypt) {
  67.                     return encrypt;
  68.                 }
  69.                 //类不加密，所有都不加密
  70.                 /**if (!encrypt) {
  71.                  return false;
  72.                  }*/
  73.             }
  74.             if (methodPresentAnno) {
  75.                 //方法上标注的是否需要解密
  76.                 encrypt = parameter.getMethod().getAnnotation(DecryptRequest.class).value();
  77.             }
  78.         }
  79.         return encrypt;
  80.     }
  81. }

ps：encryptApiFlag变量为开关变量，在配置文件中配置加解密是否生效，不需要可以去除这部分

@Value("${encrypt.api.flag}")
private boolean encryptApiFlag;

yml配置文件:

//AESUtil 加解密工具类，这里可以换成自己需要的加密方法

  1. /**
  2.  * @author gzy
  3.  */
  4. public class AESUtil {
  5.  
  6.     /**
  7.      * 加密用的Key 可以用26个字母和数字组成 此处使用AES-128-CBC加密模式，key需要为16位。
  8.      */
  9.     public static final String skey = "smkldospd121daaa";
  10.  
  11.     /**
  12.      * 加密偏移量
  13.      */
  14.     private static final String ivParameter = "1016449182184177";
  15.  
  16.     public static String encrypt(String srcData) throws Exception {
  17.         String enString = AESOperator.getInstance().Encrypt(srcData, skey, ivParameter);
  18.         return enString;
  19.     }
  20.  
  21.     public static String decrypt(String srcData) throws Exception {
  22.         String DeString = AESOperator.getInstance().Decrypt(srcData, skey, ivParameter);
  23.         return DeString;
  24.     }
  25. }

二.自定义注解：

添加在类或方法中判断接口是否需要加解密

@EncryptResponse （加密）

@DecryptRequest （解密）

 

  1. /**
  2.  * 加密注解
  3.  *
  4.  * <p>加了此注解的接口(true)将进行数据加密操作
  5.  * 可以放在类上，可以放在方法上 </p>
  6.  *
  7.  * @author gzy
  8.  */
  9. @Target({ElementType.METHOD, ElementType.TYPE})
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. public @interface EncryptResponse {
  13.     /**
  14.      * 是否对结果加密
  15.      */
  16.     boolean value() default true;
  17. }
  1. /**
  2.  * 解密注解
  3.  *
  4.  * <p>加了此注解的接口(true)将进行数据解密操作(post的body) 可
  5.  * 以放在类上，可以放在方法上 </p>
  6.  *
  7.  * @author gzy
  8.  */
  9. @Target({ElementType.METHOD, ElementType.TYPE})
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. public @interface DecryptRequest {
  13.     /**
  14.      * 是否对body进行解密
  15.      */
  16.     boolean value() default true;
  17. }

三.AES加密

//加解密操作类，本文使用的是AES，可以换成自己需要的加解密方式

// 提供了两种加解密方式（加入或者不加入偏移量，通过加入偏移量来增加加密算法复杂度）。这里需要注意一点，加密后的字符串需要去除换行符及制表符，不然前端解密时会出现无法解密的问题（下文类中replace方法）。

  1. /**
  2.  * AES加解密操作类
  3.  */
  4. public class AESOperator {
  5.  
  6.     /**
  7.      * 加密用的Key 可以用26个字母和数字组成 此处使用AES-128-CBC加密模式，key需要为16位。
  8.      */
  9.     public static final String skey = "smkldospd121daaa";
  10.     /**
  11.      * 偏移量,可自行修改
  12.      */
  13.     private static String ivParameter = "1016449182184177";
  14.  
  15.     private static AESOperator instance = null;
  16.  
  17.     private AESOperator() {
  18.  
  19.     }
  20.  
  21.     public static AESOperator getInstance() {
  22.         if (instance == null) {
  23.             instance = new AESOperator();
  24.         }
  25.         return instance;
  26.     }
  27.  
  28.     public String Encrypt(String encData, String secretKey, String vector) throws Exception {
  29.  
  30.         if (secretKey == null) {
  31.             return null;
  32.         }
  33.         if (secretKey.length() != 16) {
  34.             return null;
  35.         }
  36.         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  37.         byte[] raw = secretKey.getBytes();
  38.         SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  39.         // 使用CBC模式，需要一个向量iv，可增加加密算法的强度
  40.         IvParameterSpec iv = new IvParameterSpec(vector.getBytes());
  41.         cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
  42.         byte[] encrypted = cipher.doFinal(encData.getBytes("utf-8"));
  43.         // 此处使用BASE64做转码。
  44.         return new BASE64Encoder().encode(encrypted);
  45.     }
  46.  
  47.     /**
  48.      * 加密
  49.      *
  50.      * @param sSrc
  51.      * @param sKey
  52.      * @return
  53.      * @throws Exception
  54.      */
  55.     public String encrypt(String sSrc, String sKey) throws Exception {
  56.         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  57.         byte[] raw = sKey.getBytes();
  58.         SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  59.         // 使用CBC模式，需要一个向量iv，可增加加密算法的强度
  60.         IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
  61.         cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
  62.         byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
  63.         // 此处使用BASE64做转码。
  64.         return replace(new BASE64Encoder().encode(encrypted));
  65.     }
  66.  
  67.     /**
  68.      * 解密
  69.      *
  70.      * @param sSrc
  71.      * @param sKey
  72.      * @return
  73.      */
  74.     public String decrypt(String sSrc, String sKey) {
  75.         try {
  76.             byte[] raw = sKey.getBytes("ASCII");
  77.             SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  78.             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  79.             IvParameterSpec iv = new IvParameterSpec(ivParameter.getBytes());
  80.             cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
  81.             // 先用base64解密
  82.             byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);
  83.             byte[] original = cipher.doFinal(encrypted1);
  84.             String originalString = new String(original, "utf-8");
  85.             return originalString;
  86.         } catch (Exception ex) {
  87.             return null;
  88.         }
  89.     }
  90.  
  91.     public String Decrypt(String sSrc, String key, String ivs) {
  92.         try {
  93.             byte[] raw = key.getBytes("ASCII");
  94.             SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
  95.             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  96.             IvParameterSpec iv = new IvParameterSpec(ivs.getBytes());
  97.             cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
  98.             // 先用base64解密
  99.             byte[] encrypted1 = new BASE64Decoder().decodeBuffer(sSrc);
  100.             byte[] original = cipher.doFinal(encrypted1);
  101.             String originalString = new String(original, "utf-8");
  102.             return originalString;
  103.         } catch (Exception ex) {
  104.             return null;
  105.         }
  106.     }
  107.  
  108.     public static String encodeBytes(byte[] bytes) {
  109.         StringBuffer strBuf = new StringBuffer();
  110.  
  111.         for (int i = 0; i < bytes.length; i++) {
  112.             strBuf.append((char) (((bytes[i] >> 4) & 0xF) + ((int) 'a')));
  113.             strBuf.append((char) (((bytes[i]) & 0xF) + ((int) 'a')));
  114.         }
  115.  
  116.         return strBuf.toString();
  117.     }
  118.  
  119.     /**
  120.      * 去除 换行符、制表符
  121.      *
  122.      * @param str
  123.      * @return
  124.      */
  125.     public static String replace(String str) {
  126.         if (!StringUtil.isEmpty(str)) {
  127.             return str.replaceAll("\r|\n", "");
  128.         }
  129.         return str;
  130.     }
  131.  
  132.     //测试
  133.     public static void main(String[] args) throws Exception {
  134.         // 需要加密的字串
  135.         String cSrc = "{\"loginName\":\"master\",\"secret\":\"123456\"}";
  136.         System.out.println(cSrc);
  137.         // 加密
  138.         String enString = AESOperator.getInstance().Encrypt(cSrc, skey, ivParameter);
  139.         System.out.println("加密后的字串是：" + replace(enString));
  140.         String test = replace(enString);
  141.  
  142.         // 解密
  143.         String DeString = AESOperator.getInstance().Decrypt(test, skey, ivParameter);
  144.         System.out.println("解密后的字串是：" + DeString);
  145.     }
  146. }

四.实战

注解加在类或者方法上就可以使用啦（类的优先级高于方法）

ps：解密使用时入参不可以直接写实体类，需要先用json接收，使用实体类无法存放加密后的数据

  1. @DecryptRequest
  2. @EncryptResponse
  3. @RestController
  4. @RequestMapping("/menu")
  5. public class MenuController {
  6. .......
  7. }
  8.  
  9. 或
  10.  
  11.    /**
  12.      * 新增菜单
  13.      *
  14.      * @param params menu
  15.      * @return addMenu
  16.      */
  17.     @DecryptRequest
  18.     @EncryptResponse
  19.     @PostMapping("/add")
  20.     public ApiResult addMenu(@RequestBody JSONObject params) {
  21.         Menu menu = params.toJavaObject(Menu.class);
  22.         return menuService.addMenu(menu);
  23.     }

欢迎大家技术交流，有问题可以与我联系，微信13022509053

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/618949
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号