【JAVA】数据脱敏技术（对称加密算法、非对称加密算法、哈希算法、消息认证码（MAC）算法、密钥交换算法）使用方法

来一杯龙舌兰

于 2024-09-12 08:49:09 发布

阅读量1.5k

点赞数 20

分类专栏： Java 文章标签： java 开发语言数据脱敏技术加密算法 AES

本文链接：https://blog.csdn.net/aaaaaaatwl/article/details/142093879

版权

Java 专栏收录该内容

33 篇文章 3 订阅

订阅专栏

在这里插入图片描述

文章目录

更多相关内容可查看

数据脱敏的定义和目的

数据脱敏（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);
    }
}