精华内容
下载资源
问答
  • [](https://www.cnblogs.com/10087622blog/p/8320234.html "") 就以上链接里面提到的redhat对tpacketv3支持有问题,需要关闭tpacketv3,想请教一下各位怎么关闭?是在libpcap源码中屏蔽相关代码吗?
  • 网络开发包 libpcap

    2020-05-25 22:04:28
    Libpcap的主要作用 捕获各种数据包: 例如,网络流量统计。 过滤网络数据包: 例如,过滤掉本地上的一些数据,类似防火墙 分析网络数据包: 例如,分析网络协议,数据的采集 ...关闭网络设备 捕获网

    Libpcap的主要作用

    • 捕获各种数据包: 例如,网络流量统计。
    • 过滤网络数据包: 例如,过滤掉本地上的一些数据,类似防火墙
    • 分析网络数据包: 例如,分析网络协议,数据的采集
    • 存储网络数据包: 例如,保存捕获的数据以为将来进行分析

    Libpcap的安装

    sudo apt-get install libpcap-dev
    

    使用时需要加pcap.h头文件
    编译时需要加-lpcap

    利用libpcap函数库开发应用程序的基本步骤:

    1. 打开网络设备
    2. 设置过滤规则(可选)
    3. 捕获数据
    4. 关闭网络设备

    捕获网络数据包常用函数

    pcap_lookupdev( ) 查看设备名(可选)
    pcap_open_live( ) 打开设备
    pcap_lookupnet( ) 获取的设备IP(可选)
    pcap_compile( )pcap_setfilter( ) 设置过滤规则(可选)
    pcap_next( ) 调用一次捕获一个报文
    pcap_loop( ) 调用一次 不停捕获报文
    pcap_open_live( ) 打开设备,获得设备的句柄
    pcap_close( ) 关闭句柄

    捕获网络数据包常用函数(详细)

    1.打开设备,获取设备的句柄 pcap_open_live()

    pcap_t *pcap_open_live(const char *device,int snaplen,int promisc,int to_ms,char *ebuf)
    功能:
    	打开一个用于捕获数据的网络接口
    返回值:
    	返回一个Libpcap句柄
    参数:
    	device:网络接口的名字
    	snaplen:捕获数据包的长度
    	promise:1代表混杂模式,其它非混杂模式
    	to_ms:等待时间
    	ebuf:存储错误信息
    

    2.关闭句柄 pcap_close()

    void pcap_close(pcap_t *p)
    功能:
        关闭Libpcap操作,并销毁相应的资源
    参数
       p:需要关闭的Libpcap句柄
    返回值:
        无
    

    3.接受报文函数 pcap_next() 调用一次接受一个报文

    const u_char *pcap_next(pcap_t *p,struct pcap_pkthdr *h)
    功能:
    	捕获一个网络数据包
    参数:
        p:Libpcap句柄
        h:数据包头
    返回值:
        捕获的数据包的地址
    

    struct pcap_pkthdr结构体信息:记录接受数据的时间以及报文的长度

    struct pcap_pkthdr {
    	struct timeval ts; // 时间
    	bpf_u_int32 caplen; //部分包长度(基本和len一样)
    	bpf_u_int32 len; // 包的长度
    }
    

    4.循环的接受网络数据pcap_loop

    int pcap_loop(pcap_t *p,int cnt,pcap_handler callback,u_char *user)
    功能:
        循环捕获网络数据包,直到遇到错误或者满足退出条件;
        每次捕获一个数据包就会调用callback指示的回调函数,
        所以,可以在回调函数中进行数据包的处理操作
    返回值:
        成功返回0,失败返回负数
    参数:
        p: Libpcap句柄
        cnt: 指定捕获数据包的个数,如果是-1,就会永无休止的捕获
        callback: 回调函数
        user: 向回调函数中传递的参数
    

    回调函数的定义

    typedef void (*pcap_handler)(u_char *arg, const struct pacp_pkthdr *packet_header, const u_char *packet_content);
    
    void callback(unsigned char * argument, const struct pcap_pkthdr *packet_header, const unsigned char *packet_content)
    参数1:argument存放pcap_loop传递过来的user用户数据
    参数2:packet_header 存放接收到的报文的时间以及长度
    参数3:packet_content接收到的网络帧数据
    

    5.pcap_compile: 将用户识别的规则 转换成 pcap识别的规则

    int pcap_compile(pcap_t *p,struct bpf_program *program, char *buf,int optimize,bpf_u_int32 mask)
    功能:
        编译BPF过滤规则
    返回值:
        成功返回0,失败返回-1
    参数:
        p:Libpcap句柄
        program:bpf过滤规则(pcap识别的规则)
        buf:过滤规则字符串(用户识别的规则  重心)
        optimize:优化
        mask:掩码
    

    6.pcap_setfilter:将pcap识别的规则 设置到pcap结束数据的句柄中

    int pcap_setfilter(pcap *p,struct bpf_program*fp)
    功能:
        设置BPF过滤规则
    返回值:
        成功返回0,失败返回-1
    参数:
        p:Libpcap句柄
        fp:BPF过滤规则
    

    过滤规则:
    过滤规则1过滤规则2过滤规则3过滤规则4

    demo

    案例1: 使用pcap_next获取一次数据

    #include <stdio.h>
    #include <pcap.h>
    
    int main(int argc, char *argv[])
    {
    	//打开网卡"eth0",获取设备句柄
    	pcap_t *pcap_handler = pcap_open_live("eth0", 1500, 0, 0, NULL);
    	
    	//接收数据
    	unsigned char *msg = NULL; // 存放收到的帧数据
    	struct pcap_pkthdr pck_hdr; // 存放收到的数据的时间和报文长度
    	msg = pcap_next(pcap_handler, &pck_hdr);
    	
    	//解析报文
    	printf("报文长度:%u\n", pck_hdr.caplen);
    	unsigned char src_mac[18];//存放源端口的点分mac
    	unsigned char dst_mac[18];//存放目的端口的点分mac
    	sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0],msg[1],msg[2],msg[3],msg[4],msg[5]);
    	sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0+6],msg[1+6],msg[2+6],msg[3+6],msg[4+6],msg[5+6]);
    	printf("%s -- > %s\n", src_mac, dst_mac);
    	
    	//关闭句柄
    	pcap_close(pcap_handler);
    	return 0;
    }
    

    案例2:循环的接受网络数据pcap_loop

    #include <stdio.h>
    #include <pcap.h>
    
    void callback(u_char *arg, const struct pacp_pkthdr *packet_header, const u_char *packet_content)
    {
    	unsigned char *msg = packet_content;
    	unsigned char src_mac[18] = "";
    	unsigned char dst_mac[18] = "";
    	
    	sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0], msg[1], msg[2], msg[3], msg[4], msg[5]);
    	sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0+6],msg[1+6],msg[2+6],msg[3+6],msg[4+6],msg[5+6]);
    	printf("%s -- > %s\n", src_mac, dst_mac);
    }
    int main(int argc, char *argv[])
    {
    	//打开网络接口eth0,获取句柄
    	pcap_t * pcap_handler = pcap_open_live("eth0", 1500, 0, 0, NULL);
    	
    	//循环接受网络数据
    	pcap_loop(pcap_handler, 5, callback, NULL);
    	
    	//关闭句柄
    	pcap_close(pcap_close);
    	
    	return 0;
    }
    

    案例3:设置过滤规则

    #include <stdio.h>
    #include <pcap.h>
    
    void callback(u_char *arg, const struct pacp_pkthdr *packet_header, const u_char *packet_content)
    {
    	unsigned char *msg = packet_content;
    	unsigned char src_mac[18] = "";
    	unsigned char dst_mac[18] = "";
    	
    	sprintf(src_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0], msg[1], msg[2], msg[3], msg[4], msg[5]);
    	sprintf(dst_mac, "%02x:%02x:%02x:%02x:%02x:%02x", msg[0+6],msg[1+6],msg[2+6],msg[3+6],msg[4+6],msg[5+6]);
    	printf("%s -- > %s\n", src_mac, dst_mac);
    }
    int main(int argc, char *argv[])
    {
    	//打开网络接口eth0,获取句柄
    	pcap_t * pcap_handler = pcap_open_live("eth0", 1500, 0, 0, NULL);
    	
    	//设置过滤规则
    	struct bpf_program program;
    	pcap_compile(pcap_handler, &program, "src port 9000", 0, 0xffffff00);
    	pcap_setfilter(pcap_handler, &program);
    	
    	//循环接受网络数据
    	pcap_loop(pcap_handler, 5, callback, NULL);
    	
    	//关闭句柄
    	pcap_close(pcap_close);
    	
    	return 0;
    }
    
    
    展开全文
  • 关闭文件释放资源 libpcap是数据包捕获函数库。该库提供的C函数接口可用于需要捕获经过网络接口数据包的系统开发上。libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。这个库为不同的平台提供了一致的...


    libpcap是数据包捕获函数库。该库提供的C函数接口可用于需要捕获经过网络接口数据包的系统开发上。libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。这个库为不同的平台提供了一致的编程接口,在安装了libpcap的平台上,以libpcap为接口写的程序,能够自由的跨平台使用。

    linux下libpcap的安装:sudo apt-get install libpcap-dev

    linux下gcc编译程序:gcc my_pcap.c -lpcap

    执行程序的时候如果报错:no suitable device found,以管理员权限运行程序即可,sudo ./my_pcap

    libpcap的抓包框架:

    头文件: #include <pcap.h>/usr/local/include/pcap目录下

    1.查找网络设备

    char *pcap_lookupdev(char *errbuf) 
    

    该函数用于返回可被pcap_open_live()或pcap_lookupnet()函数调用的网络设备名(一个字符串指针)。如果函数出错,则返回NULL,同时errbuf中存放相关的错误消息。

    2.获得指定网络设备的网络号和掩码

    int pcap_lookupnet(char *device, bpf_u_int32 *netp, bpf_u_int32 *maskp, char *errbuf) 
    

    netp参数和maskp参数都是bpf_u_int32指针。如果函数出错,则返回-1,同时errbuf中存放相关的错误消息。

    Bpf_u_int32:32位无符号数

    Struct in_addr
    
    {
    
       unsigned long s_addr;
    
    }
    

    inet_ntoa();以a.b.c.d的形式显示地址。

    3.打开网络设备

     pcap_t *pcap_open_live(char *device,  int snaplen,  int promisc, int to_ms, char *ebuf) 
    

    获得用于捕获网络数据包的数据包捕获描述字。device参数为指定打开的网络设备名。snaplen参数定义捕获数据的最大字节数,65535是最大值。promisc指定 是否将网络接口置于混杂模式,设置为1表示混杂模式。to_ms参数指定超时时间(毫秒),设置为0表示超时时间无限大。ebuf参数则仅在pcap_open_live()函数出错返回NULL时用于传递 错误消息。

    typedef struct pcap pcap_t;
    

    pcap结构在libpcap源码的pcap-int.h定义,使用时一般都是使用其指针类型)。

    4.打开已有的网络数据包

    //如果是抓取数据包,这个过程不需要

    pcap_t *pcap_open_offline(char *fname, char *errbuf)
    

    fname参数指定打开的文件名。该文件中的数据格式与tcpdump兼容。errbuf参数则仅在pcap_open_offline()函数出错返回NULL时用于传递错误消息。

    pcap_t *pcap_fopen_offline(FILE *fp, char *errbuf)//打开文件指针。
    
    5.编译和设置过滤条件
    
    int pcap_compile(pcap_t *p, struct bpf_program *fp, char *str,  int optimize, bpf_u_int32 netmask) 
    

    设置过滤条件,举一些例子:

    src host 192.168.1.1:只接收源ip地址是192.168.1.1的数据包
    dst port 80:只接收tcp、udp的目的端口是80的数据包
    not tcp:只接收不使用tcp协议的数据包
    tcp[13] == 0x02 and (dst port 22 or dst port 23) :只接收 SYN 标志位置位且目标端口是 22 或 23 的数据包( tcp 首部开始的第 13 个字节)
    icmp[icmptype] == icmp-echoreply or icmp[icmptype] == icmp-echo:只接收 icmp 的 ping 请求和 ping 响应的数据包
    ehter dst 00:e0:09:c1:0e:82:只接收以太网 mac 地址是 00:e0:09:c1:0e:82 的数据包
    ip[8] == 5:只接收 ip 的 ttl=5 的数据包(ip首部开始的第8个字节)

    将str参数指定的字符串编译到过滤程序中。fp是一个bpf_program结构的指针,在pcap_compile()函数中被赋值。optimize参数控制结果代码的优化。netmask参数指定本地网络的网络掩码,当不知道的时候可以设为0。出错时返回-1.

    int pcap_setfilter(pcap_t *p, struct bpf_program *fp) 
    

    指定一个过滤程序。fp参数是bpf_program结构指针,通常取自pcap_compile()函数调用。出错时返回-1。

    6.抓取和读取数据包
    
    int pcap_dispatch(pcap_t *p, int cnt, pcap_handler callback,  u_char *user) 
    

    捕获并处理数据包。cnt参数指定函数返回前所处理数据包的最大值。cnt=-1表示在一个缓冲区中处理所有的数据包。callback参数指定一个带有三个参数的回调函数,这三个参数为:一个从 pcap_dispatch()函数传递过来的u_char指针,一个pcap_pkthdr结构的指针,和指向caplen大小的数据包的u_char指针。

    struct pcap_pkthdr { 
    
         struct tim ts;   // ts是一个结构struct timeval,它有两个部分,第一部分是1900开始以来的秒数,第二部分是当前秒之后的毫秒数
    
         bpf_u_int32 caplen;    //表示抓到的数据长度
    
         bpf_u_int32 len;    //表示数据包的实际长度
    
    }; 
    

    user参数是留给用户使用的,当callback被调用的时候这个值会传递给callback的第一个参数(也叫user)。

    成功 则返回读到的数据包数。返回0没有抓到数据包。出错时则返回-1,此时可调用pcap_perror()pcap_geterr()函数获取错误消息。返回-2表示调用了pcap_breakloop().

    int pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user)  
    

    功能基本与pcap_dispatch()函数类似,只不过此函数在cnt个数据包被处理或出现错误时才返回,但读取超时不会返回。

    u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)  
    

    读取下一个数据包,类似于pcap_dispatch()中cnt参数设为1,返回指向读到的数据包的指针,但是不返回这个包的pcap_pkthdr结构的参数。

    7.关闭文件释放资源

    void pcap_close(pcap_t *p)
    

    关闭P指针。

      #include <stdio.h>
      #include <stdlib.h>
      #include <pcap.h>
       
      #define PCAP_DATABUF_MAX 65535
      
      #define ETHERTYPE_IPV4 0x0800
      #define ETHERTYPE_IPV6 0x86DD
      
      typedef unsigned char   u_int8;
      typedef unsigned short  u_int16;
      typedef unsigned int    u_int32;
      typedef unsigned long   u_int64;
      
      /*MAC头,总长度14字节 */
      typedef struct _eth_hdr{
          u_int8 dst_mac[6];
          u_int8 src_mac[6];
          u_int16 eth_type;
      }eth_hdr;
      eth_hdr *ethernet;
      
      /*IP头*/
      typedef struct _ip_hdr{
          u_int8 ver_hl;    //版本和头长
          u_int8 serv_type; //服务类型
          u_int16 pkt_len;  //包总长
          u_int16 re_mark;  //重组标志
          u_int16 flag_seg; //标志位和段偏移量
          u_int8 surv_tm;    //生存时间
          u_int8 protocol;  //协议码(判断传输层是哪一个协议)
          u_int16 h_check;  //头检验和
          u_int32 src_ip;   //源ip
          u_int32 dst_ip;   //目的ip
          u_int32 option;   //可选选项
      }ip_hdr;
      ip_hdr *ip;
      
      /*TCP头,总长度20字节,不包括可选选项*/
      typedef struct _tcp_hdr{
          u_int16 sport;     //源端口
          u_int16 dport;     //目的端口
          u_int32 seq;       //序列号
          u_int32 ack;       //确认序号
          u_int8  head_len;  //头长度
          u_int8  flags;     //保留和标记位
          u_int16 wind_size; //窗口大小
          u_int16 check_sum; //校验和
          u_int16 urgent_p;  //紧急指针
      }tcp_hdr;
      tcp_hdr *tcp;
      
      /*UDP头,总长度8个字节*/
      typedef struct _udp_hdr{
          u_int16 sport;     //源端口
          u_int16 dport;     //目的端口
          u_int16 pktlen;    //UDP头和数据的总长度
          u_int16 check_sum; //校验和
      }udp_hdr;
      udp_hdr *udp;
      
      //ip整型转换点分十进制
      char *InttoIpv4str(u_int32 num){
          char* ipstr = (char*)calloc(128, sizeof(char*)); 
        
          if (ipstr)
              sprintf(ipstr, "%d.%d.%d.%d", num >> 24 & 255, num >> 16 & 255, num >> 8 & 255, num & 255);
          else
              printf("failed to Allocate memory...");
          
          return ipstr;
      }
      
      void pcap_callback(u_char *useless,const struct pcap_pkthdr *pkthdr, const u_char *packet)
      {
          printf("data len:%u\n", pkthdr->caplen); //抓到时的数据长度
          printf("packet size:%u\n", pkthdr->len); //数据包实际的长度
      
       /*解析数据链路层 以太网头*/
          ethernet = (struct _eth_hdr*)packet;
          u_int64 src_mac = ntohs( ethernet->src_mac );
          u_int64 dst_mac = ntohs( ethernet->dst_mac );
         
          printf("src_mac:%lu\n",src_mac);
          printf("dst_mac:%lu\n",dst_mac);
          printf("eth_type:%u\n",ethernet->eth_type);
          
          u_int32 eth_len = sizeof(struct _eth_hdr);  //以太网头的长度
          u_int32 ip_len; //ip头的长度
          u_int32 tcp_len = sizeof(struct _tcp_hdr);  //tcp头的长度
          u_int32 udp_len = sizeof(struct _udp_hdr);  //udp头的长度
          
       /*解析网络层  IP头*/
          if(ntohs(ethernet->eth_type) == ETHERTYPE_IPV4){  //IPV4
              printf("It's IPv4!\n");
              
          ip = (struct _ip_hdr*)(packet + eth_len);
          ip_len = (ip->ver_hl & 0x0f)*4;            //ip头的长度
          u_int32 saddr = (u_int32)ntohl(ip->src_ip); //网络字节序转换成主机字节序
          u_int32 daddr = (u_int32)ntohl(ip->dst_ip);
             
          printf("eth_len:%u  ip_len:%u  tcp_len:%u  udp_len:%u\n", eth_len, ip_len, tcp_len, udp_len);
             
          printf("src_ip:%s\n", InttoIpv4str(saddr));  //源IP地址
          printf("dst_ip:%s\n", InttoIpv4str(daddr));  //目的IP地址
             
          printf("ip->proto:%u\n", ip->protocol);      //传输层用的哪一个协议
             
       /*解析传输层  TCP、UDP、ICMP*/
             if(ip->protocol == 6){         //TCP
                 tcp = (struct _tcp_hdr*)(packet + eth_len + ip_len);
                 printf("tcp_sport = %u\n", tcp->sport);
                 printf("tcp_dport = %u\n", tcp->dport);
                 
     /**********(pcaket + eth_len + ip_len + tcp_len)就是TCP协议传输的正文数据了***********/
     
             }else if(ip->protocol == 17){  //UDP
                 udp = (struct _udp_hdr*)(packet + eth_len + ip_len);
                 printf("udp_sport = %u\n", udp->sport);
                 printf("udp_dport = %u\n", udp->dport);
                 
     /**********(pcaket + eth_len + ip_len + udp_len)就是UDP协议传输的正文数据了***********/
                 
             }else if(ip->protocol == 1){   //ICMP
                 
             }
             
           }else if(ntohs(ethernet->eth_type) == ETHERTYPE_IPV6){ //IPV6
             printf("It's IPv6!\n");
         }
         
         printf("============================================\n");
     }
     
     int main()
     {
         char *dev;  //设备名
         char errbuf[PCAP_ERRBUF_SIZE] = {}; //PCAP_ERRBUF_SIZE在pcap.h中已经定义
         bpf_u_int32 netp, maskp;  //网络号和掩码
         pcap_t *handler;          //数据包捕获描述字
         struct bpf_program *fp;   
         char *filter_str = "port 9000";  //过滤条件
         
       /*Find network devices*/
         if((dev = pcap_lookupdev(errbuf)) == NULL){
             printf("lookupdev failed:%s\n", errbuf);
             exit(1);
         }else{
             printf("Device:%s\n", dev);
         }
         
       /*Get the network number and mask of the network device*/
         if(pcap_lookupnet(dev, &netp, &maskp, errbuf) == -1){
             printf("%s\n", errbuf);
             exit(1);
         }
         
       /*Open network device*/
         if((handler = pcap_open_live(dev, PCAP_DATABUF_MAX, 1, 0, errbuf)) == NULL){
             printf("%s\n", errbuf);
             exit(1);
         }
         
       /*Compiling and setting filtering conditions*/
         if(pcap_compile(handler, fp, filter_str, 0, maskp) == -1){
             printf("pcap_compile error...\n");
             exit(1);
         }
         if(pcap_setfilter(handler, fp) == -1){
             printf("pcap_setfilter error...\n");
             exit(1);
         }
         
       /*Capturing and processing data packets*/
         if(pcap_loop(handler, -1, pcap_callback, NULL) == -1){
             printf("pcap_loop error...\n");
             pcap_close(handler);
         }
         
       return 0;    
     }   
    
    展开全文
  • libpcap/winpcap相关

    2014-03-28 15:41:00
    深度剖析WinPcap之(八)——打开与关闭适配器(4) http://wenku.baidu.com/link?url=W3lRRku_af2A1K9CRN_YFQnOFCwnUQn0xUdv0lrPQAPSEnv3wexHoasu8WQcMpzBLdLkA6NiZVCKsW7ZzCXmvh3OeT1w2LOINqwY7nlp1XG Linux下...

    深度剖析WinPcap之(八)——打开与关闭适配器(4)

    http://wenku.baidu.com/link?url=W3lRRku_af2A1K9CRN_YFQnOFCwnUQn0xUdv0lrPQAPSEnv3wexHoasu8WQcMpzBLdLkA6NiZVCKsW7ZzCXmvh3OeT1w2LOINqwY7nlp1XG

     

    Linux下Libpcap源码分析和包过滤机制

    libpcap是unix/linux平台下的网络数据包捕获函数包,大多数网络监控软件都以它为基础。Libpcap可以在绝大多数类unix平台下工作,本文分析了libpcap在linux 下的源代码实现,其中重点是linux的底层包捕获机制和过滤器设置方式,同时也简要的讨论了 libpcap使用的包过滤机制 BPF。
      
      网络监控
      
       绝大多数的现代操作系统都提供了对底层网络数据包捕获的机制,在捕获机制之上可以建立网络监控(Network Monitoring)应用软件。网络监控也常简称为sniffer,其最初的目的在于对网络通信情况进行监控,以对网络的一些异常情况进行调试处理。但 随着互连网的快速普及和网络攻击行为的频繁出现,保护网络的运行安全也成为监控软件的另一个重要目的。例如,网络监控在路由器,防火墙、入侵检查等方面使用也很广泛。除此而外,它也是一种比较有效的黑客手段,例如,美国政府安全部门的"肉食动物"计划。
      
      包捕获机制
      
      从广义的角度上看,一个包捕获机制包含三个主要部分:最底层是针对特定操作系统的包捕获机制,最高层是针对用户程序的接口,第三部分是包过滤机制。
      
       不同的操作系统实现的底层包捕获机制可能是不一样的,但从形式上看大同小异。数据包常规的传输路径依次为网卡、设备驱动层、数据链路层、IP层、传输 层、最后到达应用程序。而包捕获机制是在数据链路层增加一个旁路处理,对发送和接收到的数据包做过滤/缓冲等相关处理,最后直接传递到应用程序。值得注意 的是,包捕获机制并不影响操作系统对数据包的网络栈处理。对用户程序而言,包捕获机制提供了一个统一的接口,使用户程序只需要简单的调用若干函数就能获得 所期望的数据包。这样一来,针对特定操作系统的捕获机制对用户透明,使用户程序有比较好的可移植性。包过滤机制是对所捕获到的数据包根据用户的要求进行筛 选,最终只把满足过滤条件的数据包传递给用户程序。
      
      Libpcap应用程序框架
      
       Libpcap提供了系统独立的用户级别网络数据包捕获接口,并充分考虑到应用程序的可移植性。Libpcap可以在绝大多数类unix平台下工作,参考 资料 A 中是对基于 libpcap 的网络应用程序的一个详细列表。在windows平台下,一个与libpcap 很类似的函数包 winpcap 提供捕获功能,其官方网站是http://winpcap.polito.it/。
      
      Libpcap 软件包可从 http://www.tcpdump.org/ 下载,然后依此执行下列三条命令即可安装,但如果希望libpcap能在linux上正常工作,则必须使内核支持"packet"协议,也即在编译内核时打开配置选项 CONFIG_PACKET(选项缺省为打开)。
      
      ./configure
      ./make
      ./make install
      
       libpcap源代码由20多个C文件构成,但在Linux系统下并不是所有文件都用到。可以通过查看命令make的输出了解实际所用的文件。本文所针 对的libpcap版本号为0.8.3,网络类型为常规以太网。Libpcap应用程序从形式上看很简单,下面是一个简单的程序框架:
      
      char * device; /* 用来捕获数据包的网络接口的名称 */
      pcap_t * p; /* 捕获数据包句柄,最重要的数据结构 */
      struct bpf_program fcode; /* BPF 过滤代码结构 */
      
      /* 第一步:查找可以捕获数据包的设备 */
      device = pcap_lookupdev(errbuf);
      
      /* 第二步:创建捕获句柄,准备进行捕获 */
      p = pcap_open_live(device, 8000, 1, 500, errbuf);
      
      /* 第三步:如果用户设置了过滤条件,则编译和安装过滤代码 */
      pcap_compile(p, &fcode, filter_string, 0, netmask);
      pcap_setfilter(p, &fcode);
      
      /* 第四步:进入(死)循环,反复捕获数据包 */
      for( ; ; )
      {
      while((ptr = (char *)(pcap_next(p, &hdr))) == NULL);
      
      /* 第五步:对捕获的数据进行类型转换,转化成以太数据包类型 */
      eth = (struct libnet_ethernet_hdr *)ptr;
      
      /* 第六步:对以太头部进行分析,判断所包含的数据包类型,做进一步的处理 */
      if(eth->ether_type == ntohs(ETHERTYPE_IP))
      …………
      if(eth->ether_type == ntohs(ETHERTYPE_ARP))
      …………
      }
      
      /* 最后一步:关闭捕获句柄,一个简单技巧是在程序初始化时增加信号处理函数,
      以便在程序退出前执行本条代码 */
      pcap_close(p);
      
      检查网络设备
      
      libpcap 程序的第一步通常是在系统中找到合适的网络接口设备。网络接口在Linux网络体系中是一个很重要的概念,它是对具体网络硬件设备的一个抽象,在它的下面是具体的网卡驱动程序,而其上则是网络协议层。 Linux中最常见的接口设备名eth0和lo。Lo 称为回路设备,是一种逻辑意义上的设备,其主要目的是为了调试网络程序之间的通讯功能。eth0对应了实际的物理网卡,在真实网络环境下,数据包的发送和 接收都要通过 eht0。如果计算机有多个网卡,则还可以有更多的网络接口,如eth1,eth2 等等。调用命令ifconfig可以列出当前所有活跃的接口及相关信息,注意对eth0的描述中既有物理网卡的MAC地址,也有网络协议的IP地址。查看文件/proc/net/dev也可获得接口信息。
      
      Libpcap中检查网络设备中主要使用到的函数关系如下图:
      


       libpcap调用pcap_lookupdev()函数获得可用网络接口的设备名。首先利用函数 getifaddrs() 获得所有网络接口的地址,以及对应的网络掩码、广播地址、目标地址等相关信息,再利用 add_addr_to_iflist()、add_or_find_if()、get_instance() 把网络接口的信息增加到结构链表 pcap_if 中,最后从链表中提取第一个接口作为捕获设备。其中 get_instanced()的功能是从设备名开始,找第一个是数字的字符,做为接口的实例号。网络接口的设备号越小,则排在链表的越前面,因此,通常 函数最后返回的设备名为 eth0。虽然 libpcap 可以工作在回路接口上,但显然 libpcap 开发者认为捕获本机进程之间的数据包没有多大意义。在检查网络设备操作中,主要用到的数据结构和代码如下:
      
       /* libpcap 自定义的接口信息链表 [pcap.h] */
      struct pcap_if
      {
      struct pcap_if *next;
      char *name; /* 接口设备名 */
      char *description; /* 接口描述 */
      
      /*接口的 IP 地址, 地址掩码, 广播地址,目的地址 */
      struct pcap_addr addresses;
      bpf_u_int32 flags; /* 接口的参数 */
      };
      
      char * pcap_lookupdev(register char * errbuf)
      {
       pcap_if_t *alldevs;
       ……
       pcap_findalldevs(&alldevs, errbuf);
       ……
       strlcpy(device, alldevs->name, sizeof(device));
       }
      
      
      打开网络设备
      
      当设备找到后,下一步工作就是打开设备以准备捕获数据包。Libpcap的包捕获是建立在具体的操作系统所提供的捕获机制上,而Linux系统随着版本的不同,所支持的捕获机制也有所不同。
      
       2.0 及以前的内核版本使用一个特殊的socket类型SOCK_PACKET,调用形式是socket(PF_INET, SOCK_PACKET, int protocol),但 Linux 内核开发者明确指出这种方式已过时。Linux 在 2.2及以后的版本中提供了一种新的协议簇 PF_PACKET 来实现捕获机制。PF_PACKET 的调用形式为 socket(PF_PACKET, int socket_type, int protocol),其中socket类型可以是 SOCK_RAW和SOCK_DGRAM。SOCK_RAW 类型使得数据包从数据链路层取得后,不做任何修改直接传递给用户程序,而 SOCK_DRRAM 则要对数据包进行加工(cooked),把数据包的数据链路层头部去掉,而使用一个通用结构 sockaddr_ll 来保存链路信息。
      
      使用 2.0 版本内核捕获数据包存在多个问题:首先,SOCK_PACKET 方式使用结构 sockaddr_pkt来保存数据链路层信息,但该结构缺乏包类型信息;其次,如果参数 MSG_TRUNC 传递给读包函数 recvmsg()、recv()、recvfrom() 等,则函数返回的数据包长度是实际读到的包数据长度,而不是数据包真正的长度。Libpcap 的开发者在源代码中明确建议不使用 2.0 版本进行捕获。
      
      相对2.0版本SOCK_PACKET方式,2.2版本的 PF_PACKET方式则不存在上述两个问题。在实际应用中,用户程序显然希望直接得到"原始"的数据包,因此使用 SOCK_RAW 类型最好。但在下面两种情况下,libpcap 不得不使用SOCK_DGRAM类型,从而也必须为数据包合成一个"伪"链路层头部(sockaddr_ll)。
      
      某些类型的设备数据链路层头部不可用:例如 Linux 内核的 PPP 协议实现代码对 PPP 数据包头部的支持不可靠。
      
      在捕获设备为"any"时:所有设备意味着libpcap对所有接口进行捕获,为了使包过滤机制能在所有类型的数据包上正常工作,要求所有的数据包有相同的数据链路头部。
      
       打开网络设备的主函数是 pcap_open_live()[pcap-linux.c],其任务就是通过给定的接口设备名,获得一个捕获句柄:结构 pcap_t。pcap_t 是大多数libpcap函数都要用到的参数,其中最重要的属性则是上面讨论到的三种 socket方式中的某一种。首先我们看看pcap_t的具体构成。
      
      struct pcap [pcap-int.h]
      {
       int fd; /* 文件描述字,实际就是 socket */
      
       /* 在 socket 上,可以使用 select() 和 poll() 等 I/O 复用类型函数 */
       int selectable_fd;
      
       int snapshot; /* 用户期望的捕获数据包最大长度 */
       int linktype; /* 设备类型 */
       int tzoff; /* 时区位置。。。。。

     

    基于 linux 平台的 libpcap 源代码分析

    https://www.ibm.com/developerworks/cn/linux/l-libpcap/

     

    转载于:https://www.cnblogs.com/pengzheng/p/3630826.html

    展开全文
  • 何谓libnet、libpcap

    千次阅读 2011-05-09 17:02:00
    为了简化网络安全程序的编写过程,提高网络安全程序的性能和健壮性,同时使代码更易重用与移植,最好的方法就是将最常用和最繁复的过程函数,如监听套接口的打开/关闭、数据包截获、数据包构造/发送/接收等,封装...

    目前众多的网络安全程序、工具和软件都是基于socket设计和开发的。由于在安全程序中通常需要对网络通讯的细节(如连接双方地址/端口、服务类型、传输控制等)进行检查、处理或控制,象数据包截获、数据包头分析、数据包重写、甚至截断连接等,都几乎在每个网络安全程序中必须实现。为了简化网络安全程序的编写过程,提高网络安全程序的性能和健壮性,同时使代码更易重用与移植,最好的方法就是将最常用和最繁复的过程函数,如监听套接口的打开/关闭、数据包截获、数据包构造/发送/接收等,封装起来,以API library的方式提供给开发人员使用。

    在众多的API library中,对于类Unix系统平台上的网络安全工具开发而言,目前最为流行的C API library有libnet、libpcap、libnids和libicmp等。它们分别从不同层次和角度提供了不同的功能函数。使网络开发人员能够忽略网络底层细节的实现,从而专注于程序本身具体功能的设计与开发。其中,

    libnet提供的接口函数主要实现和封装了数据包的构造和发送过程。

    libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。

    利用这些C函数库的接口,网络安全工具开发人员可以很方便地编写出具有结构化强、健壮性好、可移植性高等特点的程序。因此,这些函数库在网络安全工具的开发中具有很大的价值,在scanner、sniffer、firewall、IDS等领域都获得了极其广泛的应用,著名的tcpdump软件、ethereal软件等就是在libpcap的基础上开发的。

    另外也应该指出:由于其功能强大,这些函数库也被黑客用来构造TCP/IP网络程序对目标主机进行攻击。然而,TCP/IP网络的安全不可能也不应该建立在禁止大家使用工具的基础上,一个理想的网络,首先必须是一个开放的网络,这个网络应该在使用任何工具的情况下都是安全的和健壮的。从这点考虑,这些工具的使用,对促进现有网络系统的不断完善是大有裨益的。

     




    libnet函数库框架和使用

    libnet是一个小型的接口函数库,主要用C语言写成,提供了低层网络数据报的构造、处理和发送功能。libnet的开发目的是:建立一个简单统一的网络编程接口以屏蔽不同操作系统低层网络编程的差别,使得程序员将精力集中在解决关键问题上。他的主要特点是:

    高层接口:libnet主要用C语言写成

    可移植性:libnet目前可以在Linux、FreeBSD、Solaris、WindowsNT等操作系统上运行,并且提供了统一的接口

    数据报构造:libnet提供了一系列的TCP/IP数据报文的构造函数以方便用户使用

    数据报的处理:libnet提供了一系列的辅助函数,利用这些辅助函数,帮助用户简化那些烦琐的事务性的编程工作

    数据报发送:libnet允许用户在两种不同的数据报发送方法中选择。

    另外libnet允许程序获得对数据报的绝对的控制,其中一些是传统的网络程序接口所不提供的。这也是libnet的魅力之一。

    libnet支持TCP/IP协议族中的多种协议,比如其上一个版本libnet1.0支持了10种协议,一些新的协议,比如对IPV6的支持还在开发之中。

    libnet目前最新的版本是1.1版本,在该版本中,作者将这些函数做了进一步的封装,用户的使用步骤也得到了进一步的简化。内存的初始化、管理、释放等以及校验和的计算等函数,在默认情况下,都无须用户直接干预,使得libnet的使用更为方便。作者还提供了基于老版本的应用程序移植到新版本上的方法指导。利用libnet1.1函数库开发应用程序的基本步骤以及几个关键的函数使用方法简介如下:

    1. 初始化
      libnet_t *libnet_init(int injection_type, char *device, char *err_buf); 

      该函数初始化libnet函数库,返回一个libnet_t类型的描述符,以备随后的构造数据报和发送数据报的函数中使用。injection_type指明了发送数据报使用的接口类型,如数据链路层或者原始套接字等。Device是一个网络设备名称的字符串,在Linux下是"eth0"等。如果函数错误,返回NULL,而err_buf字符串中将携带有错误的原因。

    2. 数据报的构造

      libnet提供了丰富的数据报的构造函数,可以构造TCP/IP协议族中大多数协议的报文,还提供了一些对某些参数取默认数值的更简练的构造函数供用户选择。比如libnet_autobuild_ipv4()等。

    3. 数据报的发送
      int libnet_write(libnet_t *l); 

      该函数将l中描述的数据报发送的网络上。成功将返回发送的字节数,如果失败,返回-1。你可以调用libnet_geterror()得到错误的原因

    4. 退出
      void libnet_destroy(libnet_t *l); 

     




    libpcap函数库框架和使用

    libpcap的英文意思是 Packet Capture library,即数据包捕获函数库。该库提供的C函数接口可用于需要捕获经过网络接口(通过将网卡设置为混杂模式,可以捕获所有经过该接口的数据报,目标地址不一定为本机)数据包的系统开发上。著名的TCPDUMP就是在libpcap的基础上开发而成的。libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。这个库为不同的平台提供了一致的编程接口,在安装了libpcap的平台上,以libpcap为接口写的程序,能够自由的跨平台使用。在Linux系统下,libpcap可以使用BPF(Berkeley Packet Filter)分组捕获机制来获得很高的性能。

    利用libpcap函数库开发应用程序的基本步骤以及几个关键的函数使用方法简介如下:


    1. char *pcap_lookupdev(char *errbuf) 

      该函数用于返回可被pcap_open_live()或pcap_lookupnet()函数调用的网络设备名(一个字符串指针)。如果函数出错,则返回NULL,同时errbuf中存放相关的错误消息。


    2. int pcap_lookupnet(char *device, bpf_u_int32 *netp,bpf_u_int32 *maskp, char *errbuf) 

      获得指定网络设备的网络号和掩码。netp参数和maskp参数都是bpf_u_int32指针。如果函数出错,则返回-1,同时errbuf中存放相关的错误消息。

    3. 打开设备
      pcap_t *pcap_open_live(char *device, int snaplen,int promisc, int to_ms,char *ebuf) 

      获得用于捕获网络数据包的数据包捕获描述字。device参数为指定打开的网络设备名。snaplen参数定义捕获数据的最大字节数。promisc指定是否将网络接口置于混杂模式。to_ms参数指定超时时间(毫秒)。ebuf参数则仅在pcap_open_live()函数出错返回NULL时用于传递错误消息。

    4. 编译和设置过滤器
      int pcap_compile(pcap_t *p, struct bpf_program *fp,char *str, int optimize, bpf_u_int32 netmask) 

      将str参数指定的字符串编译到过滤程序中。fp是一个bpf_program结构的指针,在pcap_compile()函数中被赋值。optimize参数控制结果代码的优化。netmask参数指定本地网络的网络掩码。

      int pcap_setfilter(pcap_t *p, struct bpf_program *fp)  

      指定一个过滤程序。fp参数是bpf_program结构指针,通常取自pcap_compile()函数调用。出错时返回-1;成功时返回0。抓取下一个数据包

    5. 抓取数据包
      int pcap_dispatch(pcap_t *p, int cnt,pcap_handler callback, u_char *user) 

      捕获并处理数据包。cnt参数指定函数返回前所处理数据包的最大值。cnt=-1表示在一个缓冲区中处理所有的数据包。cnt=0表示处理所有数据包,直到产生以下错误之一:读取到EOF;超时读取。callback参数指定一个带有三个参数的回调函数,这三个参数为:一个从pcap_dispatch()函数传递过来的u_char指针,一个pcap_pkthdr结构的指针,和一个数据包大小的u_char指针。如果成功则返回读取到的字节数。读取到EOF时则返回零值。出错时则返回-1,此时可调用pcap_perror()或pcap_geterr()函数获取错误消息。

      int pcap_loop(pcap_t *p, int cnt, pcap_handler callback, u_char *user)  

      功能基本与pcap_dispatch()函数相同,只不过此函数在cnt个数据包被处理或出现错误时才返回,但读取超时不会返回。而如果为pcap_open_live()函数指定了一个非零值的超时设置,然后调用pcap_dispatch()函数,则当超时发生时pcap_dispatch()函数会返回。cnt参数为负值时pcap_loop()函数将始终循环运行,除非出现错误。

      u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h)  

      返回指向下一个数据包的u_char指针。


    6. void pcap_close(pcap_t *p) 

      关闭p参数相应的文件,并释放资源。

    7. 其他的辅助函数
      FILE *pcap_file(pcap_t *p) 

      返回被打开文件的文件名。

      int pcap_fileno(pcap_t *p) 

      返回被打开文件的文件描述字号码。

     



    综合使用libnet和libpcap:ARP例程

    综合使用libnet和libpcap可以构造强有力的网络分析、诊断、和应用程序。一个具有普遍意义的综合使用libnet和libpcap的程序的原理框架如图1所示:

    本节给出一个综合应用libnet和libpcap的简单例程,其功能是在接收到一个来自特定主机的ARP请求报文之后,发出ARP回应报文,通知该主机请求的IP地址对应的MAC地址。这个程序实现了标准的ARP协议,但是却不同于操作系统内核中标准的实现方法:该程序利用了libpcap在数据链路层抓包,利用了libnet向数据链路层发包,是使用libnet和libpcap构造TCP/IP协议软件的一个例程。该程序很简单,但已经可以说明libnet和libpcap的综合使用方法:

    /* tell destination host with ip 'dstip' that the host with request ip 'srcip' is with mac address srcmac
    * author: white cpf  2003.5.15.
    * compile: gcc arp.c -lnet -lpcap -o arp
    */

    #include "/usr/include/libnet.h"
    #include
    void usage(char * exename){
    printf(" tell dstip with dstmac that srcip is at srcmac. /n");
    printf(" usage: %s -d dstip -s srcip -D dstmac -S srcmac /n",exename);
    return ;
    }
    //程序输入:来自命令行参数
    u_char ip_src[4],ip_dst[4];
    u_char enet_src[6],enet_dst[6];
    extern int mac_strtochar6(u_char * enet,char * macstr);//将字符串格式的MAC地址转换为6字节类型r
    int get_cmdline(int argc,char *argv[]);//命令行参数处理函数
    int main(int argc, char *argv[]){
        libnet_t *l;
        libnet_ptag_t t;
        u_char *packet;
        u_long packet_s;
        char device[5]="eth0";
        char errbuf[LIBNET_ERRBUF_SIZE];
        char filter_str[100]="";
        struct bpf_program fp;      /* hold compiled program     */
        char *dev;
        pcap_t* descr;
        struct pcap_pkthdr hdr;     /* pcap.h    */
        u_char * packet;
        bpf_u_int32 maskp;          /* subnet mask               */
        bpf_u_int32 netp;           /* ip                        */
        int promisc=0;              /* set to promisc mode? */
        int pcap_time_out=5;
        int c, ret;
        u_long i;
        if(get_cmdline(argc,argv)<=0){
    usage(argv[0]);
    exit(0);
        }
      
    dev = pcap_lookupdev(errbuf);
    if(dev == NULL){
        fprintf(stderr,"%s/n",errbuf);
        return -1;
        }
        ret=pcap_lookupnet(dev,&netp,&maskp,errbuf);
    if(ret==-1){
        fprintf(stderr,"%s/n",errbuf);
        return -1;
    }
    descr = pcap_open_live(dev,BUFSIZ,promisc,pcap_time_out,errbuf);
        if(descr == NULL){
        printf("pcap_open_live(): %s/n",errbuf);
        return -1;
        }
    sprintf(filter_str,"arp and (src net %d.%d.%d.%d)",ip_dst[0],ip_dst[1],ip_dst[2],ip_dst[3]);
    if(pcap_compile(descr,&fp,filter_str,0,netp) == -1){
    printf("Error calling pcap_compile/n");
    return -1;
    }
        if(pcap_setfilter(descr,&fp) == -1){
        printf("Error setting filter/n");
        return -1;
        }
    while(1){
    printf("wait packet:filter:%s/n",filter_str);
    packet=pcap_next(descr, &hdr);
    if(packet == NULL){
        continue;
    }
        l = libnet_init(LIBNET_LINK_ADV,device,errbuf);
        if (l == NULL){
            fprintf(stderr, "libnet_init() failed: %s", errbuf);
            exit(EXIT_FAILURE);
        }
        t = libnet_build_arp(
                ARPHRD_ETHER,                           /* hardware addr */
                ETHERTYPE_IP,                           /* protocol addr */
                6,                                      /* hardware addr size */
                4,                                      /* protocol addr size */
                ARPOP_REPLY,                            /* operation type */
                enet_src,                               /* sender hardware addr */
                ip_src,                           /* sender protocol addr */
                enet_dst,                               /* target hardware addr */
                ip_dst,                           /* target protocol addr */
                NULL,                                   /* payload */
                0,                                      /* payload size */
                l,                                      /* libnet handle */
                0);                                     /* libnet id */
        if (t == -1){
            fprintf(stderr, "Can't build ARP header: %s/n", libnet_geterror(l));
            goto bad;
        }
        t = libnet_autobuild_ethernet(
                enet_dst,                               /* ethernet destination */
                ETHERTYPE_ARP,                          /* protocol type */
                l);                                     /* libnet handle */
        if (t == -1){
            fprintf(stderr, "Can't build ethernet header: %s/n", libnet_geterror(l));
            goto bad;
        }
        c = libnet_adv_cull_packet(l, &packet, &packet_s);
        if (c == -1){
            fprintf(stderr, "libnet_adv_cull_packet: %s/n", libnet_geterror(l));
            goto bad;
        }
        c = libnet_write(l);
        if (c == -1){
            fprintf(stderr, "Write error: %s/n", libnet_geterror(l));
            goto bad;
        }
        continue;
    bad:
        libnet_destroy(l);
        return (EXIT_FAILURE);
    }
        libnet_destroy(l);
        return (EXIT_FAILURE);
    }
    int get_cmdline(int argc,char *argv[]){
    char c;
    char string[]="d:s:D:S:h";
        while((c = getopt(argc, argv, string)) != EOF){
            if(c=='d')
                *((unsigned int*)ip_dst)=(unsigned int)inet_addr(optarg);
            else if(c== 's')
                *((unsigned int*)ip_src)=(unsigned int)inet_addr(optarg);
            else if(c=='D')
                mac_strtochar6(enet_dst,optarg);
            else if(c=='S')
                mac_strtochar6(enet_dst,optarg);
            else if(c=='h')
                return 0;
            else
                return -1;
        }
    return 1;
    }

    展开全文
  • Linux查看流量情况以及关闭流量端口

    千次阅读 2019-07-29 09:22:30
    为什么每次在阿里云上面购买的云服务器老是被攻击?博主们有好的解决办法吗 ? 先说下怎么查看服务器是否被攻击了 iftop是一个实时流量监控工具,可以用来监控所有经过网卡的实时...# yum install libpcap-devel...
  • 0x00 准备工作 CentOS 6.2我是最小化安装,同时使用163的...[root@root ~]$ sudo yum install gcc make pcre pcre-devel libpcap libpcap-devel 同时需要关闭iptables、ip6tables: [root@root ~]$ sudo ser
  • mongodb 编译安装

    2018-02-27 09:20:59
    # 关闭seliinux setenforce 0 # 安装支持包 centos7 yum install cyrus-sasl cyrus-sasl-gssapi cyrus-sasl-plain krb5-libs libcurl libpcap lm_sensors-libs net-snmp net-snmp-agent-libs open...
  • Snort 2.9 引入 DAQ 代替直接调用 libpcap . 有两种网卡特性会影响 Snort : ”Large Receive Offload” (LRO) and ”Generic Receive Offload” (GRO) Snort 建议关闭这两项 ,对于linux系统 执行以下命令行 : $ ...
  • DPDK安装与简单使用

    万次阅读 2018-07-08 23:42:31
    DPDK安装与简单使用 1.dpdk安装 ...yum install libpcap-devel kernel* 之后关闭虚拟机再新添加一个网卡。 1)下载dpdk安装包:(版本:DPDK17.11.2 LTS) wget https://dpdk.org/rel/dpdk-...
  • 截获数据包的几种方式

    千次阅读 2019-01-09 11:33:57
    在实际应用中需要服务端调用libpcap模拟接收TCP连接而不实际进行accept,会存在客户端发了SYN请求,TCP协议栈直接回复了RST导致客户端直接关闭了连接的情况。(一开始是准备使用TCPreplay进行TCP数据重放的,后面...
  • RHEL5下snort 的具体配置 Mysql +Snort +apache +php+ acid+adodb+jpgraph 的配置介绍 这是我的一些版本,时间等相关信息 一 我先我们需要做的就是下载...禁用掉SELinux Snort需要libpcap和pcre这两个软件包的支持...
  • Jnetpcap 官方样例 (1)- 捕获数据包

    千次阅读 2016-10-26 19:31:47
    这个样例是非常经典的libpcap样例,它首先获取到一个网络设备的列表,用简单的ASCLL码菜单表示出来 然后 等待用户选择其中的一个接口。我们选择列表中的第一个接口代替处理输入来简化程序。 然后打开这个用于捕获...
  • jenpcap的使用

    2018-03-10 10:53:02
    这个样例是非常经典的libpcap样例,它首先获取到一个网络设备的列表,用简单的ASCLL码菜单表示出来 然后 等待用户选择其中的一个接口。我们选择列表中的第一个接口代替处理输入来简化程序。然后打开这个用于捕获的...
  • 循序渐进学习使用WINPCAP(七)

    千次阅读 2011-01-29 20:39:00
    我们也将看到如何使用WinPcap的内核转储功能来得到高性能的转储(注意:目前,由于新内核缓存的一些问题,这个功能暂时被关闭)。 转储文件的格式很简单,是libpcap的一种。它包含了所捕捉的数据报的二进制内容,...
  • Pcap和pcap-ng格式(使用libpcap> = 1.1.0或npcap时) 例子 有关使用SharpPcap的一系列示例,请参见文件夹。 CI支持 出于以下几个原因,我们支持许多CI系统: CI系统的多样性,以防其中之一关闭 如果您想自定义...
  • snort使用手册(linux)

    2010-03-26 23:42:20
    libpcap所以很轻松不用再装了) 而WINDOWS更简单只要解包出来就可以了; ---------------------------------------------------------------------- 参数介绍: 命令行是snort -[options] 选项: ; ; ; ;-A 设置模式是...
  • 12.1 libpcap文件存储格式 361 12.1.1 转储文件的头信息 361 12.1.2 每个数据包的头信息 363 12.2 使用WinPcap进行文件存储与读取 364 12.2.1 wpcap.dll导出的相应函数 364 12.2.2 文件存储与读取的实例 364 ...
  • unix网络编程卷1

    2015-04-19 16:40:48
    23.2 自动关闭的一到多式服务器程序 489 23.3 部分递送 490 23.4 通知 492 23.5 无序的数据 495 23.6 捆绑地址子集 496 23.7 确定对端和本端地址信息 497 23.8 给定IP地址找出关联ID 500 23.9 心搏和地址不...
  • 23.2 自动关闭的一到多式服务器程序 489 23.3 部分递送 490 23.4 通知 492 23.5 无序的数据 495 23.6 捆绑地址子集 496 23.7 确定对端和本端地址信息 497 23.8 给定IP地址找出关联ID 500 23.9 心搏和地址不...

空空如也

空空如也

1 2
收藏数 22
精华内容 8
关键字:

libpcap关闭