轻松实现 SpringBoot 中的隐私数据脱敏处理

开发 前端
其实要实现上面的效果,可能最先想到的方法是直接改每个接口,在返回数据前做一次加密处理,当然这个方法肯定是非常捞的。这里推荐用注解来实现,即高效又优雅,省时省力,支持扩展。

前言

这两天在整改等保测出的问题,里面有一个用户信息泄露的风险项(就是后台系统里用户的一些隐私数据直接明文显示了),其实指的就是要做数据脱敏。

数据脱敏:把系统里的一些敏感数据进行加密处理后再返回,达到保护隐私作用,实现效果图如下:

图片图片

其实要实现上面的效果,可能最先想到的方法是直接改每个接口,在返回数据前做一次加密处理,当然这个方法肯定是非常捞的。这里推荐用注解来实现,即高效又优雅,省时省力,支持扩展。

其实解决方案大体上分两种:

  • 在拿到数据时就已经脱敏了(如在 mysql 查询时用 insert 函数进行隐藏)
  • 拿到数据后在序列化的时候再进行脱敏(如用 fastjson、jackson)

这里我所选用的方案是第二种,即在接口返回数据前,在序列化的时候对敏感字段值进行处理,并且选用 jackson 的序列化来实现(推荐)

实现

创建隐私数据类型枚举

/**
 * 隐私数据类型枚举
 */
@Getter
public enum PrivacyTypeEnum {

  /** 自定义(此项需设置脱敏的范围)*/
  CUSTOMER,

  /** 姓名 */
  NAME,

  /** 身份证号 */
  ID_CARD,

  /** 手机号 */
  PHONE,

  /** 邮箱 */
  EMAIL,
}

创建自定义隐私注解

/**
 * 自定义数据脱敏注解
 */
@Target(ElementType.FIELD) // 作用在字段上
@Retention(RetentionPolicy.RUNTIME) // class文件中保留,运行时也保留,能通过反射读取到
@JacksonAnnotationsInside // 表示自定义自己的注解PrivacyEncrypt
@JsonSerialize(using = PrivacySerializer.class) // 该注解使用序列化的方式
public @interface PrivacyEncrypt {

    /**
     * 脱敏数据类型(没给默认值,所以使用时必须指定type)
     */
    PrivacyTypeEnum type();

    /**
     * 前置不需要打码的长度
     */
    int prefixNoMaskLen() default 1;

    /**
     * 后置不需要打码的长度
     */
    int suffixNoMaskLen() default 1;

    /**
     * 用什么打码
     */
    String symbol() default "*";
}

创建自定义序列化器

@NoArgsConstructor
@AllArgsConstructor
public class PrivacySerializer extends JsonSerializer<String> implements ContextualSerializer {

    // 脱敏类型
    private PrivacyTypeEnum privacyTypeEnum;
    // 前几位不脱敏
    private Integer prefixNoMaskLen;
    // 最后几位不脱敏
    private Integer suffixNoMaskLen;
    // 用什么打码
    private String symbol;

    @Override
    public void serialize(String origin, final JsonGenerator jsonGenerator,
                          final SerializerProvider serializerProvider) throws IOException {
        if (StrUtil.isEmpty(origin)) {
            origin = null;
        }
        if (null != privacyTypeEnum) {
            switch (privacyTypeEnum) {
                case CUSTOMER:
                    jsonGenerator.writeString(PrivacyUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, symbol));
                    break;
                case NAME:
                    jsonGenerator.writeString(PrivacyUtil.hideChineseName(origin));
                    break;
                case ID_CARD:
                    jsonGenerator.writeString(PrivacyUtil.hideIDCard(origin));
                    break;
                case PHONE:
                    jsonGenerator.writeString(PrivacyUtil.hidePhone(origin));
                    break;
                case EMAIL:
                    jsonGenerator.writeString(PrivacyUtil.hideEmail(origin));
                    break;
                default:
                    throw new IllegalArgumentException("unknown privacy type enum " + privacyTypeEnum);
            }
        }
    }

    @Override
    public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider,
                                              final BeanProperty beanProperty) throws JsonMappingException {
        if (null != beanProperty) {
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                PrivacyEncrypt privacyEncrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
                if (null == privacyEncrypt) {
                    privacyEncrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
                }
                if (null != privacyEncrypt) {
                    return new PrivacySerializer(privacyEncrypt.type(), privacyEncrypt.prefixNoMaskLen(),
                            privacyEncrypt.suffixNoMaskLen(), privacyEncrypt.symbol());
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(null);
    }
}

这里是具体的实现过程,因为要脱敏的数据都是 String 类型的,所以继承 JsonSerializer 时的类型填 String

  • 重写的 serialize 方法是实现脱敏的核心,根据类型 type 的不同去设置序列化后的值
  • 重写的 createContextual 方法,就是去读取我们自定义的 PrivacyEncrypt 注解,打造一个上下文的环境

隐私数据隐藏工具类

public class PrivacyUtil {

    /**
     * 中文名脱敏
     */
    public static String hideChineseName(String chineseName) {
        if (StrUtil.isEmpty(chineseName)) {
            return null;
        }
        if (chineseName.length() <= 2) {
            return desValue(chineseName, 1, 0, "*");
        }
        return desValue(chineseName, 1, 1, "*");
    }

    /**
     * 手机号脱敏
     */
    public static String hidePhone(String phone) {
        if (StrUtil.isEmpty(phone)) {
            return null;
        }
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2"); // 隐藏中间4位
//        return desValue(phone, 3, 4, "*"); // 隐藏中间4位
//        return desValue(phone, 7, 0, "*"); // 隐藏末尾4位
    }

    /**
     * 邮箱脱敏
     */
    public static String hideEmail(String email) {
        if (StrUtil.isEmpty(email)) {
            return null;
        }
        return email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
    }

    /**
     * 身份证号脱敏
     */
    public static String hideIDCard(String idCard) {
        if (StrUtil.isEmpty(idCard)) {
            return null;
        }
        return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1*****$2");
    }

    /**
     * 对字符串进行脱敏操作
     * @param origin          原始字符串
     * @param prefixNoMaskLen 左侧需要保留几位明文字段
     * @param suffixNoMaskLen 右侧需要保留几位明文字段
     * @param maskStr         用于遮罩的字符串, 如'*'
     * @return 脱敏后结果
     */
    public static String desValue(String origin, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
        if (StrUtil.isEmpty(origin)) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0, n = origin.length(); i < n; i++) {
            if (i < prefixNoMaskLen) {
                sb.append(origin.charAt(i));
                continue;
            }
            if (i > (n - suffixNoMaskLen - 1)) {
                sb.append(origin.charAt(i));
                continue;
            }
            sb.append(maskStr);
        }
        return sb.toString();
    }

}

这个工具类其实可以自己定,根据自己的业务去扩展

注解使用

@Data
public class People {

    private Integer id;

    private String name;

    private Integer sex;

    private Integer age;

    @PrivacyEncrypt(type = PrivacyTypeEnum.PHONE) // 隐藏手机号
    private String phone;

    @PrivacyEncrypt(type = PrivacyTypeEnum.EMAIL) // 隐藏邮箱
    private String email;

    private String sign;
}

到这里,脱敏工作就已经结束了,全局使用这一个注解即可,一劳永逸,支持扩展,测试效果图如下:

责任编辑:武晓燕 来源: 一安未来
相关推荐

2021-08-02 18:23:01

Spring隐私数据

2023-10-09 09:23:10

2024-01-22 08:46:37

MyBatis数据脱敏Spring

2023-10-09 07:37:01

2016-11-22 09:40:08

2021-10-22 06:53:45

脱敏处理数据

2022-06-21 14:44:38

接口数据脱敏

2020-06-17 09:49:03

潮数软件

2023-12-05 18:50:24

腾讯安全HaS大模型

2022-03-04 08:31:07

Spring异常处理

2023-10-07 08:34:27

项目API接口

2021-08-03 15:25:09

数据库Sharding SpSQL

2009-03-05 10:10:52

饼图数据库JSP

2021-10-08 08:58:35

MySQL函数脱敏

2011-04-14 10:18:20

数据迁移

2010-08-05 15:06:19

Flex数据绑定

2023-06-06 08:51:06

2018-01-26 07:53:46

数据脱敏数据安全信息安全

2017-02-05 17:27:43

2009-12-24 14:08:25

WPF数据模板
点赞
收藏

51CTO技术栈公众号