`
jakielong
  • 浏览: 229166 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

自己用libpcap来抓包

阅读更多

#define APP_NAME        "sniffex"
#define APP_DESC        "Sniffer example using libpcap"
#define APP_COPYRIGHT    "Copyright (c) 2005"
#define APP_DISCLAIMER    "THERE IS ABSOLUTELY NO WARRANTY FOR THIS PROGRAM."

#include <pcap.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

/* default snap length (maximum bytes per packet to capture) */
#define SNAP_LEN 1518

/* ethernet headers are always exactly 14 bytes [1] */
#define SIZE_ETHERNET 14

/* 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 */
};

void
got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);

void
print_payload(const u_char *payload, int len);

void
print_hex_ascii_line(const u_char *payload, int len, int offset);

void
print_app_banner(void);

void
print_app_usage(void);

/*
 * app name/banner
 */
void
print_app_banner(void)
{

    printf("%s - %s\n", APP_NAME, APP_DESC);
    printf("%s\n", APP_COPYRIGHT);
    printf("%s\n", APP_DISCLAIMER);
    printf("\n");

return;
}

/*
 * print help text
 */
void
print_app_usage(void)
{

    printf("Usage: %s [interface]\n", APP_NAME);
    printf("\n");
    printf("Options:\n");
    printf(" interface Listen on <interface> for packets.\n");
    printf("\n");

return;
}

/*
 * print data in rows of 16 bytes: offset hex ascii
 *
 * 00000 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a GET / HTTP/1.1..
 */
void
print_hex_ascii_line(const u_char *payload, int len, int offset)
{

    int i;
    int gap;
    const u_char *ch;

    /* offset */
    printf("%05d ", offset);
    
    /* hex */
    ch = payload;
    for(i = 0; i < len; i++) {
        printf("%02x ", *ch);
        ch++;
        /* print extra space after 8th byte for visual aid */
        if (i == 7)
            printf(" ");
    }
    /* print space to handle line less than 8 bytes */
    if (len < 8)
        printf(" ");
    
    /* fill hex gap with spaces if not full line */
    if (len < 16) {
        gap = 16 - len;
        for (i = 0; i < gap; i++) {
            printf(" ");
        }
    }
    printf(" ");
    
    /* ascii (if printable) */
    ch = payload;
    for(i = 0; i < len; i++) {
        if (isprint(*ch))
            printf("%c", *ch);
        else
            printf(".");
        ch++;
    }

    printf("\n");

return;
}

/*
 * print packet payload data (avoid printing binary data)
 */
void
print_payload(const u_char *payload, int len)
{

    int len_rem = len;
    int line_width = 16;            /* number of bytes per line */
    int line_len;
    int offset = 0;                    /* zero-based offset counter */
    const u_char *ch = payload;

    if (len <= 0)
        return;

    /* data fits on one line */
    if (len <= line_width) {
        print_hex_ascii_line(ch, len, offset);
        return;
    }

    /* data spans multiple lines */
    for ( ;; ) {
        /* compute current line length */
        line_len = line_width % len_rem;
        /* print line */
        print_hex_ascii_line(ch, line_len, offset);
        /* compute total remaining */
        len_rem = len_rem - line_len;
        /* shift pointer to remaining bytes to print */
        ch = ch + line_len;
        /* add offset */
        offset = offset + line_width;
        /* check if we have line width chars or less */
        if (len_rem <= line_width) {
            /* print last line and get out */
            print_hex_ascii_line(ch, len_rem, offset);
            break;
        }
    }

return;
}

/*
 * dissect/print packet
 */
void
got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{

    static int count = 1; /* packet counter */
    
    /* declare pointers to packet headers */
    const struct sniff_ethernet *ethernet; /* The ethernet header [1] */
    const struct sniff_ip *ip; /* The IP header */
    const struct sniff_tcp *tcp; /* The TCP header */
    const u_char *payload; /* Packet payload */

    int size_ip;
    int size_tcp;
    int size_payload;
    
    printf("\nPacket number %d:\n", count);
    count++;
    
    /* define ethernet header */
    ethernet = (struct sniff_ethernet*)(packet);
    
    /* define/compute ip header offset */
    ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
    size_ip = IP_HL(ip)*4;
    if (size_ip < 20) {
        printf(" * Invalid IP header length: %u bytes\n", size_ip);
        return;
    }

    /* print source and destination IP addresses */
    printf(" From: %s\n", inet_ntoa(ip->ip_src));
    printf(" To: %s\n", inet_ntoa(ip->ip_dst));
    
    /* determine protocol */    
    switch(ip->ip_p) {
        case IPPROTO_TCP:
            printf(" Protocol: TCP\n");
            break;
        case IPPROTO_UDP:
            printf(" Protocol: UDP\n");
            return;
        case IPPROTO_ICMP:
            printf(" Protocol: ICMP\n");
            return;
        case IPPROTO_IP:
            printf(" Protocol: IP\n");
            return;
        default:
            printf(" Protocol: unknown\n");
            return;
    }
    
    /*
     * OK, this packet is TCP.
     */
    
    /* define/compute tcp header offset */
    tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip);
    size_tcp = TH_OFF(tcp)*4;
    if (size_tcp < 20) {
        printf(" * Invalid TCP header length: %u bytes\n", size_tcp);
        return;
    }
    
    printf(" Src port: %d\n", ntohs(tcp->th_sport));
    printf(" Dst port: %d\n", ntohs(tcp->th_dport));
    
    /* define/compute tcp payload (segment) offset */
    payload = (u_char *)(packet + SIZE_ETHERNET + size_ip + size_tcp);
    
    /* compute tcp payload (segment) size */
    size_payload = ntohs(ip->ip_len) - (size_ip + size_tcp);
    
    /*
     * Print payload data; it might be binary, so don't just
     * treat it as a string.
     */
    if (size_payload > 0) {
        printf(" Payload (%d bytes):\n", size_payload);
        print_payload(payload, size_payload);
    }

return;
}

int main(int argc, char **argv)
{

    char *dev = NULL;            /* capture device name */
    char errbuf[PCAP_ERRBUF_SIZE];        /* error buffer */
    pcap_t *handle;                /* packet capture handle */

    char filter_exp[] = "dst 202.114.85.31 and tcp";        /* filter expression [3] */
    struct bpf_program fp;            /* compiled filter program (expression) */
    bpf_u_int32 mask;            /* subnet mask */
    bpf_u_int32 net;            /* ip */
    int num_packets = 10;            /* number of packets to capture */

    print_app_banner();

    /* check for capture device name on command-line */
    if (argc == 2) {
        dev = argv[1];
    }
    else if (argc > 2) {
        fprintf(stderr, "error: unrecognized command-line options\n\n");
        print_app_usage();
        exit(EXIT_FAILURE);
    }
    else {
        /* find a capture device if not specified on command-line */
        dev = pcap_lookupdev(errbuf);
        if (dev == NULL) {
            fprintf(stderr, "Couldn't find default device: %s\n",
             errbuf);
            exit(EXIT_FAILURE);
        }
    }
    
    /* get network number and mask associated with capture device */
    if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
        fprintf(stderr, "Couldn't get netmask for device %s: %s\n",
         dev, errbuf);
        net = 0;
        mask = 0;
    }

    /* print capture info */
    printf("Device: %s\n", dev);
    printf("Number of packets: %d\n", num_packets);
    printf("Filter expression: %s\n", filter_exp);

    /* open capture device */
    handle = pcap_open_live(dev, SNAP_LEN, 1, 1000, errbuf);
    if (handle == NULL) {
        fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);
        exit(EXIT_FAILURE);
    }

    /* make sure we're capturing on an Ethernet device [2] */
    if (pcap_datalink(handle) != DLT_EN10MB) {
        fprintf(stderr, "%s is not an Ethernet\n", dev);
        exit(EXIT_FAILURE);
    }

    /* compile the filter expression */
    if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
        fprintf(stderr, "Couldn't parse filter %s: %s\n",
         filter_exp, pcap_geterr(handle));
        exit(EXIT_FAILURE);
    }

    /* apply the compiled filter */
    if (pcap_setfilter(handle, &fp) == -1) {
        fprintf(stderr, "Couldn't install filter %s: %s\n",
         filter_exp, pcap_geterr(handle));
        exit(EXIT_FAILURE);
    }

    /* now we can set our callback function */
    pcap_loop(handle, num_packets, got_packet, NULL);

    /* cleanup */
    pcap_freecode(&fp);
    pcap_close(handle);

    printf("\nCapture complete.\n");

return 0;
}
 
分享到:
评论

相关推荐

    libpcap+抓包解析示例

    由于系统限制,包最大每次抓包最大长度为1518字节,建议自定义的基于udp的通信协议包不要超过1450字节,这样的话,通过udp传输数据,就不会分片,可以用libpcap直接抓包,不用后期组包处理数据。libpcap个人认为主要...

    linux下的libpcap抓包分析程序

    总的来说,libpcap抓包分析程序在网络安全、故障排查、性能监控和网络协议分析等领域有着广泛的应用。通过学习和使用libpcap,开发者可以深入了解网络通信的细节,为网络管理、安全检测和数据分析提供强大的工具。

    基于Libpcap实现的局域网嗅探抓包发包解析工具_嗅探抓包发包解析工具_

    基于Libpcap实现的局域;网嗅探抓包发包解析工具.

    libpcap网络抓包入门.rar

    本教程将带你走进libpcap的世界,了解如何利用这一工具进行网络抓包。 一、libpcap简介 libpcap是Linux和Unix系统上最常用的网络数据包捕获库,它也支持Windows操作系统。它的主要功能是在底层网络接口层捕获传输中...

    libpcap抓包原理[参考].pdf

    libpcap 抓包原理 libpcap 是一个常用的网络嗅探器库,用于捕获和处理网络数据包。它主要由两部分组成:网络分接头 (Network Tap) 和数据过滤器 (Packet Filter)。libpcap 的工作原理是使用 BSD Packet Filter (BPF...

    基于libpcap网卡抓包

    **基于libpcap的网卡抓包技术** libpcap是一个强大的开源库,主要用于在网络层进行数据包捕获。这个库被广泛应用于网络监控、数据分析、安全检测等多个领域。libpcap提供了对底层网络接口的访问,使得开发者可以...

    linux下libpcap抓包分析.pdf

    libpcap抓包分析 libpcap是Linux平台下的一款强大的网络抓包分析工具,能够抓取和分析网络流量。本文将对libpcap的基本原理、抓包流程、数据类型定义和API函数进行详细的介绍。 一、libpcap的基本原理 libpcap是...

    linux-get-net-packet-libpcap.rar_libpcap_libpcap抓包

    "linux-get-net-packet-libpcap.rar_libpcap_libpcap抓包"这个压缩包文件似乎包含了使用libpcap库编写的抓包程序,可能用于在Linux环境下抓取和解析网络流量。 libpcap库由随同tcpdump工具一起开发的团队创建,其...

    libpcap抓包程序.zip

    这个“libpcap抓包分析项目”是一个学习资源,旨在帮助用户理解和掌握如何利用libpcap进行网络监控和数据分析。下面将详细介绍libpcap的基本概念、工作原理以及如何通过提供的源代码文件进行学习。 1. **libpcap...

    libpcap 抓包 实现网址的显示 有注释

    在提供的`snifferhttps.c`文件中,可以看到使用libpcap进行抓包和处理HTTP数据包的具体实现。代码可能包括以下步骤: - 打开网络接口:`pcap_open_live()`用于打开一个网络接口。 - 设置过滤器:`pcap_compile()`...

    socket+linux基础编程+libpcap抓包+网络抓包.rar

    本压缩包系东北大学软件学院信息安全专业 《程序实践2》所用 代码及报告仅供参考 libpcap环境搭建等等基础linux程序设计 ├─libpcap环境搭建 ├─Linux-PDF Version │ ├─第一讲--Linux 导论 │ ├─第三讲--...

    libpcap 底层抓包源码

    pcap实现底层IP抓包,ethereal就是用的这个库 ###########资源有误,不好意思 别下 了

    Linux下实现libpcap抓包并保存在文件里的示例程序及参考文档

    本示例程序及参考资料将帮助你理解如何使用libpcap来抓取网络流量,并将捕获的数据保存到文件中。 首先,`pcap_filter.cpp`是一个展示libpcap过滤器功能的示例。libpcap提供了基于BPF(Berkeley Packet Filter)的...

    libpcap-MT多线程抓包处理包

    "libpcap-MT多线程抓包处理包" 指的是一个利用libpcap库,并采用多线程技术来实现同时抓取和处理网络数据包的程序。这里的“MT”代表多线程(Multi-Threaded),意味着程序使用了并发处理以提高性能。 **描述详解:...

    ipv6网络抓包程序

    IPv6网络抓包程序是一种用于监测和分析网络通信的工具,它使用了WpdPack库来捕获和解析IPv6数据包。WpdPack库是一个广泛使用的网络开发资源,特别适用于网络诊断、性能测试和协议分析。在这个程序中,我们重点关注的...

    libpcap网络抓包与分析.zip

    基于LINUX系统设计并实现一个网络流量的分析系统。该系统具有以下功能:(1)实时抓取网络数据。(2)网络协议分析与显示。(3)将网络数据包聚合成数据流,以源IP、目的IP、源端口、目的端口及协议等五元组的形式...

    arp.rar_arp抓包工具_libpcap_libpcap qt_pcap arp_qt 抓包

    总的来说,这个名为“arp”的压缩包文件包含了一个用C++和Qt开发的,基于libpcap库的ARP抓包工具。通过这个工具,用户可以监控网络中的ARP通信,了解设备间的IP到MAC地址映射,以及可能存在的ARP攻击,如ARP欺骗,...

    Linux网络抓包工具pcap,界面采用Qt制作

    在本案例中,开发者使用Qt Creator作为集成开发环境,设计了网络抓包工具的用户界面,使得非编程背景的用户也能方便地操作和查看网络数据包。 `socket`编程是网络编程的基础,它允许程序通过网络发送和接收数据。在...

    Libpcap+QT

    Libpcap是一个在多种操作系统上广泛使用的开源库,它的主要功能是捕获网络数据包。它提供了低级别的接口,允许开发者直接访问网络接口层,从而获取网络上的原始数据包。Libpcap不仅支持实时的数据包捕获,还支持将...

    Java抓包分析四(基于jnetpcap进行抓包)

    libpcap是广泛使用的网络抓包库,被许多网络工具如Wireshark所依赖。 首先,理解基本概念至关重要。网络封包(Packet)是数据在网络中传输的基本单位,包含了源地址、目标地址、协议类型以及数据内容等信息。抓包...

Global site tag (gtag.js) - Google Analytics