TarGuessIRefined密码生成器详细分析

一、功能概述

TarGuessIRefined是一个基于用户个人信息生成潜在密码猜测的Python工具。该程序通过分析用户的基本信息（如用户名、邮箱、电话、生日等），结合常见的密码模式和用户行为习惯，生成一系列可能的密码组合。其主要应用场景包括：

1. 密码强度测试：帮助系统管理员评估用户密码的脆弱性

2. 安全审计：用于渗透测试和红队演练中的密码猜测环节

3. 用户教育：展示基于个人信息的密码生成模式，提高用户安全意识

4. 密码策略验证：测试现有密码策略是否能有效抵御基于个人信息的攻击

二、系统架构与设计理念

2.1 分层生成策略

程序采用分层策略生成密码，从最通用的密码到高度个性化的组合：

• Tier 0：纯通用密码（前50个最常见密码）

• Tier 1：直接使用用户信息字段

• Tier 2：姓名与数字的组合

• Tier 3：账号类信息与数字的组合

• Tier 4：键盘模式和Leet变换

• Tier 5：填充密码和序列组合

这种分层设计模拟了攻击者的思维过程：从最简单直接的尝试开始，逐步增加复杂度和个性化程度。

2.2 模块化设计

程序采用面向对象的设计方法，将不同功能封装在独立的方法中，提高了代码的可读性和可维护性。每个密码生成层级都有对应的专用方法，便于单独测试和优化。

三、核心数据结构分析

3.1 静态数据集合

3.1.1 TOP200_PASSWORDS列表

TOP200_PASSWORDS = [
    # Tier 0: 前50（纯通用）
    '123456', 'password', '12345678', ...,
    # Tier 1: 51-200
    'welcome123', 'login', 'passw0rd', ...
]

这个列表包含了200个最常见的密码，分为两个层级：

• Tier 0（前50）：最通用的密码，几乎在任何密码字典中都会出现

• Tier 1（51-200）：次通用的密码，包含一些变体和简单组合

这些密码的选择基于多年来多个密码泄露事件的分析结果，反映了用户设置密码的真实习惯。

3.1.2 COMMON_SUFFIXES列表

COMMON_SUFFIXES = ['123', '123456', '666', '888', '999', '000', '007', '520', '1314', ...]

这个列表包含了用户常用的数字后缀模式：

• 简单序列：123, 123456等

• 吉利数字：666, 888, 999等（在中国文化中特别常见）

• 特殊含义：007（詹姆斯·邦德）, 520（"我爱你"的谐音）, 1314（"一生一世"的谐音）

这些后缀反映了用户在设置密码时的心理模式：在简单基础词后添加容易记忆的数字。

3.1.3 KEYBOARD_TOP列表

KEYBOARD_TOP = ['qwerty', 'asdfgh', 'zxcvbn', 'qazwsx', '123456', '654321', ...]

这个列表包含了键盘上常见的连续按键模式，这些模式因为输入方便而常被用作密码。

3.2 动态数据结构

3.2.1 用户数据字典

程序通过parse_user_data方法解析输入文件，为每个用户创建一个字典结构：

user_data = {
    'account': 'user123',           # 账号（小写）
    'username': 'john_doe',         # 用户名（小写）
    'email': 'john@example.com',    # 完整邮箱
    'email_prefix': 'john',         # 邮箱前缀（小写）
    'phone': '13800138000',         # 完整电话
    'phone_last4': '8000',          # 电话后4位
    'phone_last6': '138000',        # 电话后6位
    'birth': '19900101',            # 生日（YYYYMMDD）
    'birth_year': '1990',           # 出生年份
    'birth_yy': '90',               # 出生年份后两位
    'birth_mmdd': '0101',           # 月日
    'name': 'John|Doe',             # 完整姓名
    'first_name': 'john'            # 名字第一部分（小写）
}

这种结构化的数据存储方式便于后续的密码生成算法访问和组合不同的用户属性。

四、核心算法详解

4.1 数据解析算法

4.1.1 文件解析流程

def parse_user_data(self, file_content: str) -> List[Dict]:
    users = []
    for line in file_content.strip().split('\n'):
        if not line.strip():
            continue
            
        user_data = {}
        for field in line.split('\t'):
            if ':' in field:
                key, value = field.split(':', 1)
                user_data[key.strip()] = value.strip()
                
        self._extract_key_info(user_data)
        users.append(user_data)
        
    return users

算法流程：

1. 按行分割文件内容

2. 跳过空行

3. 按制表符分割字段

4. 对每个字段按冒号分割键值对

5. 调用关键信息提取方法

4.1.2 关键信息提取算法

def _extract_key_info(self, user_data: Dict):
    # 账号/用户名小写处理
    if user_data.get('account'):
        user_data['account'] = user_data['account'].lower()
    
    # 邮箱前缀提取
    if user_data.get('email'):
        email = user_data['email']
        if '@' in email:
            user_data['email_prefix'] = email.split('@')[0].lower()
    
    # 电话尾号提取
    if user_data.get('phone'):
        digits = re.sub(r'\D', '', user_data['phone'])  # 移除非数字字符
        if len(digits) >= 4:
            user_data['phone_last4'] = digits[-4:]
            if len(digits) >= 6:
                user_data['phone_last6'] = digits[-6:]
    
    # 生日信息分解
    if user_data.get('birth'):
        birth = user_data['birth']
        if len(birth) == 8:  # 假设格式为YYYYMMDD
            user_data['birth_year'] = birth[:4]
            user_data['birth_yy'] = birth[2:4]
            user_data['birth_mmdd'] = birth[4:8]
    
    # 姓名处理
    if user_data.get('name'):
        parts = [p.strip().lower() for p in user_data['name'].split('|') if p.strip()]
        if parts:
            user_data['first_name'] = parts[0]  # 取第一部分作为名字

该算法的设计考虑了现实世界中数据的多样性和不规则性，通过多重条件判断确保在各种数据情况下都能正确提取信息。

4.2 密码生成算法

4.2.1 Tier 0: 纯通用密码生成

def generate_tier0_pure_passwords(self) -> List[str]:
    return self.passwords[:50]

这是最简单的生成策略，直接返回预设的最常见密码列表。虽然简单，但在实际攻击中非常有效，因为大量用户仍然使用这些弱密码。

4.2.2 Tier 1: 直接值密码生成

def generate_tier1_direct_values(self, user_data: Dict) -> List[str]:
    guesses = []
    
    # 直接使用完整字段
    for field in ['account', 'email_prefix', 'username', 'first_name']:
        if user_data.get(field):
            value = user_data[field]
            if 3 <= len(value) <= 20:  # 长度限制
                guesses.append(value)
    
    return guesses[:150]  # 数量限制

该算法基于"用户倾向于使用容易记忆的信息作为密码"这一观察结果。通过直接使用用户的各种标识信息，覆盖了用户可能设置的最直接密码。

4.2.3 Tier 2: 姓名+数字组合生成

def generate_tier2_name_plus_numbers(self, user_data: Dict) -> List[str]:
    guesses = []
    
    if not user_data.get('first_name'):
        return guesses
        
    fn = user_data['first_name']
    
    # 姓名+生日组合
    if user_data.get('birth_year'):
        guesses.append(f"{fn}{user_data['birth_year']}")
        guesses.append(f"{fn}{user_data['birth_yy']}")
    if user_data.get('birth_mmdd'):
        guesses.append(f"{fn}{user_data['birth_mmdd']}")
    
    # 姓名+手机尾号组合
    if user_data.get('phone_last4'):
        guesses.append(f"{fn}{user_data['phone_last4']}")
    if user_data.get('phone_last6'):
        guesses.append(f"{fn}{user_data['phone_last6']}")
    
    # 姓名+通用后缀
    for suffix in self.suffixes[:5]:
        guesses.append(f"{fn}{suffix}")
        
    return guesses[:600]

这一层算法模拟了用户创建"个性化但仍有规律"密码的常见模式。研究表明，超过30%的用户会使用姓名结合生日或其它数字作为密码。

4.2.4 Tier 3: 账号+数字组合生成

def generate_tier3_account_plus_numbers(self, user_data: Dict) -> List[str]:
    guesses = []
    
    # 获取所有账号类字段
    account_fields = ['account', 'username', 'email_prefix']
    base_accounts = []
    for field in account_fields:
        if user_data.get(field):
            base_accounts.append(user_data[field])
    
    # 对每个基础账号生成组合
    for base in base_accounts[:2]:  # 限制基础账号数量
        if user_data.get('birth_year'):
            guesses.append(f"{base}{user_data['birth_year']}")
            guesses.append(f"{base}{user_data['birth_yy']}")
        
        if user_data.get('phone_last4'):
            guesses.append(f"{base}{user_data['phone_last4']}")
            
        for suffix in self.suffixes[:3]:
            guesses.append(f"{base}{suffix}")
            
    return guesses[:700]

这一层算法针对的是那些使用账号信息而非真实姓名作为密码基础的用户。这种模式在技术用户中更为常见。

4.2.5 Tier 4: 键盘模式和Leet变换

def generate_tier4_keyboard_and_leet(self, user_data: Dict) -> List[str]:
    guesses = []
    
    # 键盘模式
    guesses.extend(self.keyboard)
    
    # Leet变换
    short_words = []
    for field in ['account', 'username', 'first_name']:
        if user_data.get(field):
            value = user_data[field]
            if 3 <= len(value) <= 8:  # 只对短词进行变换
                short_words.append(value)
    
    for word in short_words[:2]:
        # 简单字符替换
        if 'a' in word:
            guesses.append(word.replace('a', '4'))
        if 'e' in word:
            guesses.append(word.replace('e', '3'))
        # ... 其他替换规则
    
    # 首字母大写
    for word in short_words[:2]:
        guesses.append(word.capitalize())
        
    return guesses[:1500]

Leet语（Leetspeak）是一种在线交流中常用的拼写方式，用数字和特殊字符替换字母。该算法模拟了用户试图通过简单替换"强化"密码的常见行为。

4.2.6 Tier 5: 填充密码生成

def generate_tier5_filling(self, user_data: Dict) -> List[str]:
    guesses = []
    
    # 使用次常见密码
    guesses.extend(self.passwords[50:2000])
    
    # 账号+序列数字
    base_ids = []
    for field in ['account', 'email_prefix']:
        if user_data.get(field):
            base_ids.append(user_data[field])
    
    for base in base_ids[:1]:
        for i in range(1, 100):  # 生成1-99的序列
            if len(guesses) >= 10000:
                break
            guesses.append(f"{base}{i}")
    
    return guesses

这一层作为"兜底"策略，包含了更多可能的密码变体和序列组合，确保覆盖更广泛的密码模式。

4.3 密码筛选与优化算法

def generate_for_user(self, user_data: Dict, max_guesses: int = 10000) -> List[str]:
    all_guesses = []
    
    # 按层级生成密码
    all_guesses.extend(self.generate_tier0_pure_passwords()[:50])
    all_guesses.extend(self.generate_tier1_direct_values(user_data)[:150])
    # ... 其他层级
    
    # 去重和过滤
    seen = set()
    filtered = []
    for pwd in all_guesses:
        if (pwd not in seen and 3 <= len(pwd) <= 20 and
                re.search(r'[a-zA-Z0-9]', pwd)):  # 至少包含字母或数字
            seen.add(pwd)
            filtered.append(pwd)
            if len(filtered) >= max_guesses:
                break
                
    return filtered[:max_guesses]

筛选算法确保生成的密码符合基本要求：

1. 唯一性：通过集合实现高效去重

2. 长度合理：3-20字符的长度限制

3. 字符类型：至少包含字母或数字，排除纯特殊字符密码

五、性能优化策略

5.1 生成数量控制

每个层级生成方法都有明确的输出数量限制，防止生成过多无效密码：

• Tier 0: 50个

• Tier 1: 150个

• Tier 2: 600个

• Tier 3: 700个

• Tier 4: 1500个

• Tier 5: 动态控制（最多10000个）

这种分层限制确保了在覆盖多种模式的同时，不会生成过于庞大而不实用的密码列表。

5.2 高效去重机制

使用Python集合（set）进行去重，利用其哈希表实现的O(1)查找复杂度，确保即使处理大量密码时也能保持高效。

5.3 惰性生成思想

虽然程序没有完全实现惰性生成，但通过分层控制和提前终止循环，减少了不必要的计算。在实际生成过程中，当达到最大密码数量时会立即停止。

六、安全与伦理考量

6.1 合法使用场景

该工具设计用于：

• 系统管理员评估用户密码强度

• 安全研究人员进行密码策略研究

• 企业内部的渗透测试和红队演练

• 用户安全教育演示

6.2 潜在滥用风险

该工具也可能被恶意攻击者利用进行密码破解攻击。因此，开发者和使用者都有责任确保：

1. 仅在合法授权范围内使用

2. 不针对未经授权的系统进行测试

3. 妥善保管生成的密码字典

4. 在使用后及时清理相关数据

6.3 隐私保护考虑

程序处理用户个人信息时，应注意：

1. 输入数据应进行匿名化处理

2. 生成的密码字典应安全存储

3. 使用后应及时销毁敏感信息

七、扩展性与改进方向

7.1 可扩展的架构

当前的模块化设计使得添加新的密码生成策略变得容易。可以通过以下方式扩展：

1. 添加新的Tier生成方法

2. 扩展常见密码列表

3. 增加更多的字符变换规则

7.2 国际化支持

当前程序主要针对英语用户和中英文混合环境，可以扩展支持：

1. 其他语言的常见密码模式

2. 地区特定的数字文化（如西方国家的幸运数字7）

3. 本地化的键盘布局模式

7.3 机器学习增强

可以引入机器学习算法来：

1. 分析真实密码库中的模式

2. 自动发现新的密码生成规则

3. 根据用户属性预测最可能的密码模式

7.4 性能优化方向

1. 并行生成：利用多线程/多进程同时处理多个用户

2. 流式处理：对于大量用户，采用流式处理减少内存占用

3. 智能剪枝：基于概率模型优先生成高可能性的密码

八、实际应用效果评估

根据密码学和安全研究的一般经验，此类基于个人信息的密码生成工具在实际攻击中成功率通常在15-30%之间，具体取决于：

1. 目标群体的密码习惯：普通用户比安全意识强的用户更容易被猜中密码

2. 密码策略强度：有严格密码策略的系统受影响较小

3. 信息完整性：获取的用户信息越完整，生成密码的准确性越高

九、总结

TarGuessIRefined是一个设计精良的密码生成工具，它通过多层次、多策略的方法，系统地模拟了基于个人信息的密码猜测攻击。其价值不仅在于实际安全测试中的应用，更在于它揭示了用户设置密码时的常见行为模式和心理倾向。

从技术角度看，该程序展示了良好的软件工程实践：模块化设计、清晰的接口分离、合理的算法选择。从安全角度看，它提醒我们单纯依赖个人信息创建"容易记忆"的密码存在严重安全风险。

最终，这类工具的存在强调了实施多因素认证、使用密码管理器生成随机密码、以及开展持续的用户安全教育的重要性。在日益复杂的网络安全环境中，技术和教育相结合才是保护用户账户安全的最有效途径。

源代码

import re
from collections import OrderedDict
from typing import List, Dict


TOP200_PASSWORDS = [
    # Tier 0: 前50（纯通用）
    '123456', 'password', '12345678', 'qwerty', 'abc123', '123456789', '111111', '1234567',
    'iloveyou', 'admin', 'welcome', 'monkey', '1234567890', '123123', '000000', '12345',
    '1234', 'sunshine', 'princess', 'letmein', 'solo', '123456a', 'football', 'qwerty123',
    'superman', '1qaz2wsx', 'baseball', 'password1', 'master', 'hello', 'freedom', 'whatever',
    'qazwsx', 'trustno1', '654321', 'jordan23', 'harley', '123qwe', 'michael', 'dragon',
    'mustang', 'shadow', 'ashley', 'bailey', 'blink182', '123abc', '1q2w3e4r', 'qwer1234',
    'pass123', 'admin123',

    # Tier 1: 51-200
    'welcome123', 'login', 'passw0rd', 'abc123456', 'password123', '1234qwer', '12345a', 'qwe123',
    'asdf1234', 'charlie', 'donald', 'summertime', 'starwars', 'iloveyou1', 'princess1', 'dragonball',
    'monkey123', 'football1', 'basketball', 'soccer123', 'hockey123', 'guitar123', 'piano123', 'dance123',
    'music123', 'movie123', 'book123', 'game123', 'phone123', 'laptop123', 'computer', 'internet',
    'network123', 'server123', 'database', 'webmaster', 'superuser', 'superadmin', 'admin123456',
    'admin888', 'admin666', 'root123', 'root123456', 'pass111', 'pass222', 'pass333', 'pass444',
    'pass555', 'pass666', 'pass777', 'pass888', 'pass999', 'pass000', 'aaa123', 'bbb123', 'ccc123',
    'ddd123', 'eee123', 'fff123', 'ggg123', 'hhh123', 'iii123', 'jjj123', 'kkk123', 'lll123', 'mmm123',
    'nnn123', 'ooo123', 'ppp123', 'qqq123', 'rrr123', 'sss123', 'ttt123', 'uuu123', 'vvv123', 'www123',
    'xxx123', 'yyy123', 'zzz123', 'a123456', 'b123456', 'c123456', 'd123456', 'e123456', 'f123456',
    'a123123', 'b123123', 'c123123', 'd123123', 'e123123', 'f123123', 'abc123', 'abcd123', 'abcde123',
    'abcdef123', 'abc1234', 'abc12345', 'abc123456', 'qwe123', 'qwe123456', 'qweasd', 'zxc123', 'zxc123456',
    'zxcasd', 'asd123', 'asd123456', 'asdqwe', 'qaz123', 'qaz123456', 'qazwsx', 'wsx123', 'wsx123456',
    'eda123', 'rfv123', 'tgb123', 'yhn123', 'ujm123', '123qwe', '123qweasd', '456asd', '789zxc', '147qaz',
    '258wsx', '369edc', '741qaz', '852wsx', '963edc', 'qwe', 'asd', 'zxc', 'qaz', 'wsx', 'edc', 'rfv',
    'tgb', 'yhn', 'qwer', 'asdf', 'zxcv', 'qazxsw', 'wsxedc', 'edcrfv'
]

# 常见数字后缀
COMMON_SUFFIXES = ['123', '123456', '666', '888', '999', '000', '007', '520', '1314', '5201314', '123321', '321', '111',
                   '222', '333', '444', '555']

# 键盘模式
KEYBOARD_TOP = ['qwerty', 'asdfgh', 'zxcvbn', 'qazwsx', '123456', '654321', '123123', '456456', '789789']


class TarGuessIRefined:
    def __init__(self):
        self.passwords = TOP200_PASSWORDS
        self.suffixes = COMMON_SUFFIXES
        self.keyboard = KEYBOARD_TOP

    def parse_user_data(self, file_content: str) -> List[Dict]:
        """精简数据解析"""
        users = []
        for line in file_content.strip().split('\n'):
            if not line.strip():
                continue

            user_data = {}
            for field in line.split('\t'):
                if ':' in field:
                    key, value = field.split(':', 1)
                    user_data[key.strip()] = value.strip()

            # 提取关键信息
            self._extract_key_info(user_data)
            users.append(user_data)

        return users

    def _extract_key_info(self, user_data: Dict):

        # 账号/用户名
        if user_data.get('account'):
            user_data['account'] = user_data['account'].lower()
        if user_data.get('username'):
            user_data['username'] = user_data['username'].lower()

        # 邮箱前缀
        if user_data.get('email'):
            email = user_data['email']
            if '@' in email:
                user_data['email_prefix'] = email.split('@')[0].lower()

        # 电话尾号
        if user_data.get('phone'):
            digits = re.sub(r'\D', '', user_data['phone'])
            if len(digits) >= 4:
                user_data['phone_last4'] = digits[-4:]
                if len(digits) >= 6:
                    user_data['phone_last6'] = digits[-6:]

        # 生日
        if user_data.get('birth'):
            birth = user_data['birth']
            if len(birth) == 8:
                user_data['birth_year'] = birth[:4]
                user_data['birth_yy'] = birth[2:4]
                user_data['birth_mmdd'] = birth[4:8]


        if user_data.get('name'):
            parts = [p.strip().lower() for p in user_data['name'].split('|') if p.strip()]
            if parts:
                user_data['first_name'] = parts[0]

    def generate_tier0_pure_passwords(self) -> List[str]:

        return self.passwords[:50]

    def generate_tier1_direct_values(self, user_data: Dict) -> List[str]:

        guesses = []

        # 直接使用完整字段（最可能）
        for field in ['account', 'email_prefix', 'username', 'first_name']:
            if user_data.get(field):
                value = user_data[field]
                if 3 <= len(value) <= 20:
                    guesses.append(value)


        for field in ['account', 'username']:
            if user_data.get(field):
                value = user_data[field].lower()
                if value not in guesses:
                    guesses.append(value)

        return guesses[:150]

    def generate_tier2_name_plus_numbers(self, user_data: Dict) -> List[str]:

        guesses = []

        if not user_data.get('first_name'):
            return guesses

        fn = user_data['first_name']

        # 姓名+生日
        if user_data.get('birth_year'):
            guesses.append(f"{fn}{user_data['birth_year']}")
            guesses.append(f"{fn}{user_data['birth_yy']}")
        if user_data.get('birth_mmdd'):
            guesses.append(f"{fn}{user_data['birth_mmdd']}")

        # 姓名+手机尾号
        if user_data.get('phone_last4'):
            guesses.append(f"{fn}{user_data['phone_last4']}")
        if user_data.get('phone_last6'):
            guesses.append(f"{fn}{user_data['phone_last6']}")

        # 姓名+通用后缀
        for suffix in self.suffixes[:5]:
            guesses.append(f"{fn}{suffix}")

        return guesses[:600]

    def generate_tier3_account_plus_numbers(self, user_data: Dict) -> List[str]:

        guesses = []

        # 可用账号类字段
        account_fields = ['account', 'username', 'email_prefix']
        base_accounts = []
        for field in account_fields:
            if user_data.get(field):
                base_accounts.append(user_data[field])

        # 账号+生日/手机
        for base in base_accounts[:2]:
            # +生日
            if user_data.get('birth_year'):
                guesses.append(f"{base}{user_data['birth_year']}")
                guesses.append(f"{base}{user_data['birth_yy']}")
            # +手机尾号
            if user_data.get('phone_last4'):
                guesses.append(f"{base}{user_data['phone_last4']}")
            # +通用后缀
            for suffix in self.suffixes[:3]:
                guesses.append(f"{base}{suffix}")

        return guesses[:700]

    def generate_tier4_keyboard_and_leet(self, user_data: Dict) -> List[str]:

        guesses = []

        # 键盘模式
        guesses.extend(self.keyboard)


        short_words = []
        for field in ['account', 'username', 'first_name']:
            if user_data.get(field):
                value = user_data[field]
                if 3 <= len(value) <= 8:
                    short_words.append(value)

        for word in short_words[:2]:
            # 简单Leet替换
            if 'a' in word:
                guesses.append(word.replace('a', '4'))
            if 'e' in word:
                guesses.append(word.replace('e', '3'))
            if 'i' in word:
                guesses.append(word.replace('i', '1'))
            if 'o' in word:
                guesses.append(word.replace('o', '0'))
            if 's' in word:
                guesses.append(word.replace('s', '5'))

        # 首字母大写
        for word in short_words[:2]:
            guesses.append(word.capitalize())

        return guesses[:1500]


        guesses = []


        guesses.extend(self.passwords[50:2000])


        base_ids = []
        for field in ['account', 'email_prefix']:
            if user_data.get(field):
                base_ids.append(user_data[field])

        for base in base_ids[:1]:
            for i in range(1, 100):
                if len(guesses) >= 10000:
                    break
                guesses.append(f"{base}{i}")

        return guesses

    def generate_for_user(self, user_data: Dict, max_guesses: int = 10000) -> List[str]:

        all_guesses = []


        all_guesses.extend(self.generate_tier0_pure_passwords()[:50])
        all_guesses.extend(self.generate_tier1_direct_values(user_data)[:150])
        all_guesses.extend(self.generate_tier2_name_plus_numbers(user_data)[:600])
        all_guesses.extend(self.generate_tier3_account_plus_numbers(user_data)[:700])
        all_guesses.extend(self.generate_tier4_keyboard_and_leet(user_data)[:1500])
        all_guesses.extend(self.generate_tier5_filling(user_data))


        seen = set()
        filtered = []
        for pwd in all_guesses:
            if (pwd not in seen and 3 <= len(pwd) <= 20 and
                    re.search(r'[a-zA-Z0-9]', pwd)):
                seen.add(pwd)
                filtered.append(pwd)
                if len(filtered) >= max_guesses:
                    break

        return filtered[:max_guesses]


def main():
    # 读取文件
    content = None
    for enc in ['utf-8', 'gbk', 'gb2312']:
        try:
            with open('1.txt', 'r', encoding=enc) as f:
                content = f.read()
            break
        except:
            continue

    if not content:
        print("无法读取文件")
        return

    # 生成密码
    generator = TarGuessIRefined()
    users = generator.parse_user_data(content)

    with open('2.txt', 'w', encoding='utf-8') as f:
        for i, user in enumerate(users, 1):
            guesses = generator.generate_for_user(user)
            for pwd in guesses:
                f.write(pwd + '\n')
            f.write('<END>\n')
            if i % 100 == 0:
                print(f"已处理: {i}/{len(users)}")

    print(f"完成！共处理 {len(users)} 个用户")


if __name__ == "__main__":
    main()