c语言实现linux抓包

最新推荐文章于 2022-09-01 22:57:12 发布
最新推荐文章于 2022-09-01 22:57:12 发布
阅读量1k 收藏 4
点赞数
文章标签： c/c++ 网络 数据结构与算法
验证安装libpca
引用pcap.h，确认是否能正常用libpcap开发
  #include <stdio.h>
  #include <pcap.h>

  int main(int argc, char *argv[])
  {
     char *dev = argv[1];

     printf("Device: %s\n", dev);
     return(0);
  }

然后用-lpcap选项看能不能连接上
g++ -o a a.cc a.h -lpcap


用pcap_lookupdev获取默认设备
  int main(int argc, char *argv[])
  {
    char *dev, errbuf[PCAP_ERRBUF_SIZE];
    dev = pcap_lookupdev(errbuf);
    if (dev == NULL) {
      fprintf(stderr, "%s\n", errbuf);
      return(2);
    }
    printf("Device: %s\n", dev);
    return(0);
  }



打开设备，返回一个pcap_t类型的“handle”。调用这个函数叫做“开启一个嗅探会话（sniffing session）”
pcap_t *pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)
参数
device：pcap_lookupdev返回的设备名，类似ethx的字符串
snaplen：抓包的buffer字节数
promisc：是否开启混杂模式
to_ms：超时，0表述无超时
ebuf：如果出错，会存入错误信息


   errbuf[PCAP_ERRBUF_SIZE];
   char*   dev    = pcap_lookupdev(errbuf);
   pcap_t* handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
   if (handle == NULL) {
     fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
     return(2);
   }


过滤器
先要调用pcap_compile来编译过滤器
int pcap_compile(
  pcap_t *p,  由pcap_open_live返回的“handle”
  struct bpf_program *fp,   存放编译好的过滤器的数据结构
  char *str,    过滤器表达式，如“port 23”
  int optimize,  表达式是否需要被“优化”, 取值0或1
  bpf_u_int32 netmask  有pcap_lookupnet函数获取的netmask
  )

过滤器编译好之后就可以设置到pcap_t里
int pcap_setfilter(pcap_t *p, struct bpf_program *fp)


   pcap_t *handle;    /* Session handle */
   char dev[] = "rl0";    /* Device to sniff on */
   char errbuf[PCAP_ERRBUF_SIZE]; /* Error string */
   struct bpf_program fp;   /* The compiled filter expression */
   char filter_exp[] = "port 23"; /* The filter expression */
   bpf_u_int32 mask;    /* The netmask of our sniffing device */
   bpf_u_int32 net;   /* The IP of our sniffing device */

   if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
     fprintf(stderr, "Can't get netmask for device %s\n", dev);
     net = 0;
     mask = 0;
   }
   handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
   if (handle == NULL) {
     fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
     return(2);
   }
   if ( pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
     fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
     return(2);
   }
   if ( pcap_setfilter(handle, &fp) == -1) {
     fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
     return(2);
   }


实际抓包
struct pcap_pkthdr header;  /* The header that pcap gives us */
handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);
packet = pcap_next(handle, &header);
pcap_close(handle);

调用上面的pcap_next函数可以得到header和packet
但是pcap_next只能抓一个包，libpcap提供了循环抓包的函数
int pcap_loop(
  pcap_t *p, //由pcap_open_live返回的“handle”
  int cnt,   //抓多少个包
  pcap_handler callback, //抓到包后的回调函数
  u_char *user   // 这个参数是用户自定义的，libpcap会自动将这个值传给回调函数
  )

回调函数的形式
重点是header和packet两个参数
void got_packet(
  u_char *args,  // 这个就是pcap_loop的最后一个参数u_char *user
  const struct pcap_pkthdr *header,
  const u_char *packet
  );


header的内容
  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) */
  };


packet是一个u_char*，执行一块数据，这块数据可以被转换为下面几个结构体
#define SIZE_ETHERNET 14
const struct sniff_ethernet /* The ethernet header */
const struct sniff_ip /* The IP header */
const struct sniff_tcp /* The TCP header */
以及
const char *payload; /* Packet payload */



这些数据结构介绍如下
packet其实就是包头的二进制内容，因此结构体需要按包头的格式编排各变量的大小和顺序，然后强制类型转换即可。
下面的结构体来自tcpdump官网的文章。
/* Ethernet addresses are 6 bytes */
#define ETHER_ADDR_LEN  6

  /* Ethernet header */
  struct sniff_ethernet {
    u_char ether_dhost[ETHER_ADDR_LEN]; /* Destination host address */
    u_char ether_shost[ETHER_ADDR_LEN]; /* Source host address */
    u_short ether_type; /* IP? ARP? RARP? etc */
  };

  /* IP header */
  struct sniff_ip {
    u_char ip_vhl;    /* version << 4 | header length >> 2 */
    u_char ip_tos;    /* type of service */
    u_short ip_len;   /* total length */
    u_short ip_id;    /* identification */
    u_short ip_off;   /* fragment offset field */
  #define IP_RF 0x8000    /* reserved fragment flag */
  #define IP_DF 0x4000    /* dont fragment flag */
  #define IP_MF 0x2000    /* more fragments flag */
  #define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
    u_char ip_ttl;    /* time to live */
    u_char ip_p;    /* protocol */
    u_short ip_sum;   /* checksum */
    struct in_addr ip_src,ip_dst; /* source and dest address */
  };
  #define IP_HL(ip)   (((ip)->ip_vhl) & 0x0f)
  #define IP_V(ip)    (((ip)->ip_vhl) >> 4)

  /* TCP header */
  typedef u_int tcp_seq;

  struct sniff_tcp {
    u_short th_sport; /* source port */
    u_short th_dport; /* destination port */
    tcp_seq th_seq;   /* sequence number */
    tcp_seq th_ack;   /* acknowledgement number */
    u_char th_offx2;  /* data offset, rsvd */
  #define TH_OFF(th)  (((th)->th_offx2 & 0xf0) >> 4)
    u_char th_flags;
  #define TH_FIN 0x01
  #define TH_SYN 0x02
  #define TH_RST 0x04
  #define TH_PUSH 0x08
  #define TH_ACK 0x10
  #define TH_URG 0x20
  #define TH_ECE 0x40
  #define TH_CWR 0x80
  #define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
    u_short th_win;   /* window */
    u_short th_sum;   /* checksum */
    u_short th_urp;   /* urgent pointer */
};


将u_char *packet转换成这些结构体的方法：
  #define SIZE_ETHERNET 14

  const struct sniff_ethernet *ethernet; /* The ethernet header */
  const struct sniff_ip *ip; /* The IP header */
  const struct sniff_tcp *tcp; /* The TCP header */
  const char *payload; /* Packet payload */

  u_int size_ip;
  u_int size_tcp;

  ethernet = (struct sniff_ethernet*)(packet);     // 先是链路层的头
  ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);  // 链路层头的后面是变长的ip包头
  size_ip = IP_HL(ip)*4;   // IP_HL这个宏的作用是去ip头第一个字节的后4位，这4位表示IP头的长度，单位是4byte
  if (size_ip < 20) {
    printf("   * Invalid IP header length: %u bytes\n", size_ip);
    return;
  }
  tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip); // 再后面是tcp包头 
  size_tcp = TH_OFF(tcp)*4;
  if (size_tcp < 20) {
    printf("   * Invalid TCP header length: %u bytes\n", size_tcp);
    return;
  }
  payload = (u_char *)(packet + SIZE_ETHERNET + size_ip + size_tcp);


Variable Location (in bytes)
sniff_ethernet X
sniff_ip X + SIZE_ETHERNET
sniff_tcp X + SIZE_ETHERNET + {IP header length}
payload X + SIZE_ETHERNET + {IP header length} + {TCP header length}




把前面介绍的组合起来，jius简单的抓包程序
[root@localhost cc]# cat cap.c
#include "a.h"

#define SIZE_ETHERNET 14

char errbuf[PCAP_ERRBUF_SIZE];

int addr_ntoa(int i_addr, char* str_addr)
{
    if(str_addr == NULL)
    {
        return -1;
    }
    struct in_addr addr;
    addr.s_addr = i_addr;
    char* tmp = inet_ntoa(addr);
    strcpy(str_addr, tmp);
    return 0;
}


int errstr(int ret, char* str)
{
    if(str != NULL) fprintf(stderr, "%s\n", str);
    exit(ret);
}

int err(int ret)
{
    errstr(ret, errbuf);
}



void got_packet(u_char* args, const struct pcap_pkthdr* header, const u_char* packet)
{
    u_int size_ip;
    u_int size_tcp;
    const struct sniff_ethernet *ethernet;
    const struct sniff_ip *ip;
    const struct sniff_tcp *tcp;
    const char *payload;

    ethernet = (struct sniff_ethernet*)(packet);

    ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
    if((size_ip = IP_HL(ip)*4) < 20) return;
    tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
    if((size_tcp = TH_OFF(tcp)*4) < 20) return;


    char ip_src[16];
    char ip_dst[16];
    addr_ntoa(ip->ip_src.s_addr, ip_src);
    addr_ntoa(ip->ip_dst.s_addr, ip_dst);
    printf("%s:%d>> %s:%d\n", ip_src, ntohs(tcp->th_sport), ip_dst, ntohs(tcp->th_dport));

    struct ether_header *eptr = (struct ether_header *) packet;
        u_int8_t* ptr;
    ptr = eptr->ether_shost;
    int i = ETHER_ADDR_LEN;
    printf("src MAC: [");
    do
    {
    printf("%s%x",(i == ETHER_ADDR_LEN) ? " " : ":",*ptr++);
    }
    while(--i>0);
    printf("]\n");

    ptr = eptr->ether_dhost;
    i = ETHER_ADDR_LEN;
    printf("dest MAC: [");
    do
    {
    printf("%s%x",(i == ETHER_ADDR_LEN) ? " " : ":",*ptr++);
    }
    while(--i>0);
    printf("]\n");

    struct tm* local = localtime(&(header->ts));

    printf("time: %d:%d:%d\n",local->tm_hour,local->tm_min,local->tm_sec);
    printf("package length: %d\n", header->len);
    printf("TTL: %d\n", ip->ip_ttl);


    printf("\n");
}


int main()
{
    char* dev;
    bpf_u_int32 mask;
    bpf_u_int32 net;
    pcap_t *handle;

    if ((dev = pcap_lookupdev(errbuf)) == NULL) err(-1);
    if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) err(-1);

    char strnet[16];
    char strmask[16];
    addr_ntoa(net, strnet);
    addr_ntoa(mask, strmask);
    printf("\nMonitoring: %s/%s/%s\n\n", dev, strnet, strmask);

    if((handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf)) == NULL) err(-1);
    if((pcap_loop(handle, 10, got_packet, "test1")) < 0) err(-1);

    return 0;
}



头文件里的结构体来自tcpdump官网的文章，其实就是按照包头的格式设置变量大小和顺序。
[root@localhost cc]# cat cap.h
#include <string.h>
#include <pcap.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>
#include <unistd.h>
#include <stdlib.h>
#include <net/ethernet.h>
#include <time.h>

/* Ethernet addresses are 6 bytes */
//#define ETHER_ADDR_LEN  6

/* Ethernet header */
struct sniff_ethernet {
    u_char ether_dhost[ETHER_ADDR_LEN]; /* Destination host address */
    u_char ether_shost[ETHER_ADDR_LEN]; /* Source host address */
    u_short ether_type; /* IP? ARP? RARP? etc */
};

/* IP header */
struct sniff_ip {
    u_char ip_vhl;    /* version << 4 | header length >> 2 */
    u_char ip_tos;    /* type of service */
    u_short ip_len;   /* total length */
    u_short ip_id;    /* identification */
    u_short ip_off;   /* fragment offset field */
#define IP_RF 0x8000    /* reserved fragment flag */
#define IP_DF 0x4000    /* dont fragment flag */
#define IP_MF 0x2000    /* more fragments flag */
#define IP_OFFMASK 0x1fff /* mask for fragmenting bits */
    u_char ip_ttl;    /* time to live */
    u_char ip_p;    /* protocol */
    u_short ip_sum;   /* checksum */
    struct in_addr ip_src,ip_dst; /* source and dest address */
};
#define IP_HL(ip)   (((ip)->ip_vhl) & 0x0f)
#define IP_V(ip)    (((ip)->ip_vhl) >> 4)

/* TCP header */
typedef u_int tcp_seq;

struct sniff_tcp {
    u_short th_sport; /* source port */
    u_short th_dport; /* destination port */
    tcp_seq th_seq;   /* sequence number */
    tcp_seq th_ack;   /* acknowledgement number */
    u_char th_offx2;  /* data offset, rsvd */
#define TH_OFF(th)  (((th)->th_offx2 & 0xf0) >> 4)
    u_char th_flags;
#define TH_FIN 0x01
#define TH_SYN 0x02
#define TH_RST 0x04
#define TH_PUSH 0x08
#define TH_ACK 0x10
#define TH_URG 0x20
#define TH_ECE 0x40
#define TH_CWR 0x80
#define TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
    u_short th_win;   /* window */
    u_short th_sum;   /* checksum */
    u_short th_urp;   /* urgent pointer */
};


执行效果
[root@localhost cc]# ./cap

Monitoring: enp0s8/192.168.1.0/255.255.255.0

192.168.1.66:22>> 192.168.1.1:52672
src MAC: [ 8:0:27:80:ff:b0]
dest MAC: [ a:0:27:0:0:0]
time: 15:25:4
package length: 154
TTL: 64

192.168.1.1:52672>> 192.168.1.66:22
src MAC: [ a:0:27:0:0:0]
dest MAC: [ 8:0:27:80:ff:b0]
time: 15:25:4
package length: 60
TTL: 64

192.168.1.66:22>> 192.168.1.1:52672
src MAC: [ 8:0:27:80:ff:b0]
dest MAC: [ a:0:27:0:0:0]
time: 15:25:4
package length: 378
TTL: 64

192.168.1.66:22>> 192.168.1.1:52672
src MAC: [ 8:0:27:80:ff:b0]
dest MAC: [ a:0:27:0:0:0]
time: 15:25:4
package length: 234
TTL: 64
...
...


来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/26239116/viewspace-2058238/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/26239116/viewspace-2058238/

cmbj68996
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c语言实现的抓包程序
05-21
c语言实现的抓包程序c语言实现的抓包程序c语言实现的抓包程序
Linux抓包器带图形界面.zip
01-13
在Linux下使用的抓包软件 使用gtk图形界面可以跨平台 C语言开发 编译命令为gcc -g ip_dump.c -o ip_dump `pkg-config --cflags --libs gtk+-2.0 gthread-2.0`
尝试探索基于Linux C的网卡抓包过程
ZoMoe's eye
04-11 5023
其实想探究网卡抓包问题已经有好久了。前几天找了时间算是基本上了解了那部分的一些基本东西，在这里只是赘述罢了。 抓包首先便要知道经过网卡的数据其实都是通过底层的链路层（MAC），在Linux系统中我们获取网卡的数据流量其实是直接从链路层收发数据帧。至于如何进行TCP/UDP连接本文就不再赘述(之前的一段关于web server的程序已经大概说明)，直接从最关键的原始套接字（ raw socket）
C语言实现Linux网络嗅探器
weixin_30951743的博客
12-14 1953
C语言实现Linux网络嗅探器 0x01 实验简介 网络嗅探器是拦截通过网络接口流入和流出的数据的程序。所以，如果你正在浏览的互联网，嗅探器以数据包的形式抓到它并且显示。在本实验中，我们用 C 语言实现了一个网络嗅探器。 0x02程序框架和功能描述 本程序使用c语言编程，实现linux环境下网络嗅探的功能，并实现对接收到的UDP数据报进行解析。 0x03程序代码 sniffer.h #...
1、Linux下C语言 编写简单的网络嗅探器: 基本的数据包抓取分析
qwrdxer的博客
10-20 3488
首先贴上源代码 #include <stdio.h> #include <errno.h> #include <unistd.h> #include <sys/socket.h> #include <sys/types.h> #include <arpa/inet.h> #include <cstdlib> //协议相关结构体 #include <netinet/if_ether.h> int main(
linux下sniffer程序的实现,C语言实现LINUX下网络嗅探程序SNIFFER
weixin_29819789的博客
05-06 360
#include#include#include#include#include#include#include#include#include#includeint main(int argc,char**argv){int sock,n;char buffer[2048];unsigned char*iphead,*ethhead;struct ifreq ethreq;int no=0;//...
基于Linux_C实现的网卡抓包程序
10-22
基于Linux——c实现的网卡抓包程序，写大作业必备！代码详实，直接可以交作业！
socket+linux基础编程+libpcap抓包+网络抓包.rar
07-14
本压缩包系东北大学软件学院信息安全专业 《程序实践2》所用 代码及报告仅供参考 libpcap环境搭建等等基础linux程序设计 ├─libpcap环境搭建 ├─Linux-PDF Version │ ├─第一讲--Linux 导论 │ ├─第三讲--...
linux下ip抓包分析
04-02
linux下如何用c语言实现ip数据包的抓获，并对其进行分析，并附有Makefile
用Wireshark简单分析HTTPS传输过程-抓包过程 - manjingliu的编程之旅 - CSDN博客1
08-03
摘要视图订阅manjingliu的编程之旅在校学，认真学编程登录 | 注册登录 | 注册安全（38）76494次千里之外15篇221篇1篇1条三、开始监听htt
linux 上用C++实现的网络嗅探器
04-07
在linux平台上，用C++ 封装 raw socket套节子编程，包括makefile文件的所有源代码，希望对你有帮助。
C语言网络抓包程序
04-23
简单的抓包程序#define MAX_HOSTNAME_LAN 255 #define SIO_RCVALL _WSAIOW(IOC_VENDOR,1) #define MAX_ADDR_LEN 16 #pragma comment(lib,"WS2_32.lib")
linux 下c实现简单的网络嗅探器
02-14
简单的网络嗅探器
网络抓包winpcap版本C语言实现
09-19
利用winpcap包实现了网络抓包，并对各种协议头进行初步分析，可以抓取数据链路层的数据，对计算机网络的学习有很大的帮助，C语言实现
简单的网络嗅探器（Linux 源码）
10-04
简单的网络嗅探器 Linux 下的socket 编程的实践 libnet libcap 的应用 附简单的项目文档
Linux网络嗅探器实验报告,C语言实现 Linux 网络嗅探器
weixin_35880151的博客
05-04 737
关注「实验楼」，每天分享一个项目教程网络嗅探器是拦截通过网络接口流入和流出的数据的程序。所以，如果你正在浏览的互联网，嗅探器以数据包的形式抓到它并且显示。小编今天介绍的项目呢，就是用 C 语言实现了一个网络嗅探器。项目名称：【C语言实现 Linux 网络嗅探器】项目简介：本项目通过原生套接字的方式，监听所有本地主机收发的数据链路层帧结构，然后解析数据包的类型，并记录到日志文件。实现一个轻量级的网络...
Linux whois命令C/C++实现及WHOIS协议抓包分析
chen1415886044的博客
09-01 1432
WHOIS 客户端向 WHOIS 服务器发出文本请求，然后 WHOIS 服务器回复文本内容。WHOIS 是一种基于 TCP 的面向事务的查询/响应协议，广泛用于向 Internet 用户提供信息服务。当你运行后，其中一个注册机构将处理您的请求并从相应的 whois 记录中向你发送详细信息。whois 是一个有用的 Linux 命令，可让您轻松获取有关域或网站的详细信息。可以在 Linux 中运行此命令来查找有关域的信息。这是获取有关特定域或 IP 地址的信息的一种非常有用的方法。
小白装linux ubuntu系统并搭建libpcap环境写网络嗅探器
qq_43498164的博客
05-07 675
这次疫情，我们老师要我们这些没学过Linux系统的去下载linux并在这个系统环境下写出网络嗅探器，我觉得这个老师就是在刁难我胖虎，不写不行啊，要挂科啊，最后还是硬着头皮写了，前后大概用了7或8天的样子，包括环境搭配，系统安装，程序开发什么的，最后还是不会在linux下进行界面搭建，好像要用什么gbk+？ 这里直接教大家如何从零开始构建环境。 1.安装linux系统 两种方法，u盘安装或者虚拟机，...
c语言抓包并分析
01-21
纯c语言实现抓包，分析包的来源IP，硬件地址和目的地IP硬件地址，以及以太网类型，对原始套接字学习有所帮助
c语言实现linux 命令行
最新发布
10-25
C语言可以通过调用Linux系统的API实现命令行功能。其中，使用execve函数可以执行一个可执行文件，第一个参数为可执行文件的路径，第二个参数为传递给可执行文件的参数，第三个参数为环境变量。而使用fork函数可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值