C++解析与生成PCAP抓包数据

最新推荐文章于 2023-07-26 10:47:02 发布
最新推荐文章于 2023-07-26 10:47:02 发布
阅读量7.2k 收藏 26
点赞数
分类专栏： 代码相关 抓包 PCAP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c520120/article/details/23827587
版权
代码相关 同时被 3 个专栏收录
7 篇文章 1 订阅
订阅专栏
抓包
1 篇文章 0 订阅
订阅专栏
PCAP
1 篇文章 0 订阅
订阅专栏 
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <math.h>
#include <time.h>
#include <WinSock2.h>
#include <io.h>
typedef unsigned int  bpf_u_int32;
typedef unsigned short u_short;
typedef int    bpf_int32;
typedef unsigned char  u_int8_t;
typedef unsigned short int u_int16_t;
typedef unsigned int  u_int32_t;
typedef struct pcap_file_header
{
    bpf_u_int32 magic;
    u_short version_major;
    u_short version_minor;
    bpf_int32 thiszone;
    bpf_u_int32 sigfigs;
    bpf_u_int32 snaplen;
    bpf_u_int32 linktype;
} pcap_file_header;
typedef struct timestamp
{
    bpf_u_int32 timestamp_s;
    bpf_u_int32 timestamp_ms;
} timestamp;
typedef struct pcap_header
{
    timestamp ts;
    bpf_u_int32 capture_len;
    bpf_u_int32 len;
} pcap_header;
typedef struct ether_header
{
    u_int8_t ether_dhost[6];        //destination mac address
    u_int8_t ether_shost[6]; //source mac address
    u_int16_t ether_type;  //ethernet type
} ether_header;

typedef struct ip_hdr
{
#if LITTLE_ENDIAN
    u_int8_t    ihl:4; //
    u_int8_t    version:4; //version
#else
    u_int8_t    version:4;
    u_int8_t    ihr:4;
#endif

    u_int8_t      tos;  //service type
    u_int16_t     tos_len; //total len
    u_int16_t     id;  //
    u_int16_t     frag_off; //offset
    u_int8_t      ttl;  //live time
    u_int8_t      protocol; //
    u_int16_t     chk_sum; //check sum
    struct in_addr    srcaddr; //source ip
    struct in_addr    dstaddr; //destnation ip
} ip_hdr;
//total length : 20Bytes
typedef struct tcp_hdr
{
    u_int16_t     src_port;  //source port
    u_int16_t     dst_port;  //destination port
    u_int32_t     seq_no;  //
    u_int32_t     ack_no;  //

    u_int8_t      reserved_1:4;
    u_int8_t      th1:4;  //tcp header length
    u_int8_t      flag:6;
    u_int8_t      reserverd_2:2;
    u_int16_t     wnd_size;  //16 bit windows
    u_int16_t     chk_sum;  //16 bits check sum
    u_int16_t     urgt_p;  //16 urgent p
} tcp_hdr;
//total length :8 Bytes
typedef struct udp_hdr
{
    u_int16_t src_port;
    u_int16_t dst_port;
    u_int16_t uh1;
    u_int16_t chk_sum;
} udp_hdr;
typedef struct raw_data_pcap
{
    u_int8_t   hostname[20];
    u_int8_t   *timestamp;
    u_int8_t   src_mac[6];
    u_int8_t   dst_mac[6];
    u_int16_t  NetL_type;

    u_int8_t   src_IP[4];
    u_int8_t   dst_IP[4];
    u_int8_t   TransL_type;
    u_int16_t  src_port;
    u_int16_t  dst_port;

    u_int8_t   *data;
} raw_data_pcap;
typedef struct pcap_ip_data_hdr_s {
    ip_hdr __hdr__;
    u_int32_t length;
} pcap_ip_data_hdr;
#define PCAP_IPDATA_HDR(obj) ((pcap_ip_data_hdr*)obj)
#define PCAP_IPHEADER(obj) ((ip_hdr*)obj)
typedef struct pcap_ip_raw_data_s {
    pcap_ip_data_hdr __hdr__;
    u_int8_t* data;
} pcap_ip_raw_data;
typedef struct pcap_raw_data_s {
    u_int8_t length;
    u_int8_t* data;
} pcap_raw_data;
typedef struct pcap_tcp_data_s {
    pcap_ip_data_hdr __hdr__;
    tcp_hdr hdr;
    u_int8_t* data;
} pcap_tcp_data;
typedef struct pcap_udp_data_s {
    pcap_ip_data_hdr __hdr__;
    udp_hdr hdr;
    u_int8_t* data;
} pcap_udp_data;
typedef struct pcap_link_s {
    pcap_header pcaphdr;
    ether_header etherhdr;
    void* data;
    struct pcap_link_s* next;
} pcap_link;
typedef struct pcap_s {
    pcap_file_header fhdr;
    pcap_link* link;
} pcap_data;
void free_pcap(pcap_data** pcap);
typedef enum pcap_result_s {
    PARSE_SUCCESS,
    PARSE_ERROR,
} pcap_result;
pcap_result parse_pcap(const char* fname,pcap_data**pcap)  ;
pcap_result parse_pcap(const char* fname,pcap_data**pcap) { 
    pcap_link* link=NULL;
    pcap_result result=PARSE_SUCCESS;
    ip_hdr iphdr;
    FILE* pRead = fopen(fname, "rb");
    long fsize=0;
    long foffset=0;

    if(!pRead) {
        result=PARSE_ERROR;
        goto Fail;
    }

    *pcap=(pcap_data*)calloc(1,sizeof(pcap_data));
    fseek(pRead,0,SEEK_END);
    fsize=ftell(pRead);
    fseek(pRead,0,SEEK_SET);

    if(sizeof(pcap_file_header)!=fread(&(*pcap)->fhdr, 1, sizeof(pcap_file_header), pRead)) {
        result=PARSE_ERROR;
        free_pcap(pcap);
        goto Fail;
    }

    while((fsize-(foffset=ftell(pRead)))) {
        u_int16_t ether_type=0;

        if(!link) {
            link=(pcap_link*)calloc(1,sizeof(pcap_link));
            (*pcap)->link=link;

        } else {
            link->next=(pcap_link*)calloc(1,sizeof(pcap_link));
            link=link->next;
        }

        if(sizeof(pcap_header)!=fread(&link->pcaphdr,1,sizeof(pcap_header),pRead)) {
            result=PARSE_ERROR;
            free_pcap(pcap);
            goto Fail;
        }

        if(sizeof(ether_header)!=fread(&link->etherhdr,1,sizeof(ether_header),pRead)) {
            result=PARSE_ERROR;
            free_pcap(pcap);
            goto Fail;
        }

        ether_type=ntohs(link->etherhdr.ether_type);

        switch(ether_type) {
            case 0x0800://ip
                if(sizeof(iphdr)!=fread(&iphdr,1,sizeof(iphdr),pRead)) {
                    result=PARSE_ERROR;
                    free_pcap(pcap);
                    goto Fail;
                }

                switch(iphdr.protocol) {
                    case 6://tcp
                    {
                        // tcp_hdr tcphdr;
                        pcap_tcp_data* tcpData=(pcap_tcp_data*)calloc(1,sizeof(pcap_tcp_data));
                        PCAP_IPDATA_HDR(tcpData)->length= link->pcaphdr.capture_len-sizeof(ether_header)-sizeof(ip_hdr)-sizeof(tcp_hdr);
                        *PCAP_IPHEADER(tcpData)=iphdr;

                        if(sizeof(tcp_hdr)!=fread(&tcpData->hdr,1,sizeof(tcp_hdr),pRead)) {
                            result=PARSE_ERROR;
                            free_pcap(pcap);
                            goto Fail;
                        }

                        tcpData->data=(u_int8_t*)calloc(1,PCAP_IPDATA_HDR(tcpData)->length);

                        if(PCAP_IPDATA_HDR(tcpData)->length!=fread(tcpData->data,1,PCAP_IPDATA_HDR(tcpData)->length,pRead)) {
                            result=PARSE_ERROR;
                            free_pcap(pcap);
                            goto Fail;
                        }

                        link->data=tcpData;

                        break;
                    }

                    case 17://udp
                    {
                        pcap_udp_data* udpData=(pcap_udp_data*)calloc(1,sizeof(pcap_udp_data));
                        PCAP_IPDATA_HDR(udpData)->length= link->pcaphdr.capture_len-sizeof(ether_header)-sizeof(ip_hdr)-sizeof(udp_hdr);
                        *PCAP_IPHEADER(udpData)=iphdr;

                        if(sizeof(udp_hdr)!=fread(&udpData->hdr,1,sizeof(udp_hdr),pRead)) {
                            result=PARSE_ERROR;
                            free_pcap(pcap);
                            goto Fail;
                        }

                        udpData->data=(u_int8_t*)calloc(1,udpData->__hdr__.length);

                        if(PCAP_IPDATA_HDR(udpData)->length!=fread(udpData->data,1,PCAP_IPDATA_HDR(udpData)->length,pRead)) {
                            result=PARSE_ERROR;
                            free_pcap(pcap);
                            goto Fail;
                        }

                        link->data=udpData;
                    }
                    break;

                    default:
                    {
                        pcap_ip_raw_data* rawData=(pcap_ip_raw_data*)calloc(1,sizeof(pcap_ip_raw_data));
                        PCAP_IPDATA_HDR(rawData)->length=link->pcaphdr.capture_len-sizeof(ether_header)-sizeof(ip_hdr);
                        *PCAP_IPHEADER(rawData)=iphdr;

                        if(PCAP_IPDATA_HDR(rawData)->length!=fread(rawData->data,1,PCAP_IPDATA_HDR(rawData)->length,pRead)) {
                            result=PARSE_ERROR;
                            free_pcap(pcap);
                            goto Fail;
                        }
                    }
                    break;
                }

                break;

            default:
            {
                pcap_raw_data* rawData=(pcap_raw_data*)calloc(1,sizeof(pcap_raw_data));
                rawData->length=link->pcaphdr.capture_len-sizeof(ether_header);
                rawData->data=(u_int8_t*)calloc(1,rawData->length);

                if(rawData->length!=fread(rawData->data,1,rawData->length,pRead)) {
                    result=PARSE_ERROR;
                    free_pcap(pcap);
                    goto Fail;
                }

                link->data=rawData;
            }
            break;
        }
    }

Fail:

    if(pRead) {
        fclose(pRead);
    }

    return result;
}
void free_pcap(pcap_data** pcap) {
    pcap_link* link=NULL;
    pcap_link* prv=NULL;
    link=(*pcap)->link;

    while(link) {
        int ether_type;
        ether_type=ntohs(link->etherhdr.ether_type);

        switch(ether_type) {
            case 0x0800:
            {
                switch(PCAP_IPDATA_HDR(link->data)->__hdr__.protocol)
                {
                    case 6://tcp
                    {
                        pcap_tcp_data* tcpData=(pcap_tcp_data*)link->data;
                        free(tcpData->data),tcpData->data=NULL;
                        free(tcpData),link->data=NULL;
                    }
                    break;

                    case 17://udp
                    {
                        pcap_udp_data* udpData=(pcap_udp_data*)link->data;
                        free(udpData->data),udpData->data=NULL;
                        free(udpData),link->data=NULL;

                    }
                    break;

                    default:
                    {
                        pcap_ip_raw_data* rawData=(pcap_ip_raw_data*)link->data;
                        free(rawData->data),rawData->data=NULL;
                        free(rawData),link->data=NULL;
                    }
                    break;
                }
            }
            break;

            default:
            {
                pcap_raw_data* rawData=(pcap_raw_data*)link->data;
                free(rawData->data),rawData->data=NULL;
                free(rawData),link->data=NULL;
            }
            break;
        }

        prv=link;
        link=link->next;
        free(prv);
        (*pcap)->link=link;
    }

    free(*pcap);
    *pcap=NULL;
}
int main()
{
    const char* readfile="C:/111.pcap";
	const char* writefile="C:/111_2.pcap";
    pcap_data* pcap=NULL;
    pcap_link* link=NULL; 
    FILE* pWrite = NULL;
    if(PARSE_SUCCESS!=parse_pcap(readfile,&pcap)) 
	{
		printf("parse pcap file error.");
		goto OVER;
	}
	pWrite=fopen(writefile, "wb");
	if(!pWrite){
		printf("con't create write file:%s",writefile);
		goto OVER;
	}
    link=pcap->link; 
    fwrite(&pcap->fhdr, 1, sizeof(pcap_file_header), pWrite);

    while(link) {
        int ether_type;
        fwrite(&link->pcaphdr, 1, sizeof(pcap_header), pWrite);
        fwrite(&link->etherhdr, 1, sizeof(ether_header), pWrite);
        ether_type=ntohs(link->etherhdr.ether_type);

        switch(ether_type) {
            case 0x0800:
                fwrite(&PCAP_IPDATA_HDR(link->data)->__hdr__, 1, sizeof(ip_hdr), pWrite);

                switch(PCAP_IPDATA_HDR(link->data)->__hdr__.protocol) {
                    case 6://tcp
                    {
                        pcap_tcp_data* tcpData=(pcap_tcp_data*)link->data;
                        fwrite(&tcpData->hdr, 1, sizeof(tcp_hdr), pWrite);
                        fwrite(tcpData->data, 1, PCAP_IPDATA_HDR(tcpData)->length, pWrite);
                    }
                    break;

                    case 17://udp
                    {
                        pcap_udp_data* udpData=(pcap_udp_data*)link->data;
                        fwrite(&udpData->hdr, 1, sizeof(udp_hdr), pWrite);
                        fwrite(udpData->data, 1, PCAP_IPDATA_HDR(udpData)->length, pWrite);

                    }
                    break;

                    default:
                    {
                        pcap_ip_raw_data* rawData=(pcap_ip_raw_data*)link->data;
                        fwrite(rawData->data, 1, PCAP_IPDATA_HDR(rawData)->length, pWrite);
                    }
                    break;
                }

                break;

            default:
            {
                pcap_raw_data* rawData=(pcap_raw_data*)link->data;
                fwrite(rawData->data, 1, rawData->length, pWrite);
            }
            break;
        }

        link=link->next;
    }
OVER:
    if(pWrite) fclose(pWrite);
    if(pcap) free_pcap(&pcap);
    return 0;
}

c520120
关注
专栏目录
【网络入门】详解常用的基础网络知识（面试笔试常考内容）
dvlinker的技术专栏
04-26 6万+
本文结合多年来的工作实践，来详细讲述一下作为IT从业人员要掌握的一些基础网络知识。
C++ 解析pcap文件
fulianzhou的专栏
06-08 3330
C++解析tcpdump抓取的包
PCAP文件的解析软件
07-12
具备WIRESHARK的大部分功能，主要是指针的偏移来完成的。对初学者有一定的帮助。
C++实现pcap包解析，并提取指定特征帧
weixin_47658332的博客
11-01 6211
最近这几天观察到了一个木马的网络通信特征，于是就打算通过代码实现针对该木马的检测过滤。刚开始学长提供了python编写的代码。但是在实际的工作中，每天所捕获的pcap包的数据总量很大，通常在5到15个G左右。这种情况下，python的运行时间极长，且占用大量的系统运行内存，甚至会出现卡死情况。于是我尝试用C去实现木马的过滤，因为C是偏底层的编程语言，可以自定义通信协议，所以其运行效率会更高。
VS下c++解析pcap文件
最新发布
ljjjjjjjjjjj的博客
07-26 1003
https://www.cnblogs.com/Chary/articles/15716063.html
pcap文件格式介绍、解析以及读取（c/c++）
Tartisan的博客
08-15 8949
转自：http://imzc.net/archives/181/%E8%A7%A3%E6%9E%90pcap%E6%96%87%E4%BB%B6%E5%8F%8A%E6%BA%90%E7%A0%81/ 下面pcap文件格式介绍是在网上转的,根据理解，写了个程序来进行解析pcap文件，后续再实现合并pcap功能(wireshark已经自带命令行合并pcap文件工具，在这里只是为了分析pcap文
c++ 读取pcap文件
小x的博客
04-06 3406
pcap.h #pragma once typedef unsigned int bpf_u_int32; typedef unsigned short u_short; typedef int bpf_int32; typedef struct pcap_file_header { bpf_u_int32 magic; u_short version_major; u_short version_minor; bpf_int32 thiszone; b
VS2008使用Winpcap抓包并简单分析
07-10
在Windows环境下，开发网络应用程序时，有时我们需要对网络通信数据进行抓包和分析。Visual Studio 2008（VS2008）作为一款强大的开发工具，可以与Winpcap库配合，帮助我们实现这一目标。Winpcap是一个开源的网络...
网络编程工程实训_实验五 使用Libpcap库实时抓包提取数据保存为TS文件
Sandra_93的博客
07-13 1356
实验任务： 使用前期搭建好的开发环境（Centos7.0+gcc+libpcap），使用C/C++语言开发一个应用程序，打开虚拟机网卡（与物理主机在同一个子网的）设备，实时抓取从物理主机发来的UDP数据包并进行解析，去除协议层头部，仅保留应用层数据，保存为TS文件（扩展名为ts）。 实验内容： 1.使用TS流发送软件Winsend发送TS视频数据流到虚拟机和VMnet8网卡所在的网络（或者以单播的...
pcap如何转换为pcd_激光雷达pcap包转换为bag包、pcd文件
weixin_29102619的博客
02-28 3328
参考：https://blog.csdn.net/geerniya/article/details/90681003web说明：本文选用的是速腾16线激光雷达。iview1. 采集 pcap 文件：经过 Wireshark 抓包或速腾激光雷达的上位机软件 rsview 采集数据，获得 pcap 原始文件。svg2. ros 上回放 pcap 文件：在速腾激光雷达的 ros 驱动上，修改 ros_r...
C++基于WinPcap抓UDP包并解析内容
11-14
C++基于WinPcap抓UDP包并解析内容，VS2013环境，宽字节
C语言分析pcap文件
04-15
本文档是C语言编写，基于linux下对pcap格式文件的分析，希望能够提供帮助。
pcap格式文件分析-源码
01-30
支持网络分析仪的抓包数据格式pcap格式文件解析，并可以实现根据源目标不同进行选择性分析。
pcap包 TCP/UDP/FTP分析
07-12
课程学习任务 对抓到的pcap包进行分析 输出 tcp/udp 五元组 可对ftp传输的文件还原 环境：VS2015 + wincap
c++实现对cap抓TCP、UDP包文件的解析
12-23
c++实现对cap抓TCP、UDP包文件的解析，可以用windump抓包后直接解析。通过循环解析出cap文件中每个包的IP头的各部分含义、TCP/UDP头的含义。这些部分都储存在结构体中，如果需要统计，读者可自行编写统计规则。由于本程序是逐个包按照包头各字段分块解析，因此如果读者对解包的性能要求较高的话不建议下载。
用jpcap读取pcap抓包文件并做简单的过滤显示
小懿大侠的专栏
04-15 5699
已经完成了最简单的从pcap文件中读取每个报文，然后再转换成文本格式显示报文头信息，以便于后面分析用，这里做了简单的过滤，根据源目的ip地址，或者查找tcp没有响应的报文。以后又空再完善其他的功能。 import java.net.InetAddress; import jpcap.*; import jpcap.packet.EthernetPacket; import jpcap.p
Pcap包解析
热门推荐
weixinhum
01-31 1万+
之前一直做视觉相关的工作，近期接触激光雷达才发现，激光雷达传感器厂商保存数据的方式一般采用Pcap包的形式，虽然不太清楚为什么要这么做，但不管清不清楚总归只能跟着它这么搞。 一个Pcap文件包括“Pcap报头”，“数据区”两个部分，其中数据区又分成多个数据包，每个包有报头和数据两个部分，总体结构可见下图： 其中固定大小的为“Pcap报头”和数据包中的“数据报头”。 “Pcap报头”大小为24个字...
C++使用winpcap生成wireshark可解析文件
gongxie0235的博客
09-14 810
#define HAVE_REMOTE #include "pcap.h" int test() { pcap_if_t* alldevs; pcap_if_t* d; pcap_t* adhandle; char errbuf[PCAP_ERRBUF_SIZE]; int inum; int i = 0; u_int netmask; char packet_filter[] = "ip and tcp"; struct bpf_program fcode;
C++编程->pcap文件读取源码
Rana专栏
08-26 4429
#include #include #define LINE_LEN 16 void dispatcher_handler(u_char *, const struct pcap_pkthdr *, const u_char *); int main(int argc, char **argv) { pcap_t *fp; char errbuf[PCAP_ERRBUF_SIZE];
Java解析pcap抓包文件实战教程
在计算机网络中，抓包是一种常见的诊断和分析工具，用于捕获网络上的数据包以便于研究网络行为或解决网络问题。PCAP（Packet Capture）是这样的数据包捕获文件格式，它包含了网络上原始的数据包信息。本示例主要介绍...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值