import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Utils {
    public static String md5(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(input.getBytes()); // 生成摘要字節(jié)數(shù)組
            // 轉(zhuǎn)16進(jìn)制字符串
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b)); // 02x確保不足兩位補(bǔ)0
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("MD5算法不存在", e);
        }
    }
    public static void main(String[] args) {
        System.out.println(md5("123456")); // 輸出：e10adc3949ba59abbe56e057f20f883e
    }
}

public class SHA256Utils {
    public static String sha256(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(input.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("SHA-256算法不存在", e);
        }
    }
    public static void main(String[] args) {
        System.out.println(sha256("123456")); // 輸出：8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c9
    }
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
public class BCryptUtils {
    private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    // 加密（自動(dòng)生成鹽值）
    public static String encrypt(String password) {
        return encoder.encode(password);
    }
    // 校驗(yàn)（自動(dòng)提取鹽值比對(duì)）
    public static boolean verify(String password, String encryptedPassword) {
        return encoder.matches(password, encryptedPassword);
    }
    public static void main(String[] args) {
        String pwd = "123456";
        String encrypted = encrypt(pwd);
        System.out.println("加密后：" + encrypted); // 格式如 $2a$10$xxx...（包含鹽值）
        System.out.println("校驗(yàn)結(jié)果：" + verify(pwd, encrypted)); // true
    }
}

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-crypto</artifactId>
    <version>5.7.3</version>
</dependency>

public class AESUtils {
    // 密鑰（16字節(jié)=128位，24字節(jié)=192位，32字節(jié)=256位）
    private static final String KEY = "1234567890abcdef"; // 16字節(jié)
    // IV向量（CBC模式必需，16字節(jié)，需與密鑰長(zhǎng)度一致）
    private static final String IV = "abcdef9012345678";
    // 算法/模式/填充
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
    // 加密
    public static String encrypt(String input) {
        try {
            SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), "AES");
            IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
            byte[] encrypted = cipher.doFinal(input.getBytes());
            return Base64.getEncoder().encodeToString(encrypted); // 轉(zhuǎn)Base64方便存儲(chǔ)傳輸
        } catch (Exception e) {
            throw new RuntimeException("AES加密失敗", e);
        }
    }
    // 解密
    public static String decrypt(String encryptedInput) {
        try {
            SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), "AES");
            IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
            byte[] encrypted = Base64.getDecoder().decode(encryptedInput);
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted);
        } catch (Exception e) {
            throw new RuntimeException("AES解密失敗", e);
        }
    }
    public static void main(String[] args) {
        String input = "Hello AES!";
        String encrypted = encrypt(input);
        System.out.println("加密后：" + encrypted);
        String decrypted = decrypt(encrypted);
        System.out.println("解密后：" + decrypted); // Hello AES!
    }
}

public class RSAUtils {
    // 密鑰對(duì)（實(shí)際開發(fā)中需提前生成并存儲(chǔ)，不硬編碼）
    private static KeyPair keyPair;
    static {
        try {
            // 生成RSA密鑰對(duì)（2048位）
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
            generator.initialize(2048);
            keyPair = generator.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("RSA密鑰對(duì)生成失敗", e);
        }
    }
    // 獲取公鑰（Base64編碼）
    public static String getPublicKey() {
        return Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
    }
    // 獲取私鑰（Base64編碼）
    public static String getPrivateKey() {
        return Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
    }
    // 公鑰加密
    public static String encryptByPublicKey(String input, String publicKeyStr) {
        try {
            // 解碼公鑰
            byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            // 加密（RSA加密長(zhǎng)度有限制，2048位密鑰最多加密245字節(jié)）
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] encrypted = cipher.doFinal(input.getBytes());
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("RSA公鑰加密失敗", e);
        }
    }
    // 私鑰解密
    public static String decryptByPrivateKey(String encryptedInput, String privateKeyStr) {
        try {
            // 解碼私鑰
            byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            // 解密
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] encrypted = Base64.getDecoder().decode(encryptedInput);
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted);
        } catch (Exception e) {
            throw new RuntimeException("RSA私鑰解密失敗", e);
        }
    }
    public static void main(String[] args) {
        String input = "AES密鑰1234567890abcdef"; // 小數(shù)據(jù)示例
        String publicKey = getPublicKey();
        String privateKey = getPrivateKey();
        System.out.println("公鑰：" + publicKey);
        System.out.println("私鑰：" + privateKey);
        String encrypted = encryptByPublicKey(input, publicKey);
        System.out.println("公鑰加密后：" + encrypted);
        String decrypted = decryptByPrivateKey(encrypted, privateKey);
        System.out.println("私鑰解密后：" + decrypted); // AES密鑰1234567890abcdef
    }
}

public class SignatureUtils {
    private static final String ALGORITHM = "SHA256withRSA"; // RSA+SHA256簽名
    // 私鑰簽名
    public static String sign(String data, String privateKeyStr) {
        try {
            byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initSign(privateKey);
            signature.update(data.getBytes());
            byte[] signBytes = signature.sign();
            return Base64.getEncoder().encodeToString(signBytes);
        } catch (Exception e) {
            throw new RuntimeException("簽名失敗", e);
        }
    }
    // 公鑰驗(yàn)簽
    public static boolean verify(String data, String signStr, String publicKeyStr) {
        try {
            byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initVerify(publicKey);
            signature.update(data.getBytes());
            byte[] signBytes = Base64.getDecoder().decode(signStr);
            return signature.verify(signBytes);
        } catch (Exception e) {
            throw new RuntimeException("驗(yàn)簽失敗", e);
        }
    }
    public static void main(String[] args) {
        String data = "需要簽名的數(shù)據(jù)";
        String privateKey = RSAUtils.getPrivateKey(); // 復(fù)用RSA密鑰對(duì)
        String publicKey = RSAUtils.getPublicKey();
        String sign = sign(data, privateKey);
        System.out.println("簽名：" + sign);
        boolean verifyResult = verify(data, sign, publicKey);
        System.out.println("驗(yàn)簽結(jié)果：" + verifyResult); // true
        // 篡改數(shù)據(jù)后驗(yàn)簽
        boolean fakeVerify = verify(data + "篡改", sign, publicKey);
        System.out.println("篡改后驗(yàn)簽結(jié)果：" + fakeVerify); // false
    }
}