Go 与加密：别把明文密码写进数据库

go get golang.org/x/crypto/bcrypt

package main

import (
    "fmt"
    "log"

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

func main() {
    pwd := "S3cret!2026"

    // 注册：哈希后存储。盐值自动生成并编进结果里，无需单独存
    hash, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("存储的哈希:", string(hash))

    // 登录：用存储的哈希反验，而不是再哈希一次然后比较字符串
    err = bcrypt.CompareHashAndPassword(hash, []byte(pwd))
    fmt.Println("正确密码:", err == nil) // true

    err = bcrypt.CompareHashAndPassword(hash, []byte("wrong"))
    fmt.Println("错误密码:", err == nil) // false
}

存储的哈希: $2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy
正确密码: true
错误密码: false

package main

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

func main() {
    // Go 1.24+：直接生成 URL 安全的随机文本令牌（128 位熵）
    token, err := rand.Text()
    if err != nil {
        panic(err) // Go 1.24 起 crypto/rand.Read 理论上不再失败，保留判断兼容旧版
    }
    fmt.Println("文本令牌:", token)

    // 需要 n 个随机字节（如 AES 密钥、nonce）
    key := make([]byte, 32)
    if _, err := rand.Read(key); err != nil {
        panic(err)
    }
    fmt.Println("十六进制密钥:", hex.EncodeToString(key))
}

文本令牌: JBSWY3DPEHPK3PXPJBSWY3DPEA
十六进制密钥: 8f3a1c04d9e27b65c1a0f3e8d2b47c9a51e6f08d3c7b2a49

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "fmt"
    "os"
)

func encrypt(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key) // key 必须 16/24/32 字节
    if err != nil {
        return nil, err
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    nonce := make([]byte, gcm.NonceSize()) // 12 字节
    if _, err := rand.Read(nonce); err != nil {
        return nil, err
    }
    return gcm.Seal(nonce, nonce, plaintext, nil), nil // nonce 拼在密文前
}

func decrypt(key, ciphertext []byte) ([]byte, error) {
    block, _ := aes.NewCipher(key)
    gcm, _ := cipher.NewGCM(block)
    nonce, body := ciphertext[:gcm.NonceSize()], ciphertext[gcm.NonceSize():]
    return gcm.Open(nil, nonce, body, nil)
}

func main() {
    key := make([]byte, 32) // 演示用随机密钥；实际应来自环境变量或密钥管理服务
    rand.Read(key)

    ct, err := encrypt(key, []byte("票务订单 ord-20260909-001"))
    if err != nil {
        fmt.Fprintln(os.Stderr, "加密失败:", err)
        os.Exit(1)
    }
    fmt.Println("密文长度:", len(ct))

    pt, err := decrypt(key, ct)
    fmt.Println("正确密钥解密:", string(pt), "err =", err)

    wrongKey := make([]byte, 32)
    rand.Read(wrongKey)
    _, err = decrypt(wrongKey, ct)
    fmt.Println("错误密钥解密: err =", err)
}

密文长度: 47 （nonce 12 字节 + 明文 19 字节 + 认证标签 16 字节）
正确密钥解密: 票务订单 ord-20260909-001 err = <nil>
错误密钥解密: err = cipher: message authentication failed

import (
    "crypto/pbkdf2"
    "crypto/sha256"
)

// 口令 -> AES-256 密钥；OWASP 建议 SHA-256 下 60 万次迭代起
func DeriveKey(password, salt string) ([]byte, error) {
    return pbkdf2.Key(sha256.New, password, salt, 600_000, 32)
}

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

func SignRequest(payload []byte, secret []byte) string {
    mac := hmac.New(sha256.New, secret)
    mac.Write(payload)
    return hex.EncodeToString(mac.Sum(nil))
}

func VerifyRequest(payload []byte, secret []byte, receivedHex string) bool {
    received, err := hex.DecodeString(receivedHex)
    if err != nil {
        return false
    }
    mac := hmac.New(sha256.New, secret)
    mac.Write(payload)
    return hmac.Equal(received, mac.Sum(nil)) // 恒定时间比较
}