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

【JAVA】数据脱敏技术(对称加密算法、非对称加密算法、哈希算法、消息认证码(MAC)算法、密钥交换算法)使用方法_第1张图片

文章目录

      • 数据脱敏的定义和目的
      • 数据脱敏的技术分类
        • 对称加密算法
        • 非对称加密算法
        • 哈希算法
        • 消息认证码(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);
    }
}

你可能感兴趣的:(Java,java,开发语言,数据脱敏技术,加密算法,AES)