注解加拦截器实现自动加解密和数据完整性校验

于 2024-07-31 15:23:50 发布
阅读量467 收藏
点赞数 19
文章标签： java mybatis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35091185/article/details/140822341
版权

在这里插入图片描述

概要

注解加拦截器实现自动加解密和数据完整性校验
一些敏感信息存入数据需要进行加密处理，比如电话号码，身份证号码等，从数据库取出到前端展示时需要解密
一些重要数据不可被篡改。

流程

SELECT时对添加了@SensitiveEntity注解的实体中添加了@SecurityField注解的字段type=CONFIDENTIALITY进行解密type=INTEGRITY进行完整性校验
UPDATE、INSERT时，对添加了@SensitiveEntity注解的实体中添加了@SecurityField注解的字段type=CONFIDENTIALITY进行加密type=INTEGRITY进行完整性保护

技术细节

实体注解@SensitiveEntity

/**
 * 敏感实体注解
 * 需要在实体类上添加
 * @author lq
 * @date 2024/07/30
 */
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface SecurityEntity {
}

字段注解@SecurityField

/**
 * 敏感字段注解
 * 需要在字段上添加
 * @author lq
 * @date 2024/07/30
 */
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface SecurityField {
    SecurityType[] type() default SecurityType.CONFIDENTIALITY;
}

注解操作类型SecurityType

/**
 * 注解操作类型
 * INTEGRITY完整 CONFIDENTIALITY机密 SIGNATURE签名
 * @author lq
 * @date 2024/07/30
 **/
public enum SecurityType {
    INTEGRITY,
    CONFIDENTIALITY,
    SIGNATURE;

}

MyBatis拦截器

/**
 * 加解密、完整性拦截器
 *
 * @author lq
 * @date 2024/07/30
 **/
@Component
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
})
public class SecurityInterceptor implements Interceptor {
    private static final Logger logger = LoggerFactory.getLogger(SecurityInterceptor.class);

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        Object parameter = invocation.getArgs()[1];
        logger.info("------SecurityInterceptor.sqlCommandType------{}" + sqlCommandType);
        if (parameter == null) {
            return invocation.proceed();
        }
        //查询时，做完整性校验和解密
        if (SqlCommandType.SELECT == sqlCommandType) {
            //取出查询的结果
            Object returnValue = invocation.proceed();
            if (oConvertUtils.isEmpty(returnValue)) {
                return null;
            }
          	// TODO 这里returnValue如果是List或者Map，要特殊处理
            if (isSensitiveEntity(returnValue)) {
                try {
                	//验证完整性
                    validateEntityIntegrity(returnValue);
                } catch (Exception e) {
                    validateFail(returnValue);
                    return returnValue;
                }
                //如果完整性验证不通过，就没必要做解密操作了。
                try {
                    //解密
                    entityDecrypt(returnValue);
                }catch (Exception e){
                    logger.error("解密失败:{}",e);
                }
            }
            return returnValue;
        }
        //新增或修改时，做加密和完整性保护
        if (SqlCommandType.UPDATE == sqlCommandType || SqlCommandType.INSERT == sqlCommandType) {
            if (parameter instanceof MapperMethod.ParamMap) {
                MapperMethod.ParamMap<?> p = (MapperMethod.ParamMap<?>) parameter;
                String et = "et";
                if (p.containsKey(et)) {
                    parameter = p.get(et);
                } else {
                    parameter = p.get("param1");
                }
                if (parameter == null) {
                    return invocation.proceed();
                }
            }
            if (isSensitiveEntity(parameter)) {
                //加密
                entityEncrypt(parameter);
                //完整性保护
                entityIntegrity(parameter);
            }
            return invocation.proceed();
        }
        return invocation.proceed();
    }


    /**
     * 完整性保护
     *
     * @param obj
     */
    private void entityIntegrity(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        List<String> list = new LinkedList<>();
        for (Field field : fields) {
            if (isSecurityField(field)) {
                String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                field.setAccessible(true);
                Object value = field.get(obj);
                field.setAccessible(false);
                if (types.contains(SecurityType.INTEGRITY.toString())) {
                    if (oConvertUtils.isNotEmpty(value)) {
                        list.add(value.toString());
                    }
                }
            }
        }
        if (oConvertUtils.listIsNotEmpty(list)) {
            String hmacValue = getHmacValue(list);
            for (Field field : fields) {
                if (isSecurityField(field)) {
                    String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                    if (types.contains(SecurityType.SIGNATURE.toString())) {
                        field.setAccessible(true);
                        field.set(obj, hmacValue);
                        field.setAccessible(false);
                    }
                }
            }
        }
    }

    /**
     * 验证完整性
     *
     * @param obj
     */
    private boolean validateEntityIntegrity(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        List<String> list = new LinkedList<>();
        String hmacValue = "";
        for (Field field : fields) {
            if (isSecurityField(field)) {
                String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                field.setAccessible(true);
                Object value = field.get(obj);
                field.setAccessible(false);
                if (types.contains(SecurityType.INTEGRITY.toString())) {
                    if (oConvertUtils.isNotEmpty(value)) {
                        list.add(value.toString());
                    }
                }
                if (types.contains(SecurityType.SIGNATURE.toString())) {
                    if (oConvertUtils.isNotEmpty(value)) {
                        hmacValue = value.toString();
                    }
                }
            }
        }
        if (oConvertUtils.listIsEmpty(list) || oConvertUtils.isEmpty(hmacValue)) {
            //不进行完整性验证
            return false;
        }
        boolean isValidate = this.validate(list, hmacValue);
        return isValidate;
    }

    private boolean validate(List<String> list, String hmacValue) {
        String hmacValue2 = getHmacValue(list);
        if (hmacValue.equals(hmacValue2)) {
            return true;
        } else {
            throw new RuntimeException("数据完整性校验失败");
        }
    }

    /**
     * 对需要完整性保护的字段计算得到HmacValue
     *
     * @param list
     * @return {@link String }
     */
    private String getHmacValue(List<String> list) {
        String originalValue = StringUtils.join(list, "::");
        byte[] originalByte = originalValue.getBytes(StandardCharsets.UTF_8);
        //这里是我用的计算HAMC方法，可替换自己的
        SecretKey key = SymmetricOperationUtil.exportInternalKey(10);
        byte[] hmacByte = SymmetricOperationUtil.integrityHmac(key.getEncoded(), originalByte);
        String hmacValue2 = Base64.getEncoder().encodeToString(hmacByte);
        return hmacValue2;
    }

    /**
     * 完整性验证失败
     *
     * @param obj
     * @throws IllegalAccessException
     */
    private void validateFail(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (isSecurityField(field)) {
                String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                if (types.contains(SecurityType.INTEGRITY.toString())) {
                    field.setAccessible(true);
                    //数据被篡改时，将数据改为"数据被篡改"作为提示。
                    field.set(obj, "数据被篡改");
                    field.setAccessible(false);
                }
            }
        }
    }

    /**
     * 加密
     *
     * @param obj
     */
    private void entityEncrypt(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (isSecurityField(field)) {
                String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                if (types.contains(SecurityType.CONFIDENTIALITY.toString())) {
                    logger.info("类：{}，加密字段：{}", obj.getClass(), field.getName());
                    field.setAccessible(true);
                    Object value = field.get(obj);
                    if (oConvertUtils.isNotEmpty(value)) {
                    	//这里是我用的加密操作，可以替换为自己的加密操作。
                        byte[] indata = value.toString().getBytes(StandardCharsets.UTF_8);
                        String encData = SymmetricOperationUtil.internalSm4Enc(1, "CBC", true, indata, new byte[16]);
                        field.set(obj, encData);
                    }
                    field.setAccessible(false);
                }
            }
        }
    }

    /**
     * 解密
     *
     * @param obj
     */
    private void entityDecrypt(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (isSecurityField(field)) {
                String types = StringUtils.join(field.getAnnotation(SecurityField.class).type(), ",");
                if (types.contains(SecurityType.CONFIDENTIALITY.toString())) {
                    field.setAccessible(true);
                    Object value = field.get(obj);
                    field.setAccessible(false);
                    if (oConvertUtils.isNotEmpty(value)) {
                        logger.info("{}:value:{}", field.getName(), value);
                        String decStr;
                        try {
                        	//这里是我用的解密操作，可以替换为自己的解密操作。
                            byte[] indata = Base64.getDecoder().decode(value.toString());
                            decStr = SymmetricOperationUtil.internalSm4Dec(1, "CBC", true, indata, new byte[16]);
                        }catch (Exception e){
                            logger.info("解密失败");
                            decStr = "解密失败";
                        }
                        field.setAccessible(true);
                        field.set(obj, decStr);
                        field.setAccessible(false);
                    }
                }
            }
        }
    }

    /**
     * 是否包含注解SensitiveEntity
     *
     * @param obj
     * @return boolean
     */
    private boolean isSensitiveEntity(Object obj) {
        if (oConvertUtils.isEmpty(obj)) {
            return false;
        }
        return obj.getClass().isAnnotationPresent(SecurityEntity.class);
    }

    /**
     * 是否包含注解SensitiveField
     *
     * @param field
     * @return boolean
     */
    private boolean isSecurityField(Field field) {
        if (oConvertUtils.isEmpty(field)) {
            return false;
        }
        return field.isAnnotationPresent(SecurityField.class);
    }
}

小结

只需要在对应的实体上增加相应的注解，即可实现

@SecurityEntity
public class AppUser implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    @TableId(type = IdType.ASSIGN_ID)
    @ApiModelProperty(value = "id")
    private String id;
    /**
     * 用户名
     */
    @Excel(name = "用户名", width = 15)
    @ApiModelProperty(value = "用户名")
    private String loginName;
    /**
     * 手机号
     */
    @Excel(name = "手机号", width = 15)
    @ApiModelProperty(value = "手机号")
    @SecurityField(type = {SecurityType.CONFIDENTIALITY, SecurityType.INTEGRITY})
    private String phoneNo;
    /**
     * 身份证号码
     */
    @Excel(name = "身份证号码", width = 15)
    @ApiModelProperty(value = "身份证号码")
    @SecurityField(type = {SecurityType.CONFIDENTIALITY, SecurityType.INTEGRITY})
    private String idCardNo;
    /**
     * HMAC值
     */
    @SecurityField(type = SecurityType.SIGNATURE)
    private String hmacValue;
}

新增编辑AppUser ，可以对相应的字段进行完整性保护和加密
查询AppUser 时会对相应字段进行完整性校验和解密。

不支持对缓冲数据进行操作

Aaron丶琦琦
关注
  • 19
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot实现接口数据的加解密功能
08-25
SpringBoot实现接口数据的加解密功能是指在SpringBoot项目中实现对接口数据的加密和解密操作，以保护数据的安全性和完整性。该功能主要有两种实现方式，一种是使用自定义消息转换器，另一种是使用Spring提供的接口...
java 元注解+拦截器实现自定义注解.rar
08-19
java 元注解+拦截器实现自定义注解 @CmwAutoWired：自定义依赖注入 注意:注入的接口和实现类需要在同一包名下,注解的是类则无限制 @FieldAnnotation：自定义属性注解 @MethodAnnotation：自定义方法注解 @...
MyBatisPlus数据自动加解密存取和字段防篡改有效性校验码自动生成存储处理器
qq_37148232的博客
07-19 1415
5、SecretDecryptInterceptor，拦截ResultSetHandler.handleResultSets，解密带SecretField字段的entity属性。10、SeretSecurityAutoConfiguration，总配置类，用于开启是否向Spring注册启用加密码组件。SecretWrarpperEnhancer:低层次代码向高层次代码的entity对象设置一些加解密字段的扩展接口。7、SecretModel，标记该实体有需要加解密的字段。
java 注解 权限_Java注解 + 基于注解 & 拦截器实现登录验证 / 权限控制
weixin_33788825的博客
02-16 565
2017-04-17token可以通过加密(如DES)的方式构造 / 解密：在线加密解密密码(秘钥)生成：在线生成随机密码一、注解的作用1、生成文档。这是最常见的，也是Java最早提供的注解。常用的有@see @param @return 等；2、跟踪代码依赖性，实现替代配置文件功能。比较常见的是spring 2.5 开始的基于注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文...
MyBatis拦截器四种类型和自定义拦截器的使用流程
相关项目可以查看https://gitee.com/fan-pl或https://github.com/fpl1116
03-12 2766
MyBatis拦截器四种类型和自定义拦截器的使用流程
SpringMVC之JSR303和拦截器
djssubddbj的博客
09-12 409
拦截器的作用是可以统一处理请求和响应数据，比如请求参数的校验、权限认证、日志记录等，可以减少代码重复、提高代码复用性、增强代码的可维护性和可测试性。在拦截器中，可以获取请求的相关参数、请求头等信息，可以对请求参数进行验证和修改，还可以在请求前后记录日志等操作。增加程序的健壮性：通过对Java Bean属性的验证，可以有效地防止非法输入数据对程序的影响，减少程序出错的概率，增加程序的健壮性。提高程序的安全性：通过对Java Bean属性的验证，可以确保输入数据的有效性和完整性，从而减少了程序被攻击的风险。
简单例子gateway网关加密解密子服务分发请求
qq_19342829的博客
01-17 900
简单例子gateway网关加密解密子服务分发请求，子服务参数校验，以及业务简单分发功能
芝法酱躺平攻略（11）——SpringBoot下使用注解做参数校验与参数加密
hataksumo的博客
01-21 527
SpringBoot下的参数校验，以及使用注解做字段加密解密
千万别再问加解密、加签验签的问题了，全给你整理好了
码猿技术专栏
06-27 701
点击上方☝码猿技术专栏轻松关注，设为星标！及时获取有趣有料的技术来源：r6d.cn/acJae面对MD5、SHA、DES、AES、RSA等等这些名词你是否有很多问号？这些名词都是什么？还...
接口安全校验
qq_43050847的博客
09-13 393
文章目录自定义鉴权注解AuthCheck.java加密辅助类SignUtil.javaapi拦截器ApiInterceptor.java 自定义鉴权注解AuthCheck.java import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import
SpringBoot项目实战 - SpringBoot实现请求参数与响应参数加解密
知行
03-10 3699
Target({* @description: 参数加密设置/*** 入参是否解密，默认解密/*** 返回是否加密，默认加密。
EasyValidate优雅地校验提交数据完整性
08-26
在Android开发过程中，确保用户提交的数据完整性至关重要，而`EasyValidate`是一个优秀的工具，它能够帮助开发者优雅地处理数据校验。本文将详细介绍如何利用`EasyValidate`进行数据完整性校验，以及其主要特性和...
spring自定义注解实现拦截器的实现方法
08-29
本篇文章主要介绍了spring自定义注解实现拦截器的实现方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 345
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 437
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 237
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 609
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 256
集合之Map
写出使用springboot 注解加拦截器实现权限认证代码
04-26
好的，以下是使用Spring Boot注解与拦截器实现权限认证的代码示例： 1. 创建自定义拦截器： ```java public class AuthInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 在此处实现权限认证逻辑 String token = request.getHeader("Authorization"); if(token == null || token.isEmpty()) { response.setStatus(HttpStatus.UNAUTHORIZED.value()); return false; } // 验证通过，放行 return true; } } ``` 2. 创建配置类： ```java @Configuration public class WebMvcConfig implements WebMvcConfigurer { @Autowired private AuthInterceptor authInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(authInterceptor) .addPathPatterns("/**") .excludePathPatterns("/login", "/register"); } } ``` 3. 在Controller类或方法上标注注解： ```java @RestController @RequestMapping("/api") public class MyController { // 标注注解，需要认证权限 @GetMapping("/userinfo") @AuthRequired public String getUserInfo() { // 实现获取用户信息逻辑 return "UserInfo"; } } ``` 4. 创建自定义注解： ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface AuthRequired { } ``` 5. 在拦截器中获取自定义注解： ```java @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 获取请求处理方法的所有注解 Method method = ((HandlerMethod)handler).getMethod(); Annotation[] annotations = method.getDeclaredAnnotations(); // 遍历注解数组，寻找 AuthRequired 注解 boolean authRequired = false; for(Annotation annotation : annotations) { if(annotation.annotationType() == AuthRequired.class) { authRequired = true; break; } } if(authRequired) { // 需要认证权限的逻辑处理 } // 验证通过，放行 return true; } ``` 以上就是使用Spring Boot注解与拦截器实现权限认证的简单示例代码。请注意，在实际项目中，需要根据具体需求进行修改和完善。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值