import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

/**
 * AES對(duì)稱加密工具類（可直接復(fù)用）
 * 說明：128位密鑰無需額外配置，256位密鑰需安裝JCE無限制權(quán)限文件
 */
public class AesEncryptUtil {

    // 加密算法：AES，模式：ECB，填充方式：PKCS5Padding（實(shí)際開發(fā)推薦用CBC模式，需加偏移量）
    private static final String ALGORITHM = "AES/ECB/PKCS5Padding";
    private static final String KEY_ALGORITHM = "AES";
    private static final int KEY_SIZE = 128; // 密鑰長度：128/256

    /**
     * 生成AES密鑰（返回Base64編碼后的密鑰字符串，方便存儲(chǔ)）
     */
    public static String generateKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM);
        keyGenerator.init(KEY_SIZE);
        SecretKey secretKey = keyGenerator.generateKey();
        return Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }

    /**
     * 加密：明文 -> Base64編碼的密文
     * @param plainText 明文（待加密的字符串）
     * @param keyStr Base64編碼后的密鑰
     */
    public static String encrypt(String plainText, String keyStr) throws Exception {
        // 1. 解碼密鑰
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        SecretKeySpec secretKey = new SecretKeySpec(keyBytes, KEY_ALGORITHM);
        // 2. 初始化加密器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        // 3. 加密并返回Base64編碼的密文
        byte[] encryptBytes = cipher.doFinal(plainText.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encryptBytes);
    }

    /**
     * 解密：Base64編碼的密文 -> 明文
     * @param cipherText Base64編碼后的密文
     * @param keyStr Base64編碼后的密鑰
     */
    public static String decrypt(String cipherText, String keyStr) throws Exception {
        // 1. 解碼密鑰和密文
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        byte[] cipherBytes = Base64.getDecoder().decode(cipherText);
        SecretKeySpec secretKey = new SecretKeySpec(keyBytes, KEY_ALGORITHM);
        // 2. 初始化解密器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        // 3. 解密并返回明文
        byte[] decryptBytes = cipher.doFinal(cipherBytes);
        return new String(decryptBytes, "UTF-8");
    }

    // 測(cè)試方法
    public static void main(String[] args) throws Exception {
        // 1. 生成密鑰（實(shí)際開發(fā)中密鑰需妥善保管，如配置在Nacos、Vault中）
        String key = generateKey();
        System.out.println("AES密鑰（Base64編碼）：" + key);

        // 2. 加密
        String plainText = "用戶身份證號(hào)：110101199001011234";
        String cipherText = encrypt(plainText, key);
        System.out.println("加密后的密文：" + cipherText);

        // 3. 解密
        String decryptText = decrypt(cipherText, key);
        System.out.println("解密后的明文：" + decryptText);
    }
}

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * RSA非對(duì)稱加密工具類（可直接復(fù)用）
 * 說明：密鑰長度推薦2048位（安全性足夠），4096位加密速度較慢
 */
public class RsaEncryptUtil {

    private static final String ALGORITHM = "RSA";
    private static final int KEY_SIZE = 2048; // 密鑰長度：2048/4096
    // 簽名算法：SHA256withRSA（SHA256哈希+RSA簽名，安全性更高）
    private static final String SIGN_ALGORITHM = "SHA256withRSA";

    /**
     * 生成RSA密鑰對(duì)（公鑰+私鑰），返回Base64編碼后的字符串
     * @return 數(shù)組：[0]公鑰，[1]私鑰
     */
    public static String[] generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 公鑰編碼為Base64字符串
        String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
        // 私鑰編碼為Base64字符串
        String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());

        return new String[]{publicKey, privateKey};
    }

    /**
     * 公鑰加密（適合加密小數(shù)據(jù)，如AES密鑰）
     * @param plainText 明文（待加密的字符串）
     * @param publicKeyStr Base64編碼后的公鑰
     */
    public static String encryptByPublicKey(String plainText, String publicKeyStr) throws Exception {
        // 1. 解碼公鑰
        byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        // 2. 初始化加密器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        // 3. 加密（RSA加密有長度限制，需分段加密，這里簡化處理短字符串）
        byte[] encryptBytes = cipher.doFinal(plainText.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encryptBytes);
    }

    /**
     * 私鑰解密
     * @param cipherText Base64編碼后的密文
     * @param privateKeyStr Base64編碼后的私鑰
     */
    public static String decryptByPrivateKey(String cipherText, String privateKeyStr) throws Exception {
        // 1. 解碼私鑰
        byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

        // 2. 初始化解密器
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        // 3. 解密
        byte[] cipherBytes = Base64.getDecoder().decode(cipherText);
        byte[] decryptBytes = cipher.doFinal(cipherBytes);
        return new String(decryptBytes, "UTF-8");
    }

    /**
     * 私鑰簽名（用于數(shù)據(jù)防篡改、來源認(rèn)證）
     * @param data 待簽名的數(shù)據(jù)
     * @param privateKeyStr Base64編碼后的私鑰
     */
    public static String sign(String data, String privateKeyStr) throws Exception {
        // 1. 解碼私鑰
        byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

        // 2. 生成簽名
        Signature signature = Signature.getInstance(SIGN_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data.getBytes("UTF-8"));
        byte[] signBytes = signature.sign();
        return Base64.getEncoder().encodeToString(signBytes);
    }

    /**
     * 公鑰驗(yàn)簽（驗(yàn)證數(shù)據(jù)是否被篡改、簽名是否有效）
     * @param data 原始數(shù)據(jù)
     * @param sign 簽名值（Base64編碼）
     * @param publicKeyStr Base64編碼后的公鑰
     */
    public static boolean verifySign(String data, String sign, String publicKeyStr) throws Exception {
        // 1. 解碼公鑰
        byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        // 2. 驗(yàn)證簽名
        Signature signature = Signature.getInstance(SIGN_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data.getBytes("UTF-8"));
        return signature.verify(Base64.getDecoder().decode(sign));
    }

    // 測(cè)試方法
    public static void main(String[] args) throws Exception {
        // 1. 生成密鑰對(duì)
        String[] keyPair = generateKeyPair();
        String publicKey = keyPair[0];
        String privateKey = keyPair[1];
        System.out.println("RSA公鑰（Base64編碼）：" + publicKey);
        System.out.println("RSA私鑰（Base64編碼）：" + privateKey);

        // 2. 加密解密（加密AES密鑰示例）
        String aesKey = "1234567890abcdef"; // 假設(shè)生成的AES密鑰
        String encryptAesKey = encryptByPublicKey(aesKey, publicKey);
        System.out.println("公鑰加密后的AES密鑰：" + encryptAesKey);
        String decryptAesKey = decryptByPrivateKey(encryptAesKey, privateKey);
        System.out.println("私鑰解密后的AES密鑰：" + decryptAesKey);

        // 3. 簽名驗(yàn)簽
        String data = "接口返回?cái)?shù)據(jù)：{\"code\":200,\"msg\":\"success\"}";
        String sign = sign(data, privateKey);
        System.out.println("私鑰簽名值：" + sign);
        boolean verifyResult = verifySign(data, sign, publicKey);
        System.out.println("公鑰驗(yàn)簽結(jié)果：" + verifyResult); // true表示驗(yàn)簽通過
    }
}