散列函数：MD5、SHA、SM3 与 HMAC

输入（任意长度）       →  散列函数  →  输出（固定长度）
"hello"              →  SHA-256  →  2cf24dba5fb0a30e...（64 hex = 256 bit）
"hello world"        →  SHA-256  →  b94d27b9934d3e08...（64 hex = 256 bit）
整本《红楼梦》(2MB)   →  SHA-256  →  固定 64 hex 字符

2004 年：王小云团队首次攻破 MD5 碰撞
2006 年：碰撞攻击可在数秒内完成
2008 年：利用 MD5 碰撞伪造了合法的 CA 证书
2012 年：Flame 恶意软件利用 MD5 碰撞伪造 Windows Update 签名

import java.security.MessageDigest;
import java.util.HexFormat;

public class SHA256Example {
    public static String sha256(String input) {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(input.getBytes("UTF-8"));
        return HexFormat.of().formatHex(hash);
    }
}

sha256("hello")  = 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
sha256("hello ") = 32926e0a1bc2be1e5e21da61595d8e5f42a3c0c1cf17bc1eb6a81beaac3a46d3
                   ↑ 多一个空格，输出完全不同

Sponge Construction（海绵结构）：

     输入分块: M1, M2, M3, ...
        │
   ┌────▼────┐
   │ Absorb  │ ← 逐块吸收输入
   │  Phase   │
   └────┬────┘
        │
   ┌────▼────┐
   │ Squeeze │ ← 挤出固定长度输出
   │  Phase   │
   └────┬────┘
        │
      输出 H

import org.bouncycastle.jce.provider.BouncyCastleProvider;
import java.security.MessageDigest;
import java.security.Security;

public class SM3Example {
    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    public static String sm3(String input) {
        MessageDigest md = MessageDigest.getInstance("SM3");
        byte[] hash = md.digest(input.getBytes("UTF-8"));
        return HexFormat.of().formatHex(hash);
    }
}

sm3("hello") = becbbfaae6548b8bf0cfcad5a27183cd1be6093b1cceccc303d9c61d0a645268

HMAC(K, M) = H((K ⊕ opad) || H((K ⊕ ipad) || M))

其中：
  K = 密钥（不足则补零，超长则先 Hash）
  ipad = 0x36 重复到块长度
  opad = 0x5C 重复到块长度

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.util.HexFormat;

public class HMACUtil {

    public static String hmacSha256(String key, String message) {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256"));
        byte[] result = mac.doFinal(message.getBytes("UTF-8"));
        return HexFormat.of().formatHex(result);
    }

    // HMAC-SM3（需要 BouncyCastle）
    public static String hmacSm3(String key, String message) {
        Mac mac = Mac.getInstance("HmacSM3", "BC");
        mac.init(new SecretKeySpec(key.getBytes("UTF-8"), "HmacSM3"));
        byte[] result = mac.doFinal(message.getBytes("UTF-8"));
        return HexFormat.of().formatHex(result);
    }
}

❌ 错误做法：SHA256(key + message)
   存在"长度扩展攻击"：攻击者不知道 key，但能根据 H(key+msg)
   算出 H(key+msg+padding+extra) 的值

✅ 正确做法：HMAC-SHA256(key, message)
   双层 Hash 结构，免疫长度扩展攻击

❌ 数据库存储：SHA256("123456") = 8d969...
   问题：
   1. 彩虹表攻击：预计算常见密码的 Hash，直接反查
   2. 速度太快：GPU 每秒可算数十亿次 SHA-256，暴力破解轻松
   3. 无盐：相同密码相同 Hash，一个泄露全部泄露

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12); // cost=12

// 注册时：生成哈希
String hashed = encoder.encode("user_password");
// 结果：$2a$12$LJ3m/Y7xmG0k8.hFzK8O5e5x5X5Y5Y5Y5Y5Y5Y5Y5Y5Y5Y5Y5Y

// 登录时：验证
boolean matches = encoder.matches("user_password", hashed); // true

$2a$12$LJ3m/Y7xmG...（共 60 字符）
 │  │  │
 │  │  └── 22字符盐 + 31字符哈希（Base64 编码）
 │  └── cost factor = 12（2^12 = 4096 次迭代）
 └── 算法版本（2a/2b）

import org.springframework.security.crypto.argon2.Argon2PasswordEncoder;

// 参数：saltLength, hashLength, parallelism, memory(KB), iterations
Argon2PasswordEncoder encoder = new Argon2PasswordEncoder(16, 32, 1, 65536, 3);

String hashed = encoder.encode("user_password");
boolean matches = encoder.matches("user_password", hashed);

BCrypt:
  cost = 12（约 250ms / 次），每年 +1 跟随硬件发展

Argon2id:
  memory = 64 MB（65536 KB）
  iterations = 3
  parallelism = 1
  目标：单次验证耗时 200-500ms

用户密码 "mypassword"
    │
    ▼ KDF（加盐、迭代）
    │
    ├── 派生密钥 1 → 用于 AES 加密
    ├── 派生密钥 2 → 用于 HMAC
    └── 派生密钥 3 → 用于其他用途

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class HKDF {

    // Extract: 从输入密钥材料中提取固定长度的伪随机密钥
    public static byte[] extract(byte[] salt, byte[] ikm) {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(salt, "HmacSHA256"));
        return mac.doFinal(ikm);
    }

    // Expand: 将伪随机密钥扩展为所需长度
    public static byte[] expand(byte[] prk, byte[] info, int length) {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(prk, "HmacSHA256"));

        byte[] result = new byte[length];
        byte[] block = new byte[0];
        int offset = 0;
        int counter = 1;

        while (offset < length) {
            mac.update(block);
            mac.update(info);
            mac.update((byte) counter);
            block = mac.doFinal();

            int toCopy = Math.min(block.length, length - offset);
            System.arraycopy(block, 0, result, offset, toCopy);
            offset += toCopy;
            counter++;
        }
        return result;
    }
}

/**
 * API 请求签名工具
 * 签名算法：HMAC-SHA256
 * 签名串：method + "\n" + path + "\n" + timestamp + "\n" + body
 */
public class ApiSignUtil {

    // 生成签名
    public static String sign(String secretKey, String method,
                              String path, long timestamp, String body) {
        String signString = method.toUpperCase() + "\n"
            + path + "\n"
            + timestamp + "\n"
            + (body == null ? "" : body);

        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(
            secretKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
        byte[] sig = mac.doFinal(signString.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(sig);
    }

    // 验证签名
    public static boolean verify(String secretKey, String method,
                                 String path, long timestamp,
                                 String body, String signature) {
        // 检查时间戳（5 分钟有效期）
        if (Math.abs(System.currentTimeMillis() - timestamp) > 300_000) {
            return false;
        }
        String expected = sign(secretKey, method, path, timestamp, body);
        return MessageDigest.isEqual(
            expected.getBytes(), signature.getBytes());
    }
}

需要做什么？
│
├─ 校验数据完整性（文件/消息）
│   └─ SHA-256 / SM3
│
├─ 带密钥的消息认证
│   └─ HMAC-SHA256 / HMAC-SM3
│
├─ 存储用户密码
│   ├─ 新项目 → Argon2id
│   └─ 已有项目 → BCrypt (cost≥12)
│
├─ 从密码派生加密密钥
│   └─ PBKDF2 (≥600000次) 或 Argon2
│
├─ 从主密钥派生多个子密钥
│   └─ HKDF
│
├─ 高性能场景（大文件哈希）
│   └─ BLAKE3
│
└─ 国密合规要求
    └─ SM3 / HMAC-SM3