以下代码均运行在Linux环境，需要注意的是，在编译的时候需要链接pcap库
常见函数
1.获取网络接口
char * pcap_lookupdev(char * errbuf)
//上面这个函数返回第一个合适的网络接口的字符串指针，如果出错，则errbuf存放出错信息字符串，errbuf至少应该是PCAP_ERRBUF_SIZE个字节长度的
int pcap_lookupnet(const char * device, bpf_u_int32 * netp, bpf_u_int32 * maskp, char * errbuf)
//可以获取指定设备的ip地址，子网掩码等信息
//netp：传出参数，指定网络接口的ip地址
//maskp：传出参数，指定网络接口的子网掩码
//pcap_lookupnet()失败返回-1
//net,mask的转换方式，inet_ntoa可以把他转换成10机制字符串 头文件 arpa/inet.h
addr.s_addr=netp;
net=inet_ntoa(addr);
addr.s_addr=maskp;
mask=inet_ntoa(addr);
2.打开网络接口
pcap_t * pcap_open_live(const char * device, int snaplen, int promisc, int to_ms, char * errbuf)
//上面这个函数会返回指定接口的pcap_t类型指针，后面的所有操作都要使用这个指针。
//第一个参数是第一步获取的网络接口字符串，可以直接使用硬编码。
//第二个参数是对于每个数据包，从开头要抓多少个字节，我们可以设置这个值来只抓每个数据包的头部，而不关心具体的内容。典型的以太网帧长度是1518字节，但其他的某些协议的数据包会更长一点，但任何一个协议的一个数据包长度都必然小于65535个字节。
//第三个参数指定是否打开混杂模式(Promiscuous Mode)，0表示非混杂模式，任何其他值表示混合模式。如果要打开混杂模式，那么网卡必须也要打开混杂模式，可以使用如下的命令打开eth0混杂模式：ifconfig eth0 promisc
//第四个参数指定需要等待的毫秒数，超过这个数值后，第3步获取数据包的这几个函数就会立即返回。0表示一直等待直到有数据包到来。
//第五个参数是存放出错信息的数组。
3.释放网络接口
void pcap_close(pcap_t * p)
//该函数用于关闭pcap_open_live()获取的pcap_t的网络接口对象并释放相关资源。
4.获取数据包
u_char * pcap_next(pcap_t * p, struct pcap_pkthdr * h)
//如果返回值为NULL，表示没有抓到包
//第一个参数是第2步返回的pcap_t类型的指针
//第二个参数是保存收到的第一个数据包的pcap_pkthdr类型的指针
//pcap_pkthdr类型的定义如下
struct pcap_pkthdr
{
struct timeval ts; /* time stamp */
bpf_u_int32 caplen; /* length of portion present */
bpf_u_int32 len; /* length this packet (off wire) */
};
5.回调函数
int pcap_loop(pcap_t * p, int cnt, pcap_handler callback, u_char * user)
//第一个参数是第2步返回的pcap_t类型的指针
//第二个参数是需要抓的数据包的个数，一旦抓到了cnt个数据包，pcap_loop立即返回。负数的cnt表示pcap_loop永远循环抓包，直到出现错误。
//第三个参数是一个回调函数指针，它必须是如下的形式：
void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
//第一个参数是pcap_loop的最后一个参数，当收到足够数量的包后pcap_loop会调用callback回调函数，同时将pcap_loop()的user参数传递给它
//第二个参数是收到的数据包的pcap_pkthdr类型的指针
//第三个参数是收到的数据包数据
跳出回调函数：
void pcap_breakloop(pcap_t *);
6.过滤
构造过滤表达式
int pcap_compile(pcap_t * p, struct bpf_program * fp, char * str, int optimize, bpf_u_int32 netmask)
//fp：这是一个传出参数，存放编译后的bpf
//str：过滤表达式
//optimize：是否需要优化过滤表达式
//metmask：简单设置为0即可
设置规则
int pcap_setfilter(pcap_t * p, struct bpf_program * fp)
//参数fp就是pcap_compile()的第二个参数，存放编译后的bpf
例子
struct bpf_program filter;
pcap_compile(device, &filter, "dst port 80", 1, 0); //只接受80端口的TCP/UDP数据包
pcap_setfilter(device, &filter);
7.保存为文件
打开用于保存捕获数据包的文件，用于写入
pcap_dumper_t *pcap_dump_open(pcap_t *p, char *fname)
//fname 参数为”-“时表示标准输出。出错时返回NULL。p参数为调用pcap_open_offline()或pcap_open_live()函数后返回的 pcap结构指针。fname参数指定打开的文件名。如果返回NULL，则可调用pcap_geterr()函数获取错误消息。
关闭文件
void pcap_dump_close(pcap_dumper_t *p);
刷新缓冲区，把捕获的数据包从缓冲区真正拷贝到文件
int pcap_dump_flush(pcap_dumper_t *p)
将数据输入到文件
//输出数据到文件，与pcap_loop的第二个参数回调函数void callback(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet) 形式完全相同，可以直接当pcap_loop的第二个参数；
void pcap_dump(u_char * userarg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
例子
1.输出设备信息
#include <stdio.h>
#include <pcap.h>
#include <time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
void show_ip_mask(char* dev)
{
char errbuf[1024];
struct in_addr addr;
char *net,*mask;
bpf_u_int32 netp,maskp;
//获取IP地址和子网掩码信息
int err=pcap_lookupnet(dev,&netp,&maskp,errbuf);
if(err==-1){
printf("couldn't detect the ip and maskp: %s\n",errbuf);
return;
}
//ip转换为十进制
addr.s_addr=netp;
net=inet_ntoa(addr);
if(net==NULL){
printf("ip error\n");
return;
}
printf("ip: %s\n",net);
addr.s_addr=maskp;
mask=inet_ntoa(addr);
if(mask==NULL){
printf("mask errorn");
return;
}
printf("mask: %s\n",mask);
}
int main()
{
char *dev, errbuf[1024];
char select='a';
printf("select(dispaly the packet in detail)/n:( Y/N ?))");
scanf("%c",&select);
while(select!='Y'&&select!='y'&&select!='n'&&select!='N'){
printf("input the error!\nplease input the Y/N/y/n:");
scanf("%c",&select);
}
//返回第一个合适的网络接口字符串指针，errbuf存放出错信息字符串
//look for the net device
dev=pcap_lookupdev(errbuf);
if(dev==NULL){
printf("couldn't find default device: %s\n",errbuf);
return 1;
}
else{
printf("fidn success: device :%s\n",dev);
}
//ip mask display
show_ip_mask(dev);
return 0;
}
2.输出详细信息
#include <stdio.h>
#include <pcap.h>
#include <time.h>
void capture_packet1(pcap_t* device)
{
struct pcap_pkthdr packet;
char errbuf[1024];
//capture the packet
const u_char* pkt=pcap_next(device,&packet);
if(!pkt){
printf("couldn't capture packet: %s\n",errbuf);
return;
}
//output the pacaket length byte and time
printf("Packet length: %d\n", packet.len);
printf("Number of bytes: %d\n", packet.caplen);
printf("Recieved time: %s\n", ctime((const time_t*)&packet.ts.tv_sec));
}
void getPacket(u_char * arg, const struct pcap_pkthdr * pkthdr, const u_char * packet)
{
int * id = (int *)arg;
printf("id: %d\n", ++(*id));
printf("Packet length: %d\n", pkthdr->len);
printf("Number of bytes: %d\n", pkthdr->caplen);
printf("Recieved time: %s\n", ctime((const time_t *)&pkthdr->ts.tv_sec));
//print packet
int i;
for(i=0; i<pkthdr->len; ++i) {
printf(" %02x", packet[i]);
if( (i + 1) % 16 == 0 )
printf("\n");
}
printf("\n\n");
if(id == 10)
return;
}
void capture_packet2(pcap_t* device)
{
struct pcap_pkthdr packet;
int id = 0;
//capture the packet
int i = pcap_loop(device,-1,getPacket,(u_char*)&id);
printf("i=%d",i);
}
int main()
{
char *dev, errbuf[1024];
char select='a';
printf("select(dispaly the packet in detail)/n:( Y/N ?))");
scanf("%c",&select);
while(select!='Y'&&select!='y'&&select!='n'&&select!='N'){
printf("input the error!\nplease input the Y/N/y/n:");
scanf("%c",&select);
}
//look for the net device
dev=pcap_lookupdev(errbuf);
if(dev==NULL){
printf("couldn't find default device: %s\n",errbuf);
return 1;
}
else{
printf("fidn success: device :%s\n",dev);
}
//open the finded device(must set :ifconfig eth0 promisc)
/*
* dev->网络接口字符串
* 65535->对于每个数据包，从开头都抓取65535个字节
* 1->混杂模式
* 0->指定需要等待的毫秒数，超过这个数值，函数会立即返回。0表示一直等待数据包的到来。
* errbuf->出错信息的数组
*/
pcap_t* device=pcap_open_live(dev,65535,1,0,errbuf);
if(!device){
printf("couldn't open the net device: %s\n",errbuf);
return 1;
}
if(select=='Y')
capture_packet2(device);
else
while(1)//由于pcap_next()函数只返回下一个数据包的指针
capture_packet1(device);
return 0;
}
输出详细包信息
不输出详细包信息
3.实现网络数据包嗅探器
#include <stdio.h>
#include <pcap.h>
#include <time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
//链路层数据包格式
typedef struct {
u_char DestMac[6];
u_char SrcMac[6];
u_char Etype[2];
}ETHHEADER;
//IP层数据包格式
typedef struct {
int header_len:4;
int version:4;
u_char tos:8;
int total_len:16;
int ident:16;
int flags:16;
u_char ttl:8;
u_char proto:8;
int checksum:16;
u_char sourceIP[4];
u_char destIP[4];
}IPHEADER;
//协议映射表
char *Proto[]={
"Reserved","ICMP","IGMP","GGP","IP","ST","TCP"
};
//回调函数
void pcap_handle(u_char* user,const struct pcap_pkthdr* header,const u_char* pkt_data)
{
ETHHEADER *eth_header=(ETHHEADER*)pkt_data;
printf("---------------Begin Analysis-----------------\n");
printf("----------------------------------------------\n");
printf("Packet length: %d \n",header->len);
//解析数据包IP头部
if(header->len>=14){
IPHEADER *ip_header=(IPHEADER*)(pkt_data+14);
//解析协议类型
char strType[100];
if(ip_header->proto>7)
strcpy(strType,"IP/UNKNWN");
else
strcpy(strType,Proto[ip_header->proto]);
printf("Source MAC : %02X-%02X-%02X-%02X-%02X-%02X==>",eth_header->SrcMac[0],eth_header->SrcMac[1],eth_header->SrcMac[2],eth_header->SrcMac[3],eth_header->SrcMac[4],eth_header->SrcMac[5]);
printf("Dest MAC : %02X-%02X-%02X-%02X-%02X-%02X\n",eth_header->DestMac[0],eth_header->DestMac[1],eth_header->DestMac[2],eth_header->DestMac[3],eth_header->DestMac[4],eth_header->DestMac[5]);
printf("Source IP : %d.%d.%d.%d==>",ip_header->sourceIP[0],ip_header->sourceIP[1],ip_header->sourceIP[2],ip_header->sourceIP[3]);
printf("Dest IP : %d.%d.%d.%d\n",ip_header->destIP[0],ip_header->destIP[1],ip_header->destIP[2],ip_header->destIP[3]);
printf("Protocol : %s\n",strType);
//显示数据帧内容
int i;
for(i=0; i<(int)header->len; ++i) {
printf(" %02x", pkt_data[i]);
if( (i + 1) % 16 == 0 )
printf("\n");
}
printf("\n\n");
}
}
int main(int argc, char **argv)
{
char *device="eth0";
char errbuf[1024];
pcap_t *phandle;
bpf_u_int32 ipaddress,ipmask;
struct bpf_program fcode;
int datalink;
if((device=pcap_lookupdev(errbuf))==NULL){
perror(errbuf);
return 1;
}
else
printf("device: %s\n",device);
phandle=pcap_open_live(device,200,0,500,errbuf);
if(phandle==NULL){
perror(errbuf);
return 1;
}
if(pcap_lookupnet(device,&ipaddress,&ipmask,errbuf)==-1){
perror(errbuf);
return 1;
}
else{
char ip[INET_ADDRSTRLEN],mask[INET_ADDRSTRLEN];
if(inet_ntop(AF_INET,&ipaddress,ip,sizeof(ip))==NULL)
perror("inet_ntop error");
else if(inet_ntop(AF_INET,&ipmask,mask,sizeof(mask))==NULL)
perror("inet_ntop error");
printf("IP address: %s, Network Mask: %s\n",ip,mask);
}
int flag=1;
while(flag){
//input the design filter
printf("Input packet Filter: ");
char filterString[1024];
scanf("%s",filterString);
if(pcap_compile(phandle,&fcode,filterString,0,ipmask)==-1)
fprintf(stderr,"pcap_compile: %s,please input again....\n",pcap_geterr(phandle));
else
flag=0;
}
if(pcap_setfilter(phandle,&fcode)==-1){
fprintf(stderr,"pcap_setfilter: %s\n",pcap_geterr(phandle));
return 1;
}
if((datalink=pcap_datalink(phandle))==-1){
fprintf(stderr,"pcap_datalink: %s\n",pcap_geterr(phandle));
return 1;
}
printf("datalink= %d\n",datalink);
pcap_loop(phandle,-1,pcap_handle,NULL);
return 0;
}
4.将捕获的数据包保存为.pcap文件
#include <stdio.h>
#include <pcap.h>
#include <time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
//链路层数据包格式
typedef struct {
u_char DestMac[6];
u_char SrcMac[6];
u_char Etype[2];
}ETHHEADER;
//IP层数据包格式
typedef struct {
int header_len:4;
int version:4;
u_char tos:8;
int total_len:16;
int ident:16;
int flags:16;
u_char ttl:8;
u_char proto:8;
int checksum:16;
u_char sourceIP[4];
u_char destIP[4];
}IPHEADER;
//协议映射表
char *Proto[]={
"Reserved","ICMP","IGMP","GGP","IP","ST","TCP"
};
//回调函数
void pcap_handle(u_char* user,const struct pcap_pkthdr* header,const u_char* pkt_data)
{
pcap_dump(user, header, pkt_data);
ETHHEADER *eth_header=(ETHHEADER*)pkt_data;
printf("---------------Begin Analysis-----------------\n");
printf("----------------------------------------------\n");
printf("Packet length: %d \n",header->len);
//解析数据包IP头部
if(header->len>=14){
IPHEADER *ip_header=(IPHEADER*)(pkt_data+14);
//解析协议类型
char strType[100];
if(ip_header->proto>7)
strcpy(strType,"IP/UNKNWN");
else
strcpy(strType,Proto[ip_header->proto]);
printf("Source MAC : %02X-%02X-%02X-%02X-%02X-%02X==>",eth_header->SrcMac[0],eth_header->SrcMac[1],eth_header->SrcMac[2],eth_header->SrcMac[3],eth_header->SrcMac[4],eth_header->SrcMac[5]);
printf("Dest MAC : %02X-%02X-%02X-%02X-%02X-%02X\n",eth_header->DestMac[0],eth_header->DestMac[1],eth_header->DestMac[2],eth_header->DestMac[3],eth_header->DestMac[4],eth_header->DestMac[5]);
printf("Source IP : %d.%d.%d.%d==>",ip_header->sourceIP[0],ip_header->sourceIP[1],ip_header->sourceIP[2],ip_header->sourceIP[3]);
printf("Dest IP : %d.%d.%d.%d\n",ip_header->destIP[0],ip_header->destIP[1],ip_header->destIP[2],ip_header->destIP[3]);
printf("Protocol : %s\n",strType);
//显示数据帧内容
int i;
for(i=0; i<(int)header->len; ++i) {
printf(" %02x", pkt_data[i]);
if( (i + 1) % 16 == 0 )
printf("\n");
}
printf("\n\n");
}
}
int main(int argc, char **argv)
{
char *device="eth0";
char errbuf[1024];
pcap_t *phandle;
bpf_u_int32 ipaddress,ipmask;
struct bpf_program fcode;
int datalink;
if((device=pcap_lookupdev(errbuf))==NULL){
perror(errbuf);
return 1;
}
else
printf("device: %s\n",device);
phandle=pcap_open_live(device,200,0,500,errbuf);
if(phandle==NULL){
perror(errbuf);
return 1;
}
if(pcap_lookupnet(device,&ipaddress,&ipmask,errbuf)==-1){
perror(errbuf);
return 1;
}
else{
char ip[INET_ADDRSTRLEN],mask[INET_ADDRSTRLEN];
if(inet_ntop(AF_INET,&ipaddress,ip,sizeof(ip))==NULL)
perror("inet_ntop error");
else if(inet_ntop(AF_INET,&ipmask,mask,sizeof(mask))==NULL)
perror("inet_ntop error");
printf("IP address: %s, Network Mask: %s\n",ip,mask);
}
int flag=1;
while(flag){
//input the design filter
printf("Input packet Filter: ");
char filterString[1024];
scanf("%s",filterString);
if(pcap_compile(phandle,&fcode,filterString,0,ipmask)==-1)
fprintf(stderr,"pcap_compile: %s,please input again....\n",pcap_geterr(phandle));
else
flag=0;
}
if(pcap_setfilter(phandle,&fcode)==-1){
fprintf(stderr,"pcap_setfilter: %s\n",pcap_geterr(phandle));
return 1;
}
if((datalink=pcap_datalink(phandle))==-1){
fprintf(stderr,"pcap_datalink: %s\n",pcap_geterr(phandle));
return 1;
}
printf("datalink= %d\n",datalink);
pcap_dumper_t* out_pcap; //创建文件指针
out_pcap = pcap_dump_open(phandle,"../pack.pcap"); //打开用于保存捕获数据包的文件，用于写入
pcap_loop(phandle,3,pcap_handle,(u_char *)out_pcap);
pcap_dump_flush(out_pcap); //将缓冲区内容写到文件
pcap_dump_close(out_pcap);
pcap_close(phandle);
return 0;
}
8653
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
