基于Qt实现的网络嗅探器

Tommorow

发布日期: 2021-01-13 18:52:56 浏览量: 192
评分：
star star star star star star star star star star_border
*转载请注明来自write-bug.com

一、概述

Sniffer程序是一种利用以太网的特性把网络适配卡（NIC，一般为以太网卡）置为混杂（promiscuous）模式状态的工具，一旦网卡设置为这种模式，它就能接收传输在网络上的每一个信息包。

普通的情况下，网卡只接收和自己的地址有关的信息包，即传输到本地主机的信息包。要使Sniffer能接收并处理这种方式的信息，系统需要支持 BPF，Linux下需要支持SOCKET-PACKET。但一般情况下，网络硬件和TCP/IP堆栈不支持接收或者发送与本地计算机无关的数据包，所以，为了绕过标准的TCP/IP堆栈，网卡就必须设置为混杂模式。一般情况下，要激活这种方式，内核必须支持这种伪设备BPFilter，而且需要root权限来运行这种程序，所以Sniffer需要root身份安装，如果只是以本地用户的身份进入了系统，那么不可能嗅探到root的密码，因为不能运行Sniffer。

基于Sniffer这样的模式，可以分析各种信息包并描述出网络的结构和使用的机器，由于它接收任何一个在同一网段上传输的数据包，所以也就存在着捕获密码、各种信息、秘密文档等一些没有加密的信息的可能性。

二、程序运行效果展示

系统设计主要分为以下几个功能模块：

  • 获取当前主机中的网卡

  • 设置过滤规则，并依据过滤规则捕获数据包

  • 捕获数据包在主面板中的实时显示（类似wireshark抓包动态显示）

  • 数据包解析、协议树显示以及数据包内容十六进制显示

  • 捕获数据包统计

  • 捕获数据包的保存以及读取

三、实现思路

获取当前运行程序主机中的网卡。

WinPcap中提供了pcap_findalldevs_ex()函数用于获得已连接的网络适配器列表，该函数返回的是一个pcap_if结构的链表，该结构数据域中的name和description表示一个适配器名称和一个适配器的可理解描述。 

  1. void MainWindow::initCaps(){
  2.     ui->comboBox->addItem("请选择一个网卡接口（必选）");
  3.     if(pcap_findalldevs_ex(PCAP_SRC_IF_STRING,NULL,&allDevs,errbuf)>0){
  4.         qDebug("pcap_findallDevs_ex failed!");
  5.     }
  6.     QStringList texts;
  7.     for(dev=allDevs;dev->next!=NULL;dev=dev->next){
  8.         texts.append(dev->description);
  9.     }
  10.     dev=NULL;
  11.     ui->comboBox->addItems(texts);
  12. }

设置过滤规则，并依据过滤规则捕获数据包。

  1.     if (dev->addresses != NULL)
  2.         /* Retrieve the mask of the first address of the interface */
  3.         netmask=((struct sockaddr_in *)(dev->addresses->netmask))->sin_addr.S_un.S_addr;
  4.     else
  5.         /* If the interface is without an address we suppose to be in a C class network */
  6.         netmask=0xffffff;
  7.     std::string str = ui->lineEdit->text().toStdString();
  8.     const char* c_s = str.c_str();
  9.     if (pcap_compile(handle, &fcode, c_s, 1, netmask) <0 )
  10.     {
  11.         qDebug("语法错误，无法编译过滤器");
  12.         return;
  13.     }
  14.     if (pcap_setfilter(handle,&fcode)<0)
  15.     {
  16.         qDebug("语法错误，无法设置滤器");
  17.         return;
  18.     }

嗅探器相关结构体的定义以及主面板数据包的动态显示（类似wireshark抓包动态显示）：

通过qt独有的信号与槽机制，抓包线程每读取到一个数据包即将其解析并将其显示到tableView中，当双击某行时，将该数据包解析并显示在treeView和textedit中：

  1. void MainWindow::setData(datapkt *data){
  2.     int i=tableModel->rowCount();
  3.     QString src_mac,dest_mac,len,src_ip,dest_ip,time;
  4.     char* buf=(char*)malloc(80*sizeof(char));
  5.     sprintf(buf,"%02x-%02x-%02x-%02x-%02x-%02x",data->ethh->src[0],data->ethh->src[1],data->ethh->src[2],data->ethh->src[3],data->ethh->src[4],data->ethh->src[5]);
  6.     src_mac=QString(QLatin1String(buf));
  7.     sprintf(buf,"%02x-%02x-%02x-%02x-%02x-%02x",data->ethh->dest[0],data->ethh->dest[1],data->ethh->dest[2],data->ethh->dest[3],data->ethh->dest[4],data->ethh->dest[5]);
  8.     dest_mac=QString(QLatin1String(buf));
  9.     len=QString::number(data->len);
  10.     switch(data->ethh->type)
  11.     {
  12.         case 0x0806:
  13.             sprintf(buf,"%d.%d.%d.%d",data->arph->ar_srcip[0],data->arph->ar_srcip[1],data->arph->ar_srcip[2],data->arph->ar_srcip[3]);
  14.             src_ip=QString(QLatin1String(buf));
  15.             sprintf(buf,"%d.%d.%d.%d",data->arph->ar_destip[0],data->arph->ar_destip[1],data->arph->ar_destip[2],data->arph->ar_destip[3]);
  16.             dest_ip=QString(QLatin1String(buf));
  17.             break;
  18.         case 0x0800:
  19.             ipvalue_to_ipaddr(ntohl(data->iph->saddr),buf);
  20.             src_ip=QString(QLatin1String(buf));
  21.             ipvalue_to_ipaddr(ntohl(data->iph->daddr),buf);
  22.             dest_ip=QString(QLatin1String(buf));
  23.             break;
  24.         default:
  25.             break;
  26.     }
  27.     current_date_time =QDateTime::currentDateTime();
  28.     current_date=current_date_time.toString("yyyy.MM.dd hh:mm:ss");
  29.     tableModel->setItem(i,0,new QStandardItem(src_mac));
  30.     tableModel->setItem(i,1,new QStandardItem(dest_mac));
  31.     tableModel->setItem(i,2,new QStandardItem(len));
  32.     tableModel->setItem(i,3,new QStandardItem(data->pktType));
  33.     tableModel->setItem(i,4,new QStandardItem(src_ip));
  34.     tableModel->setItem(i,5,new QStandardItem(dest_ip));
  35.     tableModel->setItem(i,6,new QStandardItem(current_date));
  36. }
  37. void MainWindow::setNum(pktcount *npacket){
  38.     QString num_arp=QString::number(npacket->n_arp);
  39.     QString num_count=QString::number(npacket->n_sum);
  40.     QString num_icmp=QString::number(npacket->n_icmp);
  41.     QString num_ip=QString::number(npacket->n_ip);
  42.     QString num_tcp=QString::number(npacket->n_tcp);
  43.     QString num_udp=QString::number(npacket->n_udp);
  44.     QString num_http=QString::number(npacket->n_http);
  45.     QString num_others=QString::number(npacket->n_other);
  47.     ui->TCP->setText(num_tcp);
  48.     ui->UDP->setText(num_udp);
  49.     ui->ICMP->setText(num_icmp);
  50.     ui->HTTP->setText(num_http);
  51.     ui->IPv4->setText(num_ip);
  52.     ui->OTHERS->setText(num_others);
  53.     ui->COUNT->setText(num_count);
  54.     ui->ARP->setText(num_arp);
  55. }

通过print_packet_hex函数将数据包以十六进制存入char数组中：

在实现过程中通过sprintf和strcat函数解决了输出的数值转换问题！

  1. void print_packet_hex(char* pkt,int size_pkt,char *buf)
  2. {
  3.     int i=0,j = 0,rowcount;
  4.     char ch;
  5.     char tempbuf[8];
  6.     memset(tempbuf,0,8);
  7.     for(i= 0;i<size_pkt;i+=16)
  8.     {
  9.         sprintf(tempbuf,"%04x: ",i);
  10.         strcat(buf,tempbuf);
  11.         rowcount= (size_pkt-i) > 16 ? 16 : (size_pkt-i);
  13.         for(j = 0; j < rowcount; j++){
  14.             sprintf(tempbuf,"%02x  ",pkt[i+j]);
  15.             strcat(buf,tempbuf);
  16.         }
  17.                    //不足16，用空格补足
  19.         for(j=rowcount;j<16;j++){
  20.             strcpy(tempbuf,"    ");
  21.             strcat(buf,tempbuf);
  22.         }
  23.         for(j = 0; j < rowcount; j++)
  24.         {
  25.             ch = pkt[i+j];
  26.             ch = isprint(ch) ? ch : '.';
  27.             sprintf(tempbuf,"%c  ",ch);
  28.             strcat(buf,tempbuf);
  29.         }
  30.         if(rowcount<16)
  31.             return;
  32.     }
  33. }

双击tableview将数据包解析的结果显示在treeview和textedit中：

  1. void MainWindow::on_tableView_doubleClicked(const QModelIndex &index)
  2. {
  3.     int row=index.row();
  4.     QString src_mac,dest_mac;
  5.     char* buf=(char*)malloc(108*sizeof(char));
  6.     sprintf(buf,"%02x-%02x-%02x-%02x-%02x-%02x",alldatapkt[row]->ethh->src[0],alldatapkt[row]->ethh->src[1],alldatapkt[row]->ethh->src[2],alldatapkt[row]->ethh->src[3],alldatapkt[row]->ethh->src[4],alldatapkt[row]->ethh->src[5]);
  7.     src_mac=QString(QLatin1String(buf));
  8.     sprintf(buf,"%02x-%02x-%02x-%02x-%02x-%02x",alldatapkt[row]->ethh->dest[0],alldatapkt[row]->ethh->dest[1],alldatapkt[row]->ethh->dest[2],alldatapkt[row]->ethh->dest[3],alldatapkt[row]->ethh->dest[4],alldatapkt[row]->ethh->dest[5]);
  9.     dest_mac=QString(QLatin1String(buf));
  11.     ui->data->setText("");
  12.     int i=0,j = 0,rowcount;char ch;
  13.     char tempbuf[8];strcpy(tempbuf,"");strcpy(buf,"");
  14.     int size_pkt=alldatapkt[row]->len;u_char* pkt=datavec[row];
  15.     for(i= 0;i<size_pkt;i+=16)
  16.     {
  17.         sprintf(tempbuf,"%04x:",i);
  18.         strcat(buf,tempbuf);
  19.         rowcount= (size_pkt-i) > 16 ? 16 : (size_pkt-i);
  20.         for(j = 0; j < rowcount; j++){
  21.             sprintf(tempbuf,"%02x ",pkt[i+j]);strcat(buf,tempbuf);
  22.         }
  24.         for(j=rowcount;j<16;j++){
  25.             strcpy(tempbuf,"    ");strcat(buf,tempbuf);
  26.         }
  27.         for(j = 0; j < rowcount; j++){
  28.             ch = pkt[i+j];
  29.             ch = isprint(ch) ? ch : '.';
  30.             sprintf(tempbuf,"%c ",ch);
  31.             strcat(buf,tempbuf);
  32.         }
  33.             strcat(buf,"\n");
  34.             ui->data->append(buf);
  35.             strcpy(buf,"");
  36.             if(rowcount<16)
  37.                 break;
  38.     }
  39.     QString h="接受到的第"+QString::number(row+1)+"个数据包";
  40.     QStandardItem *head=new QStandardItem(h);
  41.     QStandardItem *ethdata=new QStandardItem("链路层数据");
  42.     QStandardItem *arpdata=new QStandardItem("ARP协议头");
  43.     QStandardItem *ipdata=new QStandardItem("IP协议头");
  44.     QStandardItem *tcpdata=new QStandardItem("TCP协议头");
  45.     QStandardItem *udpdata=new QStandardItem("UDP协议头");
  46.     QStandardItem *icmpdata=new QStandardItem("ICMP协议头");
  47.     treeModel->setItem(0,head);
  48.     head->setChild(0,ethdata);
  49.     ethdata->setChild(0,new QStandardItem("源MAC："+src_mac));
  50.     ethdata->setChild(1,new QStandardItem("目的MAC："+dest_mac));
  51.     sprintf(tempbuf,"0x%04x",alldatapkt[row]->ethh->type);
  52.     ethdata->setChild(2,new QStandardItem("类型："+QString(QLatin1String(tempbuf))));
  53.     QModelIndex current_index;
  54.     switch (alldatapkt[row]->ethh->type) {
  55.     case 0x0806:
  56.         head->setChild(1,arpdata);
  57.         arpdata->setChild(0,new QStandardItem("硬件类型："+QString::number(alldatapkt[row]->arph->ar_hrd)));
  58.         arpdata->setChild(1,new QStandardItem("协议类型："+QString::number(alldatapkt[row]->arph->ar_pro)));
  59.         arpdata->setChild(2,new QStandardItem("硬件地址长度："+QString::number(alldatapkt[row]->arph->ar_hln)));
  60.         arpdata->setChild(3,new QStandardItem("协议地址长度："+QString::number(alldatapkt[row]->arph->ar_pln)));
  61.         sprintf(buf,"%0d.%d.%d.%d",alldatapkt[row]->arph->ar_srcip[0],alldatapkt[row]->arph->ar_srcip[1],alldatapkt[row]->arph->ar_srcip[2],alldatapkt[row]->arph->ar_srcip[3]);
  62.         arpdata->setChild(4,new QStandardItem("发送方IP："+QString(QLatin1String(buf))));
  63.         sprintf(buf,"%0d.%d.%d.%d",alldatapkt[row]->arph->ar_destip[0],alldatapkt[row]->arph->ar_destip[1],alldatapkt[row]->arph->ar_destip[2],alldatapkt[row]->arph->ar_destip[3]);
  64.         arpdata->setChild(5,new QStandardItem("接受方IP："+QString(QLatin1String(buf))));
  65.         break;
  66.     case 0x0800:
  67.         head->setChild(1,ipdata);
  68.         ipdata->setChild(0,new QStandardItem("版本号："+QString::number(alldatapkt[row]->iph->version)));
  69.         ipdata->setChild(1,new QStandardItem("头部长度："+QString::number(alldatapkt[row]->iph->ihl)));
  70.         ipdata->setChild(2,new QStandardItem("服务类型TOS："+QString::number(alldatapkt[row]->iph->tos)));
  71.         ipdata->setChild(3,new QStandardItem("总长度："+QString::number(alldatapkt[row]->iph->tlen)));
  72.         sprintf(tempbuf,"0x%04x",alldatapkt[row]->iph->id);
  73.         ipdata->setChild(4,new QStandardItem("标识："+QString(QLatin1String(tempbuf))));
  74.         ipdata->setChild(5,new QStandardItem("位偏移："+QString::number(alldatapkt[row]->iph->frag_off)));
  75.         ipdata->setChild(6,new QStandardItem("生存时间TTL："+QString::number(alldatapkt[row]->iph->ttl)));
  76.         ipdata->setChild(7,new QStandardItem("协议："+QString::number(alldatapkt[row]->iph->proto)));
  77.         ipdata->setChild(8,new QStandardItem("头部校验和："+QString::number(alldatapkt[row]->iph->check)));
  78.         current_index=tableModel->index(row,4);
  79.         ipdata->setChild(9,new QStandardItem("源IP："+tableModel->data(current_index).toString()));
  80.         current_index=tableModel->index(row,5);
  81.         ipdata->setChild(10,new QStandardItem("目的IP："+tableModel->data(current_index).toString()));
  82.         switch (alldatapkt[row]->iph->proto) {
  83.         case PROTO_TCP:
  84.             head->setChild(2,tcpdata);
  85.             tcpdata->setChild(0,new QStandardItem("源端口："+QString::number(alldatapkt[row]->tcph->sport)));
  86.             tcpdata->setChild(1,new QStandardItem("目的端口："+QString::number(alldatapkt[row]->tcph->dport)));
  87.             tcpdata->setChild(2,new QStandardItem("序列号："+QString::number(alldatapkt[row]->tcph->seq)));
  88.             tcpdata->setChild(3,new QStandardItem("确认序列号："+QString::number(alldatapkt[row]->tcph->ack_seq)));
  89.             tcpdata->setChild(4,new QStandardItem("窗口大小："+QString::number(alldatapkt[row]->tcph->window)));
  90.             tcpdata->setChild(5,new QStandardItem("SYN："+QString::number(alldatapkt[row]->tcph->syn)));
  91.             tcpdata->setChild(6,new QStandardItem("ACK："+QString::number(alldatapkt[row]->tcph->ack)));
  92.             tcpdata->setChild(7,new QStandardItem("FIN："+QString::number(alldatapkt[row]->tcph->fin)));
  93.             tcpdata->setChild(8,new QStandardItem("校验和："+QString::number(alldatapkt[row]->tcph->check)));
  94.             tcpdata->setChild(9,new QStandardItem("紧急指针："+QString::number(alldatapkt[row]->tcph->urg_ptr)));
  95.             break;
  96.         case PROTO_UDP:
  97.             head->setChild(2,udpdata);
  98.             udpdata->setChild(0,new QStandardItem("源端口："+QString::number(alldatapkt[row]->udph->sport)));
  99.             udpdata->setChild(1,new QStandardItem("目的端口："+QString::number(alldatapkt[row]->udph->dport)));
  100.             udpdata->setChild(2,new QStandardItem("数据报长度："+QString::number(alldatapkt[row]->udph->len)));
  101.             udpdata->setChild(3,new QStandardItem("校验和："+QString::number(alldatapkt[row]->udph->check)));
  102.             break;
  103.         case PROTO_ICMP:
  104.             head->setChild(2,icmpdata);
  105.             icmpdata->setChild(0,new QStandardItem("类型："+QString::number(alldatapkt[row]->icmph->type)));
  106.             icmpdata->setChild(1,new QStandardItem("代码："+QString::number(alldatapkt[row]->icmph->code)));
  107.             icmpdata->setChild(2,new QStandardItem("序列号："+QString::number(alldatapkt[row]->icmph->seq)));
  108.             icmpdata->setChild(3,new QStandardItem("校验和："+QString::number(alldatapkt[row]->icmph->chksum)));
  109.             break;
  110.         default:
  111.             break;
  112.         }
  113.         break;
  114.     default:
  115.         break;
  116.     }
  117. }

接下来介绍数据包协议分析的实现：

在上面的代码中可以看到，在抓包线程的运行函数中很关键的一步是调用analyze类中的analyze_frame函数进行协议分析。

各协议头数据结构定义：

  1. //Mac帧头 占14个字节
  2. typedef struct _ethhdr
  3. {
  4.     u_char dest[6];            //6个字节 目标地址
  5.     u_char src[6];                //6个字节 源地址
  6.     u_short type;                //2个字节 类型
  7. }ethhdr;
  9. //ARP头
  10. typedef struct _arphdr
  11. {
  12.     u_short ar_hrd;                        //硬件类型
  13.     u_short ar_pro;                        //协议类型
  14.     u_char ar_hln;                        //硬件地址长度
  15.     u_char ar_pln;                        //协议地址长度
  16.     u_short ar_op;                        //操作码，1为请求 2为回复
  17.     u_char ar_srcmac[6];            //发送方MAC
  18.     u_char ar_srcip[4];                //发送方IP
  19.     u_char ar_destmac[6];            //接收方MAC
  20.     u_char ar_destip[4];                //接收方IP
  21. }arphdr;
  23. //定义IP头
  24. typedef struct _iphdr
  25. {
  26. #if defined(LITTLE_ENDIAN)
  27.     u_char ihl:4;
  28.     u_char version:4;
  29. #elif defined(BIG_ENDIAN)
  30.     u_char version:4;
  31.     u_char  ihl:4;
  32. #endif
  33.     u_char tos;                //TOS 服务类型
  34.     u_short tlen;            //包总长 u_short占两个字节
  35.     u_short id;                //标识
  36.     u_short frag_off;    //片位移
  37.     u_char ttl;                //生存时间
  38.     u_char proto;        //协议
  39.     u_short check;        //校验和
  40.     u_int saddr;            //源地址
  41.     u_int daddr;            //目的地址
  42.     u_int    op_pad;        //选项等
  43. }iphdr;
  45. //定义TCP头
  46. typedef struct _tcphdr
  47. {
  48.     u_short sport;                            //源端口地址  16位
  49.     u_short dport;                            //目的端口地址 16位
  50.     u_int seq;                                    //序列号 32位
  51.     u_int ack_seq;                            //确认序列号
  52. #if defined(LITTLE_ENDIAN)
  53.     u_short res1:4,
  54.                 doff:4,
  55.                 fin:1,
  56.                 syn:1,
  57.                 rst:1,
  58.                 psh:1,
  59.                 ack:1,
  60.                 urg:1,
  61.                 ece:1,
  62.                 cwr:1;
  63. #elif defined(BIG_ENDIAN)
  64.     u_short doff:4,
  65.                 res1:4,
  66.                 cwr:1,
  67.                 ece:1,
  68.                 urg:1,
  69.                 ack:1,
  70.                 psh:1,
  71.                 rst:1,
  72.                 syn:1,
  73.                 fin:1;
  74. #endif
  75.     u_short window;                    //窗口大小 16位
  76.     u_short check;                        //校验和 16位
  77.     u_short urg_ptr;                    //紧急指针 16位
  78.     u_int opt;                                //选项
  79. }tcphdr;
  82. //定义UDP头
  83. typedef struct _udphdr
  84. {
  85.     u_short sport;        //源端口  16位
  86.     u_short dport;        //目的端口 16位
  87.     u_short len;            //数据报长度 16位
  88.     u_short check;        //校验和 16位
  89. }udphdr;
  91. //定义ICMP
  92. typedef struct _icmphdr
  93. {
  94.     u_char type;            //8位 类型
  95.     u_char code;            //8位 代码
  96.     u_char seq;            //序列号 8位
  97.     u_char chksum;        //8位校验和
  98. }icmphdr;
  101. //对各种包进行计数
  102. typedef struct _pktcount
  103. {
  104.     int n_ip;
  105.     int n_arp;
  106.     int n_tcp;
  107.     int n_udp;
  108.     int n_icmp;
  109.     int n_http;
  110.     int n_other;
  111.     int n_sum;
  112.     _pktcount(){
  113.         n_ip=0;
  114.         n_arp=0;
  115.         n_tcp=0;
  116.         n_udp=0;
  117.         n_icmp=0;
  118.         n_http=0;
  119.         n_other=0;
  120.         n_sum=0;
  121.     }
  122. }pktcount;
  124. //要保存的数据结构
  125. typedef struct _datapkt
  126. {
  127.     char  pktType[8];                    //包类型
  128.     int time[6];                                //时间
  129.     int len;                                    //长度
  131.     ethhdr* ethh;                //链路层包头
  133.     arphdr* arph;                //ARP包头
  134.     iphdr* iph;                    //IP包头
  136.     icmphdr* icmph;        //ICMP包头
  137.     udphdr* udph;            //UDP包头
  138.     tcphdr* tcph;                //TCP包头
  139.     bool isHttp;
  140.     void *apph;                            //应用层包头
  141. }datapkt;
  142. #endif

解析数据包函数：

  1. #include "protocol.h"
  2. #include <QDebug>
  3. #include "mainwindow.h"
  4. #include <winsock2.h>
  5. #include <analyze.h>
  6. ///*pkt为网络中捕获的包，data为要存为本机上的数据*
  7. ///*分析链路层*/
  8. int analyze_frame(const u_char * pkt,datapkt * data,pktcount* npacket)
  9. {
  10.         int i;
  11.         ethhdr *ethh = (ethhdr*)pkt;
  12.         data->ethh = (ethhdr*)malloc(sizeof(ethhdr));
  13.         if(NULL == data->ethh)
  14.             return -1;
  16.         for(i=0;i<6;i++)
  17.         {
  18.             data->ethh->dest[i] = ethh->dest[i];
  19.             data->ethh->src[i] = ethh->src[i];
  20.         }
  22.         npacket->n_sum++;
  24.         /*由于网络字节顺序原因，需要对齐*/
  25.         data->ethh->type = ntohs(ethh->type);
  27.         //处理ARP还是IP包？
  28.         switch(data->ethh->type)
  29.         {
  30.             case 0x0806:          
  31.                 return analyze_arp((u_char*)pkt+14,data,npacket);      //mac 头大小为14个字节
  32.                 break;
  33.             case 0x0800:            
  34.                 return analyze_ip((u_char*)pkt+14,data,npacket);
  35.                 break;
  36.             default:
  37.                 npacket->n_other++;
  38.                 return -1;
  39.                 break;
  40.         }
  41.         return 1;
  42. }
  44. ///*分析网络层：ARP*/
  45. int analyze_arp(const u_char* pkt,datapkt *data,pktcount* npacket)
  46. {
  47.     int i;
  48.     arphdr *arph = (arphdr*)pkt;
  49.     data->arph = (arphdr*)malloc(sizeof(arphdr));
  51.     if(NULL == data->arph)
  52.         return -1;
  54.     //复制IP及MAC
  55.     for(i=0;i<6;i++)
  56.     {
  57.         if(i<4)
  58.         {
  59.             data->arph->ar_destip[i] = arph->ar_destip[i];
  60.             data->arph->ar_srcip[i] = arph->ar_srcip[i];
  61.         }
  62.         data->arph->ar_destmac[i] = arph->ar_destmac[i];
  63.         data->arph->ar_srcmac[i]= arph->ar_srcmac[i];
  64.     }
  65.     npacket->n_arp++;
  66.     data->arph->ar_hln = arph->ar_hln;
  67.     data->arph->ar_hrd = ntohs(arph->ar_hrd);
  68.     data->arph->ar_op = ntohs(arph->ar_op);
  69.     data->arph->ar_pln = arph->ar_pln;
  70.     data->arph->ar_pro = ntohs(arph->ar_pro);
  71. //    qDebug(""+data->arph->ar_hln);
  72.     strcpy(data->pktType,"ARP");
  73.     return 1;
  74. }
  76. ///*分析网络层：IP*/
  77. int analyze_ip(const u_char* pkt,datapkt *data,pktcount *npacket)
  78. {
  79.     int i;
  80.     iphdr *iph = (iphdr*)pkt;
  81.     data->iph = (iphdr*)malloc(sizeof(iphdr));
  83.     if(NULL == data->iph)
  84.         return -1;
  85.     data->iph->check = iph->check;
  86.     npacket->n_ip++;
  88.     /*for(i = 0;i<4;i++)
  89.     {
  90.         data->iph->daddr[i] = iph->daddr[i];
  91.         data->iph->saddr[i] = iph->saddr[i];
  92.     }*/
  93.     data->iph->saddr = iph->saddr;
  94.     data->iph->daddr = iph->daddr;
  96.     data->iph->frag_off = iph->frag_off;
  97.     data->iph->id = iph->id;
  98.     data->iph->proto = iph->proto;
  99.     data->iph->tlen = ntohs(iph->tlen);
  100.     data->iph->tos = iph->tos;
  101.     data->iph->ttl = iph->ttl;
  102.     data->iph->ihl = iph->ihl;
  103.     data->iph->version = iph->version;
  104.     //data->iph->ver_ihl= iph->ver_ihl;
  105.     data->iph->op_pad = iph->op_pad;
  107.     int iplen = iph->ihl*4;                            //ip头长度
  108.     switch(iph->proto)
  109.     {
  110.         case PROTO_ICMP:
  111.             return analyze_icmp((u_char*)iph+iplen,data,npacket);
  112.             break;
  113.         case PROTO_TCP:
  114.             return analyze_tcp((u_char*)iph+iplen,data,npacket);
  115.             break;
  116.         case PROTO_UDP:
  117.             return analyze_udp((u_char*)iph+iplen,data,npacket);
  118.             break;
  119.         default :
  120.             return-1;
  121.             break;
  122.     }
  123.     return 1;
  124. }
  126. ///*分析传输层：ICMP*/
  127. int analyze_icmp(const u_char* pkt,datapkt *data,pktcount *npacket)
  128. {
  129.     icmphdr* icmph = (icmphdr*)pkt;
  130.     data->icmph = (icmphdr*)malloc(sizeof(icmphdr));
  132.     if(NULL == data->icmph)
  133.         return -1;
  135.     data->icmph->chksum = icmph->chksum;
  136.     data->icmph->code = icmph->code;
  137.     data->icmph->seq =icmph->seq;
  138.     data->icmph->type = icmph->type;
  139.     strcpy(data->pktType,"ICMP");
  140.     npacket->n_icmp++;
  141.     return 1;
  142. }
  144. ///*分析传输层：TCP*/
  145. int analyze_tcp(const u_char* pkt,datapkt *data,pktcount *npacket)
  146. {
  147.     tcphdr *tcph = (tcphdr*)pkt;
  148.     data->tcph = (tcphdr*)malloc(sizeof(tcphdr));
  149.     if(NULL == data->tcph)
  150.         return -1;
  152.     data->tcph->ack_seq = tcph->ack_seq;
  153.     data->tcph->check = tcph->check;
  155.     data->tcph->doff = tcph->doff;
  156.     data->tcph->res1 = tcph->res1;
  157.     data->tcph->cwr = tcph->cwr;
  158.     data->tcph->ece = tcph->ece;
  159.     data->tcph->urg = tcph->urg;
  160.     data->tcph->ack = tcph->ack;
  161.     data->tcph->psh = tcph->psh;
  162.     data->tcph->rst = tcph->rst;
  163.     data->tcph->syn = tcph->syn;
  164.     data->tcph->fin = tcph->fin;
  165.     //data->tcph->doff_flag = tcph->doff_flag;
  167.     data->tcph->dport = ntohs(tcph->dport);
  168.     data->tcph->seq = tcph->seq;
  169.     data->tcph->sport = ntohs(tcph->sport);
  170.     data->tcph->urg_ptr = tcph->urg_ptr;
  171.     data->tcph->window= tcph->window;
  172.     data->tcph->opt = tcph->opt;
  173.     if(ntohs(tcph->dport) == 80 || ntohs(tcph->sport)==80)
  174.     {
  175.         npacket->n_http++;
  176.         strcpy(data->pktType,"HTTP");
  177.     }
  178.     else{
  179.         npacket->n_tcp++;
  180.         strcpy(data->pktType,"TCP");
  181.     }
  182.     return 1;
  183. }
  185. /*分析传输层：UDP*/
  186. int analyze_udp(const u_char* pkt,datapkt *data,pktcount *npacket)
  187. {
  188.     udphdr* udph = (udphdr*)pkt;
  189.     data->udph = (udphdr*)malloc(sizeof(udphdr));
  190.     if(NULL == data->udph )
  191.         return -1;
  193.     data->udph->check = udph->check;
  194.     data->udph->dport = ntohs(udph->dport);
  195.     data->udph->len = ntohs(udph->len);
  196.     data->udph->sport = ntohs(udph->sport);
  198.     strcpy(data->pktType,"UDP");
  199.     npacket->n_udp++;
  200.     return 1;
  201. }

运行结果示例：

IP数据包

UDP数据包

TCP数据包

ARP数据包

ICMP数据数据包

上传的附件 cloud_download sniffer.7z ( 1.04mb, 6次下载 )
error_outline 下载需要9点积分

keyboard_arrow_left上一篇 : 基于Jsp和MySql的汽车租赁系统 基于中央定位服务器的P2P网络聊天系统 : 下一篇keyboard_arrow_right

comment 0

Tommorow

发送私信

成功其实很简单，就是当你坚持不住的时候，再坚持一下

10
文章数
8
评论数
最近文章
highlight comment

Copyright @2020-WRITE-BUG.COM 技术支持 - YCY科技 - 备案/许可证编号：京ICP备16025663号-5

eject