Bcrypt 密码哈希指南：成本因子、盐值与安全实践（2026）

密码: "mypassword"

第一次哈希:  $2b$10$N9qo8uLOickgx2ZMRZoMy.MqrqQb9lYz6H8Kj7OvBOyj5uYjiPWmu
第二次哈希: $2b$10$ZGdlbGVwaGFudHNhcmVjb.7xJ8L9KjQvMnOpRsTuVwXyZaBcDeFgH

两个都是 "mypassword" 的有效哈希 - 不同的盐值，相同的密码！

// 在登录时检查哈希是否需要升级
async function loginAndUpgrade(password, storedHash) {
  const isValid = await bcrypt.compare(password, storedHash);
  
  if (isValid) {
    const currentCost = parseInt(storedHash.split('$')[2]);
    const targetCost = 12;
    
    if (currentCost < targetCost) {
      // 使用更高的成本因子重新哈希
      const newHash = await bcrypt.hash(password, targetCost);
      await updateUserHash(newHash);
    }
  }
  
  return isValid;
}

$2b$12$N9qo8uLOickgx2ZMRZoMyeKj7OvBOyj5uYjiPWmuabcdefghijk
│ │  │  │                     │
│ │  │  │                     └── 校验部分编码（31个字符）
│ │  │  └── 盐值（22个字符）
│ │  └── 成本因子（2位数字）
│ └── 算法版本
└── 前缀标记

const bcrypt = require('bcryptjs');

// 生成哈希
async function hashPassword(password) {
  const costFactor = 12; // 仅为示例，应根据部署环境校准
  const hash = await bcrypt.hash(password, costFactor);
  return hash;
}

// 验证密码
async function verifyPassword(password, hash) {
  const isMatch = await bcrypt.compare(password, hash);
  return isMatch;
}

// 使用示例
async function main() {
  const password = 'test-only-password-from-a-fixture';
  
  // 哈希密码
  const hash = await hashPassword(password);
  // 将哈希存入受保护的凭据存储，不要记录日志。
  
  // 验证正确密码
  const isValid = await verifyPassword(password, hash);
  console.log('有效:', isValid); // true
  
  // 验证错误密码
  const isInvalid = await verifyPassword('wrongPassword', hash);
  console.log('无效:', isInvalid); // false
}

main();

import bcrypt

def hash_password(password: str) -> bytes:
    """使用bcrypt哈希密码"""
    salt = bcrypt.gensalt(rounds=12)
    hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
    return hashed

def verify_password(password: str, hashed: bytes) -> bool:
    """验证密码与哈希是否匹配"""
    return bcrypt.checkpw(password.encode('utf-8'), hashed)

# 使用示例
password = "test-only-password-from-a-fixture"

# 哈希
hashed = hash_password(password)
# 将哈希存入受保护的凭据存储，不要记录日志。

# 验证
is_valid = verify_password(password, hashed)
print(f"有效: {is_valid}")  # True

is_invalid = verify_password("wrongPassword", hashed)
print(f"无效: {is_invalid}")  # False

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

public class BcryptExample {
    public static void main(String[] args) {
        // 创建强度（成本因子）为12的编码器
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12);
        
        String password = "test-only-password-from-a-fixture";
        
        // 哈希密码
        String hash = encoder.encode(password);
        // 将哈希存入受保护的凭据存储，不要记录日志。
        
        // 验证密码
        boolean isValid = encoder.matches(password, hash);
        System.out.println("有效: " + isValid); // true
        
        boolean isInvalid = encoder.matches("wrongPassword", hash);
        System.out.println("无效: " + isInvalid); // false
    }
}

package main

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

func hashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 12)
    return string(bytes), err
}

func verifyPassword(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

func main() {
    password := "test-only-password-from-a-fixture"
    
    // 哈希
    hash, err := hashPassword(password)
    if err != nil {
        panic(err) // 生产代码应返回结构化错误
    }
    // 将哈希存入受保护的凭据存储，不要记录日志。
    
    // 验证
    isValid := verifyPassword(password, hash)
    fmt.Println("有效:", isValid) // true
    
    isInvalid := verifyPassword("wrongPassword", hash)
    fmt.Println("无效:", isInvalid) // false
}

const bcrypt = require('bcryptjs');

async function hashPasswordWithLengthPolicy(password) {
  if (Buffer.byteLength(password, 'utf8') > 72) {
    throw new Error('password_too_long_for_bcrypt_policy');
  }
  const costFactor = 12; // 应根据部署环境校准
  return bcrypt.hash(password, costFactor);
}

async function migrateHash(password, user, costFactor) {
  const valid = await verifyLegacyMd5ForUser(password, user.legacyHash);
  if (!valid) {
    return false;
  }
  const newHash = await bcrypt.hash(password, costFactor);
  await replaceCredentialInTransaction(user.id, newHash, {
    removeLegacyHash: true
  });
  return true;
}