--- theme: smartblue --- > 首发公众号：【[赵侠客](https://mp.weixin.qq.com/s/Ky3nfUKM73jzYJV24A2FUQ)】 # 引言数据脱敏是一种通过对敏感信息进行处理，以保护数据隐私和安全的技术手段。它通过对数据进行伪装、加密、匿名化或模糊处理，使得未经授权的人员无法识别或还原原始数据，从而防止数据泄露和滥用。常见的脱敏技术包括替换、掩码、随机化和数据混淆等。数据脱敏广泛应用于金融、医疗、互联网等行业，在数据测试、开发和共享过程中，确保了数据的安全性和隐私性，同时又不影响数据的整体分析和使用价值 # 二、哪些数据需要脱敏个人身份信息（PII）： - 姓名：包括用户的真实姓名、昵称等。如：赵侠客脱敏为赵*客 - 身份证号：如社会保障号码、身份证号码等。如：342822199202230227 脱敏为 ***************0227 - 出生日期：完整的生日信息。如：将"1990-05-15"脱敏为"1990-0*-1*" - 地址：家庭住址、邮寄地址等。如：“北京市海淀区中关村大街27号”脱敏为“北京市海淀区*街*号 - 联系方式：电话号码、电子邮件地址等。如：18283741313 脱敏为：182****1313 金融信息： - 信用卡信息：信用卡号、有效期、安全码等。 - 银行账户信息：银行账户号码、路由号码等。 - 交易记录：包括交易时间、交易金额、交易对象等。医疗信息： - 医疗记录：包括病史、诊断信息、治疗记录等。 - 保险信息：健康保险号码、保险公司信息等。登录凭证和认证信息： - 用户名和密码：账户登录名、密码、加密后的密码等。 - 多因素认证信息：包括安全问题答案、二次认证代码等。设备和网络信息： - IP地址：用户的公网IP地址和内网IP地址。 - MAC地址：设备的物理地址。 - 设备标识符：如设备ID、序列号等。行为和偏好数据： - 浏览历史：用户访问的网站、点击记录等。 - 搜索记录：用户的搜索查询记录。 - 购买历史：用户在电商平台上的购买记录、购物车内容等。通信内容： - 电子邮件：邮件内容、附件等。 - 聊天记录：即时通讯工具中的聊天记录、消息内容等。 - 社交媒体信息：用户在社交媒体上的发言、评论、私信等。地理位置数据： - GPS数据：设备的精确地理位置。 - 位置历史：用户过去的位置信息记录。工作和教育信息： - 工作记录：工作单位、职位、薪资等。 - 教育记录：学校、学历、学位等。客户服务数据： - 客服记录：用户与客服的交流记录、服务请求内容等。 # 三、传统脱敏代码 ## 3.1 自己写代码我想大部公司都有自己的一套工具类，自己写代码脱敏可能就是自己写一个工具类，然后放到公共包中，其它项目需要使用引用这个公共包就可以调用，如以下： ``` public class StrUtil { /** * 脱敏手机号码 * 将手机号码的中间4位替换为星号 * * @param phoneNumber 原始手机号码 * @return 脱敏后的手机号码 */ public static String maskPhoneNumber(String phoneNumber) { if (phoneNumber == null || phoneNumber.length() != 11) { throw new IllegalArgumentException("手机号码格式不正确"); } return phoneNumber.substring(0, 3) + "****" + phoneNumber.substring(7); } public static void main(String[] args) { String phoneNumber = "13812345678"; String maskedPhoneNumber = maskPhoneNumber(phoneNumber); System.out.println("原始手机号码: " + phoneNumber); System.out.println("脱敏手机号码: " + maskedPhoneNumber); } } ``` ## 3.2 使用第三方工具如：Hutool 很多第三方工具类都提供了字段脱敏的工具类，如Hutool，我们可以很方便的调用DesensitizedUtil.desensitized来完成数据脱敏，如以下代码 ``` //D.d为DesensitizedUtil.desensitized简写方便阅读 //DT为DesensitizedType的缩写 D.d("admin", DT.USER_ID); D.d("赵侠客", DT.CHINESE_NAME); D.d("323455100993934554", DT.ID_CARD); D.d("0571-8331223", DT.FIXED_PHONE); D.d("18034232232",DT.MOBILE_PHON); D.d("浙江省杭州市西湖区西湖大道1号", DT.ADDRESS); D.d("zhaoxiake@163.com", DT.EMAIL); D.d("123456789", DT.PASSWORD); D.d("浙A888888", DT.CAR_LICENSE); D.d("62122612028837228932", DT.BANK_CARD); D.d("10.100.12.12", DesensitDTizedType.IPV4); D.d("2001:0db8:85a3:0000:0000:8a2e:0370:7334", DT.IPV6); D.d("1231231", DT.FIRST_MASK); ``` 输出： ``` 0 赵** 3***************54 3234************54 057******2234 浙江省杭州市西******** z********@163.com ********* 浙A8****8 6212 **** **** **** 8932 10.*.*.* 2001:*:*:*:*:*:*:* 1****** ``` ## 3.3 这些方法的缺点我觉得这些方法有以下缺点： - 不够建优雅，每次使用都需要手动调用 - 无法通用，如果产品提出个性手机号脱敏显示规则，这些方法都不能通用了 - 没有面向对象，这些方法没有融入到项目框架中，还是面向过程化编写 # 四、基于Jackson优雅脱敏 ## 4.1 使用方法首先我们看一下如何使用，看看是不是很优雅，添加@FieldAnonymize注解，指定脱敏策略，如果想自定义增加自己的脱敏方法如：testStrategy，就不需要写其它代码了 ``` @Data public class SentiveUser { private Long id; @FieldAnonymize("testStrategy") private String username; @FieldAnonymize(AnonymizeType.mobile) private String mobile; @FieldAnonymize(AnonymizeType.email) private String email; @FieldAnonymize(AnonymizeType.chineseName) private String chineseName; @FieldAnonymize(AnonymizeType.idCard) private String idCard; @FieldAnonymize(AnonymizeType.phone) private String phone; @FieldAnonymize(AnonymizeType.address) private String address; @FieldAnonymize(AnonymizeType.bankCard) private String bankCard; @FieldAnonymize(AnonymizeType.password) private String password; @FieldAnonymize(AnonymizeType.carNumber) private String carNumber; } ``` 使用方法: ``` @Test public void testAnonymize() { //自定义脱敏策略 AnonymizeImpl strategy= new AnonymizeImpl().addStrategy("testStrategy", t -> t + "***test***"); AnonymizeSerializer.setAnonymizeStrategy(strategy); SentiveUser sentiveUser=new SentiveUser(); sentiveUser.setMobile("0571-85312234"); sentiveUser.setUsername("admin"); sentiveUser.setEmail("zhaoxiake@163.com"); sentiveUser.setChineseName("赵侠客"); sentiveUser.setAddress("浙江省杭州市西湖区西湖大道1号"); sentiveUser.setPhone("180723432123"); sentiveUser.setIdCard("323455100993934554"); sentiveUser.setBankCard("62122612028837228932"); sentiveUser.setCarNumber("浙AA1126"); sentiveUser.setPassword("Aa123456"); String json=JsonUtils.toJson(sentiveUser); System.out.println(json); } ``` 这样我们所有JSON序列化输出结果都脱敏了，包括使用SpringBoot开发接口返回的JSON数据，前提是使用了Jackson做JSON数据序列化： ``` { "username": "admin***test***", "mobile": "057********34", "email": "zha******@163.com", "chineseName": "赵**", "idCard": "**************4554", "phone": "********2123", "address": "浙江省杭州市西********", "bankCard": "621226**********8932", "password": "********", "carNumber": "浙A****6" } ``` ## 4.2 实现步骤定义注解： ``` @Retention(RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonSerialize(using = AnonymizeSerializer.class) public @interface FieldAnonymize { String value(); } ``` 定义接口： ``` public interface AnonymizeType { String chineseName = "chineseName"; String idCard = "idCard"; String phone = "phone"; String mobile = "mobile"; String address = "address"; String email = "email"; String bankCard = "bankCard"; String password = "password"; String carNumber = "carNumber"; } public interface IAnonymize { default String handle(String type, String value) { return ((Function)getStrategyFunctionMap().get(type)).apply(value); } Map> getStrategyFunctionMap(); } public interface IJacksonSerializer extends ContextualSerializer { default JsonSerializer createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException { if (null != property) { return getJsonSerializer(provider, property); } return provider.findNullValueSerializer(null); } default A getAnnotation(BeanProperty property, Class clazz) { Annotation annotation = property.getAnnotation(clazz); if (null == annotation) { annotation = property.getContextAnnotation(clazz); } return (A) annotation; } JsonSerializer getJsonSerializer(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty) throws JsonMappingException; } ``` 默认实现： ``` public class AnonymizeImpl implements IAnonymize { private static Map> STRATEGY_FUNCTION_MAP; public AnonymizeImpl() { STRATEGY_FUNCTION_MAP = new HashMap<>(); STRATEGY_FUNCTION_MAP.put(AnonymizeType.chineseName, DefaultAnonymize::chineseName); STRATEGY_FUNCTION_MAP.put(AnonymizeType.idCard, DefaultAnonymize::idCard); STRATEGY_FUNCTION_MAP.put(AnonymizeType.phone, DefaultAnonymize::phone); STRATEGY_FUNCTION_MAP.put(AnonymizeType.mobile, DefaultAnonymize::mobile); STRATEGY_FUNCTION_MAP.put(AnonymizeType.address, DefaultAnonymize::address); STRATEGY_FUNCTION_MAP.put(AnonymizeType.email, DefaultAnonymize::email); STRATEGY_FUNCTION_MAP.put(AnonymizeType.bankCard, DefaultAnonymize::bankCard); STRATEGY_FUNCTION_MAP.put(AnonymizeType.password, DefaultAnonymize::password); STRATEGY_FUNCTION_MAP.put(AnonymizeType.carNumber, DefaultAnonymize::carNumber); } public Map> getStrategyFunctionMap() { return STRATEGY_FUNCTION_MAP; } public AnonymizeImpl addStrategy(String paramString, Function paramFunction) { STRATEGY_FUNCTION_MAP.put(paramString, paramFunction); return this; } } ``` 定义序列化器： ``` public class AnonymizeSerializer extends JsonSerializer implements IJacksonSerializer { private static IAnonymize ANONYMIZE_STRATEGY; private String type; public AnonymizeSerializer() { } public AnonymizeSerializer(String type) { this.type = type; } public static void setAnonymizeStrategy(IAnonymize anonymizeStrategy) { ANONYMIZE_STRATEGY = anonymizeStrategy; } public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException { if (null == ANONYMIZE_STRATEGY) { throw new RuntimeException("You used the annotation `@FieldAnonymize` but did not inject `AnonymizeStrategy`"); } Object fieldValue = ANONYMIZE_STRATEGY.handle(this.type, value); gen.writeObject(fieldValue); } public JsonSerializer getJsonSerializer(SerializerProvider provider, BeanProperty property) throws JsonMappingException { if (Objects.equals(property.getType().getRawClass(), String.class)) { FieldAnonymize anonymizeInfo = getAnnotation(property, FieldAnonymize.class); if (null != anonymizeInfo) { return new AnonymizeSerializer(anonymizeInfo.value()); } } return provider.findValueSerializer(property.getType(), property); } } ``` 定义默认脱敏方法： ``` public class DefaultAnonymize { /** * 对中文姓名进行脱敏处理，保留首字，其余用*替代 * 例如：脱敏前：张三脱敏后：张* * * @param originalChineseName 原始的中文姓名字符串 * @return 脱敏处理后的中文姓名字符串 */ public static String chineseName(String originalChineseName) { return processString(originalChineseName, x -> StrUtil.concatStr(StrUtil.subStrFromHead(originalChineseName, 1), StrUtil.nullSafeLength(originalChineseName), "*")); } /** * 对身份证号进行脱敏处理，保留后 4 位，其余用*替代 * 例如：脱敏前：123456789012345678 脱敏后：**********1234 * * @param originalIdCard 原始的身份证号字符串 * @return 脱敏处理后的身份证号字符串 */ public static String idCard(String originalIdCard) { return processString(originalIdCard, x -> StrUtil.maskStart(StrUtil.subStrFromLast(originalIdCard, 4), StrUtil.nullSafeLength(originalIdCard), "*")); } /** * 对电话号码进行脱敏处理，保留后 4 位，其余用*替代 * 例如：脱敏前：13812345678 脱敏后：****5678 * * @param originalPhoneNumber 原始的电话号码字符串 * @return 脱敏处理后的电话号码字符串 */ public static String phone(String originalPhoneNumber) { return processString(originalPhoneNumber, x -> StrUtil.maskStart(StrUtil.subStrFromLast(originalPhoneNumber, 4), StrUtil.nullSafeLength(originalPhoneNumber), "*")); } /** * 对手机号码进行脱敏处理，保留前 3 位和后 2 位，中间用*替代 * 例如：脱敏前：13812345678 脱敏后：138****5678 * * @param originalMobileNumber 原始的手机号码字符串 * @return 脱敏处理后的手机号码字符串 */ public static String mobile(String originalMobileNumber) { return processString(originalMobileNumber, x -> StrUtil.subStrFromHead(originalMobileNumber, 3).concat(StrUtil.removeFromHeader(StrUtil.maskStart(StrUtil.subStrFromLast(originalMobileNumber, 2), StrUtil.nullSafeLength(originalMobileNumber), "*"), "***"))); } /** * 对地址进行脱敏处理，如果长度小于等于 8 则保持不变，否则保留前 i - 8 位，其余用*替代 * 例如：脱敏前：北京市海淀区脱敏后：北京市海淀区 * 脱敏前：北京市海淀区中关村大街脱敏后：北京市**** * * @param originalAddress 原始的地址字符串 * @return 脱敏处理后的地址字符串 */ public static String address(String originalAddress) { return processString(originalAddress, paramString1 -> { int i = StrUtil.nullSafeLength(originalAddress); return (i <= 8) ? originalAddress : StrUtil.concatStr(StrUtil.subStrFromHead(originalAddress, i - 8), i, "*"); }); } /** * 对电子邮箱进行脱敏处理，根据 "@" 的位置决定保留的前缀长度，其余用*替代，然后拼接后缀 * 例如：脱敏前：example@example.com 脱敏后：ex****@example.com * * @param originalEmail 原始的电子邮箱字符串 * @return 脱敏处理后的电子邮箱字符串 */ public static String email(String originalEmail) { return processString(originalEmail, x -> { int i = StrUtil.findIndex(originalEmail, "@"); byte b = 1; if (i > 5) b = 3; return (1 == i) ? originalEmail : StrUtil.concatStr(StrUtil.subStrFromHead(originalEmail, b), i, "*").concat(StrUtil.subStrFromIndex(originalEmail, i, StrUtil.nullSafeLength(originalEmail))); }); } /** * 对银行卡号进行脱敏处理，保留前 6 位和后 4 位，中间用*替代 * 例如：脱敏前：1234567890123456 脱敏后：123456******3456 * * @param originalBankCardNumber 原始的银行卡号字符串 * @return 脱敏处理后的银行卡号字符串 */ public static String bankCard(String originalBankCardNumber) { return processString(originalBankCardNumber, x -> StrUtil.subStrFromHead(originalBankCardNumber, 6).concat(StrUtil.removeFromHeader(StrUtil.maskStart(StrUtil.subStrFromLast(originalBankCardNumber, 4), StrUtil.nullSafeLength(originalBankCardNumber), "*"), "******"))); } /** * 对密码进行脱敏处理，全部用*替代 * 例如：脱敏前：123456 脱敏后：****** * * @param originalPassword 原始的密码字符串 * @return 脱敏处理后的密码字符串 */ public static String password(String originalPassword) { return processString(originalPassword, x -> StrUtil.concatStr(StrUtil.subStrFromHead(originalPassword, 0), StrUtil.nullSafeLength(originalPassword), "*")); } /** * 对车牌号进行脱敏处理，保留前 2 位和后 1 位，中间用*替代 * 例如：脱敏前：浙AA1156 脱敏后：浙A****6 * * @param originalCarNumber 原始的车牌号字符串 * @return 脱敏处理后的车牌号字符串 */ public static String carNumber(String originalCarNumber) { return processString(originalCarNumber, x -> StrUtil.subStrFromHead(originalCarNumber, 2).concat(StrUtil.removeFromHeader(StrUtil.maskStart(StrUtil.subStrFromLast(originalCarNumber, 1), StrUtil.nullSafeLength(originalCarNumber), "*"), "**"))); } /** * 通用的脱敏处理方法 * * @param originalString 原始字符串 * @param anonymizeFunction 具体的脱敏处理函数 * @return 脱敏处理后的字符串，如果原始字符串全为空则返回 null */ private static String processString(String originalString, Function anonymizeFunction) { return StrUtil.isBlank(originalString)? null : anonymizeFunction.apply(originalString); } } ``` # 总结本文针对互联网项目常见的数据脱敏需求，提供了一种基于Jackson优雅、通用、灵活的的数据脱敏方法，主要有以下优点： - 使用优雅，只需要添加一个注解 - 和SpringBoot框架无缝对接，实体增加注解后所有接口JSON数据自动脱敏 - 代码通用，所有人都可以使用该方法 - 策略灵活，可以自定义策略符StrUtil源码： ``` public class StrUtil { /** * 根据指定参数在字符串起始位置进行填充 * * @param originalString 原始字符串 * @param targetLength 填充后的总长度 * @param fillElement 用于填充的元素，可以是字符串或单个字符 * @return 填充后的字符串 * 示例： * 原始字符串："hello"，填充总长度 10，填充字符串 "**" 处理后："******hello" * 原始字符串："world"，填充总长度 8，填充字符 '*' 处理后："****world" */ public static String maskStart(String originalString, int targetLength, Object fillElement) { if (originalString == null) { return null; } int originalStringLength = originalString.length(); int paddingLength = targetLength - originalStringLength; if (paddingLength <= 0) { return originalString; } if (fillElement instanceof String) { String fillString = (String) fillElement; if (isBlank(fillString)) { fillString = " "; } int fillStringLength = fillString.length(); if (fillStringLength == 1 && paddingLength <= 8192) { return maskStart(originalString, targetLength, fillString.charAt(0)); } if (paddingLength == fillStringLength) { return fillString.concat(originalString); } if (paddingLength < fillStringLength) { return fillString.substring(0, paddingLength).concat(originalString); } char[] paddingChars = new char[paddingLength]; char[] fillStringChars = fillString.toCharArray(); for (byte b = 0; b < paddingLength; b++) { paddingChars[b] = fillStringChars[b % fillStringLength]; } return new String(paddingChars).concat(originalString); } else if (fillElement instanceof Character) { char fillChar = (char) fillElement; return paddingLength <= 0 ? originalString : (paddingLength > 8192 ? maskStart(originalString, targetLength, String.valueOf(fillChar)) : repeatChar(fillChar, paddingLength).concat(originalString)); } return originalString; } /** * 连接两个字符串，根据指定的总长度和第二个字符串/字符进行处理 * * @param firstString 第一个字符串 * @param totalLength 连接后的总长度 * @param secondElement 第二个元素，可以是字符串或单个字符 * @return 连接后的字符串 * 示例： * 第一个字符串："hello"，连接后总长度 10，第二个字符串："world" 处理后："hello world " * 第一个字符串："hello"，连接后总长度 8，第二个字符：'*' 处理后："hello***" */ public static String concatStr(String firstString, int totalLength, Object secondElement) { if (firstString == null) { return null; } int firstStringLength = firstString.length(); int paddingLength = totalLength - firstStringLength; if (paddingLength <= 0) { return firstString; } if (secondElement instanceof String) { String secondString = (String) secondElement; if (isBlank(secondString)) { secondString = " "; } int secondStringLength = secondString.length(); if (secondStringLength == 1 && paddingLength <= 8192) { return concatStr(firstString, totalLength, secondString.charAt(0)); } if (paddingLength == secondStringLength) { return firstString.concat(secondString); } if (paddingLength < secondStringLength) { return firstString.concat(secondString.substring(0, paddingLength)); } char[] paddingChars = new char[paddingLength]; char[] secondStringChars = secondString.toCharArray(); for (byte b = 0; b < paddingLength; b++) { paddingChars[b] = secondStringChars[b % secondStringLength]; } return firstString.concat(new String(paddingChars)); } else if (secondElement instanceof Character) { char secondChar = (char) secondElement; return paddingLength <= 0 ? firstString : (paddingLength > 8192 ? concatStr(firstString, totalLength, String.valueOf(secondChar)) : firstString.concat(repeatChar(secondChar, paddingLength))); } return firstString; } private static String repeatChar(char charToRepeat, int repeatCount) { if (repeatCount <= 0) { return ""; } char[] repeatedChars = new char[repeatCount]; for (int i = repeatCount - 1; i >= 0; i--) { repeatedChars[i] = charToRepeat; } return new String(repeatedChars); } /** * 查找字符串中的子字符串索引 * * @param sourceString 原始字符串 * @param subString 要查找的子字符串 * @return 子字符串在原始字符串中的索引，如果原始字符串为空则返回 -1 * 示例： * 原始字符串："hello world"，子字符串："world" * 返回：6 */ public static int findIndex(String sourceString, String subString) { if (isBlank(sourceString)) { return -1; } return sourceString.indexOf(subString); } /** * 判断字符序列是否为空 * * @param charSequence 要判断的字符序列 * @return 如果字符序列为 null 或长度为 0 则返回 true * 示例： * 输入：null * 返回：true * 输入："" * 返回：true */ public static boolean isBlank(CharSequence charSequence) { return charSequence == null || charSequence.length() == 0; } /** * 获取字符序列的安全长度（如果为 null 则返回 0） * * @param charSequence 要获取长度的字符序列 * @return 字符序列的长度，如果为 null 则返回 0 * 示例： * 输入：null * 返回：0 * 输入："hello" * 返回：5 */ public static int nullSafeLength(CharSequence charSequence) { return charSequence == null ? 0 : charSequence.length(); } /** * 对两个字符串进行条件判断和相应处理 * * @param firstStr 第一个字符串 * @param secondStr 第二个字符串 * @return 根据条件返回相应的字符串 * 示例： * 第一个字符串："hello"，第二个字符串："he" * 处理后："llo" */ public static String removeFromHeader(String firstStr, String secondStr) { return isBlank(firstStr) || isBlank(secondStr) ? firstStr : (firstStr.startsWith(secondStr) ? firstStr.substring(secondStr.length()) : firstStr); } /** * 从字符串头部截取指定长度的子串 * * @param sourceString 原始字符串 * @param subLength 要截取的长度 * @return 截取后的子串，如果参数不合法则返回相应的默认值 * 示例： * 原始字符串："hello world"，截取长度 5 * 处理后："hello" */ public static String subStrFromHead(String sourceString, int subLength) { if (sourceString == null) { return null; } return subLength < 0 ? "" : sourceString.length() <= subLength ? sourceString : sourceString.substring(0, subLength); } /** * 从字符串尾部截取指定长度的子串 * * @param sourceString 原始字符串 * @param subLength 要截取的长度 * @return 截取后的子串，如果参数不合法则返回相应的默认值 * 示例： * 原始字符串："hello world"，截取长度 5 * 处理后："world" */ public static String subStrFromLast(String sourceString, int subLength) { if (sourceString == null) { return null; } return subLength < 0 ? "" : sourceString.length() <= subLength ? sourceString : sourceString.substring(sourceString.length() - subLength); } /** * 从字符串指定索引开始截取指定长度的子串 * * @param sourceString 原始字符串 * @param startIndex 起始索引 * @param subLength 要截取的长度 * @return 截取后的子串，如果参数不合法则返回空字符串 * 示例： * 原始字符串："hello world"，起始索引 6，截取长度 5 * 处理后："world" */ public static String subStrFromIndex(String sourceString, int startIndex, int subLength) { if (sourceString == null) { return null; } if (subLength < 0 || startIndex > sourceString.length()) { return ""; } if (startIndex < 0) { startIndex = 0; } return sourceString.length() <= startIndex + subLength ? sourceString.substring(startIndex) : sourceString.substring(startIndex, startIndex + subLength); } } ```