
## 一、为什么需要数据脱敏

数据安全和隐私保护日益重要：

**法规要求：**
- 《个人信息保护法》
- 《数据安全法》
- GDPR（欧盟通用数据保护条例）

**数据泄露风险：**
- 内部人员泄露
- 黑客攻击
- 第三方系统漏洞

**数据脱敏的目标：**
- 保护敏感数据不被泄露
- 保证数据可用性（开发测试可用）
- 满足合规要求

## 二、常见脱敏策略

### 1. 掩码处理

```
原始数据：13812345678
脱敏后：  138****5678

原始数据：北京市朝阳区xxx街道
脱敏后：  北京市朝阳区***
```

### 2. 替换处理

```
原始数据：Tom
脱敏后：  张三

原始数据：user@example.com
脱敏后：  user@test.com
```

### 3. 泛化处理

```
原始数据：32岁
脱敏后：  30-40岁

原始数据：10000元
脱敏后：  10000-20000元
```

### 4. 加密处理

```
原始数据：123456
脱敏后：  AES加密后的密文（需要时解密）
```

## 三、脱敏规则设计

### 1. 脱敏规则表

```sql
CREATE TABLE data_masking_rules (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    table_name VARCHAR(64) NOT NULL COMMENT '表名',
    column_name VARCHAR(64) NOT NULL COMMENT '列名',
    masking_type VARCHAR(32) NOT NULL COMMENT '脱敏类型',
    masking_params TEXT COMMENT '脱敏参数(JSON)',
    priority INT DEFAULT 0 COMMENT '优先级',
    status TINYINT DEFAULT 1 COMMENT '状态',
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    UNIQUE KEY uk_table_column (table_name, column_name)
);

-- 插入脱敏规则
INSERT INTO data_masking_rules (table_name, column_name, masking_type, masking_params) VALUES
('users', 'phone', 'PHONE', '{"keepStart": 3, "keepEnd": 4}'),
('users', 'email', 'EMAIL', '{"domain": "example.com"}'),
('users', 'name', 'NAME', '{"type": "random"}'),
('users', 'id_card', 'ID_CARD', '{"keepStart": 6, "keepEnd": 4}'),
('orders', 'address', 'ADDRESS', '{"keepParts": 2}'),
('orders', 'amount', 'AMOUNT', '{"minRange": 0, "maxRange": 100}');
```

### 2. 脱敏类型枚举

```java
public enum MaskingType {
    PHONE("手机号脱敏"),
    EMAIL("邮箱脱敏"),
    NAME("姓名脱敏"),
    ID_CARD("身份证脱敏"),
    ADDRESS("地址脱敏"),
    AMOUNT("金额泛化"),
    CUSTOM("自定义脱敏"),
    AES_ENCRYPT("AES加密"),
    HASH("哈希脱敏"),
    NULL("置空");
    
    private final String description;
    
    MaskingType(String description) {
        this.description = description;
    }
}
```

## 四、Java脱敏实现

### 1. 脱敏工具类

```java
@Component
@Slf4j
public class DataMaskingUtil {
    
    // 手机号脱敏：13812345678 -> 138****5678
    public static String maskPhone(String phone) {
        if (StringUtils.isEmpty(phone)) {
            return phone;
        }
        
        int length = phone.length();
        if (length < 7) {
            return phone.substring(0, 2) + "****";
        }
        
        return phone.substring(0, 3) + "****" + phone.substring(length - 4);
    }
    
    // 邮箱脱敏：user@example.com -> u***@example.com
    public static String maskEmail(String email) {
        if (StringUtils.isEmpty(email)) {
            return email;
        }
        
        int atIndex = email.indexOf('@');
        if (atIndex <= 1) {
            return "***" + email.substring(atIndex);
        }
        
        String local = email.substring(0, atIndex);
        String domain = email.substring(atIndex);
        
        if (local.length() <= 2) {
            return local.charAt(0) + "***" + domain;
        }
        
        return local.charAt(0) + "***" + local.charAt(local.length() - 1) + domain;
    }
    
    // 姓名脱敏：张三 -> *三 / 李四 -> *四
    public static String maskName(String name) {
        if (StringUtils.isEmpty(name)) {
            return name;
        }
        
        int length = name.length();
        if (length == 1) {
            return "*";
        } else if (length == 2) {
            return "*" + name.charAt(1);
        } else {
            return name.charAt(0) + "**" + name.charAt(length - 1);
        }
    }
    
    // 身份证脱敏：110101199001011234 -> 110101********1234
    public static String maskIdCard(String idCard) {
        if (StringUtils.isEmpty(idCard)) {
            return idCard;
        }
        
        int length = idCard.length();
        if (length < 10) {
            return idCard;
        }
        
        return idCard.substring(0, 6) + "********" + idCard.substring(length - 4);
    }
    
    // 地址脱敏：保留前两部分
    public static String maskAddress(String address, int keepParts) {
        if (StringUtils.isEmpty(address)) {
            return address;
        }
        
        String[] parts = address.split("[区县街路号]");
        if (parts.length <= keepParts) {
            return address;
        }
        
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < keepParts && i < parts.length; i++) {
            result.append(parts[i]);
        }
        
        return result.toString() + "***";
    }
    
    // 金额泛化
    public static String maskAmount(BigDecimal amount, int range) {
        if (amount == null) {
            return null;
        }
        
        long rounded = (amount.longValue() / range) * range;
        return String.format("%d-%d", rounded, rounded + range);
    }
    
    // AES加密
    public static String encryptAES(String content, String key) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(key.getBytes()));
            SecretKey secretKey = kgen.generateKey();
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encrypted = cipher.doFinal(content.getBytes("UTF-8"));
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            log.error("AES加密失败", e);
            return content;
        }
    }
    
    // AES解密
    public static String decryptAES(String encrypted, String key) {
        try {
            byte[] content = Base64.getDecoder().decode(encrypted);
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(key.getBytes()));
            SecretKey secretKey = kgen.generateKey();
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decrypted = cipher.doFinal(content);
            return new String(decrypted, "UTF-8");
        } catch (Exception e) {
            log.error("AES解密失败", e);
            return encrypted;
        }
    }
    
    // MD5哈希（不可逆）
    public static String hashMD5(String content) {
        return DigestUtils.md5Hex(content);
    }
    
    // SHA256哈希
    public static String hashSHA256(String content) {
        return DigestUtils.sha256Hex(content);
    }
}
```

### 2. 脱敏注解

```java
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SensitiveField {
    
    MaskingType type() default MaskingType.DEFAULT;
    
    String params() default "{}";
}
```

### 3. 实体类使用

```java
public class User {
    
    private Long id;
    
    @SensitiveField(type = MaskingType.NAME)
    private String name;
    
    @SensitiveField(type = MaskingType.PHONE)
    private String phone;
    
    @SensitiveField(type = MaskingType.EMAIL)
    private String email;
    
    @SensitiveField(type = MaskingType.ID_CARD)
    private String idCard;
    
    @SensitiveField(type = MaskingType.CUSTOM, params = "{\"keepParts\": 2}")
    private String address;
}
```

### 4. 脱敏处理器

```java
@Component
@Slf4j
public class DataMaskingProcessor {
    
    private final Map<MaskingType, Function<Pair<String, String>, String>> maskingFunctions = new HashMap<>();
    
    @PostConstruct
    public void init() {
        maskingFunctions.put(MaskingType.PHONE, 
            p -> DataMaskingUtil.maskPhone(p.getLeft()));
        maskingFunctions.put(MaskingType.EMAIL, 
            p -> DataMaskingUtil.maskEmail(p.getLeft()));
        maskingFunctions.put(MaskingType.NAME, 
            p -> DataMaskingUtil.maskName(p.getLeft()));
        maskingFunctions.put(MaskingType.ID_CARD, 
            p -> DataMaskingUtil.maskIdCard(p.getLeft()));
        maskingFunctions.put(MaskingType.ADDRESS, 
            p -> DataMaskingUtil.maskAddress(p.getLeft(), 2));
        maskingFunctions.put(MaskingType.AES_ENCRYPT, 
            p -> DataMaskingUtil.encryptAES(p.getLeft(), p.getRight()));
        maskingFunctions.put(MaskingType.HASH, 
            p -> DataMaskingUtil.hashSHA256(p.getLeft()));
        maskingFunctions.put(MaskingType.NULL, 
            p -> null);
    }
    
    public String mask(String value, MaskingType type, String params) {
        if (StringUtils.isEmpty(value)) {
            return value;
        }
        
        Function<Pair<String, String>, String> function = maskingFunctions.get(type);
        if (function == null) {
            return value;
        }
        
        return function.apply(Pair.of(value, params));
    }
    
    // 反射处理整个对象
    public <T> T maskObject(T obj) {
        if (obj == null) {
            return null;
        }
        
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            SensitiveField annotation = field.getAnnotation(SensitiveField.class);
            if (annotation == null) {
                continue;
            }
            
            field.setAccessible(true);
            try {
                Object value = field.get(obj);
                if (value instanceof String) {
                    String masked = mask((String) value, annotation.type(), annotation.params());
                    field.set(obj, masked);
                }
            } catch (IllegalAccessException e) {
                log.error("字段访问失败: {}", field.getName(), e);
            }
        }
        
        return obj;
    }
}
```

## 五、数据库层脱敏

### 1. MySQL UDF脱敏

```sql
-- 创建脱敏函数
DELIMITER //

CREATE FUNCTION mask_phone(phone VARCHAR(20))
RETURNS VARCHAR(20)
BEGIN
    IF phone IS NULL OR LENGTH(phone) < 7 THEN
        RETURN phone;
    END IF;
    RETURN CONCAT(SUBSTRING(phone, 1, 3), '****', SUBSTRING(phone, LENGTH(phone) - 3));
END //

CREATE FUNCTION mask_email(email VARCHAR(100))
RETURNS VARCHAR(100)
BEGIN
    IF email IS NULL OR email NOT LIKE '%@%' THEN
        RETURN email;
    END IF;
    RETURN CONCAT(SUBSTRING_INDEX(email, '@', 1), '@example.com');
END //

CREATE FUNCTION mask_name(name VARCHAR(50))
RETURNS VARCHAR(50)
BEGIN
    IF name IS NULL OR LENGTH(name) < 2 THEN
        RETURN '*';
    END IF;
    RETURN CONCAT('*', SUBSTRING(name, 2));
END //

DELIMITER ;

-- 使用示例
SELECT 
    id,
    mask_name(name) as name,
    mask_phone(phone) as phone,
    mask_email(email) as email
FROM users;
```

### 2. 视图脱敏

```sql
-- 创建脱敏视图
CREATE VIEW v_users_masked AS
SELECT 
    id,
    CASE 
        WHEN LENGTH(name) = 2 THEN CONCAT('*', SUBSTRING(name, 2))
        ELSE CONCAT(LEFT(name, 1), '**')
    END as name,
    CONCAT(SUBSTRING(phone, 1, 3), '****', SUBSTRING(phone, -4)) as phone,
    CONCAT(SUBSTRING_INDEX(email, '@', 1), '@masked.com') as email,
    CONCAT(LEFT(id_card, 6), '********', RIGHT(id_card, 4)) as id_card
FROM users;

-- 查询脱敏视图
SELECT * FROM v_users_masked;
```

## 六、应用层脱敏

### 1. API响应脱敏

```java
@RestController
public class UserController {
    
    @Autowired
    private DataMaskingProcessor maskingProcessor;
    
    @GetMapping("/api/users/{id}")
    public UserVO getUser(@PathVariable Long id) {
        User user = userService.getById(id);
        
        // 手动脱敏
        UserVO vo = new UserVO();
        vo.setId(user.getId());
        vo.setName(DataMaskingUtil.maskName(user.getName()));
        vo.setPhone(DataMaskingUtil.maskPhone(user.getPhone()));
        vo.setEmail(DataMaskingUtil.maskEmail(user.getEmail()));
        
        return vo;
    }
}
```

### 2. 统一响应脱敏

```java
@Component
public class ResponseMaskingAdvice implements ResponseBodyAdvice<Object> {
    
    @Autowired
    private DataMaskingProcessor maskingProcessor;
    
    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        // 只对标记了脱敏注解的响应进行处理
        return returnType.hasMethodAnnotation(MaskingResponse.class);
    }
    
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType,
            MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> converterType,
            ServerHttpRequest request, ServerHttpResponse response) {
        
        return maskingProcessor.maskObject(body);
    }
}

// 使用示例
@GetMapping("/api/user")
@MaskingResponse
public User getUser() {
    return userService.getById(1L);
}
```

## 七、数据权限控制

### 1. 行级权限

```java
@Component
public class DataPermissionInterceptor {
    
    @Autowired
    private CurrentUserService currentUserService;
    
    public String addDataPermission(String sql, String userId) {
        // 根据用户角色添加行级过滤
        UserRole role = currentUserService.getUserRole(userId);
        
        switch (role) {
            case CITY_MANAGER:
                // 市经理只能看本市数据
                return sql.replace("WHERE", 
                    "WHERE city_id = '" + currentUserService.getCityId(userId) + "' AND");
                
            case SHOP_OWNER:
                // 商家只能看自己店铺数据
                return sql.replace("WHERE", 
                    "WHERE shop_id = '" + currentUserService.getShopId(userId) + "' AND");
                
            default:
                return sql;
        }
    }
}
```

### 2. 列级权限

```java
@Component
public class ColumnPermissionAspect {
    
    @Autowired
    private PermissionService permissionService;
    
    @Around("execution(* com.example.mapper.*Mapper.*(..))")
    public Object checkColumnPermission(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        String methodName = signature.getName();
        String className = signature.getDeclaringType().getSimpleName();
        
        // 获取当前用户权限
        Set<String> allowedColumns = permissionService.getAllowedColumns(className, methodName);
        
        // 过滤返回结果中的敏感列
        Object result = point.proceed();
        
        if (result instanceof List) {
            return ((List<?>) result).stream()
                .map(this::filterColumns)
                .collect(Collectors.toList());
        }
        
        return filterColumns(result);
    }
    
    private Object filterColumns(Object obj) {
        // 根据权限过滤列
        return obj;
    }
}
```

## 八、敏感数据存储

### 1. 敏感数据加密存储

```java
@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue
    private Long id;
    
    // 普通字段
    private String username;
    
    // 加密存储的敏感字段
    @Convert(converter = AesEncryptConverter.class)
    private String idCard;
    
    @Convert(converter = AesEncryptConverter.class)
    private String bankCard;
}

@Component
public class AesEncryptConverter implements AttributeConverter<String, String> {
    
    @Value("${encryption.key}")
    private String encryptionKey;
    
    @Override
    public String convertToDatabaseColumn(String attribute) {
        if (StringUtils.isEmpty(attribute)) {
            return attribute;
        }
        return DataMaskingUtil.encryptAES(attribute, encryptionKey);
    }
    
    @Override
    public String convertToEntityAttribute(String dbData) {
        if (StringUtils.isEmpty(dbData)) {
            return dbData;
        }
        return DataMaskingUtil.decryptAES(dbData, encryptionKey);
    }
}
```

### 2. 密钥管理

```java
@Configuration
public class KeyManagementConfig {
    
    @Bean
    public String encryptionKey() {
        // 生产环境应从密钥管理服务（KMS）获取
        return System.getenv("ENCRYPTION_KEY");
    }
}
```

## 九、总结

数据脱敏是保护隐私的重要手段：

- **脱敏策略**：掩码、替换、泛化、加密
- **多层防护**：数据库层、应用层、API层
- **权限控制**：行级权限、列级权限
- **密钥管理**：安全存储加密密钥

**实施建议：**
1. 梳理敏感数据资产
2. 制定统一的脱敏规则
3. 在数据入口统一脱敏
4. 定期审计脱敏效果

**思考题**：你们系统有哪些敏感数据？如何保护的？

---

*个人观点，仅供参考*

【架构实战】数据脱敏与隐私保护架构

数据脱敏是保护隐私的重要手段：

- **脱敏策略**：掩码、替换、泛化、加密
- **多层防护**：数据库层、应用层、API层
- **权限控制**：行级权限、列级权限
- **密钥管理**：安全存储加密密钥

研发部经理

编程语言

数据脱敏是保护隐私安全的关键技术，涵盖掩码、替换、泛化、加密等多种策略。通过数据库层、应用层、API层等多层防护，结合行级和列级权限控制，确保敏感数据安全。实施时需梳理数据资产、制定统一规则，并定期审计效果，满足《个人信息保护法》等法规要求。

数据可用性

数据保护

数据存储

数据加密

数据泄露

数据安全

数据脱敏

密钥管理

敏感数据

数据库

JSON

Java

2026采购季 | AI焕新·智启新局

casb

dmask

dsgc

tencentdb-catalog

对象存储COS新用户低至1元！


cloudhsm

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

【架构实战】数据脱敏与隐私保护架构-腾讯云开发者社区-腾讯云

【架构实战】数据脱敏与隐私保护架构

【架构实战】数据脱敏与隐私保护架构

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐