密码存储与加密策略

发布时间: 2025-03-23 12:56

↑

# 密码存储与加密策略

## 密码安全概述

密码是用户身份验证最常用的凭证，其存储安全直接关系到用户账户的安全性。本文将详细介绍密码存储的最佳实践，包括哈希算法选择、加盐策略、密钥派生函数等关键技术。

## 密码存储的安全风险

### 1. 常见攻击方式

1. 暴力破解
2. 字典攻击
3. 彩虹表攻击
4. 数据库泄露
5. SQL注入获取密码

### 2. 不安全的存储方式

```sql
-- 明文存储（极其危险）
CREATE TABLE users (
    id INT PRIMARY KEY,
    username VARCHAR(50),
    password VARCHAR(50)  -- 明文密码
);

-- 简单加密（不安全）
INSERT INTO users VALUES (1, 'admin', MD5('password123'));
```

## 安全的密码存储策略

### 1. 密码哈希

```python
# Python示例：使用现代哈希算法
import hashlib
import os

def hash_password(password: str) -> tuple[str, str]:
    # 生成随机盐值
    salt = os.urandom(32)
    # 使用SHA-256进行哈希
    hash = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # 迭代次数
    )
    return salt.hex(), hash.hex()

def verify_password(password: str, salt_hex: str, hash_hex: str) -> bool:
    salt = bytes.fromhex(salt_hex)
    hash = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000
    )
    return hash.hex() == hash_hex
```

### 2. 加盐策略

```java
// Java示例：BCrypt实现
import org.mindrot.jbcrypt.BCrypt;

public class PasswordService {
    public String hashPassword(String password) {
        // BCrypt自动生成盐值并将其包含在哈希结果中
        return BCrypt.hashpw(password, BCrypt.gensalt(12));
    }
    
    public boolean verifyPassword(String password, String hashedPassword) {
        return BCrypt.checkpw(password, hashedPassword);
    }
}
```

### 3. 密钥派生函数

```javascript
// Node.js示例：使用Argon2
const argon2 = require('argon2');

async function hashPassword(password) {
    try {
        // Argon2id变体，内存成本16MB，时间成本3次迭代
        return await argon2.hash(password, {
            type: argon2.argon2id,
            memoryCost: 16384,
            timeCost: 3,
            parallelism: 2
        });
    } catch (err) {
        throw new Error('密码哈希失败');
    }
}

async function verifyPassword(password, hash) {
    try {
        return await argon2.verify(hash, password);
    } catch (err) {
        throw new Error('密码验证失败');
    }
}
```

### 4. 密码重置机制

```php
// PHP示例：安全的密码重置
class PasswordReset {
    private $db;
    private $config;
    
    public function createResetToken($userId) {
        $token = bin2hex(random_bytes(32));
        $expiry = time() + 3600; // 1小时有效期
        
        // 存储重置令牌
        $stmt = $this->db->prepare(
            "INSERT INTO password_resets (user_id, token, expiry) 
             VALUES (?, ?, ?)"
        );
        $stmt->execute([$userId, hash('sha256', $token), $expiry]);
        
        return $token;
    }
    
    public function resetPassword($token, $newPassword) {
        $stmt = $this->db->prepare(
            "SELECT user_id, expiry FROM password_resets 
             WHERE token = ? AND used = 0"
        );
        $stmt->execute([hash('sha256', $token)]);
        $reset = $stmt->fetch();
        
        if (!$reset || time() > $reset['expiry']) {
            throw new Exception('无效或过期的重置令牌');
        }
        
        // 更新密码并标记令牌为已使用
        $this->updatePassword($reset['user_id'], $newPassword);
        $this->markTokenUsed($token);
    }
}
```

## 密码策略实施

### 1. 密码强度要求

```python
# Python示例：密码强度检查
import re

class PasswordPolicy:
    def __init__(self):
        self.min_length = 12
        self.require_uppercase = True
        self.require_lowercase = True
        self.require_numbers = True
        self.require_special = True
    
    def validate(self, password: str) -> tuple[bool, str]:
        if len(password) < self.min_length:
            return False, f'密码长度必须至少{self.min_length}个字符'
        
        if self.require_uppercase and not re.search(r'[A-Z]', password):
            return False, '密码必须包含大写字母'
        
        if self.require_lowercase and not re.search(r'[a-z]', password):
            return False, '密码必须包含小写字母'
        
        if self.require_numbers and not re.search(r'\d', password):
            return False, '密码必须包含数字'
        
        if self.require_special and not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
            return False, '密码必须包含特殊字符'
        
        return True, '密码符合要求'
```

### 2. 密码历史记录

```sql
-- 密码历史记录表结构
CREATE TABLE password_history (
    id SERIAL PRIMARY KEY,
    user_id INTEGER NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- 存储过程：检查新密码是否在历史记录中
DELIMITER //
CREATE PROCEDURE check_password_history(
    IN p_user_id INTEGER,
    IN p_new_password_hash VARCHAR(255),
    OUT p_is_reused BOOLEAN
)
BEGIN
    SELECT EXISTS (
        SELECT 1 FROM password_history
        WHERE user_id = p_user_id
        AND password_hash = p_new_password_hash
        AND created_at > DATE_SUB(NOW(), INTERVAL 1 YEAR)
    ) INTO p_is_reused;
END //
DELIMITER ;
```

### 3. 密码过期策略

```typescript
// TypeScript示例：密码过期检查
interface User {
    id: number;
    passwordLastChanged: Date;
    passwordExpiryDays: number;
}

class PasswordExpiryService {
    private readonly DEFAULT_EXPIRY_DAYS = 90;
    
    public isPasswordExpired(user: User): boolean {
        const expiryDays = user.passwordExpiryDays || this.DEFAULT_EXPIRY_DAYS;
        const expiryDate = new Date(user.passwordLastChanged);
        expiryDate.setDate(expiryDate.getDate() + expiryDays);
        
        return new Date() > expiryDate;
    }
    
    public getDaysUntilExpiry(user: User): number {
        const expiryDays = user.passwordExpiryDays || this.DEFAULT_EXPIRY_DAYS;
        const expiryDate = new Date(user.passwordLastChanged);
        expiryDate.setDate(expiryDate.getDate() + expiryDays);
        
        const daysRemaining = Math.ceil(
            (expiryDate.getTime() - new Date().getTime()) / (1000 * 60 * 60 * 24)
        );
        
        return Math.max(0, daysRemaining);
    }
}
```

## 最佳实践

1. 哈希算法选择
   - 使用现代哈希算法（Argon2、bcrypt、PBKDF2）
   - 避免使用过时算法（MD5、SHA1）
   - 定期评估和更新哈希算法

2. 盐值处理
   - 使用加密安全的随机数生成器
   - 每个密码使用唯一的盐值
   - 盐值长度至少16字节

3. 密码策略
   - 实施强密码要求
   - 定期密码更新
   - 维护密码历史记录
   - 实施账户锁定机制

4. 系统安全
   - 加密数据库连接
   - 实施访问控制
   - 定期安全审计
   - 监控异常活动

5. 应急响应
   - 制定密码泄露应急预案
   - 建立用户通知机制
   - 准备回滚方案
   - 记录详细的事件日志

## 总结

密码存储安全是Web应用程序安全的基础。通过采用现代的密码哈希算法、合理的加盐策略、安全的密钥派生函数，并配合完善的密码策略，可以有效保护用户密码安全。同时要注意：

1. 定期评估和更新安全措施
2. 关注密码学发展趋势
3. 平衡安全性和用户体验
4. 做好应急响应准备

密码安全没有银弹，需要综合运用多种安全措施，并持续关注和应对新的安全威胁。

元素码农