加密工具类

🔐 功能特性

1. MD5 加密

md5() - 32位小写 MD5
md5Short() - 16位 MD5（中间16位）
md5WithSalt() - MD5 加盐加密

2. SHA-256 加密

sha256() - SHA-256 加密（更安全）
sha256WithSalt() - SHA-256 加盐加密

3. AES 对称加密

aesEncrypt() - AES 加密
aesDecrypt() - AES 解密
generateAesKey() - 生成随机 AES 密钥

4. Base64 编码

base64Encode() - Base64 编码
base64Decode() - Base64 解码

5. 密码加密（推荐）⭐

encryptPassword() - 加密密码（SHA-256 + 随机盐）
verifyPassword() - 验证密码

6. 工具方法

generateSalt() - 生成随机盐值
generateRandomString() - 生成随机字符串

package com.belnuan.common.utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * 加密工具类
 * 支持 MD5、SHA-256、AES、Base64 等多种加密方式
 */
public class CryptoUtils {

    private static final String AES_ALGORITHM = "AES";
    private static final String AES_TRANSFORMATION = "AES/ECB/PKCS5Padding";
    private static final int AES_KEY_SIZE = 128;

    // ==================== MD5 加密 ====================

    /**
     * MD5 加密（32位小写）
     */
    public static String md5(String text) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(text.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(digest);
        } catch (Exception e) {
            throw new RuntimeException("MD5加密失败", e);
        }
    }

    /**
     * MD5 加密（16位小写 - 取中间16位）
     */
    public static String md5Short(String text) {
        String md5 = md5(text);
        return md5.substring(8, 24);
    }

    /**
     * MD5 加盐加密
     */
    public static String md5WithSalt(String text, String salt) {
        return md5(text + salt);
    }

    // ==================== SHA-256 加密 ====================

    /**
     * SHA-256 加密
     */
    public static String sha256(String text) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(text.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(digest);
        } catch (Exception e) {
            throw new RuntimeException("SHA-256加密失败", e);
        }
    }

    /**
     * SHA-256 加盐加密
     */
    public static String sha256WithSalt(String text, String salt) {
        return sha256(text + salt);
    }

    // ==================== AES 对称加密 ====================

    /**
     * AES 加密（返回 Base64 字符串）
     * @param text 明文
     * @param key 密钥（建议16位）
     */
    public static String aesEncrypt(String text, String key) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
            Cipher cipher = Cipher.getInstance(AES_TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encrypted = cipher.doFinal(text.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("AES加密失败", e);
        }
    }

    /**
     * AES 解密
     * @param encryptedText 密文（Base64 字符串）
     * @param key 密钥（建议16位）
     */
    public static String aesDecrypt(String encryptedText, String key) {
        try {
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
            Cipher cipher = Cipher.getInstance(AES_TRANSFORMATION);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encryptedText));
            return new String(decrypted, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException("AES解密失败", e);
        }
    }

    /**
     * 生成随机 AES 密钥（Base64 编码）
     */
    public static String generateAesKey() {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance(AES_ALGORITHM);
            keyGen.init(AES_KEY_SIZE, new SecureRandom());
            SecretKey secretKey = keyGen.generateKey();
            return Base64.getEncoder().encodeToString(secretKey.getEncoded());
        } catch (Exception e) {
            throw new RuntimeException("生成AES密钥失败", e);
        }
    }

    // ==================== Base64 编码/解码 ====================

    /**
     * Base64 编码
     */
    public static String base64Encode(String text) {
        return Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
    }

    /**
     * Base64 解码
     */
    public static String base64Decode(String encodedText) {
        byte[] decoded = Base64.getDecoder().decode(encodedText);
        return new String(decoded, StandardCharsets.UTF_8);
    }

    /**
     * Base64 编码（字节数组）
     */
    public static String base64Encode(byte[] bytes) {
        return Base64.getEncoder().encodeToString(bytes);
    }

    /**
     * Base64 解码（返回字节数组）
     */
    public static byte[] base64DecodeToBytes(String encodedText) {
        return Base64.getDecoder().decode(encodedText);
    }

    // ==================== 工具方法 ====================

    /**
     * 字节数组转十六进制字符串
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    /**
     * 生成随机盐值（16位）
     */
    public static String generateSalt() {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[16];
        random.nextBytes(salt);
        return bytesToHex(salt);
    }

    /**
     * 生成随机字符串（指定长度）
     */
    public static String generateRandomString(int length) {
        String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        SecureRandom random = new SecureRandom();
        StringBuilder sb = new StringBuilder(length);
        for (int i = 0; i < length; i++) {
            sb.append(chars.charAt(random.nextInt(chars.length())));
        }
        return sb.toString();
    }

    // ==================== 密码加密推荐方法 ====================

    /**
     * 密码加密（推荐用于用户密码存储）
     * 使用 SHA-256 + 随机盐值
     * 返回格式：salt$hashedPassword
     */
    public static String encryptPassword(String password) {
        String salt = generateSalt();
        String hashed = sha256WithSalt(password, salt);
        return salt + "$" + hashed;
    }

    /**
     * 密码验证
     * @param password 用户输入的明文密码
     * @param encryptedPassword 数据库中存储的加密密码（格式：salt$hashedPassword）
     */
    public static boolean verifyPassword(String password, String encryptedPassword) {
        try {
            String[] parts = encryptedPassword.split("\\$");
            if (parts.length != 2) {
                return false;
            }
            String salt = parts[0];
            String storedHash = parts[1];
            String inputHash = sha256WithSalt(password, salt);
            return storedHash.equals(inputHash);
        } catch (Exception e) {
            return false;
        }
    }

    // ==================== 测试示例 ====================

    public static void main(String[] args) {
        System.out.println("========== MD5 加密 ==========");
        String text = "Hello, World!";
        System.out.println("原文: " + text);
        System.out.println("MD5(32位): " + md5(text));
        System.out.println("MD5(16位): " + md5Short(text));
        System.out.println("MD5加盐: " + md5WithSalt(text, "mysalt"));

        System.out.println("\n========== SHA-256 加密 ==========");
        System.out.println("SHA-256: " + sha256(text));
        System.out.println("SHA-256加盐: " + sha256WithSalt(text, "mysalt"));

        System.out.println("\n========== AES 加密/解密 ==========");
        String aesKey = "1234567890123456"; // 16位密钥
        String encrypted = aesEncrypt(text, aesKey);
        String decrypted = aesDecrypt(encrypted, aesKey);
        System.out.println("AES密钥: " + aesKey);
        System.out.println("加密后: " + encrypted);
        System.out.println("解密后: " + decrypted);

        System.out.println("\n========== Base64 编码/解码 ==========");
        String encoded = base64Encode(text);
        String decoded = base64Decode(encoded);
        System.out.println("Base64编码: " + encoded);
        System.out.println("Base64解码: " + decoded);

        System.out.println("\n========== 密码加密（推荐） ==========");
        String password = "myPassword123";
        String encryptedPwd = encryptPassword(password);
        System.out.println("原始密码: " + password);
        System.out.println("加密后: " + encryptedPwd);
        System.out.println("验证正确密码: " + verifyPassword(password, encryptedPwd));
        System.out.println("验证错误密码: " + verifyPassword("wrongPassword", encryptedPwd));

        System.out.println("\n========== 工具方法 ==========");
        System.out.println("随机盐值: " + generateSalt());
        System.out.println("随机字符串(16位): " + generateRandomString(16));
        System.out.println("随机AES密钥: " + generateAesKey());
    }
}