密码加密与安全存储

import { createHash } from 'crypto'
 
const hash = createHash('sha256').update('password123').digest('hex')
// a1b2c3d4... (64 字符)

// ❌ 不安全：太快，容易被暴力破解
import { createHash } from 'crypto'
 
const hash = createHash('sha256').update('password123').digest('hex')

import { hash, compare } from 'bcrypt'
 
// 哈希密码
const SALT_ROUNDS = 12
const passwordHash = await hash('password123', SALT_ROUNDS)
// $2b$12$K7L1OJ45/4Y2nIcbRbKZZeOZQqZqZqZqZqZqZqZqZqZqZqZq
 
// 验证密码
const isValid = await compare('password123', passwordHash)
// true

// 工作因子 10：约 100ms
const hash10 = await hash('password', 10)
 
// 工作因子 12：约 400ms
const hash12 = await hash('password', 12)
 
// 工作因子 14：约 1.6s
const hash14 = await hash('password', 14)

import { hashSync } from 'bcrypt'
 
const start = Date.now()
hashSync('test', 12)
const duration = Date.now() - start
 
console.log(`Cost 12 takes ${duration}ms`)

const hash1 = await hash('password', 12)
const hash2 = await hash('password', 12)
 
console.log(hash1 !== hash2)  // true，因为盐值不同

import { hash, verify } from '@node-rs/argon2'
 
// 哈希密码
const passwordHash = await hash('password123')
 
// 验证密码
const isValid = await verify(passwordHash, 'password123')

import { hash, AlgorithmType } from '@node-rs/argon2'
 
const passwordHash = await hash('password123', {
  algorithm: AlgorithmType.Argon2id,  // 推荐 id 变体
  memoryCost: 65536,  // 内存使用 64MB
  timeCost: 3,  // 迭代 3 次
  parallelism: 4,  // 4 个线程
})

const passwordSchema = z.string().min(8, 'Password must be at least 8 characters')

// ✅ 合理的要求
const passwordSchema = z.string()
  .min(8, 'At least 8 characters')
  .regex(/[A-Z]/, 'Must contain uppercase letter')
  .regex(/[a-z]/, 'Must contain lowercase letter')
  .regex(/[0-9]/, 'Must contain number')
 
// ❌ 过度要求
const passwordSchema = z.string()
  .min(16, 'At least 16 characters')
  .regex(/[A-Z]/, 'Must contain uppercase')
  .regex(/[a-z]/, 'Must contain lowercase')
  .regex(/[0-9]/, 'Must contain number')
  .regex(/[^A-Za-z0-9]/, 'Must contain special character')
  .refine(p => !p.includes('password'), 'Cannot contain "password"')
  .refine(p => !p.includes('123'), 'Cannot contain "123"')

const COMMON_PASSWORDS = new Set([
  'password123',
  '12345678',
  'qwerty123',
  // ...
])
 
const passwordSchema = z.string()
  .min(8)
  .refine(p => !COMMON_PASSWORDS.has(p), 'Password is too common')

import { createHash } from 'crypto'
 
async function isPasswordPwned(password: string): Promise<boolean> {
  // 计算 SHA-1 哈希
  const hash = createHash('sha1').update(password).digest('hex').toUpperCase()
  const prefix = hash.slice(0, 5)
  const suffix = hash.slice(5)
 
  // 查询 API（k-Anonymity 协议）
  const response = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`)
  const text = await response.text()
 
  // 检查后缀是否匹配
  return text.split('\n').some(line => line.startsWith(suffix))
}
 
// 使用
app.post('/auth/register', async (c) => {
  const { password } = await c.req.json()
 
  if (await isPasswordPwned(password)) {
    return c.json({
      error: 'This password has been compromised. Please choose a different one.',
    }, 400)
  }
 
  // ... 继续注册 ...
})

export const users = pgTable('users', {
  id: uuid('id').primaryKey().defaultRandom(),
  email: text('email').notNull().unique(),
  passwordHash: text('password_hash').notNull(),  // 存储完整哈希（含盐值）
  createdAt: timestamp('created_at').defaultNow().notNull(),
})

// 1. 请求重置
app.post('/auth/forgot-password', async (c) => {
  const { email } = await c.req.json()
 
  const user = await db.query.users.findFirst({
    where: eq(users.email, email),
  })
 
  if (!user) {
    // 不泄露用户是否存在
    return c.json({ message: 'If the email exists, a reset link has been sent.' })
  }
 
  // 生成重置 Token
  const resetToken = randomBytes(32).toString('hex')
  const expiresAt = new Date(Date.now() + 60 * 60 * 1000)  // 1 小时
 
  await db.insert(passwordResetTokens).values({
    userId: user.id,
    token: resetToken,
    expiresAt,
  })
 
  // 发送重置邮件
  const resetUrl = `${process.env.FRONTEND_URL}/reset-password?token=${resetToken}`
  await sendEmail({
    to: user.email,
    subject: 'Reset your password',
    html: `<a href="${resetUrl}">Click here to reset</a>`,
  })
 
  return c.json({ message: 'If the email exists, a reset link has been sent.' })
})
 
// 2. 执行重置
app.post('/auth/reset-password', async (c) => {
  const { token, newPassword } = await c.req.json()
 
  // 查找 Token
  const record = await db.query.passwordResetTokens.findFirst({
    where: eq(passwordResetTokens.token, token),
  })
 
  if (!record || record.expiresAt < new Date()) {
    return c.json({ error: 'Invalid or expired token' }, 400)
  }
 
  // 更新密码
  const passwordHash = await hash(newPassword, 12)
  await db
    .update(users)
    .set({ passwordHash })
    .where(eq(users.id, record.userId))
 
  // 删除 Token
  await db
    .delete(passwordResetTokens)
    .where(eq(passwordResetTokens.id, record.id))
 
  return c.json({ message: 'Password reset successfully' })
})

app.post('/auth/change-password', async (c) => {
  const user = c.get('user')
  const { currentPassword, newPassword } = await c.req.json()
 
  // 验证当前密码
  const dbUser = await db.query.users.findFirst({
    where: eq(users.id, user.id),
  })
 
  const isValid = await compare(currentPassword, dbUser!.passwordHash)
  if (!isValid) {
    return c.json({ error: 'Current password is incorrect' }, 400)
  }
 
  // 更新密码
  const passwordHash = await hash(newPassword, 12)
  await db
    .update(users)
    .set({ passwordHash })
    .where(eq(users.id, user.id))
 
  return c.json({ message: 'Password changed successfully' })
})

// 登录时检查哈希算法
async function verifyPassword(password: string, hash: string): Promise<boolean> {
  // 旧系统：MD5
  if (hash.startsWith('$md5$')) {
    const isValid = md5Verify(password, hash)
    if (isValid) {
      // 升级到 bcrypt
      const newHash = await bcrypt.hash(password, 12)
      await updateUser(userId, { passwordHash: newHash })
    }
    return isValid
  }
 
  // 新系统：bcrypt
  return bcrypt.compare(password, hash)
}