一文看透对称加密、非对称加密与哈希加密的本质区别

<dependencies>
    <!-- Lombok用于简化日志和POJO类 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.30</version>
        <scope>provided</scope>
    </dependency>

    <!-- Spring工具类 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>6.1.4</version>
    </dependency>

    <!-- Swagger3用于API文档 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>

    <!-- FastJSON2用于JSON处理 -->
    <dependency>
        <groupId>com.alibaba.fastjson2</groupId>
        <artifactId>fastjson2</artifactId>
        <version>2.0.41</version>
    </dependency>

    <!-- Guava集合工具类 -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>32.1.3-jre</version>
    </dependency>
</dependencies>

package com.example.crypto.utils;

import cn.hutool.crypto.digest.HMac;
import cn.hutool.crypto.digest.HmacAlgorithm;
import com.alibaba.fastjson2.JSON;
import com.google.common.collect.Maps;
import lombok.Slf4j;
import org.springframework.util.Base64Utils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

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

/**
 * AES加密解密工具类
 * 采用AES-256-GCM模式，提供高安全性的对称加密功能
 *
 * @author ken
 */
@Slf4j
public class AesUtils {

    /**
     * 算法名称
     */
    private static final String ALGORITHM = "AES";

    /**
     * 加密模式和填充方式
     * GCM模式提供认证功能，不需要额外的消息认证码
     */
    private static final String TRANSFORMATION = "AES/GCM/NoPadding";

    /**
     * 密钥长度：256位，提供最高级别的安全性
     */
    private static final int KEY_SIZE = 256;

    /**
     * GCM模式需要的IV长度：12字节（96位）
     * 这是NIST推荐的长度，提供最佳安全性和性能平衡
     */
    private static final int GCM_IV_LENGTH = 12;

    /**
     * GCM模式的认证标签长度：16字节（128位）
     */
    private static final int GCM_TAG_LENGTH = 128;

    /**
     * 生成AES密钥
     * 
     * @return 生成的密钥，使用Base64编码
     */
    public static String generateKey() {
        try {
            // 使用SecureRandom确保密钥的随机性
            SecureRandom secureRandom = SecureRandom.getInstanceStrong();

            // 初始化密钥生成器
            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
            keyGenerator.init(KEY_SIZE, secureRandom);

            // 生成密钥并进行Base64编码以便存储和传输
            SecretKey secretKey = keyGenerator.generateKey();
            return Base64Utils.encodeToString(secretKey.getEncoded());
        } catch (Exception e) {
            log.error("生成AES密钥失败", e);
            throw new RuntimeException("生成AES密钥失败", e);
        }
    }

    /**
     * 加密数据
     * 
     * @param plaintext 明文数据
     * @param keyBase64 Base64编码的密钥
     * @return 加密结果，包含IV和密文的JSON字符串
     */
    public static String encrypt(String plaintext, String keyBase64) {
        // 参数校验
        StringUtils.hasText(plaintext, "明文不能为空");
        StringUtils.hasText(keyBase64, "密钥不能为空");

        try {
            // 解码密钥
            byte[] keyBytes = Base64Utils.decodeFromString(keyBase64);
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, ALGORITHM);

            // 生成随机IV（初始向量）
            byte[] iv = new byte[GCM_IV_LENGTH];
            SecureRandom secureRandom = SecureRandom.getInstanceStrong();
            secureRandom.nextBytes(iv);

            // 初始化加密器
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, parameterSpec);

            // 执行加密
            byte[] ciphertext = cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));

            // 将IV和密文一起返回，IV不需要保密
            Map<String, String> resultMap = Maps.newHashMap();
            resultMap.put("iv", Base64Utils.encodeToString(iv));
            resultMap.put("ciphertext", Base64Utils.encodeToString(ciphertext));

            return JSON.toJSONString(resultMap);
        } catch (Exception e) {
            log.error("AES加密失败", e);
            throw new RuntimeException("AES加密失败", e);
        }
    }

    /**
     * 解密数据
     * 
     * @param encryptedData 加密数据，包含IV和密文的JSON字符串
     * @param keyBase64 Base64编码的密钥
     * @return 解密后的明文
     */
    public static String decrypt(String encryptedData, String keyBase64) {
        // 参数校验
        StringUtils.hasText(encryptedData, "加密数据不能为空");
        StringUtils.hasText(keyBase64, "密钥不能为空");

        try {
            // 解析加密数据
            Map<String, String> dataMap = JSON.parseObject(encryptedData, Map.class);
            String ivBase64 = dataMap.get("iv");
            String ciphertextBase64 = dataMap.get("ciphertext");

            // 校验解析结果
            StringUtils.hasText(ivBase64, "IV不能为空");
            StringUtils.hasText(ciphertextBase64, "密文不能为空");

            // 解码密钥、IV和密文
            byte[] keyBytes = Base64Utils.decodeFromString(keyBase64);
            byte[] iv = Base64Utils.decodeFromString(ivBase64);
            byte[] ciphertext = Base64Utils.decodeFromString(ciphertextBase64);

            // 初始化解密器
            SecretKeySpec secretKeySpec = new SecretKeySpec(keyBytes, ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH, iv);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, parameterSpec);

            // 执行解密
            byte[] plaintextBytes = cipher.doFinal(ciphertext);
            return new String(plaintextBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            log.error("AES解密失败", e);
            throw new RuntimeException("AES解密失败", e);
        }
    }
}

package com.example.crypto.demo;

import com.example.crypto.utils.AesUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 对称加密演示控制器
 *
 * @author ken
 */
@RestController
@RequestMapping("/api/symmetric")
@Api(tags = "对称加密演示接口")
@Slf4j
public class SymmetricEncryptionController {

    /**
     * 演示AES加密解密过程
     *
     * @param plaintext 要加密的明文
     * @return 加密解密结果信息
     */
    @PostMapping("/aes-demo")
    @ApiOperation(value = "AES加密解密演示", notes = "生成密钥，对明文进行加密，然后解密验证结果")
    public String aesDemo(@RequestParam String plaintext) {
        // 生成AES密钥
        String key = AesUtils.generateKey();
        log.info("生成的AES密钥: {}", key);

        // 加密数据
        String encryptedData = AesUtils.encrypt(plaintext, key);
        log.info("加密后的数据: {}", encryptedData);

        // 解密数据
        String decryptedText = AesUtils.decrypt(encryptedData, key);
        log.info("解密后的明文: {}", decryptedText);

        // 验证解密结果
        if (plaintext.equals(decryptedText)) {
            return String.format("AES加密解密成功！\n密钥: %s\n明文: %s\n加密后: %s\n解密后: %s",
                    key, plaintext, encryptedData, decryptedText);
        } else {
            return "AES加密解密失败，解密结果与原明文不一致";
        }
    }
}

package com.example.crypto.utils;

import com.alibaba.fastjson2.JSON;
import com.google.common.collect.Maps;
import lombok.Slf4j;
import org.springframework.util.Base64Utils;
import org.springframework.util.StringUtils;

import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Map;

/**
 * RSA加密解密与签名验证工具类
 * 提供RSA非对称加密、解密、签名和验证功能
 *
 * @author ken
 */
@Slf4j
public class RsaUtils {

    /**
     * 算法名称
     */
    private static final String ALGORITHM = "RSA";

    /**
     * 签名算法：SHA256withRSA
     * 使用SHA-256进行消息摘要，然后用RSA进行签名
     */
    private static final String SIGNATURE_ALGORITHM = "SHA256withRSA";

    /**
     * 密钥长度：2048位
     * 提供足够的安全性，同时保持较好的性能
     */
    private static final int KEY_SIZE = 2048;

    /**
     * 生成RSA密钥对
     * 
     * @return 包含公钥和私钥的Map，公钥使用"publicKey"键，私钥使用"privateKey"键
     */
    public static Map<String, String> generateKeyPair() {
        try {
            // 使用SecureRandom确保密钥的随机性
            SecureRandom secureRandom = SecureRandom.getInstanceStrong();

            // 初始化密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
            keyPairGenerator.initialize(KEY_SIZE, secureRandom);

            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            // 获取公钥和私钥，并进行Base64编码以便存储和传输
            String publicKey = Base64Utils.encodeToString(keyPair.getPublic().getEncoded());
            String privateKey = Base64Utils.encodeToString(keyPair.getPrivate().getEncoded());

            // 将公钥和私钥存入Map返回
            Map<String, String> keyMap = Maps.newHashMap();
            keyMap.put("publicKey", publicKey);
            keyMap.put("privateKey", privateKey);

            return keyMap;
        } catch (Exception e) {
            log.error("生成RSA密钥对失败", e);
            throw new RuntimeException("生成RSA密钥对失败", e);
        }
    }

    /**
     * 使用公钥加密数据
     * 
     * @param plaintext 明文数据
     * @param publicKeyBase64 Base64编码的公钥
     * @return 加密后的密文，使用Base64编码
     */
    public static String encryptByPublicKey(String plaintext, String publicKeyBase64) {
        // 参数校验
        StringUtils.hasText(plaintext, "明文不能为空");
        StringUtils.hasText(publicKeyBase64, "公钥不能为空");

        try {
            // 解码公钥
            byte[] publicKeyBytes = Base64Utils.decodeFromString(publicKeyBase64);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(keySpec);

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

            // 由于RSA加密长度有限制，需要分段加密
            byte[] plaintextBytes = plaintext.getBytes(StandardCharsets.UTF_8);
            byte[] ciphertextBytes = encryptByPublicKeySegment(plaintextBytes, cipher);

            // 对加密结果进行Base64编码
            return Base64Utils.encodeToString(ciphertextBytes);
        } catch (Exception e) {
            log.error("RSA公钥加密失败", e);
            throw new RuntimeException("RSA公钥加密失败", e);
        }
    }

    /**
     * 使用私钥解密数据
     * 
     * @param ciphertextBase64 Base64编码的密文
     * @param privateKeyBase64 Base64编码的私钥
     * @return 解密后的明文
     */
    public static String decryptByPrivateKey(String ciphertextBase64, String privateKeyBase64) {
        // 参数校验
        StringUtils.hasText(ciphertextBase64, "密文不能为空");
        StringUtils.hasText(privateKeyBase64, "私钥不能为空");

        try {
            // 解码私钥
            byte[] privateKeyBytes = Base64Utils.decodeFromString(privateKeyBase64);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

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

            // 解码密文并分段解密
            byte[] ciphertextBytes = Base64Utils.decodeFromString(ciphertextBase64);
            byte[] plaintextBytes = decryptByPrivateKeySegment(ciphertextBytes, cipher);

            // 将解密结果转换为字符串
            return new String(plaintextBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            log.error("RSA私钥解密失败", e);
            throw new RuntimeException("RSA私钥解密失败", e);
        }
    }

    /**
     * 使用私钥对数据进行签名
     * 
     * @param data 要签名的数据
     * @param privateKeyBase64 Base64编码的私钥
     * @return 签名结果，使用Base64编码
     */
    public static String sign(String data, String privateKeyBase64) {
        // 参数校验
        StringUtils.hasText(data, "待签名数据不能为空");
        StringUtils.hasText(privateKeyBase64, "私钥不能为空");

        try {
            // 解码私钥
            byte[] privateKeyBytes = Base64Utils.decodeFromString(privateKeyBase64);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

            // 初始化签名器
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initSign(privateKey);

            // 更新要签名的数据
            signature.update(data.getBytes(StandardCharsets.UTF_8));

            // 执行签名并对结果进行Base64编码
            byte[] signBytes = signature.sign();
            return Base64Utils.encodeToString(signBytes);
        } catch (Exception e) {
            log.error("RSA签名失败", e);
            throw new RuntimeException("RSA签名失败", e);
        }
    }

    /**
     * 使用公钥验证签名
     * 
     * @param data 原始数据
     * @param signBase64 Base64编码的签名
     * @param publicKeyBase64 Base64编码的公钥
     * @return 验证结果：true表示签名有效，false表示签名无效
     */
    public static boolean verify(String data, String signBase64, String publicKeyBase64) {
        // 参数校验
        StringUtils.hasText(data, "原始数据不能为空");
        StringUtils.hasText(signBase64, "签名不能为空");
        StringUtils.hasText(publicKeyBase64, "公钥不能为空");

        try {
            // 解码公钥
            byte[] publicKeyBytes = Base64Utils.decodeFromString(publicKeyBase64);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(keySpec);

            // 初始验证器
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            signature.initVerify(publicKey);

            // 更新原始数据
            signature.update(data.getBytes(StandardCharsets.UTF_8));

            // 解码签名并执行验证
            byte[] signBytes = Base64Utils.decodeFromString(signBase64);
            return signature.verify(signBytes);
        } catch (Exception e) {
            log.error("RSA签名验证失败", e);
            throw new RuntimeException("RSA签名验证失败", e);
        }
    }

    /**
     * 分段加密，解决RSA加密长度限制问题
     * 
     * @param data 要加密的数据
     * @param cipher 加密器
     * @return 加密后的字节数组
     * @throws GeneralSecurityException 加密过程中可能抛出的异常
     */
    private static byte[] encryptByPublicKeySegment(byte[] data, Cipher cipher) throws GeneralSecurityException {
        // 计算最大加密块大小
        int maxBlockSize = cipher.getBlockSize();

        // 创建输出流存储加密结果
        java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();

        // 分段加密
        int offset = 0;
        while (offset < data.length) {
            int length = Math.min(data.length - offset, maxBlockSize);
            byte[] encryptedBlock = cipher.doFinal(data, offset, length);
            out.write(encryptedBlock);
            offset += length;
        }

        // 关闭输出流并返回结果
        out.close();
        return out.toByteArray();
    }

    /**
     * 分段解密，解决RSA解密长度限制问题
     * 
     * @param data 要解密的数据
     * @param cipher 解密器
     * @return 解密后的字节数组
     * @throws GeneralSecurityException 解密过程中可能抛出的异常
     */
    private static byte[] decryptByPrivateKeySegment(byte[] data, Cipher cipher) throws GeneralSecurityException {
        // 计算最大解密块大小
        int maxBlockSize = cipher.getBlockSize();

        // 创建输出流存储解密结果
        java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();

        // 分段解密
        int offset = 0;
        while (offset < data.length) {
            int length = Math.min(data.length - offset, maxBlockSize);
            byte[] decryptedBlock = cipher.doFinal(data, offset, length);
            out.write(decryptedBlock);
            offset += length;
        }

        // 关闭输出流并返回结果
        out.close();
        return out.toByteArray();
    }
}

package com.example.crypto.demo;

import com.example.crypto.utils.RsaUtils;
import com.google.common.collect.Maps;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

/**
 * 非对称加密演示控制器
 *
 * @author ken
 */
@RestController
@RequestMapping("/api/asymmetric")
@Api(tags = "非对称加密演示接口")
@Slf4j
public class AsymmetricEncryptionController {

    /**
     * 演示RSA加密解密和签名验证过程
     *
     * @param plaintext 要加密的明文
     * @return 加密解密和签名验证的结果信息
     */
    @PostMapping("/rsa-demo")
    @ApiOperation(value = "RSA加密解密与签名验证演示", notes = "生成密钥对，进行加密解密，并演示签名和验证过程")
    public String rsaDemo(@RequestParam String plaintext) {
        // 生成RSA密钥对
        Map<String, String> keyPair = RsaUtils.generateKeyPair();
        String publicKey = keyPair.get("publicKey");
        String privateKey = keyPair.get("privateKey");

        log.info("生成的RSA公钥: {}", publicKey);
        log.info("生成的RSA私钥: {}", privateKey);

        // 使用公钥加密
        String encryptedData = RsaUtils.encryptByPublicKey(plaintext, publicKey);
        log.info("RSA公钥加密后的数据: {}", encryptedData);

        // 使用私钥解密
        String decryptedText = RsaUtils.decryptByPrivateKey(encryptedData, privateKey);
        log.info("RSA私钥解密后的明文: {}", decryptedText);

        // 验证加密解密结果
        boolean encryptDecryptSuccess = plaintext.equals(decryptedText);

        // 使用私钥签名
        String signature = RsaUtils.sign(plaintext, privateKey);
        log.info("数据签名结果: {}", signature);

        // 使用公钥验证签名
        boolean verifySuccess = RsaUtils.verify(plaintext, signature, publicKey);
        log.info("签名验证结果: {}", verifySuccess);

        // 验证签名被篡改的情况
        String tamperedData = plaintext + "被篡改了";
        boolean tamperedVerifyResult = RsaUtils.verify(tamperedData, signature, publicKey);
        log.info("篡改数据后的签名验证结果: {}", tamperedVerifyResult);

        // 构建结果信息
        StringBuilder result = new StringBuilder();
        result.append("RSA加密解密与签名验证演示结果:\n");
        result.append("公钥: ").append(publicKey).append("\n");
        result.append("私钥: ").append(privateKey).append("\n");
        result.append("原始明文: ").append(plaintext).append("\n");
        result.append("加密后的数据: ").append(encryptedData).append("\n");
        result.append("解密后的数据: ").append(decryptedText).append("\n");
        result.append("加密解密是否成功: ").append(encryptDecryptSuccess ? "是" : "否").append("\n");
        result.append("签名结果: ").append(signature).append("\n");
        result.append("签名验证是否成功: ").append(verifySuccess ? "是" : "否").append("\n");
        result.append("数据被篡改后签名验证是否成功: ").append(tamperedVerifyResult ? "是" : "否").append("\n");

        return result.toString();
    }
}

package com.example.crypto.utils;

import com.alibaba.fastjson2.JSON;
import lombok.Slf4j;
import org.springframework.util.StringUtils;
import org.mindrot.jbcrypt.BCrypt;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * 哈希算法工具类
 * 提供各种哈希算法的实现，包括普通哈希和密码哈希
 *
 * @author ken
 */
@Slf4j
public class HashUtils {

    /**
     * 使用SHA-256计算哈希值
     * 
     * @param data 要计算哈希的数据
     * @return 计算得到的SHA-256哈希值，使用Base64编码
     */
    public static String sha256(String data) {
        StringUtils.hasText(data, "数据不能为空");

        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            log.error("SHA-256哈希计算失败", e);
            throw new RuntimeException("SHA-256哈希计算失败", e);
        }
    }

    /**
     * 使用SHA-512计算哈希值
     * 
     * @param data 要计算哈希的数据
     * @return 计算得到的SHA-512哈希值，使用Base64编码
     */
    public static String sha512(String data) {
        StringUtils.hasText(data, "数据不能为空");

        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-512");
            byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            log.error("SHA-512哈希计算失败", e);
            throw new RuntimeException("SHA-512哈希计算失败", e);
        }
    }

    /**
     * 使用MD5计算哈希值（仅用于演示，不建议用于安全场景）
     * 
     * @param data 要计算哈希的数据
     * @return 计算得到的MD5哈希值，使用Base64编码
     */
    public static String md5(String data) {
        StringUtils.hasText(data, "数据不能为空");

        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            byte[] hashBytes = digest.digest(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            log.error("MD5哈希计算失败", e);
            throw new RuntimeException("MD5哈希计算失败", e);
        }
    }

    /**
     * 使用BCrypt对密码进行哈希处理
     * BCrypt会自动生成盐值并进行密钥拉伸
     * 
     * @param password 原始密码
     * @param workFactor 工作因子，范围4-31，值越大计算越慢，安全性越高
     * @return 包含盐值的BCrypt哈希结果
     */
    public static String bcryptHash(String password, int workFactor) {
        StringUtils.hasText(password, "密码不能为空");

        // 验证工作因子的有效性
        if (workFactor < 4 || workFactor > 31) {
            throw new IllegalArgumentException("工作因子必须在4到31之间");
        }

        try {
            // BCrypt.hashpw会自动生成盐值并应用密钥拉伸
            return BCrypt.hashpw(password, BCrypt.gensalt(workFactor));
        } catch (Exception e) {
            log.error("BCrypt哈希计算失败", e);
            throw new RuntimeException("BCrypt哈希计算失败", e);
        }
    }

    /**
     * 验证密码是否与BCrypt哈希值匹配
     * 
     * @param password 待验证的密码
     * @param hashedPassword BCrypt哈希后的密码
     * @return 如果密码匹配返回true，否则返回false
     */
    public static boolean bcryptVerify(String password, String hashedPassword) {
        StringUtils.hasText(password, "密码不能为空");
        StringUtils.hasText(hashedPassword, "哈希密码不能为空");

        try {
            return BCrypt.checkpw(password, hashedPassword);
        } catch (Exception e) {
            log.error("BCrypt密码验证失败", e);
            throw new RuntimeException("BCrypt密码验证失败", e);
        }
    }

    /**
     * 演示哈希算法的雪崩效应：输入的微小变化会导致输出的巨大变化
     * 
     * @param original 原始字符串
     * @param modified 微小修改后的字符串
     * @return 包含原始和修改后字符串哈希值的比较结果
     */
    public static String demonstrateAvalancheEffect(String original, String modified) {
        StringUtils.hasText(original, "原始字符串不能为空");
        StringUtils.hasText(modified, "修改后的字符串不能为空");

        String originalSha256 = sha256(original);
        String modifiedSha256 = sha256(modified);

        // 计算两个哈希值的差异程度
        int diffCount = 0;
        for (int i = 0; i < originalSha256.length() && i < modifiedSha256.length(); i++) {
            if (originalSha256.charAt(i) != modifiedSha256.charAt(i)) {
                diffCount++;
            }
        }

        double diffPercentage = (double) diffCount / Math.max(originalSha256.length(), modifiedSha256.length()) * 100;

        return String.format(
            "原始字符串: %s\n修改后字符串: %s\n" +
            "原始SHA-256哈希: %s\n修改后SHA-256哈希: %s\n" +
            "差异字符数: %d\n差异百分比: %.2f%%",
            original, modified, originalSha256, modifiedSha256, diffCount, diffPercentage
        );
    }
}

<!-- BCrypt密码哈希库 -->
<dependency>
    <groupId>org.mindrot</groupId>
    <artifactId>jBCrypt</artifactId>
    <version>0.4</version>
</dependency>

package com.example.crypto.demo;

import com.example.crypto.utils.HashUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * 哈希算法演示控制器
 *
 * @author ken
 */
@RestController
@RequestMapping("/api/hash")
@Api(tags = "哈希算法演示接口")
@Slf4j
public class HashAlgorithmController {

    /**
     * 演示各种哈希算法的使用
     *
     * @param data 要计算哈希的数据
     * @return 各种哈希算法的计算结果
     */
    @PostMapping("/hash-demo")
    @ApiOperation(value = "哈希算法演示", notes = "展示不同哈希算法的计算结果和特性")
    public String hashDemo(@RequestParam String data) {
        // 计算不同哈希算法的结果
        String md5Hash = HashUtils.md5(data);
        String sha256Hash = HashUtils.sha256(data);
        String sha512Hash = HashUtils.sha512(data);

        log.info("数据: {}", data);
        log.info("MD5哈希值: {}", md5Hash);
        log.info("SHA-256哈希值: {}", sha256Hash);
        log.info("SHA-512哈希值: {}", sha512Hash);

        // 演示雪崩效应
        String modifiedData = data + "x"; // 仅在原始数据后添加一个字符
        String avalancheEffect = HashUtils.demonstrateAvalancheEffect(data, modifiedData);

        // 构建结果信息
        StringBuilder result = new StringBuilder();
        result.append("哈希算法演示结果:\n");
        result.append("原始数据: ").append(data).append("\n");
        result.append("MD5哈希值: ").append(md5Hash).append(" (不安全，仅作演示)\n");
        result.append("SHA-256哈希值: ").append(sha256Hash).append("\n");
        result.append("SHA-512哈希值: ").append(sha512Hash).append("\n\n");
        result.append("雪崩效应演示:\n").append(avalancheEffect).append("\n");

        return result.toString();
    }

    /**
     * 演示密码哈希和验证过程
     *
     * @param password 要处理的密码
     * @return 密码哈希和验证的结果
     */
    @PostMapping("/password-hash-demo")
    @ApiOperation(value = "密码哈希演示", notes = "展示如何安全地哈希和验证密码")
    public String passwordHashDemo(@RequestParam String password) {
        // 使用BCrypt哈希密码，工作因子设为12
        String hashedPassword = HashUtils.bcryptHash(password, 12);
        log.info("原始密码: {}", password);
        log.info("BCrypt哈希后的密码: {}", hashedPassword);

        // 验证正确密码
        boolean correctPasswordResult = HashUtils.bcryptVerify(password, hashedPassword);

        // 验证错误密码
        String wrongPassword = password + "wrong";
        boolean wrongPasswordResult = HashUtils.bcryptVerify(wrongPassword, hashedPassword);

        // 演示相同密码的不同哈希结果（因为盐值不同）
        String hashedPassword2 = HashUtils.bcryptHash(password, 12);
        boolean samePasswordDifferentHash = !hashedPassword.equals(hashedPassword2);
        boolean verifySecondHash = HashUtils.bcryptVerify(password, hashedPassword2);

        // 构建结果信息
        StringBuilder result = new StringBuilder();
        result.append("密码哈希演示结果:\n");
        result.append("原始密码: ").append(password).append("\n");
        result.append("BCrypt哈希结果1: ").append(hashedPassword).append("\n");
        result.append("BCrypt哈希结果2: ").append(hashedPassword2).append("\n");
        result.append("两次哈希结果是否不同: ").append(samePasswordDifferentHash ? "是 (因为盐值不同)" : "否").append("\n");
        result.append("正确密码验证结果: ").append(correctPasswordResult ? "成功" : "失败").append("\n");
        result.append("错误密码验证结果: ").append(wrongPasswordResult ? "成功" : "失败").append("\n");
        result.append("使用第二个哈希值验证正确密码: ").append(verifySecondHash ? "成功" : "失败").append("\n");

        return result.toString();
    }
}