1. 项目概述：为什么“加盐”是密码安全的基石

在后台系统里，最让我头疼的从来不是复杂的业务逻辑，而是那些看似简单、一旦出事就是“天塌下来”的安全问题。其中，用户密码的存储，绝对是安全防线的第一道，也是最脆弱的一道。你可能觉得，把密码用MD5或者SHA-256哈希一下存进数据库就万事大吉了？十年前或许可以，但在今天，这无异于把家门钥匙藏在脚垫下面。

我见过太多因为密码存储不当导致的数据泄露。攻击者根本不需要破解你的加密算法，他们手里有现成的“彩虹表”——一种预先计算好的哈希值与明文密码的映射字典。如果你的数据库被拖库，用户又用了“123456”或者“password”这种常见密码，黑客几乎可以瞬间“解密”出大量明文密码。这时候，“密码加盐”就不再是一个可选项，而是必须严格遵守的底线操作。

简单来说，密码加盐就是在对用户密码进行哈希计算之前，混入一段随机生成的数据（即“盐”）。这段盐对每个用户都是独一无二的、足够长的随机字符串。它的核心价值在于：即使两个用户使用了完全相同的密码，由于他们各自的“盐”不同，最终生成的哈希值也截然不同。这就彻底废掉了攻击者使用彩虹表进行批量破解的能力，迫使他们对每个账户的密码都必须单独进行暴力破解，将攻击成本提升到难以承受的高度。

在Go语言中实现这套机制，我们主要会用到标准库中的crypto/rand来生成密码学安全的随机盐，以及golang.org/x/crypto中的bcrypt或argon2这类专门为密码哈希设计的算法。接下来，我会从一个老开发的角度，带你从头到尾拆解密码加盐的完整实现，包括原理、选型、代码、以及我踩过的那些坑。

2. 核心原理深度拆解：不止是“加把盐”那么简单

很多人对密码加盐的理解停留在“密码+盐，然后哈希”这一步，这没错，但要想真正做好，必须理解其背后的安全逻辑和攻击模型。

2.1 彩虹表攻击与盐的防御机制

假设我们有一个用户表，密码字段存储的是SHA256(password)的结果。

• 用户A密码是“123456”，哈希值是8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92。
• 用户B密码也是“123456”，哈希值同样是8d969e...c6c92。

攻击者拿到数据库后，只需要计算一次“123456”的SHA256值，然后在整个数据库里搜索这个哈希值，所有匹配的记录密码就都被破解了。这就是彩虹表攻击的效率所在——一次计算，批量破解。

现在，我们引入“盐”：

• 为用户A生成一个随机的盐，比如s1 = “a1b2c3d4e5”。
• 为用户B生成另一个随机的盐，比如s2 = “f6g7h8i9j0”。
• 存储时，我们不再存储Hash(password)，而是存储Hash(password + s1)和Hash(password + s2)，同时把各自的盐（s1,s2）也存下来。

此时，即使用户A和B密码相同，他们的哈希值也完全不同。攻击者即使知道用户A的盐是s1，破解了A的密码是“123456”，他也无法直接用这个结论去破解用户B。因为用户B的盐s2不同，Hash(“123456” + s2)的结果与A的哈希值毫无关系。攻击者必须为每个用户单独构建彩虹表或进行暴力破解，成本呈指数级增长。

注意：这里用“密码+盐”的字符串拼接只是最直观的示意。在实际的密码哈希函数（如bcrypt）中，盐的混合方式更为复杂和严谨，是函数内部机制的一部分。

2.2 盐的核心属性与要求

理解了防御原理，就能明白为什么对“盐”有严格的要求：

1. 唯一性：每个用户的盐必须是全局唯一的。重复的盐会削弱防御效果，如果两个用户巧合用了相同的盐，那么相同的密码又会产生相同的哈希值。
2. 足够长度：盐的长度必须足够，通常建议至少16字节（128位）。过短的盐（比如4字节），其可能的组合数有限，攻击者仍有可能为所有可能的盐值预计算彩虹表，虽然这比没有盐困难得多，但并非绝对安全。
3. 密码学安全的随机性：盐必须使用密码学安全的伪随机数生成器（CSPRNG）生成。绝对禁止使用时间戳、用户ID、用户名等可预测或低熵的值作为盐。Go语言中，crypto/rand包就是用于此目的的标准库。
4. 公开存储：这是一个关键点，盐不需要保密，它可以和哈希值一起明文存储在数据库中。盐的作用不是保密，而是使预计算攻击（彩虹表）失效。即使攻击者拿到了盐，他也必须为这个特定的盐重新计算所有可能的密码哈希，这回到了为每个用户单独暴力破解的困境。

2.3 哈希算法的演进与选择：从SHA到专门的口令哈希

早期我们可能直接用SHA-256甚至MD5来做密码哈希，但这存在严重问题：

• 速度过快：MD5、SHA系列是设计用来快速校验数据完整性的，计算速度极快。这意味着攻击者可以在短时间内进行海量的哈希计算（每秒数十亿次），使得暴力破解变得可行。
• 无成本参数：算法本身没有调节计算难度的参数，无法跟上硬件（GPU、ASIC）算力的发展。

因此，现代密码存储必须使用专门设计的、慢速的密码哈希函数。它们有三个共同特点：

1. 慢：故意设计得计算缓慢，增加暴力破解的时间成本。
2. 可配置成本：允许开发者设置一个“工作因子”（如迭代次数、内存开销），未来硬件升级后，可以通过提高这个因子来维持安全性。
3. 内置盐处理：算法本身已经完美集成了加盐的逻辑。

目前业界主流的选择是：

• bcrypt：历史较久，经受住了时间考验，抵抗GPU/ASIC攻击有一定效果。在Go中可通过golang.org/x/crypto/bcrypt使用。
• scrypt：不仅计算慢，还要求大量内存，从而更有效地抵抗定制硬件攻击。
• Argon2：2015年密码哈希竞赛的获胜者，被认为是当前的最佳选择。它提供了Argon2i、Argon2d、Argon2id三种变体，在抵抗侧信道攻击和GPU攻击之间取得了更好平衡。Go中可通过golang.org/x/crypto/argon2使用。

在接下来的Go实现中，我将重点演示bcrypt和Argon2id，因为前者应用广泛、API简单，后者代表当前最佳实践。

3. Go语言实现：从基础到生产级方案

理论说再多，不如一行代码。我们直接进入Go的实战环节。我会分层次讲解，从最基础的手动加盐哈希，到使用标准库的bcrypt，再到更先进的Argon2id实现。

3.1 方案一：手动实现加盐与哈希（理解原理，不推荐生产）

这个方案帮助我们理解过程，但强烈不推荐用于生产环境，因为它使用了不合适的快速哈希算法（SHA-256）。

package main import ( "crypto/rand" "crypto/sha256" "encoding/base64" "fmt" ) // generateSalt 生成指定长度的随机盐 func generateSalt(length int) ([]byte, error) { salt := make([]byte, length) _, err := rand.Read(salt) // 使用密码学安全的随机源 if err != nil { return nil, fmt.Errorf("生成盐失败: %w", err) } return salt, nil } // hashPasswordWithSalt 使用SHA-256和盐对密码进行哈希 func hashPasswordWithSalt(password string, salt []byte) string { // 将密码转换为字节，并与盐拼接 // 注意：简单拼接在专业算法中不够安全，这里仅为演示 combined := append([]byte(password), salt...) // 计算SHA-256哈希 hash := sha256.Sum256(combined) // 返回Base64编码的字符串，便于存储 return base64.StdEncoding.EncodeToString(hash[:]) } func main() { password := "MySuperSecretPassword!123" // 生成一个16字节（128位）的盐 salt, err := generateSalt(16) if err != nil { panic(err) } hashedPwd := hashPasswordWithSalt(password, salt) fmt.Printf("原始密码: %s\n", password) fmt.Printf("生成盐 (Base64): %s\n", base64.StdEncoding.EncodeToString(salt)) fmt.Printf("加盐哈希值 (Base64): %s\n", hashedPwd) // 验证密码示例 inputPassword := "MySuperSecretPassword!123" computedHash := hashPasswordWithSalt(inputPassword, salt) if computedHash == hashedPwd { fmt.Println("密码验证成功！") } else { fmt.Println("密码验证失败！") } }

这段代码的问题：

1. 哈希算法不当：SHA-256太快，不适合密码存储。
2. 拼接方式简单：password + salt的拼接在某些情况下可能存在安全隐患（如长度扩展攻击），专业算法有更复杂的混合方式。
3. 无成本参数：无法调整计算难度。

所以，这只是一个教学示例。真实项目中，请直接使用下一节的方案。

3.2 方案二：使用bcrypt（简单可靠的生产方案）

bcrypt是Go社区最常用的密码哈希库，API极其简洁，内部已经完美处理了盐的生成、存储和验证。

package main import ( "fmt" "golang.org/x/crypto/bcrypt" ) func main() { password := "MySuperSecretPassword!123" // 1. 生成加盐哈希 // bcrypt.GenerateFromPassword 会自动生成随机盐，并混入哈希结果中 // 第二个参数 cost 是工作因子，范围4-31，值越大计算越慢、越安全 // 通常 cost=10-12 在安全性和性能间取得较好平衡 cost := 12 hashedBytes, err := bcrypt.GenerateFromPassword([]byte(password), cost) if err != nil { panic(err) } hashedPassword := string(hashedBytes) fmt.Printf("原始密码: %s\n", password) fmt.Printf("bcrypt哈希值: %s\n", hashedPassword) // 输出类似：$2a$12$CwFQ7T...很长的一串... // 这个字符串已经包含了算法版本、cost、盐和哈希值，全部用特定格式编码在一起。 // 2. 验证密码 inputPassword := "MySuperSecretPassword!123" err = bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(inputPassword)) if err != nil { fmt.Println("密码验证失败:", err) } else { fmt.Println("密码验证成功！") } // 3. 演示错误密码 wrongPassword := "WrongPassword" err = bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(wrongPassword)) if err != nil { fmt.Println("错误密码验证失败（符合预期）:", err) } }

bcrypt哈希字符串解析： 以$2a$12$CwFQ7T...为例：

• $2a$: 表示bcrypt算法版本。
• 12$: 表示cost因子为12（2^12次迭代）。
• CwFQ7T...: 前22个字符是Base64编码的盐（16字节盐编码为22字符），剩余部分就是实际的哈希值。

bcrypt的优点：

• 极其简单：两行核心代码完成哈希和验证。
• 盐内置：无需自己管理盐的生成和存储。
• 可调成本：通过cost参数适应未来算力增长。
• 久经考验：部署广泛，安全性有保障。

bcrypt的注意事项：

• 密码长度限制：bcrypt最多处理72字节的密码。如果用户密码更长，超出的部分会被忽略。这是一个潜在的陷阱！解决方法是在调用bcrypt前，先对长密码进行一次快速的SHA-256哈希（这不会削弱安全性，因为bcrypt的慢哈希才是关键），或者使用无此限制的Argon2。
• Cost值选择：需要在安全性和用户体验间权衡。在服务器上测试不同cost值的耗时（目标：验证一次密码大约需要100-500毫秒），并据此选择。通常10-12是2020年代后期的合理值。

3.3 方案三：使用Argon2id（当前最佳实践）

Argon2是更现代、更灵活、被密码学专家广泛推荐的选择。Argon2id变体在抵抗侧信道攻击和GPU破解攻击之间提供了最佳平衡。

package main import ( "crypto/rand" "crypto/subtle" "encoding/base64" "fmt" "strings" "golang.org/x/crypto/argon2" ) // argon2Params 定义Argon2的参数 type argon2Params struct { memory uint32 // 内存开销（单位为KB） iterations uint32 // 迭代次数 parallelism uint8 // 并行度 saltLength uint32 // 盐长度 keyLength uint32 // 输出密钥长度 } // 定义一组推荐的参数（可根据服务器性能调整） var defaultParams = &argon2Params{ memory: 64 * 1024, // 64MB iterations: 3, parallelism: 2, saltLength: 16, keyLength: 32, // 输出256位密钥 } // generateRandomBytes 生成密码学安全的随机字节 func generateRandomBytes(n uint32) ([]byte, error) { b := make([]byte, n) _, err := rand.Read(b) if err != nil { return nil, err } return b, nil } // generateHashFromPassword 使用Argon2id生成密码哈希 // 返回格式：$argon2id$v=19$m=65536,t=3,p=2$<base64_salt>$<base64_hash> func generateHashFromPassword(password string, p *argon2Params) (string, error) { // 1. 生成随机盐 salt, err := generateRandomBytes(p.saltLength) if err != nil { return "", err } // 2. 调用Argon2id函数 hash := argon2.IDKey([]byte(password), salt, p.iterations, p.memory, p.parallelism, p.keyLength) // 3. 将参数、盐、哈希编码为字符串存储 b64Salt := base64.RawStdEncoding.EncodeToString(salt) b64Hash := base64.RawStdEncoding.EncodeToString(hash) // 格式化存储字符串 encodedHash := fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", argon2.Version, p.memory, p.iterations, p.parallelism, b64Salt, b64Hash) return encodedHash, nil } // comparePasswordAndHash 验证密码与哈希是否匹配 func comparePasswordAndHash(password, encodedHash string) (bool, error) { // 1. 解析存储的哈希字符串，提取参数和盐 vals := strings.Split(encodedHash, "$") if len(vals) != 6 { return false, fmt.Errorf("无效的哈希格式") } if vals[1] != "argon2id" { return false, fmt.Errorf("不支持的算法: %s", vals[1]) } var version int _, err := fmt.Sscanf(vals[2], "v=%d", &version) if err != nil { return false, err } if version != argon2.Version { return false, fmt.Errorf("版本不匹配") } p := &argon2Params{} _, err = fmt.Sscanf(vals[3], "m=%d,t=%d,p=%d", &p.memory, &p.iterations, &p.parallelism) if err != nil { return false, err } salt, err := base64.RawStdEncoding.DecodeString(vals[4]) if err != nil { return false, err } p.saltLength = uint32(len(salt)) expectedHash, err := base64.RawStdEncoding.DecodeString(vals[5]) if err != nil { return false, err } p.keyLength = uint32(len(expectedHash)) // 2. 使用相同的参数和盐，对输入的密码进行哈希 actualHash := argon2.IDKey([]byte(password), salt, p.iterations, p.memory, p.parallelism, p.keyLength) // 3. 使用恒定时间比较函数，防止时序攻击 if subtle.ConstantTimeCompare(actualHash, expectedHash) == 1 { return true, nil } return false, nil } func main() { password := "MySuperSecretPassword!123" // 生成哈希 hashedPassword, err := generateHashFromPassword(password, defaultParams) if err != nil { panic(err) } fmt.Printf("原始密码: %s\n", password) fmt.Printf("Argon2id哈希值: %s\n", hashedPassword) // 验证密码（正确） match, err := comparePasswordAndHash(password, hashedPassword) if err != nil { panic(err) } fmt.Printf("正确密码验证结果: %v\n", match) // 验证密码（错误） match, err = comparePasswordAndHash("WrongPassword", hashedPassword) if err != nil { panic(err) } fmt.Printf("错误密码验证结果: %v\n", match) }

Argon2参数选择指南：

• memory (m)：定义算法使用的内存大小（单位为KB）。增加内存能有效抵抗GPU/ASIC攻击，因为这类硬件擅长并行计算但内存带宽有限。通常设置为64MB到1GB之间。示例中64 * 1024即64MB。
• iterations (t)：迭代次数。增加迭代次数会线性增加计算时间。通常1-5次即可。
• parallelism (p)：并行线程数。增加此值可以利用多核CPU，但不会显著增加攻击者的成本（因为他们也可以并行）。通常设置为CPU的物理核心数或逻辑核心数。
• saltLength：盐长度，16字节是安全下限，32字节更好。
• keyLength：输出哈希长度，32字节（256位）是标准选择。

如何确定参数？没有“最佳”参数，只有“适合你系统”的参数。你需要进行基准测试：在你的生产服务器上，调整参数，使密码哈希运算耗时在100毫秒到1秒之间。这个延迟对用户登录体验影响微乎其微，但能将攻击者的破解速度降低数个数量级。golang.org/x/crypto/argon2包提供了基准测试函数。

4. 数据库存储设计与实战集成

知道了怎么算，还得知道怎么存。存储设计不当，前面的努力可能白费。

4.1 数据库表结构设计

假设我们有一个users表，存储密码哈希的字段设计至关重要。

CREATE TABLE users ( id BIGSERIAL PRIMARY KEY, username VARCHAR(255) NOT NULL UNIQUE, email VARCHAR(255) NOT NULL UNIQUE, -- 关键字段：存储完整的密码哈希字符串 password_hash VARCHAR(255) NOT NULL, -- 其他字段... created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(), updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() );

重点：

• password_hash字段需要足够长。bcrypt哈希值固定为60字符，但Argon2id的哈希字符串可能更长（包含参数和盐），建议预留255字符。
• 绝对不要单独创建salt字段。对于bcrypt和我们的Argon2id实现，盐已经编码在password_hash字符串里了。单独存储是冗余且容易出错的。
• 字段名建议用password_hash或password_digest，明确表示存储的是哈希值而非明文。

4.2 Go Web服务集成示例（以Gin框架为例）

在实际的Web应用中，我们通常在用户注册和登录两个环节处理密码。

package main import ( "net/http" "github.com/gin-gonic/gin" "golang.org/x/crypto/bcrypt" // 或使用上面实现的argon2 ) type UserRegisterRequest struct { Username string `json:"username" binding:"required,min=3"` Email string `json:"email" binding:"required,email"` Password string `json:"password" binding:"required,min=8"` } type UserLoginRequest struct { Username string `json:"username" binding:"required"` Password string `json:"password" binding:"required"` } // 模拟数据库 var userStore = make(map[string]string) // username -> password_hash func main() { r := gin.Default() // 用户注册 r.POST("/register", func(c *gin.Context) { var req UserRegisterRequest if err := c.ShouldBindJSON(&req); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } // 检查用户是否已存在 if _, exists := userStore[req.Username]; exists { c.JSON(http.StatusConflict, gin.H{"error": "用户名已存在"}) return } // 使用bcrypt生成密码哈希 hashedBytes, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost) // DefaultCost 当前是10 if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": "系统错误"}) return } // 存储用户信息（模拟数据库插入） userStore[req.Username] = string(hashedBytes) // 在实际项目中，这里应该将 username, email, hashedPassword 插入数据库 c.JSON(http.StatusCreated, gin.H{ "message": "用户注册成功", "username": req.Username, }) }) // 用户登录 r.POST("/login", func(c *gin.Context) { var req UserLoginRequest if err := c.ShouldBindJSON(&req); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } // 从“数据库”查询用户哈希密码 storedHash, exists := userStore[req.Username] if !exists { // 即使用户不存在，也返回通用错误信息，防止用户名枚举攻击 c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"}) return } // 使用bcrypt验证密码 err := bcrypt.CompareHashAndPassword([]byte(storedHash), []byte(req.Password)) if err != nil { // 密码不匹配 c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"}) return } // 密码正确，生成会话或JWT Token（此处省略） c.JSON(http.StatusOK, gin.H{ "message": "登录成功", "username": req.Username, }) }) r.Run(":8080") }

关键安全实践：

• 注册时：对前端传来的密码直接进行哈希，服务端永远不要存储或记录明文密码。
• 登录时：使用CompareHashAndPassword进行验证，该函数内部会解析哈希字符串中的盐和参数，自动完成对比。
• 错误信息泛化：无论是用户名不存在还是密码错误，都返回相同的错误信息（如“用户名或密码错误”），这是为了防止攻击者通过响应差异来枚举系统中存在的有效用户名。

5. 进阶话题与生产环境避坑指南

掌握了基础实现，我们来看看那些容易踩坑的进阶问题。

5.1 密码策略与前端传输

加盐哈希解决了存储问题，但密码安全是一个链条。

• 密码强度策略：强制要求用户使用足够长的密码（如最少12位），并包含字母、数字、符号。但这会带来用户体验下降。更好的方式是采用密码强度评估并给出建议，同时结合密码泄露检查API（如HaveIBeenPwned），在用户设置已知泄露的密码时发出强烈警告。
• 前端传输安全：密码从用户浏览器到服务器的传输必须使用HTTPS（TLS）。绝对不要在HTTP下传输密码。在极端安全要求的场景下，可以考虑在前端先对密码进行一次哈希（使用固定盐或密钥），然后再传输到后端进行真正的加盐哈希。但这会引入前端代码被篡改等新的攻击面，需要谨慎设计，对于绝大多数Web应用，强制使用HTTPS已足够。

5.2 哈希值升级策略

随着算力增长，过去认为安全的cost因子或哈希算法可能变弱。我们需要有升级策略。

1. 识别：在用户登录验证时，检查存储的哈希值字符串。
   • 对于bcrypt，可以检查cost因子（哈希字符串中的$2a$10$表示cost=10）。
   • 对于自定义格式（如上面的Argon2id），可以解析版本和参数。
2. 升级：如果发现参数低于当前安全标准（例如cost=8，而新标准是12），或者算法过时（例如从SHA256升级到Argon2id），则在验证密码成功后，立即用新的参数/算法重新计算哈希值，并更新数据库。
3. 示例（bcrypt升级）：

   func checkAndUpgradeHash(storedHash, password string) (string, error) { cost, err := bcrypt.Cost([]byte(storedHash)) if err != nil { return "", err } newCost := 12 // 当前安全标准 if cost < newCost { // 验证旧密码 if bcrypt.CompareHashAndPassword([]byte(storedHash), []byte(password)) == nil { // 密码正确，生成新哈希 newHash, err := bcrypt.GenerateFromPassword([]byte(password), newCost) if err != nil { return "", err } // 返回新哈希，由调用者更新数据库 return string(newHash), nil } } // 无需升级或密码错误，返回原哈希 return storedHash, nil }

5.3 常见问题排查与性能考量

1. 验证速度慢，影响登录体验？

   • 定位：这是设计使然。慢哈希是为了增加攻击成本。但“慢”是相对的。
   • 解决：调整cost(bcrypt) 或iterations/memory(Argon2) 参数，在你自己服务器的性能测试中，将单次验证时间控制在可接受范围内（如200ms）。同时，确保你的登录接口有适当的速率限制，防止攻击者通过大量请求进行DoS攻击。

2. 数据库中的哈希值看起来每次都不一样？

   • 原因：这是正常的，也是加盐的目的。因为每次生成的随机盐不同，所以即使对同一个密码，最终哈希值也不同。验证函数bcrypt.CompareHashAndPassword或自定义的comparePasswordAndHash会从存储的字符串中提取出盐，用相同的盐去计算输入密码的哈希，然后进行比较。

3. 使用bcrypt时，长密码被截断？

   • 现象：用户设置了超过72字符的密码，但后续登录用完整密码却失败，用前72字符反而成功。
   • 原因：bcrypt的底层算法限制。
   • 解决：
     • 方案A（推荐）：在调用bcrypt.GenerateFromPassword前，先对密码进行一次快速的SHA-256哈希，将哈希值（固定32字节）传给bcrypt。这样既突破了长度限制，又不会引入新的安全风险（因为主要的安全强度仍来自bcrypt的慢哈希）。

     func hashPasswordForBcrypt(password string) ([]byte, error) { // 先对长密码进行SHA-256哈希 sum := sha256.Sum256([]byte(password)) // 将哈希值作为bcrypt的“密码” return bcrypt.GenerateFromPassword(sum[:], bcrypt.DefaultCost) } func comparePasswordForBcrypt(hashedPassword, password string) error { sum := sha256.Sum256([]byte(password)) return bcrypt.CompareHashAndPassword([]byte(hashedPassword), sum[:]) }

     • 方案B：直接采用无此限制的Argon2id。

4. 如何为测试和开发环境配置？

   • 在开发或测试环境中，为了提升测试速度，可以显著降低cost或iterations。但必须通过环境变量或配置中心来区分，确保生产环境使用的是高强度的参数。一个常见的做法是设置一个BCRYPT_COST环境变量，开发环境设为4，生产环境设为12。

密码安全无小事。从理解“为什么加盐”，到选择正确的算法（bcrypt或Argon2），再到妥善地集成到数据库和Web框架中，每一步都需要谨慎。这套流程已经成为现代Web开发的标配，希望这篇结合了原理、代码和实战经验的梳理，能帮你筑牢系统的第一道安全防线。记住，在安全上多花一小时设计，可能避免未来无数小时的危机处理。