密码枚举攻击技术完全指南

← 返回指南列表

密码枚举攻击技术完全指南

一、密码枚举攻击概述

1.1 攻击定义与原理

密码枚举攻击是一种通过系统地尝试各种可能的密码组合来获取账户访问权限的攻击方式。

核心原理:

  • 利用计算机计算能力遍历密码空间
  • 基于字符集和规则生成候选密码
  • 通过比对验证密码正确性

1.2 枚举攻击分类

类型 描述 特点
传统枚举 暴力遍历所有组合 时间复杂度高,成功率低
实时计算枚举 边生成边验证 内存占用低,实时反馈
彩虹表攻击 预计算哈希值 速度快,存储需求大
字典攻击 使用预定义字典 依赖字典质量

1.3 密码空间分析

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

二、传统枚举密码攻击

2.1 原理与实现

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

PYTHON
import itertools

class TraditionalEnumerator:
    """传统密码枚举器"""
    
    def __init__(self, charset=None):
        self.charset = charset or 'abcdefghijklmnopqrstuvwxyz0123456789'
    
    def generate_passwords(self, min_length, max_length):
        """生成指定长度范围的所有密码"""
        for length in range(min_length, max_length + 1):
            for combo in itertools.product(self.charset, repeat=length):
                yield ''.join(combo)
    
    def brute_force(self, target_hash, hash_func, min_len=4, max_len=8):
        """暴力破解哈希值"""
        for password in self.generate_passwords(min_len, max_len):
            if hash_func(password) == target_hash:
                return password
        return None

# 使用示例
enumerator = TraditionalEnumerator()
result = enumerator.brute_force(
    target_hash='5f4dcc3b5aa765d61d8327deb882cf99',  # md5('password')
    hash_func=lambda p: __import__('hashlib').md5(p.encode()).hexdigest(),
    min_len=8,
    max_len=8
)
print(f"找到密码: {result}")

2.2 性能分析

时间复杂度:O(C^L),其中 C 是字符集大小,L 是密码长度

字符集 长度 组合数 时间(1000次/秒)
数字(10) 4 10,000 10秒
数字(10) 6 1,000,000 16分钟
小写(26) 6 308,915,776 9.8年
混合(62) 8 218万亿 6924年

2.3 优化策略

PYTHON
class OptimizedEnumerator:
    """优化的传统枚举器"""
    
    def __init__(self):
        self.frequency_order = 'etaoinshrdlcumwfgypbvkjxqz'  # 字母频率排序
    
    def generate_by_frequency(self, length):
        """按字母频率优先生成"""
        chars = self.frequency_order + '0123456789'
        return self._generate_with_order(chars, length)
    
    def _generate_with_order(self, chars, length):
        """按优先级顺序生成组合"""
        if length == 1:
            for c in chars:
                yield c
        else:
            for c in chars:
                for suffix in self._generate_with_order(chars, length - 1):
                    yield c + suffix
    
    def smart_brute_force(self, target_hash, hash_func, max_len=8):
        """智能暴力破解:先尝试常见模式"""
        # 先尝试常见密码
        common_passwords = ['password', '123456', 'qwerty', 'abc123']
        for pwd in common_passwords:
            if hash_func(pwd) == target_hash:
                return pwd
        
        # 按长度递增尝试
        for length in range(4, max_len + 1):
            for pwd in self.generate_by_frequency(length):
                if hash_func(pwd) == target_hash:
                    return pwd
        
        return None

2.4 应用场景

PYTHON
# 场景1:破解简单密码
def crack_simple_passwords(hash_list):
    """批量破解简单密码哈希"""
    enumerator = OptimizedEnumerator()
    results = {}
    
    for target_hash in hash_list:
        result = enumerator.smart_brute_force(
            target_hash,
            lambda p: __import__('hashlib').md5(p.encode()).hexdigest(),
            max_len=6
        )
        if result:
            results[target_hash] = result
    
    return results

# 场景2:验证密码强度
def check_password_strength(password):
    """评估密码抵抗暴力破解的能力"""
    charset_size = 0
    if any(c.islower() for c in password): charset_size += 26
    if any(c.isupper() for c in password): charset_size += 26
    if any(c.isdigit() for c in password): charset_size += 10
    if any(c in '!@#$%^&*' for c in password): charset_size += 8
    
    combinations = charset_size ** len(password)
    time_seconds = combinations / 1000000  # 假设每秒100万次尝试
    
    if time_seconds < 3600:
        return "弱密码"
    elif time_seconds < 31536000:
        return "中等密码"
    else:
        return "强密码"

三、实时计算枚举攻击

3.1 原理与实现

原理:边生成密码边计算哈希并验证,无需预存

PYTHON
import hashlib
from itertools import product

class RealTimeEnumerator:
    """实时计算枚举器"""
    
    def __init__(self):
        self.charsets = {
            'lower': 'abcdefghijklmnopqrstuvwxyz',
            'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'digits': '0123456789',
            'special': '!@#$%^&*()_+-=[]{}|;:,.<>?'
        }
    
    def build_charset(self, use_lower=True, use_upper=True, use_digits=True, use_special=False):
        """构建自定义字符集"""
        charset = ''
        if use_lower: charset += self.charsets['lower']
        if use_upper: charset += self.charsets['upper']
        if use_digits: charset += self.charsets['digits']
        if use_special: charset += self.charsets['special']
        return charset
    
    def enumerate_realtime(self, target_hash, hash_algorithm='md5', **kwargs):
        """实时枚举破解"""
        charset = self.build_charset(**kwargs)
        hash_func = getattr(hashlib, hash_algorithm)
        
        # 从最短开始尝试
        for length in range(1, 13):
            for combo in product(charset, repeat=length):
                password = ''.join(combo)
                computed_hash = hash_func(password.encode()).hexdigest()
                
                if computed_hash == target_hash:
                    return password
                
                # 进度输出(每100万次)
                if (length * 10**8 + hash(password)) % 1000000 == 0:
                    print(f"已尝试 {length} 位密码...")
        
        return None

# 使用示例
enumerator = RealTimeEnumerator()
result = enumerator.enumerate_realtime(
    target_hash='098f6bcd4621d373cade4e832627b4f6',  # md5('test')
    hash_algorithm='md5',
    use_lower=True,
    use_upper=False,
    use_digits=False,
    use_special=False
)
print(f"找到密码: {result}")

3.2 分布式实时枚举

PYTHON
from multiprocessing import Pool, cpu_count

class DistributedEnumerator:
    """分布式实时枚举器"""
    
    def __init__(self):
        self.pool = Pool(processes=cpu_count())
    
    def _worker(self, params):
        """工作进程:负责一部分密码空间"""
        start_char, end_char, length, charset, target_hash, hash_algorithm = params
        hash_func = getattr(__import__('hashlib'), hash_algorithm)
        
        start_idx = charset.index(start_char)
        end_idx = charset.index(end_char) + 1
        
        for first_char in charset[start_idx:end_idx]:
            remaining_chars = charset
            for combo in product(remaining_chars, repeat=length - 1):
                password = first_char + ''.join(combo)
                computed_hash = hash_func(password.encode()).hexdigest()
                
                if computed_hash == target_hash:
                    return password
        
        return None
    
    def distributed_crack(self, target_hash, length, charset, hash_algorithm='md5'):
        """分布式破解"""
        # 将字符集分成多个区间
        num_workers = cpu_count()
        chunk_size = len(charset) // num_workers
        
        params = []
        for i in range(num_workers):
            start_char = charset[i * chunk_size]
            end_char = charset[min((i + 1) * chunk_size - 1, len(charset) - 1)]
            params.append((start_char, end_char, length, charset, target_hash, hash_algorithm))
        
        # 并行执行
        results = self.pool.map(self._worker, params)
        
        # 查找非None结果
        for result in results:
            if result:
                return result
        
        return None

# 使用示例
dist_enumerator = DistributedEnumerator()
result = dist_enumerator.distributed_crack(
    target_hash='5f4dcc3b5aa765d61d8327deb882cf99',
    length=8,
    charset='abcdefghijklmnopqrstuvwxyz',
    hash_algorithm='md5'
)
print(f"找到密码: {result}")

3.3 GPU加速枚举

PYTHON
import pycuda.autoinit
import pycuda.driver as cuda
from pycuda.compiler import SourceModule

class GPUEnumerator:
    """GPU加速枚举器"""
    
    def __init__(self):
        # CUDA内核代码
        self.mod = SourceModule("""
            __global__ void md5_kernel(char *passwords, char *target, int *result) {
                int idx = blockIdx.x * blockDim.x + threadIdx.x;
                // 简化的MD5计算(实际实现需要完整MD5算法)
                // ...
            }
        """)
    
    def gpu_crack(self, target_hash, charset, max_length):
        """使用GPU加速破解"""
        # 准备数据
        passwords = self._generate_passwords(charset, max_length)
        
        # 分配GPU内存
        passwords_gpu = cuda.mem_alloc(passwords.nbytes)
        target_gpu = cuda.mem_alloc(len(target_hash))
        result_gpu = cuda.mem_alloc(4)
        
        # 复制数据到GPU
        cuda.memcpy_htod(passwords_gpu, passwords)
        cuda.memcpy_htod(target_gpu, target_hash.encode())
        
        # 启动内核
        md5_kernel = self.mod.get_function("md5_kernel")
        md5_kernel(
            passwords_gpu,
            target_gpu,
            result_gpu,
            block=(256, 1, 1),
            grid=(len(passwords) // 256 + 1, 1)
        )
        
        # 读取结果
        result = numpy.empty(1, dtype=numpy.int32)
        cuda.memcpy_dtoh(result, result_gpu)
        
        return result[0]

四、彩虹表攻击

4.1 原理与结构

原理:预计算哈希值对照表,以空间换时间

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

4.2 彩虹表生成

PYTHON
import hashlib
import os

class RainbowTableGenerator:
    """彩虹表生成器"""
    
    def __init__(self, chain_length=1000, num_chains=1000000):
        self.chain_length = chain_length
        self.num_chains = num_chains
        self.table = {}
    
    def _hash(self, data):
        """计算MD5哈希"""
        return hashlib.md5(data.encode()).hexdigest()
    
    def _reduction(self, hash_val, index):
        """降函数:将哈希值转换为密码候选"""
        chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
        result = ''
        hash_int = int(hash_val, 16)
        
        for i in range(8):
            result += chars[(hash_int + index + i) % len(chars)]
        
        return result
    
    def generate_chain(self, start_password):
        """生成一条彩虹链"""
        current = start_password
        
        for i in range(self.chain_length):
            current_hash = self._hash(current)
            current = self._reduction(current_hash, i)
        
        return start_password, current  # (起点, 终点)
    
    def build_table(self, charset='abcdefghijklmnopqrstuvwxyz0123456789'):
        """构建彩虹表"""
        print(f"正在生成彩虹表...")
        
        for i in range(self.num_chains):
            # 生成随机起点
            start_password = ''.join([charset[ord(os.urandom(1)) % len(charset)] for _ in range(8))
            start, end = self.generate_chain(start_password)
            
            # 存储到表中(按终点索引)
            if end not in self.table:
                self.table[end] = []
            self.table[end].append(start)
            
            if (i + 1) % 100000 == 0:
                print(f"已生成 {i + 1} 条链")
    
    def save_table(self, filename):
        """保存彩虹表到文件"""
        import pickle
        with open(filename, 'wb') as f:
            pickle.dump(self.table, f)
    
    def load_table(self, filename):
        """从文件加载彩虹表"""
        import pickle
        with open(filename, 'rb') as f:
            self.table = pickle.load(f)

4.3 彩虹表查询

PYTHON
class RainbowTableCracker:
    """彩虹表破解器"""
    
    def __init__(self, table):
        self.table = table
        self.chain_length = 1000  # 需与生成时一致
    
    def _hash(self, data):
        return hashlib.md5(data.encode()).hexdigest()
    
    def _reduction(self, hash_val, index):
        chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
        result = ''
        hash_int = int(hash_val, 16)
        
        for i in range(8):
            result += chars[(hash_int + index + i) % len(chars)]
        
        return result
    
    def crack(self, target_hash):
        """使用彩虹表破解哈希"""
        current_hash = target_hash
        
        # 沿着链条逆向查找
        for i in range(self.chain_length - 1, -1, -1):
            # 计算当前位置的候选密码
            candidate = self._reduction(current_hash, i)
            
            # 检查是否在表中
            if candidate in self.table:
                # 遍历所有可能的起点
                for start in self.table[candidate]:
                    # 重新生成链条
                    current = start
                    for j in range(self.chain_length):
                        current_hash_check = self._hash(current)
                        
                        if current_hash_check == target_hash:
                            return current
                        
                        current = self._reduction(current_hash_check, j)
            
            # 向前走一步
            current_hash = self._hash(self._reduction(current_hash, i))
        
        return None

# 使用示例
# 生成彩虹表(首次使用)
# generator = RainbowTableGenerator(chain_length=1000, num_chains=100000)
# generator.build_table()
# generator.save_table('rainbow_table.pkl')

# 加载并使用
cracker = RainbowTableCracker({})
cracker.load_table('rainbow_table.pkl')
result = cracker.crack('5f4dcc3b5aa765d61d8327deb882cf99')
print(f"找到密码: {result}")

4.4 彩虹表优化

PYTHON
class OptimizedRainbowTable:
    """优化的彩虹表"""
    
    def __init__(self):
        self.tables = {}  # 按密码长度分组
    
    def build_multi_length_table(self, min_length=4, max_length=10):
        """为不同长度的密码构建单独的表"""
        for length in range(min_length, max_length + 1):
            generator = RainbowTableGenerator(
                chain_length=500 + length * 50,
                num_chains=500000 + length * 100000
            )
            generator.build_table()
            self.tables[length] = generator.table
    
    def crack_with_length(self, target_hash, password_length):
        """针对特定长度破解"""
        if password_length not in self.tables:
            return None
        
        cracker = RainbowTableCracker(self.tables[password_length])
        return cracker.crack(target_hash)

五、防御策略

5.1 密码策略强化

PYTHON
import re

def enforce_password_policy(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', 'welcome'}
    if password.lower() in common_passwords:
        errors.append("密码过于常见")
    
    return len(errors) == 0, errors

5.2 加盐哈希

PYTHON
import hashlib
import os

class SaltedHasher:
    """加盐哈希器"""
    
    def __init__(self, salt_length=16):
        self.salt_length = salt_length
    
    def generate_salt(self):
        """生成随机盐值"""
        return os.urandom(self.salt_length).hex()
    
    def hash_password(self, password, salt=None):
        """计算加盐哈希"""
        if salt is None:
            salt = self.generate_salt()
        
        # 使用 PBKDF2 进行慢哈希
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode(),
            salt.encode(),
            100000  # 迭代次数
        )
        
        return f"{salt}:{hashed.hex()}"
    
    def verify_password(self, password, stored_hash):
        """验证密码"""
        salt, hash_val = stored_hash.split(':')
        
        computed_hash = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode(),
            salt.encode(),
            100000
        )
        
        return computed_hash.hex() == hash_val

# 使用示例
hasher = SaltedHasher()
stored = hasher.hash_password('my_secure_password')
print(f"存储的哈希: {stored}")

# 验证
is_valid = hasher.verify_password('my_secure_password', stored)
print(f"密码验证: {is_valid}")

5.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,
    storage_uri="memory://"
)

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # 每分钟最多5次尝试
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    
    # 验证逻辑
    if verify_credentials(username, password):
        return "登录成功"
    else:
        return "登录失败", 401

5.4 账户锁定

PYTHON
from datetime import datetime, timedelta

class AccountLockout:
    """账户锁定机制"""
    
    def __init__(self, max_attempts=5, lockout_duration=300):
        self.max_attempts = max_attempts
        self.lockout_duration = timedelta(seconds=lockout_duration)
        self.attempts = {}  # username -> {'count': int, 'last_attempt': datetime}
    
    def record_failure(self, username):
        """记录失败尝试"""
        now = datetime.now()
        
        if username not in self.attempts:
            self.attempts[username] = {'count': 0, 'last_attempt': now}
        
        self.attempts[username]['count'] += 1
        self.attempts[username]['last_attempt'] = now
    
    def is_locked(self, username):
        """检查账户是否被锁定"""
        if username not in self.attempts:
            return False
        
        record = self.attempts[username]
        
        # 检查是否超过最大尝试次数
        if record['count'] < self.max_attempts:
            return False
        
        # 检查锁定时间是否已过期
        if datetime.now() - record['last_attempt'] >= self.lockout_duration:
            # 重置计数器
            self.attempts[username]['count'] = 0
            return False
        
        return True
    
    def reset_attempts(self, username):
        """重置失败尝试计数器"""
        if username in self.attempts:
            self.attempts[username]['count'] = 0

六、攻击工具与平台

6.1 常用工具

工具 类型 特点
Hashcat GPU加速 最快的密码破解工具
John the Ripper 多平台 支持多种哈希算法
RainbowCrack 彩虹表 专用彩虹表工具
Hydra 网络协议 在线密码破解
Medusa 并行破解 高性能

6.2 Hashcat 使用示例

BASH
# 基础使用
hashcat -m 0 -a 0 hash.txt rockyou.txt  # MD5字典攻击

# 暴力攻击(8位小写字母)
hashcat -m 0 -a 3 hash.txt ?l?l?l?l?l?l?l?l

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

# 掩码攻击(大写字母+数字)
hashcat -m 0 -a 3 hash.txt ?u?l?l?l?l?d?d?d

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

6.3 John the Ripper 使用示例

BASH
# 基础破解
john hash.txt

# 指定字典
john --wordlist=rockyou.txt hash.txt

# 指定哈希类型
john --format=md5 hash.txt

# 暴力模式
john --incremental hash.txt

# 恢复进度
john --restore

七、实战案例分析

7.1 案例一:MD5 哈希破解

PYTHON
# 场景:破解泄露的MD5哈希
import hashlib

def crack_md5_hash(target_hash):
    """破解MD5哈希"""
    # 常见密码字典
    common_passwords = [
        'password', '123456', '12345678', 'qwerty', 'abc123',
        'monkey', '123123', 'dragon', 'baseball', 'iloveyou'
    ]
    
    for password in common_passwords:
        if hashlib.md5(password.encode()).hexdigest() == target_hash:
            return password
    
    return None

# 测试
target = '5f4dcc3b5aa765d61d8327deb882cf99'  # password
result = crack_md5_hash(target)
print(f"破解结果: {result}")

7.2 案例二:彩虹表破解实战

PYTHON
# 模拟彩虹表破解流程
def simulate_rainbow_attack():
    """模拟彩虹表攻击"""
    # 目标哈希(假设从数据库泄露)
    target_hash = '098f6bcd4621d373cade4e832627b4f6'  # md5('test')
    
    # 预计算彩虹表(简化版)
    rainbow_table = {
        'test': '098f6bcd4621d373cade4e832627b4f6',
        'password': '5f4dcc3b5aa765d61d8327deb882cf99',
        '123456': 'e10adc3949ba59abbe56e057f20f883e'
    }
    
    # 反向查找
    for password, hash_val in rainbow_table.items():
        if hash_val == target_hash:
            print(f"找到密码: {password}")
            return password
    
    print("未找到密码")
    return None

simulate_rainbow_attack()

7.3 案例三:实时枚举破解

PYTHON
def realtime_attack_demo():
    """实时枚举演示"""
    target_password = 'pass123'
    target_hash = hashlib.md5(target_password.encode()).hexdigest()
    
    print(f"目标哈希: {target_hash}")
    print("开始实时枚举...")
    
    charset = 'abcdefghijklmnopqrstuvwxyz0123456789'
    
    # 尝试4-8位密码
    for length in range(4, 9):
        for combo in itertools.product(charset, repeat=length):
            password = ''.join(combo)
            if hashlib.md5(password.encode()).hexdigest() == target_hash:
                print(f"找到密码: {password}")
                return
    
    print("未找到密码")

realtime_attack_demo()

八、总结与展望

8.1 技术对比

攻击类型 优点 缺点 适用场景
传统枚举 简单直接 速度慢 短密码
实时枚举 内存占用低 计算量大 中等长度密码
彩虹表 速度快 存储需求大 批量破解
字典攻击 效率高 依赖字典 常见密码

8.2 防御建议

层面 建议
密码策略 长度≥12位,混合字符
哈希算法 使用 bcrypt/Argon2
加盐处理 每个密码独立盐值
速率限制 限制登录尝试频率
账户锁定 多次失败后锁定

8.3 未来趋势

  1. 量子计算威胁:量子计算机可能破解传统哈希算法
  2. 新型哈希算法:抗量子攻击的哈希函数
  3. 行为分析:基于行为的异常检测
  4. 无密码认证:生物识别、FIDO2等

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