文章目录
- 数据脱敏的定义和目的
- 数据脱敏的技术分类
- 对称加密算法
- 非对称加密算法
- 哈希算法
- 消息认证码（MAC）算法
- 密钥交换算法
- 数据脱敏的技术方案实现
- 字符替换
- 哈希算法（例如:SHA-3 算法）
- 消息认证码（MAC）算法(CMAC)
- 消息认证码（MAC）算法(HMAC)
- 对称/非对称加密实现方式（例如：AES加密算法）
- 数据分段
- 数据伪装
更多相关内容可查看
数据脱敏的定义和目的
数据脱敏（Data Masking）是指对数据进行处理，替换或掩盖其真实内容，以防止敏感信息被未经授权的用户访问。脱敏后的数据仍然能够保留原数据的格式和某些特征，但无法反映真实的敏感信息。其主要目的是保护隐私、遵守法律法规、以及降低数据泄露的风险。
数据脱敏的技术分类
对称加密算法
对称加密算法使用相同的密钥进行加密和解密。常见的对称加密算法包括：
- AES (Advanced Encryption Standard): AES是一种
广泛使用的对称加密算法，支持128位、192位和256位密钥长度。 DES (Data Encryption Standard): DES曾经是标准的对称加密算法，但由于密钥长度较短（56位），现在已经不再推荐用于安全敏感的应用。- 3DES (Triple DES): 是DES的增强版本，通过
三次加密增加安全性。 - Blowfish: 一种
可变密钥长度的对称加密算法，速度快且安全性高。 - Twofish: Blowfish的后续版本，
支持256位密钥。
非对称加密算法
非对称加密算法使用一对密钥（公钥和私钥），加密和解密使用不同的密钥。常见的非对称加密算法包括：
- RSA (Rivest–Shamir–Adleman): 一种广泛使用的非对称加密算法，主要用于安全数据传输。
- DSA (Digital Signature Algorithm): 用于数字签名的算法，通常与SHA算法一起使用。
- ECC (Elliptic Curve Cryptography): 使用椭圆曲线数学的非对称加密算法，提供相对较高的安全性和效率。
哈希算法
哈希算法将任意长度的数据映射到固定长度的散列值，不可逆转。常见的哈希算法包括：
MD5 (Message Digest Algorithm 5): 生成128位散列值，但由于安全性问题现在已经不再推荐使用。SHA-1 (Secure Hash Algorithm 1): 生成160位散列值，但也因为安全问题逐渐被淘汰。- SHA-2 (Secure Hash Algorithm 2): 包括SHA-224、SHA-256、SHA-384和SHA-512，提供更强的安全性。
- SHA-3 (Secure Hash Algorithm 3): 最新的哈希标准，提供比SHA-2更高的安全性。
消息认证码（MAC）算法
MAC算法用于确保消息的完整性和验证消息的来源。常见的MAC算法包括：
- HMAC (Hash-based Message Authentication Code): 结合了哈希算法（如SHA-256）与密钥，确保消息完整性和认证。
- CMAC (Cipher-based Message Authentication Code): 结合了对称加密算法（如AES）与密钥，用于生成认证码。
密钥交换算法
这些算法用于安全地交换密钥。常见的密钥交换算法包括：
- Diffie-Hellman: 用于在不安全的通道上安全地交换密钥。
- Elliptic Curve Diffie-Hellman (ECDH): 基于椭圆曲线的Diffie-Hellman算法，提供更高的安全性和效率。
在Java中，这些加密算法通常通过 javax.crypto、java.security 和 java.security.cert包提供
数据脱敏的技术方案实现
字符替换
将敏感数据的字符替换为特定的符号或字符。例如，将身份证号码的中间部分替换为“*”：
public class DataMasking {
public static String maskIdNumber(String idNumber) {
if (idNumber == null || idNumber.length() < 6) {
return idNumber;
}
return idNumber.substring(0, 3) + "****" + idNumber.substring(7);
}
public static void main(String[] args) {
String idNumber = "123456789012345";
System.out.println(maskIdNumber(idNumber)); // 输出: 123****345
}
}
哈希算法（例如:SHA-3 算法）
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HexFormat;
public class SHA3Example {
// 使用SHA-3进行哈希
public static String hashWithSHA3(String data) throws NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("SHA3-256"); // 可以用 "SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512"
byte[] hashBytes = digest.digest(data.getBytes());
return HexFormat.of().formatHex(hashBytes); // 将字节数组转换为十六进制字符串
}
public static void main(String[] args) {
try {
String originalData = "Hello, SHA-3!";
String hashedData = hashWithSHA3(originalData);
System.out.println("Original Data: " + originalData);
System.out.println("SHA-3 Hash: " + hashedData);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
}
消息认证码（MAC）算法(CMAC)
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.Mac;
import javax.crypto.spec.IvParameterSpec;
import java.util.Arrays;
import java.util.Base64;
public class CMACExample {
private static final String AES = "AES";
private static final String CMAC = "AESCMAC";
// 生成CMAC
public static String generateCMAC(String data, String key) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(key.getBytes("UTF-8"), AES);
Mac mac = Mac.getInstance(CMAC);
mac.init(keySpec);
byte[] dataBytes = data.getBytes("UTF-8");
byte[] cmacBytes = mac.doFinal(dataBytes);
return Base64.getEncoder().encodeToString(cmacBytes);
}
// 验证CMAC
public static boolean verifyCMAC(String data, String key, String cmac) throws Exception {
String generatedCmac = generateCMAC(data, key);
return generatedCmac.equals(cmac);
}
public static void main(String[] args) {
try {
String data = "Hello, CMAC!";
String key = "mysecretkey1234"; // 16-byte key for AES
// 生成CMAC
String cmac = generateCMAC(data, key);
System.out.println("Generated CMAC: " + cmac);
// 验证CMAC
boolean isValid = verifyCMAC(data, key, cmac);
System.out.println("Is the CMAC valid? " + isValid);
} catch (Exception e) {
e.printStackTrace();
}
}
}
消息认证码（MAC）算法(HMAC)
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class HMACExample {
private static final String HMAC_ALGORITHM = "HmacSHA256";
// 生成HMAC
public static String generateHMAC(String data, String secret) throws Exception {
SecretKeySpec keySpec = new SecretKeySpec(secret.getBytes("UTF-8"), HMAC_ALGORITHM);
Mac mac = Mac.getInstance(HMAC_ALGORITHM);
mac.init(keySpec);
byte[] rawHmac = mac.doFinal(data.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(rawHmac);
}
// 验证HMAC
public static boolean verifyHMAC(String data, String secret, String hmac) throws Exception {
String generatedHmac = generateHMAC(data, secret);
return generatedHmac.equals(hmac);
}
public static void main(String[] args) {
try {
String data = "Hello, HMAC!";
String secret = "mysecretkey";
// 生成HMAC
String hmac = generateHMAC(data, secret);
System.out.println("Generated HMAC: " + hmac);
// 验证HMAC
boolean isValid = verifyHMAC(data, secret, hmac);
System.out.println("Is the HMAC valid? " + isValid);
} catch (Exception e) {
e.printStackTrace();
}
}
}
对称/非对称加密实现方式（例如：AES加密算法）
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class DataEncryption {
// AES算法
private static final String ALGORITHM = "AES";
// 加密方法
public static String encrypt(String data, SecretKey key) throws Exception {
// 创建Cipher对象，指定加密算法
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 初始化Cipher对象为加密模式
cipher.init(Cipher.ENCRYPT_MODE, key);
// 执行加密操作，返回加密后的字节数组
byte[] encryptedBytes = cipher.doFinal(data.getBytes());
// 将加密后的字节数组转换为Base64编码的字符串
return Base64.getEncoder().encodeToString(encryptedBytes);
}
// 解密方法
public static String decrypt(String encryptedData, SecretKey key) throws Exception {
// 创建Cipher对象，指定加密算法
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 初始化Cipher对象为解密模式
cipher.init(Cipher.DECRYPT_MODE, key);
// 将Base64编码的字符串解码为字节数组
byte[] decodedBytes = Base64.getDecoder().decode(encryptedData);
// 执行解密操作，返回解密后的字节数组
byte[] decryptedBytes = cipher.doFinal(decodedBytes);
// 将解密后的字节数组转换为字符串
return new String(decryptedBytes);
}
// 生成密钥的方法
public static SecretKey generateKey() throws Exception {
// 创建KeyGenerator对象，指定加密算法
KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
// 初始化KeyGenerator对象，指定密钥长度（128位）
keyGen.init(128);
// 生成密钥
return keyGen.generateKey();
}
public static void main(String[] args) throws Exception {
// 生成一个密钥
SecretKey key = generateKey();
// 原始数据
String originalData = "SensitiveData";
// 加密数据
String encryptedData = encrypt(originalData, key);
// 解密数据
String decryptedData = decrypt(encryptedData, key);
// 打印结果
System.out.println("Original Data: " + originalData);
System.out.println("Encrypted Data: " + encryptedData);
System.out.println("Decrypted Data: " + decryptedData);
}
}
数据分段
将敏感数据分段存储，每个分段单独处理。例如，将一个长字符串分成几段，每段单独存储和加密。
数据伪装
生成与真实数据结构相似但内容虚假的数据，用于开发和测试。例如，将真实的用户姓名替换为虚假的名字：
public class DataPseudonymization {
public static String pseudonymizeName(String name) {
// 简单示例，生成虚假的名字
return "User" + (int)(Math.random() * 1000);
}
public static void main(String[] args) {
String realName = "John Doe";
String pseudonymizedName = pseudonymizeName(realName);
System.out.println("Original Name: " + realName);
System.out.println("Pseudonymized Name: " + pseudonymizedName);
}
}
