c语言实现linux抓包

最新推荐文章于 2022-05-14 18:49:41 发布
最新推荐文章于 2022-05-14 18:49:41 发布
阅读量1.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
关注
linux下c语言抓包,C语言实现抓包工具
weixin_35318150的博客
05-12 2059
本文使用libpcap库在linux下面开发自定义抓包工具，同学们也可以在win下编写同样的代码。抓包的目的：1、分析协议2、伪造数据包3、获取重要信息，例如用户名和密码4、做某些攻击使用抓包的工具(1)Wireshark 可视化的工具(2)Tcpdump是命令行的工具。(3)自定义抓包工具原因1: 只抓取感兴趣的部分，去掉无关紧要的东西，为其他目的服务。原因2：如果有别的目的，例如偷偷安装在别的...
linux下c语言抓包,linux下c语言抓包库libpcap
weixin_35867508的博客
05-12 539
安装命令：sudo apt-get install libpcap-dev由于自己还没仔细研究过，暂时也只是想在这里留个记录，方便以后需要时使用。下面是百度百科里的例子。#include #include #include int main(int argc, char *argv[]){pcap_if_t *alldevs;pcap_if_t *device;char errbuf[PCAP_E...
c语言实现的抓包程序
05-21
c语言实现的抓包程序c语言实现的抓包程序c语言实现的抓包程序
基于Linux_C实现的网卡抓包程序
10-22
基于Linux——c实现的网卡抓包程序，写大作业必备！代码详实，直接可以交作业！
Linux&C语言简单实现抓包分析-Wireshark
qq_47355554的博客
05-14 2371
目录一、数据交互1.Windows运行网络调试助手作为 TCP 服务器2.Ubuntu启动一个TCP客户端程序客户端---02client.c执行结果二、抓包分析wireshark1.应用层---用户数据2.传输层---TCP协议转载：3.网络层---IP协议路由器是根据ip地址来收发数据的，路由器是一个工作在网络层的设备4.链路层---以太网(MAC)交换机是根据mac地址收发数据的，所以交换机是工作在链路层的设备6. 非原创 一、数据交互 1.Windows运行网络调试助手作为 TCP 服务器 Net
尝试探索基于Linux C的网卡抓包过程
ZoMoe's eye
04-11 5085
其实想探究网卡抓包问题已经有好久了。前几天找了时间算是基本上了解了那部分的一些基本东西，在这里只是赘述罢了。 抓包首先便要知道经过网卡的数据其实都是通过底层的链路层（MAC），在Linux系统中我们获取网卡的数据流量其实是直接从链路层收发数据帧。至于如何进行TCP/UDP连接本文就不再赘述(之前的一段关于web server的程序已经大概说明)，直接从最关键的原始套接字（ raw socket）
c语言抓包程序
04-04
用c语言写的抓包程序，能在vc++6.0上面直接运行的，比较不错的
C语言实现的网卡监控抓包代码
06-23
综上所述，这个“C语言实现的网卡监控抓包代码”项目涵盖了诸多核心IT概念，包括网络数据包抓取原理、C语言编程、套接字编程、网络协议理解、数据处理和文件I/O操作。对于学习计算机科学的学生而言，完成这样一个...
abc.rar_C语言抓包_abc命令_c语言 wireshark_抓包
09-21
在C语言中，实现抓包功能需要使用低级的网络接口，如在Linux系统中可能使用`libpcap`库。`libpcap`提供了操作系统级别的接口，可以直接访问网络接口捕获原始数据包，而无需通过高层的socket API。 4. **abc命令**...
c语言网络抓包程序代码,基于C语言实现的Ping程序
weixin_35524300的博客
05-17 888
【前言】Ping 是用于测试网络连接量的程序,利用它可以检查网络是否能够连通。Ping程序的实现原理非常简单，即发送一个ICMP回声请求消息给目的地并报告是否收到所希望的ICMP回声应答。本文采用C语言编写一个ing功能的程序。0.ICMP协议简介ICMP是(Internet Control Message Protocol)Internet控制报文协议。它是TCP/IP协议族的一个子协议，用于在...
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")
网络编程-----抓包程序（C语言版）
10-07
winsock 抓包，抓TCP,UDP，并解析报文头
c语言抓包并分析
01-21
纯c语言实现抓包，分析包的来源IP，硬件地址和目的地IP硬件地址，以及以太网类型，对原始套接字学习有所帮助
c语言下winpcap抓包
01-04
程序功能： 1、构造arp包，并发送。程序参数顺序：源IP、目的IP、mac地址、flag 2、获取网络中的ARP数据包，解析数据包的内容。程序参数：日志文件名
网络抓包winpcap版本C语言实现
09-19
利用winpcap包实现了网络抓包，并对各种协议头进行初步分析，可以抓取数据链路层的数据，对计算机网络的学习有很大的帮助，C语言实现
C语言-编写抓包
(∪.∪ )...zzz的博客
10-28 3402
这里写自定义目录标题实验需求libpcap安装获取targetIP编译运行capture.c：开启监听 实验需求 使用Libpcap库捕获局域网中的IP包，要求： 打印数据包的源与目的物理地址； 打印源IP与目的IP地址； 打印出上层协议类型； 如果上层协议为TCP或UDP协议，打印目的与源端口信息； 如果上层协议为TCP或UDP协议，将数据以16进制与ASCII的两种方式同时打印出来，不可打印字符以’.'代替； 00000 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 3
linux c抓包,基于Linux C的socket抓包程序和Package分析
weixin_33577842的博客
05-16 241
测试运行平台：CentOS 6.5发行版，内核版本3.113. 利用wireshark分析数据包如果要使用wireshark分析数据包，则应将抓取到的数据按照pcap文件指定格式存储到文件中。附：安装wiresharksudo yum install wiresharksudo yum install wireshak-gnome(1)pcap文件头格式的结构体定义如下。typedef struc...
linux下c语言抓包库libpcap
11-14 3560
安装命令：sudo apt-get install libpcap-dev 由于自己还没仔细研究过，暂时也只是想在这里留个记录，方便以后需要时使用。下面是百度百科里的例子。 #include #include #include int main(int argc, char *argv[]) { pcap_if_t *alldevs; pcap_if
linux c抓包程序,基于Linux C实现的网卡抓包程序
weixin_39754411的博客
05-12 145
/********************************************************* 功能：网络抓包工具* 环境: GCC-4.2.4* 作者：YSQ-NJUST,yushengqiangyu@163.com* 备注：自由软件，主要用于学习、交流、共享。*******************************************************/#...
Linux摄像头抓包实战项目：C语言源码解析
资源摘要信息:"本资源主要提供了一个利用Linux系统进行抓包操作的C语言项目源码，此项目名为'实验42 照相机实验'，主要用于学习和理解Linux下摄像头的操作以及网络抓包技术。项目源码中包含了必要的C语言代码，这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值