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 saltRounds = 12;
  const hash = await bcrypt.hash(password, saltRounds);
  return hash;
}

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

// 使用示例
async function main() {
  const password = 'mySecurePassword123';
  
  // 哈希密码
  const hash = await hashPassword(password);
  console.log('哈希:', hash);
  // 输出: $2a$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/X4.G5e0oO0oa5m6Wy
  
  // 验证正确密码
  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 = "mySecurePassword123"

# 哈希
hashed = hash_password(password)
print(f"哈希: {hashed.decode()}")

# 验证
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 = "mySecurePassword123";
        
        // 哈希密码
        String hash = encoder.encode(password);
        System.out.println("哈希: " + hash);
        
        // 验证密码
        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 := "mySecurePassword123"
    
    // 哈希
    hash, _ := hashPassword(password)
    fmt.Println("哈希:", hash)
    
    // 验证
    isValid := verifyPassword(password, hash)
    fmt.Println("有效:", isValid) // true
    
    isInvalid := verifyPassword("wrongPassword", hash)
    fmt.Println("无效:", isInvalid) // false
}

// 使用 SHA-256 预哈希长密码
const crypto = require('crypto');
const bcrypt = require('bcryptjs');

async function hashLongPassword(password) {
  // 如果密码可能超过72字节，先预哈希
  const preHash = crypto
    .createHash('sha256')
    .update(password)
    .digest('base64');
  
  return bcrypt.hash(preHash, 12);
}

async function migrateHash(password, oldMd5Hash) {
  const md5 = crypto.createHash('md5').update(password).digest('hex');
  
  if (md5 === oldMd5Hash) {
    // 密码正确，创建新的 bcrypt 哈希
    const newHash = await bcrypt.hash(password, 12);
    await updateUserHash(newHash);
    return true;
  }
  return false;
}