public class IdCardDesensitizer {
    /**
     * 身份证号脱敏：显示前6位和后4位，中间用*代替
     * @param idCard 原始身份证号
     * @return 脱敏后的身份证号
     */
    public static String maskIdCard(String idCard) {
        if (idCard == null || idCard.length() != 18) {
            return "无效身份证号";
        }
        return idCard.substring(0, 6) + "********" + idCard.substring(14);
    }

    public static void main(String[] args) {
        String originalId = "110101199001011234";
        String maskedId = maskIdCard(originalId);
        System.out.println("原始身份证号：" + originalId);
        System.out.println("脱敏后身份证号：" + maskedId); // 输出：110101********1234
    }
}

import java.util.Random;

public class PhoneDesensitizer {
    /**
     * 手机号脱敏：生成随机有效手机号替换原号码（保持格式一致）
     * @param phone 原始手机号
     * @return 脱敏后的手机号
     */
    public static String replacePhone(String phone) {
        if (phone == null || phone.length() != 11 || !phone.matches("\\d+")) {
            return "无效手机号";
        }
        // 保留前3位运营商号段，后8位随机生成
        String prefix = phone.substring(0, 3);
        Random random = new Random();
        StringBuilder suffix = new StringBuilder();
        for (int i = 0; i < 8; i++) {
            suffix.append(random.nextInt(10));
        }
        return prefix + suffix;
    }

    public static void main(String[] args) {
        String originalPhone = "13812345678";
        String replacedPhone = replacePhone(originalPhone);
        System.out.println("原始手机号：" + originalPhone);
        System.out.println("脱敏后手机号：" + replacedPhone); // 输出：138xxxx5678（xxxx为随机数字）
    }
}

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESCrypto {
    private final String key;
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";

    public AESCrypto(String key) {
        // 密钥长度需为16/24/32字节
        if (key.length() != 16 && key.length() != 24 && key.length() != 32) {
            throw new IllegalArgumentException("密钥长度必须为16/24/32字节");
        }
        this.key = key;
    }

    /**
     * 加密数据
     * @param data 原始数据
     * @return 加密后的Base64字符串
     */
    public String encrypt(String data) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
        IvParameterSpec iv = new IvParameterSpec(key.substring(0, 16).getBytes("UTF-8")); // IV取密钥前16字节
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
        byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encrypted);
    }

    /**
     * 解密数据
     * @param encryptedData 加密后的Base64字符串
     * @return 解密后的原始数据
     */
    public String decrypt(String encryptedData) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
        IvParameterSpec iv = new IvParameterSpec(key.substring(0, 16).getBytes("UTF-8"));
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
        byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decrypted, "UTF-8");
    }

    public static void main(String[] args) throws Exception {
        AESCrypto crypto = new AESCrypto("mysecretkey12345"); // 16字节密钥
        String originalData = "敏感商业数据：2023年营收1000万";
        String encryptedData = crypto.encrypt(originalData);
        String decryptedData = crypto.decrypt(encryptedData);
        
        System.out.println("原始数据：" + originalData);
        System.out.println("加密后：" + encryptedData);
        System.out.println("解密后：" + decryptedData); // 解密后与原始数据一致
    }
}

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;

public class SHA256Hasher {
    /**
     * 使用SHA-256哈希算法脱敏（不可逆）
     * @param data 原始数据
     * @param salt 盐值（增加破解难度）
     * @return 哈希后的数据（16进制字符串）
     */
    public static String hashData(String data, String salt) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest((data + salt).getBytes(StandardCharsets.UTF_8));
            // 转换为16进制字符串
            StringBuilder hexString = new StringBuilder();
            for (byte b : hash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            return hexString.toString();
        } catch (Exception e) {
            throw new RuntimeException("哈希计算失败", e);
        }
    }

    public static void main(String[] args) {
        String originalPwd = "user_password123";
        String hashedPwd = hashData(originalPwd, "random_salt_789");
        System.out.println("原始密码：" + originalPwd);
        System.out.println("哈希后密码：" + hashedPwd); // 输出：64位哈希值（不可逆）
    }
}

import java.util.HashMap;
import java.util.Map;

public class DynamicDesensitizer {
    /**
     * 动态脱敏：根据用户角色返回不同脱敏程度的数据
     * @param data 原始数据Map
     * @param userRole 用户角色（admin/normal/guest）
     * @return 脱敏后的数据Map
     */
    public static Map<String, String> dynamicDesensitize(Map<String, String> data, String userRole) {
        Map<String, String> result = new HashMap<>();
        switch (userRole) {
            case "admin":
                // 管理员可见完整数据
                result.putAll(data);
                break;
            case "normal":
                // 普通用户可见部分脱敏数据
                result.put("id", data.get("id"));
                result.put("name", data.get("name"));
                result.put("id_card", IdCardDesensitizer.maskIdCard(data.get("id_card")));
                String phone = data.get("phone");
                result.put("phone", phone.substring(0, 3) + "****" + phone.substring(7));
                break;
            case "guest":
                // 访客可见高度脱敏数据
                result.put("id", "***");
                String name = data.get("name");
                result.put("name", name.charAt(0) + "*".repeat(name.length() - 1));
                result.put("id_card", "************" + data.get("id_card").substring(14));
                result.put("phone", "***********");
                break;
            default:
                throw new IllegalArgumentException("无效的用户角色");
        }
        return result;
    }

    public static void main(String[] args) {
        Map<String, String> userData = new HashMap<>();
        userData.put("id", "001");
        userData.put("name", "张三");
        userData.put("id_card", "110101199001011234");
        userData.put("phone", "13812345678");

        System.out.println("管理员看到的数据：" + dynamicDesensitize(userData, "admin"));
        System.out.println("普通用户看到的数据：" + dynamicDesensitize(userData, "normal"));
        System.out.println("访客看到的数据：" + dynamicDesensitize(userData, "guest"));
    }
}