哈希函数把任意长度的输入,映射到固定长度的输出——但"映射"二字不重要, 重要的是它需要满足的三个安全性质。 这三个性质既是哈希函数的"凭据",也是它的"局限"—— 理解它们,才能明白为什么 MD5 已被宣判死刑, 也才能明白为什么哪怕是最新的 SHA-3,也不该用来存密码。

三个安全性质

常见算法对比

工程用途

用 MD5(password) 或者 SHA-256(password) 存数据库, 是后端工程师最常见的"看起来安全实则裸奔"的代码。 问题不在"哈希了没有",而在用错了哈希—— 通用哈希为"快"而生,密码哈希必须为"慢"而生。 这一节就是要讲清这个反直觉的设计哲学。

用 SHA-256 存密码的攻击

三个对抗手段

1. 加盐 (Salt)。 每个用户一个随机盐, 拼到密码上再哈希。作用: 让"全表彩虹表"失效——攻击者必须对每个用户单独跑字典, 不能复用结果。
2. 慢哈希 (Slow Hashing)。 故意做几千~几十万次迭代, 让一次校验耗时 50-500ms。用户登录感觉不到, 攻击者却被拖慢几个数量级。
3. 消耗内存 (Memory-Hard)。 算法故意需要大量 RAM(几十~几百 MB), 让 GPU / ASIC 优势失效——GPU 单卡显存只有几十 GB, 同时跑几百路就被卡死。

主流密码哈希算法

Go 实战: bcrypt 与 argon2id

// password_bcrypt.go · 最简单 — golang.org/x/crypto/bcrypt
package main

import (
    "fmt"
    "golang.org/x/crypto/bcrypt"
)

func main() {
    pw := []byte("correct horse battery staple")

    // 1) 哈希存储 — cost=12 是 2024 年合理值
    hashed, _ := bcrypt.GenerateFromPassword(pw, 12)
    fmt.Println("DB:", string(hashed))
    // → $2a$12$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

    // 2) 登录时校验 — 不需要单独取盐, hashed 字符串里自带
    err := bcrypt.CompareHashAndPassword(hashed, pw)
    fmt.Println("OK?", err == nil)
}

// password_argon2.go · 更现代 — golang.org/x/crypto/argon2
package main

import (
    "crypto/rand"
    "crypto/subtle"
    "encoding/base64"
    "fmt"
    "strings"

    "golang.org/x/crypto/argon2"
)

// OWASP 2024 推荐参数
const (
    memKiB   = 64 * 1024  // 64 MB
    iters    = 3
    parallel = 4
    saltLen  = 16
    keyLen   = 32
)

func Hash(pw string) string {
    salt := make([]byte, saltLen)
    _, _ = rand.Read(salt)
    h := argon2.IDKey([]byte(pw), salt, iters, memKiB, parallel, keyLen)

    // 标准编码格式 (PHC string format): $argon2id$v=19$m=...$salt$hash
    return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
        argon2.Version, memKiB, iters, parallel,
        base64.RawStdEncoding.EncodeToString(salt),
        base64.RawStdEncoding.EncodeToString(h))
}

func Verify(pw, encoded string) bool {
    parts := strings.Split(encoded, "$")
    // 简化版: 实际生产请解析参数, 这里假设跟 Hash 一致
    salt, _ := base64.RawStdEncoding.DecodeString(parts[4])
    expected, _ := base64.RawStdEncoding.DecodeString(parts[5])

    actual := argon2.IDKey([]byte(pw), salt, iters, memKiB, parallel, keyLen)
    return subtle.ConstantTimeCompare(actual, expected) == 1
}

func main() {
    enc := Hash("correct horse battery staple")
    fmt.Println("DB:", enc)
    fmt.Println("OK?", Verify("correct horse battery staple", enc))
}

加密分两大流派,区别只有一句话: 对称用同一把密钥加密和解密——快,但密钥必须事先约定; 非对称用一对公私钥,公钥加密私钥解密——慢,但公钥可以随便发。 现代世界用的是混合加密: 非对称协商一次性的对称密钥,后续通信走对称。TLS 1.3 就是这个套路。

两种加密的对比示意

主流算法对照

Go 实战: AES-256-GCM

// aes_gcm.go · 标准库 crypto/aes + crypto/cipher
package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "fmt"
)

func main() {
    // 1) 准备 32 字节 (256-bit) 密钥 — 生产请从 KMS / 配置中心取
    key := make([]byte, 32)
    _, _ = rand.Read(key)

    block, _ := aes.NewCipher(key)
    gcm, _ := cipher.NewGCM(block)

    // 2) 12 字节随机 nonce — 同一密钥下绝不能重复
    nonce := make([]byte, gcm.NonceSize())
    _, _ = rand.Read(nonce)

    plaintext := []byte("hello, day02")
    aad := []byte("user_id=42")  // 附加认证数据 (不加密但参与认证)

    // 3) Seal: 密文 = nonce || ciphertext || tag
    ct := gcm.Seal(nil, nonce, plaintext, aad)
    fmt.Println("ciphertext:", hex.EncodeToString(ct))

    // 4) Open: 任何字节被篡改都会返回 error
    pt, err := gcm.Open(nil, nonce, ct, aad)
    if err != nil {
        fmt.Println("verify failed:", err); return
    }
    fmt.Println("plaintext:", string(pt))
}

加密保证秘密, 但很多场景我们不需要秘密,只需要完整性 + 来源可证—— "这条消息确实是 Alice 发的,而且没被改"。 解决这件事的两个工具是 HMAC(对称密钥, 双方都能算) 和 数字签名(非对称密钥, 只有私钥持有方能签)。 JWT / Webhook / OAuth 签名 / TLS 证书全部建立在这两个工具之上。

HMAC vs 数字签名 · 对比示意

HMAC: 为什么不是 H(K ‖ msg)?

最朴素的想法: 既然要"用密钥认证消息", 那 SHA256(key + msg) 不就行了? 不行。基于 Merkle–Damgård 结构的哈希函数(SHA-1 / SHA-256) 存在长度扩展攻击: 攻击者拿到 H(key + msg) 和 msg, 不需要知道 key, 就能算出 H(key + msg + suffix)。 这意味着攻击者可以"在合法消息后面追加任意内容并伪造出有效 MAC"。

Go 实战: HMAC-SHA256

// hmac_sha256.go · 验证 Webhook 签名的标准套路
package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func sign(key, msg []byte) string {
    mac := hmac.New(sha256.New, key)
    mac.Write(msg)
    return hex.EncodeToString(mac.Sum(nil))
}

func verify(key, msg []byte, sig string) bool {
    expected := sign(key, msg)
    return hmac.Equal([]byte(expected), []byte(sig))  // 常量时间比较
}

func main() {
    key := []byte("my-app-secret")
    msg := []byte("event=order.paid&order_id=42&ts=1234567890")

    sig := sign(key, msg)
    fmt.Println("X-Signature:", sig)

    fmt.Println("OK?", verify(key, msg, sig))
}

数字签名: 比 HMAC 多解决什么

现代签名算法

Go 实战: Ed25519 签名与验证

// ed25519_sign.go · 标准库 crypto/ed25519, 不需要任何外部依赖
package main

import (
    "crypto/ed25519"
    "crypto/rand"
    "encoding/hex"
    "fmt"
)

func main() {
    // 1) 生成密钥对 — pub 公开, priv 严格保密
    pub, priv, _ := ed25519.GenerateKey(rand.Reader)
    fmt.Println("public  (", len(pub),  "B):", hex.EncodeToString(pub))
    fmt.Println("private (", len(priv), "B):", hex.EncodeToString(priv))

    msg := []byte("hello, day02")

    // 2) 签名 — 输出 64 字节
    sig := ed25519.Sign(priv, msg)
    fmt.Println("sig  (", len(sig), "B):", hex.EncodeToString(sig))

    // 3) 验证 — 只需要公钥
    ok := ed25519.Verify(pub, msg, sig)
    fmt.Println("verify?", ok)

    // 4) 改一个字符再验, 必然失败
    ok = ed25519.Verify(pub, []byte("hello, day03"), sig)
    fmt.Println("tampered verify?", ok)
}

1. 用一句话分别讲清哈希函数的三个安全性质——原像抗性 / 第二原像抗性 / 抗碰撞。SHA-1 在 2017 年"被破"指的是哪一个性质?
2. 为什么 SHA256(key + msg) 不是安全的 MAC, 而 HMAC 解决了什么问题? (提示: 长度扩展攻击)
3. argon2id 的三个关键参数(memory / time / parallelism)分别防什么? OWASP 2024 推荐的值是多少?
4. AEAD 是什么, 为什么裸 AES-CBC 不是 AEAD? Padding Oracle 攻击为什么能恢复明文?
5. 动手写一段 Go 代码: 用 argon2id 哈希一个密码, 然后写一个 Verify(pw, encoded string) bool 函数, 必须用常量时间比较。