精华内容
下载资源
问答
  • libnet

    2013-03-20 17:40:18
    libnet
  • Libnet

    2019-03-26 17:20:35
    下载https://download.csdn.net/download/lzwml/2293174 libnet介绍与分析https://www.cnblogs.com/hnrainll/archive/2011/09/21/2183940.html http://blog.chinaunix.net/uid-10167808-id-25912.html ...
    展开全文
  • Libnet is an API to help with the construction and injection of network packets. It provides a portable framework for low-level network packet writing and handling (use libnet in conjunction with ...
  • Bundle libnet

    2020-11-29 03:22:19
    <p>I have the usage of bundled libraries (right now, just libnet) enabled by default. libnet will be statically linked into the binary, so we're not dropping new shared libs onto the system. <p>...
  • Libnet入门

    2015-09-07 10:52:26
    在Unix系统平台上的网络安全工具开发中,目前最为流行的C API library有libnet、libpcap、libnids和libicmp等。它们分别从不同层次和角度提供了不同的功能函数。使网络开发人员能够忽略网络底层细节的实现,从而专注...
  • tests, libnet: Relocate validation to libnet <p>Cloud-Init network data enables network configuration to be set on a VMI through the cloud-init nocloud option. <p>Converted an existing helper ...
  • Libnet 概念 专业的构造和发送网络数据包的开发工具包 是个高层次的 API 函数库,允许开发者自己构造和发送网络数据包 Libnet 特点 隐藏了很多底层细节,省去了很多麻烦;如缓冲区管理、字节流顺序、校验和...

                                               粉丝不过W 

    Libnet 概念

        专业的构造和发送网络数据包的开发工具包

        是个高层次的 API 函数库,允许开发者自己构造和发送网络数据包

    Libnet 特点

         隐藏了很多底层细节,省去了很多麻烦;如缓冲区管理、字节流顺序、校验和计算等问题,使开发者把重心放到程序的开发中

         可轻松、快捷的构造任何形式的网络数据包,从而开发各种各样的网络程序

         使用非常广泛,如著名的软件 Ettercap、Firewalk、Snort、Tcpreplay

      Libnet 的安装

    sudo apt-get install libnet-dev

    Libnet 开发实例

       Libnet 开发流程

            利用 libnet 函数库开发应用程序的基本步骤:

                 数据包内存初始化

                构造数据包

                发送数据

                释放资源

           libnet 库主要功能: 

                内存管理

                地址解析

                包处理

    libnet_init 

    /*
     *function:
     *  数据包内存初始化及环境建立
     *parameter:
     *  injection_type: 构造的类型
            LIBNET_LINK
            LIBNET_RAW4
            LIBNET_LINK_ADV
            LIBNET_RAW4_ADV
     *  device:网络接口,如"eth0",或 IP 地址,亦可为 NULL(自动查询搜索)
     *  err_buf: 存放出错的信息
     *return:
     *  成功: 一个 libnet 句柄
     *  失败: NULL
     */
    libnet_t *libnet_init(int injection_type, char *device, char *err_buf);
    lib_net = libnet_init(LIBNET_LINK_ADV, "eth0", err_buf);
    if(NULL == lib_net)
    {
        perror("libnet_init");
        exit(-1);
    }

    libnet_destroy

    /*
     *function:
     *  释放资源
     *parameter:
     *  l: libnet 句柄
     */
    void libnet_destroy(libnet_t *l);
    libnet_destroy(lib_net);

    libnet_build_udp

    /*
     *function:
     *  构造 udp 数据包
     *parameter:
     *  sp:        源端口号
     *  dp:       目的端口号
     *  len:      udp 包总长度
     *  sum:      校验和,设为 0,libnet 自动填充
     *  payload:  负载,可设置为 NULL
     *  payload_s:负载长度,或为 0
     *  l:         libnet 句柄
     *  ptag:     协议标记
     *return:
     *  成功: 协议标记
     *  失败: -1
     */
    libnet_ptag_t libnet_build_udp( u_int16_t sp,
                                    u_int16_t dp,
                                    u_int16_t len,
                                    u_int16_t sum,
                                    u_int8_t *payload,
                                    u_int32_t payload_s,
                                    libnet_t *l,
                                    libnet_ptag_t ptag)

    libnet_build_ipv4

    /*
     *function:
     *  构造一个 IPv4 数据包
     *parameter:
     *  ip_len:   ip 包总长
     *  tos:      服务类型
     *  id:       ip 标识
     *  flag:     片偏移
     *  ttl:      生存时间
     *  prot:     上层协议
     *  sum:      校验和,设为 0,libnet 自动填充
     *  src:       源 ip 地址
     *  dst:      目的 ip 地址
     *  payload:  负载,可设置为 NULL
     *  payload_s:负载长度,或为 0
     *  l:         libnet 句柄
     *  ptag:     协议标记
     *return:
     *  成功: 协议标记
     *  失败: -1
     */
    libnet_ptag_t libnet_build_ipv4(u_int16_t ip_len,
                                    u_int8_t tos,
                                    u_int16_t id,
                                    u_int16_t flag,
                                    u_int8_t ttl,
                                    u_int8_t prot,
                                    u_int16 sum,
                                    u_int32_t src,
                                    u_int32_t dst,
                                    u_int8_t *payload,
                                    u_int32_t payload_s,
                                    libnet_t *l,
                                    libnet_ptag_t ptag)

    libnet_build_ethernet

    /*
     *function:
     *  构造一个以太网数据包
     *parameter:
     *  dst:      目的 mac
     *  src:      源 mac
     *  type:     上层协议类型
     *  payload:  负载,即附带的数据
     *  payload_s:负载长度
     *  l:        libnet 句柄
     *  ptag:     协议标记
     *return:
     *  成功: 协议标记
     *  失败: -1
     */
    libnet_ptag_t libnet_build_ethernet(u_int8_t *dst,
                                        u_int8_t *src,
                                        u_int16_t type,
                                        u_int8_t *payload,
                                        u_int32_t payload_s,
                                        libnet_t *l,
                                        libnet_ptag_t ptag);

     libnet_write

    /*
     *function:
     *  发送数据到网络
     *parameter:
     *  l:libnet 句柄
     *return:
     *  失败:-1
     *  成功:其他
     */
    int libnet_write(libnet_t * l)

    demo:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <libnet.h>
    
    int main(int argc, char *argv[])
    {
        char send_msg[1000] = "";
        char err_buf[100] = "";
        libnet_t *lib_net = NULL;
        int lens = 0;
        libnet_ptag_t lib_t = 0;
        unsigned char src_mac[6] = {0x00, 0x0c, 0x29, 0x1b, 0x22, 0x0a};    //发送者网卡地址
        unsigned char dst_mac[6] = {0xc8, 0x9c, 0xdc, 0xa9, 0x52, 0x3c};    //接收者网卡地址
        char *src_ip_str = "172.20.226.3"; //源主机IP地址
        char *dst_ip_str = "172.20.226.2"; //目的主机IP地址
        unsigned long src_ip, dst_ip = 0;
        int res = 0;
    
        lens = sprintf(send_msg, 
                       "1_lbt4_5#131200#C89CDCB70F19#0#0#0#305b#5:%d:%s:%s:%d:%s",    
                       123,
                       "he.liang",
    	               "HE-LIANG",
                       32,
                       "lh");
    
        lib_net = libnet_init(LIBNET_LINK_ADV, "eth0", err_buf);	//初始化
        if(NULL == lib_net)
        {
            perror("libnet_init");
            exit(-1);
        }
        //将字符串类型的ip转换为顺序网络字节流
        src_ip = libnet_name2addr4(lib_net, src_ip_str, LIBNET_RESOLVE);
        dst_ip = libnet_name2addr4(lib_net, dst_ip_str, LIBNET_RESOLVE);
    
        //构造udp数据包
        lib_t = libnet_build_udp(2425,
                                 2425,
                                 8 + lens,
                                 0,
                                 send_msg,
                                 lens,
                                 lib_net,
                                 0);
        //构造ip数据包
        lib_t = libnet_build_ipv4(20+8+lens,
                                  0,
                                  500,
                                  0,
                                  10,
                                  17,
                                  0,
                                  src_ip,
                                  dst_ip,
                                  NULL,
                                  0,
                                  lib_net,
                                  0);
        //构造以太网数据包
        lib_t = libnet_build_ethernet((u_int8_t *)dst_mac,
                                      (u_int8_t *)src_mac,
                                      ETHERTYPE_IP,
                                      NULL,
                                      0,
                                      lib_net,
                                      0);
    
        res = libnet_write(lib_net);	//发送数据包
        if(-1 == res)
        {
            perror("libnet_write");
            exit(-1);
        }
    
        libnet_destroy(lib_net);	//销毁资源
        printf("----ok-----\n");
    	return 0;
    }

     ARP 欺骗

    局域网中的网络流通是按照 MAC 地址进行传输的,可以通过欺骗通信双方的 MAC 地址,即可达到干扰通信的目的

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <libnet.h>
    #include <pcap.h>
    
    #define MAC_ADDR_LEN 6
    #define IP_ADDR_LEN 4
    
    typedef unsigned char uchar;
    typedef unsigned long ulong;
    
    int main(int argc,char **argv)
    {
        libnet_t *net_t = NULL; 	//定义libnet_t指针变量
        char *dev = "eth0"; 		//定义设备名称
        char err_buf[LIBNET_ERRBUF_SIZE];
        libnet_ptag_t p_tag; 		//定义libnet_ptag_t变量
    
        //发送者网卡地址(伪装mac)
        uchar src_mac[MAC_ADDR_LEN] = {0x00,0x00,0x00,0x00,0x00,0x00};
        //接收者网卡地址
        uchar dst_mac[MAC_ADDR_LEN] = {0xff,0xff,0xff,0xff,0xff,0xff};
        char src_ip_str[20] = ""; //源主机IP地址(被伪装的ip)
        ulong src_ip,dst_ip = 0;
        char *net_interface = NULL;
        int res;
    
        printf("please input the aim ip:\n");
        fgets(src_ip_str, sizeof(src_ip_str), stdin);
        src_ip_str[strlen(src_ip_str)-1]='\0';
    
        //将字符串类型的ip转换为顺序网络字节流
        src_ip = libnet_name2addr4(net_t,src_ip_str,LIBNET_RESOLVE);
    
        net_interface = pcap_lookupdev(err_buf);
        if(NULL == net_interface)
        {
            perror("pcap_lookupdev");
            exit(-1);
        }
    
        net_t  = libnet_init(LIBNET_LINK_ADV, net_interface, err_buf);//初始化发送包结构
        if(net_t == NULL)
        {
            printf("libnet_init error\n");
            exit(-1);
        }
    
        p_tag = libnet_build_arp(ARPHRD_ETHER,           //以太网
                                 ETHERTYPE_IP,           //protocol type ip协议
                                 MAC_ADDR_LEN,           //mac length  6
                                 IP_ADDR_LEN,            //protocol length  4
                                 ARPOP_REPLY,            //op type  2 arp应答
                                 (u_int8_t *)src_mac,    //更新目的地的arp表
                                 (u_int8_t *)&src_ip,    //source ip addr
                                 (u_int8_t *)dst_mac,    //dest mac addr
                                 (u_int8_t *)&dst_ip,    //dest ip  addr
                                 NULL,                   //payload
                                 0,                      //payload length
                                 net_t,                  //libnet context
                                 0 );                    //0 stands to build a new one
        if(-1 == p_tag)
        {
            printf("libnet_build_arp error");
            exit(-1);
        }
        //以太网头部
        p_tag = libnet_build_ethernet((u_int8_t *)dst_mac,    //dest mac addr
                                      (u_int8_t *)src_mac,    //source mac addr
                                      ETHERTYPE_ARP,          //protocol type
                                      NULL,                   //payload
                                      0,                      //payload length
                                      net_t,                  //libnet context
                                      0);                     //0 to build a new one
        if(-1 == p_tag)
        {
            printf("libnet_build_ethernet error");
            exit(-1);
        }
    
        res = libnet_write(net_t);   //发送
        if(-1 == res)
        {
            printf("libnet_write error!\n");
            exit(-1);
        }
    
        libnet_destroy(net_t); //释放资源 
        printf("----SUCCESS----\n");
        return 0;
    }

     

    生成结果

     

    展开全文
  • libnet编译后的libnet.dll跟libnet.lib。实在太难找了,欢迎大家下载,分数高一点,算是大家给一点资助
  • 本人刚学网络编程在用VC++6.0编译libnet是出错,哪位高人指点下Compiling...libnet_link_win32.cc:\programfiles\microsoftplatformsdk\include\iphlpapi.h(183):errorC2146:syntaxer...本人刚学网络编程 在用VC ++ ...

    本人刚学网络编程在用VC++6.0编译libnet是出错,哪位高人指点下Compiling...libnet_link_win32.cc:\programfiles\microsoftplatformsdk\include\iphlpapi.h(183):errorC2146:syntaxer...

    本人刚学网络编程 在用VC ++ 6.0 编译libnet是出错,哪位高人指点下

    Compiling...

    libnet_link_win32.c

    c:\program files\microsoft platform sdk\include\iphlpapi.h(183) : error C2146: syntax error : missing ')' before identifier 'pStats'

    c:\program files\microsoft platform sdk\include\iphlpapi.h(183) : error C2061: syntax error : identifier 'pStats'

    c:\program files\microsoft platform sdk\include\iphlpapi.h(183) : error C2059: syntax error : ';'

    c:\program files\microsoft platform sdk\include\iphlpapi.h(183) : error C2059: syntax error : ','

    c:\program files\microsoft platform sdk\include\iphlpapi.h(185) : error C2059: syntax error : ')'

    f:\microsoft visual studio\vc98\include\ws2tcpip.h(56) : error C2011: 'in6_addr' : 'struct' type redefinition

    libnet_prand.c

    e:\libnetcap\libnet\src\libnet_prand.c(79) : error C2065: 'HCRYPTPROV' : undeclared identifier

    e:\libnetcap\libnet\src\libnet_prand.c(79) : error C2146: syntax error : missing ';' before identifier 'hProv'

    e:\libnetcap\libnet\src\libnet_prand.c(79) : error C2065: 'hProv' : undeclared identifier

    e:\libnetcap\libnet\src\libnet_prand.c(80) : warning C4013: 'CryptAcquireContext' undefined; assuming extern returning int

    e:\libnetcap\libnet\src\libnet_prand.c(81) : error C2065: 'PROV_RSA_FULL' : undeclared identifier

    e:\libnetcap\libnet\src\libnet_prand.c(82) : error C2065: 'CRYPT_VERIFYCONTEXT' : undeclared identifier

    e:\libnetcap\libnet\src\libnet_prand.c(84) : warning C4013: 'CryptGenRandom' undefined; assuming extern returning int

    e:\libnetcap\libnet\src\libnet_prand.c(86) : warning C4013: 'CryptReleaseContext' undefined; assuming extern returning int

    Generating Code...

    Error executing cl.exe.

    Results

    Libnet.dll - 11 error(s), 3 warning(s)

    展开

    展开全文
  • libnet1.1.2编译完成后的libnet.dll与libnet.lib
  • libnet 2.0.1

    2010-07-03 00:44:02
    libnet 2.0.1最新版 功能强大的数据包构造,数据包的处理,数据包发送,函数库。 例如我们要构造一个ip数据包,可以使用如下函数: libnet_ptag_t libnet_build_ipv4(u_short len, u_char tos, u_short id, u_short ...
  • libnet函数详解

    2013-06-06 10:23:44
    libnet函数详解 官方文档 libnet-functions.h File Reference
  • libnet-1.1.4

    2010-01-20 08:45:49
    libnet源码libnet源码libnet源码libnet源码libnet源码libnet源码libnet源码libnet源码
  • isic依赖库libnet

    2018-09-30 16:22:34
    libnet是一个小型的接口函数库,主要用C语言写成,提供了低层网络数据包的构造、处理和发送功能。libnet的开发目的是:建立一个简单统一的网络编程接口以屏蔽不同操作系统底层网络编程的差别,使得程序员将精力集中...
  • libnet入门

    2017-04-23 11:27:56
    在Unix系统平台上的网络安全工具开发中,目前最为流行的C API library有libnet、libpcap、libnids和libicmp等。它们分别从不同层次和角度提供了不同的功能函数。使网络开发人员能够忽略网络底层细节的实现,从而专注...

    在Unix系统平台上的网络安全工具开发中,目前最为流行的C API library有libnet、libpcap、libnids和libicmp等。它们分别从不同层次和角度提供了不同的功能函数。使网络开发人员能够忽略网络底层细节的实现,从而专注于程序本身具体功能的设计与开发。其中,
    * libnet提供的接口函数主要实现和封装了数据包的构造和发送过程。
    * libpcap提供的接口函数主要实现和封装了与数据包截获有关的过程。
    * libnids提供的接口函数主要实现了开发网络入侵监测系统所必须的一些结构框架。
    * libicmp等相对较为简单,它封装的是ICMP数据包的主要处理过程(构造、发送、接收等)。 利用这些C函数库的接口,网络安全工具开发人员可以很方便地编写出具有结构化强、健壮性好、可移植性高等特点的程序,如scanner、sniffer、firewall、IDS等。
    ---[[ libnet ]]------------------------------------------
    libnet库的最新版本为1.0.0,它一共约7600行C源代码,33个源程序文件,12个C头文件,50余个自定义函数,提供的接口函数包含15种数据包生成器和两种数据包发送器(IP层和数据链路层)。目前只支持IPv4,不支持IPv6。已经过测试的系统平台包括:
    * OpenBSD 2.6snap, 2.5, 2.4, 2.3, 2.2 (i386)
    * FreeBSD 4.0-STABLE, 3.3-STABLE, 3.2-RELEASE, 3.1-CURRENT, 3.0, 2.2 (i386)
    * NetBSD 1.3.2 (i386)
    * BSD/OS 3.x (i386)
    * BSDi 3.0 (i386)
    * Linux 2.2.x, 2.0.3x, 2.1.124 (i386, alpha) (libc: 2.4.x, glibc: 2.0.x)
    * Solaris 7 (SPARC, gcc 2.7.2[13], 2.8.2), 2.6 (SPARC, gcc 2.8.2),
    2.5.x (SPARC, gcc 2.7.2[13])
    * IRIX 6.2
    * MacOS 5.3rhapsody (powerpc)
    libnet提供的接口函数按其作用可分为四类:

    * 内存管理(分配和释放)函数
    * 地址解析函数
    * 数据包构造函数
    * 数据包发送函数

    以下分别列出这些接口函数及其功能(其参数含义简单易懂,不再解释):


    ★ 内存管理函数

    单数据包内存初始化:
    int libnet_init_packet(u_short packet_size, u_char **buf);

    单数据包内存释放:
    void libnet_destroy_packet(u_char **buf);

    多数据包内存初始化:
    int libnet_init_packet_arena(struct libnet_arena **arena,
    u_short packet_num, u_short packet_size);

    访问多数据包内存中的下一个数据包:
    u_char *libnet_next_packet_from_arena(struct libnet_arena **arena,
    u_short packet_size);

    多数据包内存释放:
    void libnet_destroy_packet_arena(struct libnet_arena **arena);


    ★ 地址解析函数

    解析主机名:
    u_char *libnet_host_lookup(u_long ip, u_short use_name);

    解析主机名(可重入函数):
    void libnet_host_lookup_r(u_long ip, u_short use_name, u_char *buf);

    域名解析:
    u_long libnet_name_resolve(u_char *ip, u_short use_name);

    获取接口设备IP地址:
    u_long libnet_get_ipaddr(struct libnet_link_int *l,
    const u_char *device, const u_char *ebuf);

    获取接口设备硬件地址:
    struct ether_addr *libnet_get_hwaddr(struct libnet_link_int *l,
    const u_char *device,
    const u_char *ebuf);


    ★ 数据包构造函数

    ARP协议数据包:
    int libnet_build_arp(u_short hrdw, u_short prot, u_short h_len,
    u_short p_len, u_short op, u_char *s_ha,
    u_char *s_pa, u_char *t_ha, u_char *t_pa,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    DNS协议数据包:
    int libnet_build_dns(u_short id, u_short flags, u_short num_q,
    u_short num_answ_rr, u_short num_auth_rr,
    u_short num_add_rr, const u_char * payload,
    int payload_len, u_char *packet_buf);

    以太网协议数据包:
    int libnet_build_ethernet(u_char *daddr, u_char *saddr, u_short id,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    ICMP协议数据包(ICMP_ECHO / ICMP_ECHOREPLY):
    int libnet_build_icmp_echo(u_char type, u_char code, u_short id,
    u_short seq, const u_char *payload,
    int payload_len, u_char *packet_buf);

    ICMP协议数据包(ICMP_MASKREQ / ICMP_MASKREPLY):
    int libnet_build_icmp_mask(u_char type, u_char code, u_short id,
    u_short seq, u_long mask,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    ICMP协议数据包(ICMP_UNREACH):
    int libnet_build_icmp_unreach(u_char type, u_char code,
    u_short orig_len, u_char orig_tos,
    u_short orig_id, u_short orig_frag,
    u_char orig_ttl, u_char orig_prot,
    u_long orig_saddr, u_long orig_daddr,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    ICMP协议数据包(ICMP_TIMEXCEED):
    int libnet_build_icmp_timeexceed(u_char type, u_char code,
    u_short orig_len, u_char orig_tos,
    u_short orig_id, u_short orig_frag,
    u_char orig_ttl, u_char orig_prot,
    u_long orig_saddr, u_long orig_daddr,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    ICMP协议数据包(ICMP_REDIRECT):
    int libnet_build_icmp_redirect(u_char type, u_char code, u_long gateway,
    u_short orig_len, u_char orig_tos,
    u_short orig_id, u_short orig_frag,
    u_char orig_ttl, u_char orig_prot,
    u_long orig_saddr, u_long orig_daddr,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    ICMP协议数据包(ICMP_TSTAMP / ICMP_TSTAMPREPLY):
    int libnet_build_icmp_timestamp(u_char type, u_char code, u_short id,
    u_short seq, n_time otime, n_time rtime,
    n_time ttime, const u_char *payload,
    int payload_len, u_char *packet_buf);

    IGMP协议数据包:
    int libnet_build_igmp(u_char type, u_char code, u_long ip,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    IP协议数据包:
    int libnet_build_ip(u_short len, u_char tos, u_short ip_id, u_short frag,
    u_char ttl, u_char protocol, u_long saddr,
    u_long daddr, const u_char *payload, int payload_len,
    u_char *packet_buf);

    OSPF路由协议数据包:
    int libnet_build_ospf(u_short len, u_char type, u_long router_id,
    u_long area_id, u_short auth_type,
    const char *payload, int payload_s, u_char *buf);

    OSPF路由协议数据包(Hello):
    int libnet_build_ospf_hello(u_long netmask, u_short interval,
    u_char options, u_char priority,
    u_int dead_interval, u_long des_router,
    u_long backup, u_long neighbor,
    const char *payload, int payload_s,
    u_char *buf);

    OSPF路由协议数据包(DataBase Description (DBD)):
    int libnet_build_ospf_dbd(u_short len, u_char options, u_char type,
    u_int sequence_num, const char *payload,
    int payload_s, u_char *buf);

    OSPF路由协议数据包(Link State Request (LSR)):
    int libnet_build_ospf_lsr(u_int type, u_int ls_id, u_long adv_router,
    const char *payload, int payload_s,
    u_char *buf);

    OSPF路由协议数据包(Link State Update (LSU)):
    int libnet_build_ospf_lsu(u_int num, const char *payload,
    int payload_s, u_char *buf);

    OSPF路由协议数据包(Link State Acknowledgement (LSA)):
    int libnet_build_ospf_lsa(u_short age, u_char options, u_char type,
    u_int ls_id, u_long adv_router,
    u_int sequence_num, u_short len,
    const char *payload, int payload_s,
    u_char *buf);

    OSPF路由协议数据包(OSPF Link Sate NetworkLink State Router):
    int libnet_build_ospf_lsa_net(u_long netmask, u_int router_id,
    const char *payload, int payload_s,
    u_char *buf);

    OSPF路由协议数据包(Link State Router):
    int libnet_build_ospf_lsa_rtr(u_short flags, u_short num, u_int id,
    u_int data, u_char type, u_char tos,
    u_short metric, const char *payload,
    int payload_s, u_char *buf);

    OSPF路由协议数据包(Link State Summary):
    int libnet_build_ospf_lsa_sum(u_long netmask, u_int metric, u_int tos,
    const char *payload, int payload_s,
    u_char *buf);

    OSPF路由协议数据包(Link State AS External):
    int libnet_build_ospf_lsa_as(u_long netmask, u_int metric,
    u_long fwd_addr, u_int tag,
    const char *payload, int payload_s,
    u_char *buf);

    RIP路由协议数据包:
    int libnet_build_rip(u_char cmd, u_char ver, u_short domain,
    u_short addr_fam, u_short route_tag, u_long ip,
    u_long mask, u_long next_hop, u_long metric,
    const u_char *payload, int payload_len,
    u_char *packet_buf);

    TCP协议数据包:
    int libnet_build_tcp(u_short th_sport, u_short th_dport, u_long th_seq,
    u_long th_ack, u_char th_flags, u_short th_win,
    u_short th_urg, const u_char *payload,
    int payload_len, u_char *packet_buf);

    UDP协议数据包:
    int libnet_build_udp(u_short sport, u_short dport, const u_char *payload,
    int payload_len, u_char *packet_buf);

    IP协议数据包选项:
    int libnet_insert_ipo(struct ipoption *opt, u_char opt_len,
    u_char *packet_buf);

    TCP协议数据包选项:
    int libnet_insert_tcpo(struct tcpoption *opt, u_char opt_len,
    u_char *packet_buf);


    ★ 数据包发送函数

    打开raw socket:
    int libnet_open_raw_sock(int protocol);

    关闭raw socket:
    int libnet_close_raw_sock(int socket);

    选择接口设备:
    int libnet_select_device(struct sockaddr_in *sin,
    u_char **device, u_char *ebuf);

    打开链路层接口设备:
    struct libnet_link_int *libnet_open_link_interface(char *device,
    char *ebuf);

    关闭链路层接口设备:
    int libnet_close_link_interface(struct libnet_link_int *l);

    发送IP数据包:
    int libnet_write_ip(int socket, u_char *packet, int packet_size);

    发送链路层数据包:
    int libnet_write_link_layer(struct libnet_link_int *l,
    const u_char *device, u_char *packet,
    int packet_size);

    检验和计算:
    int libnet_do_checksum(u_char *packet, int protocol, int packet_size);


    ★ 相关的支持函数

    随机数种子生成器:
    int libnet_seed_prand();

    获取随机数:
    u_long libnet_get_prand(int modulus);

    16进制数据输出:
    void libnet_hex_dump(u_char * buf, int len, int swap, FILE *stream);

    端口列表链初始化:
    int libnet_plist_chain_new(struct libnet_plist_chain **plist,
    char *token_list);

    获取端口列表链的下一项(端口范围):
    int libnet_plist_chain_next_pair(struct libnet_plist_chain *plist,
    u_short *bport, u_short *eport);

    端口列表链输出显示:
    int libnet_plist_chain_dump(struct libnet_plist_chain *plist);

    获取端口列表链:
    u_char *libnet_plist_chain_dump_string(struct libnet_plist_chain *plist);

    端口列表链内存释放:
    void libnet_plist_chain_free(struct libnet_plist_chain *plist);


    ★ 数据常量

    ==================================================================================
    数据包头大小定义:

    常量名 数值(字节数)
    LIBNET_ARP_H 28
    LIBNET_DNS_H 12
    LIBNET_ETH_H 14
    LIBNET_ICMP_H 4
    LIBNET_ICMP_ECHO_H 8
    LIBNET_ICMP_MASK_H 12
    LIBNET_ICMP_UNREACH_H 8
    LIBNET_ICMP_TIMXCEED_H 8
    LIBNET_ICMP_REDIRECT_H 8
    LIBNET_ICMP_TS_H 20
    LIBNET_IGMP_H 8
    LIBNET_IP_H 20
    LIBNET_RIP_H 24
    LIBNET_TCP_H 20
    LIBNET_UDP_H 8

    ==================================================================================
    数据包内存常量:

    常量名 含义
    LIBNET_PACKET TCP/UDP数据包头 + IP数据包头使用的内存
    LIBNET_OPTS IP或TCP选项使用的内存
    LIBNET_MAX_PACKET IP_MAXPACKET (65535字节)使用的内存

    ==================================================================================
    随机数发生器常量(libnet_get_prand()函数使用):

    常量名 数值
    LIBNET_PRAND_MAX 65535
    LIBNET_PR2 0 - 2
    LIBNET_PR8 0 - 255
    LIBNET_PR16 0 - 32767
    LIBNET_PRu16 0 - 65535
    LIBNET_PR32 0 - 2147483647
    LIBNET_PRu32 0 - 4294967295

    ==================================================================================
    错误消息常量(libnet_error()函数使用):

    常量名 含义
    LIBNET_ERR_WARNING 警告类型消息
    LIBNET_ERR_CRITICAL 紧急类型消息
    LIBNET_ERR_FATAL 致命错误消息

    ==================================================================================
    libnet_host_lookup()、libnet_host_lookup_r()和libnet_name_resolve()函数使用的常量:

    常量名 含义
    LIBNET_DONT_RESOLVE 不将IP地址解析为FQDN名
    LIBNET_RESOLVE 尝试将IP地址解析为FQDN名

    ==================================================================================
    宏定义

    宏名 功能
    LIBNET_GET_ARENA_SIZE(arena) 返回多数据包内存缓冲区大小(字节数)
    LIBNET_GET_ARENA_REMAINING_BYTES(arena) 返回多数据包内存缓冲区剩余空间大小(字节数)
    LIBNET_PRINT_ETH_ADDR(e) 输出显示ether_addr结构中的以太网地址

    ==================================================================================


    ---[[ libnet应用实例 ]]----------------------------------

    利用libnet函数库开发应用程序的基本步骤非常简单:

    1、数据包内存初始化;
    2、网络接口初始化;
    3、构造所需数据包;
    4、计算数据包检验和;
    5、发送数据包;
    6、关闭网络接口;
    7、释放数据包内存。

    以下是四个使用了libnet接口函数编写的数据包发送程序。在编译前必须确保libnet库已成功安装。

    例一:

    1. /* Example 1 [raw socket api - TCP packet] */  
    2. /* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x \  
    3. `libnet-config --libs` */  
    4.   
    5. #include <libnet.h>  
    6.   
    7. void usage(char *);  
    8.   
    9. int main(int argc, char **argv)   
    10. {   
    11.     int network, /* our network interface */   
    12.         packet_size, /* packet size */   
    13.         c; /* misc */   
    14.     u_long src_ip, dst_ip; /* ip addresses */   
    15.     u_short src_prt, dst_prt; /* ports */   
    16.     u_char *cp, *packet; /* misc / packet */  
    17.   
    18.     printf("libnet example code:\tmodule 1\n\n");   
    19.     printf("packet injection interface:\traw socket\n");   
    20.     printf("packet type:\t\t\tTCP [no payload]\n");  
    21.   
    22.     src_ip = 0;   
    23.     dst_ip = 0;   
    24.     src_prt = 0;   
    25.     dst_prt = 0;  
    26.   
    27.     while((c = getopt(argc, argv, "d:s:")) != EOF)   
    28.     {   
    29.         switch (c)   
    30.         {   
    31.             /*  
    32.             * We expect the input to be of the form `ip.ip.ip.ip.port`. We  
    33.             * point cp to the last dot of the IP address/port string and  
    34.             * then seperate them with a NULL byte. The optarg now points to  
    35.             * just the IP address, and cp points to the port.  
    36.             */   
    37.         case 'd':   
    38.             if (!(cp = strrchr(optarg, '.')))   
    39.             {   
    40.                 usage(argv[0]);   
    41.             }   
    42.             *cp++ = 0;   
    43.             dst_prt = (u_short)atoi(cp);   
    44.             if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    45.             {   
    46.                 libnet_error(LIBNET_ERR_FATAL,   
    47.                     "Bad destination IP address: %s\n", optarg);   
    48.             }   
    49.             break;   
    50.         case 's':   
    51.             if (!(cp = strrchr(optarg, '.')))   
    52.             {   
    53.                 usage(argv[0]);   
    54.             }   
    55.             *cp++ = 0;   
    56.             src_prt = (u_short)atoi(cp);   
    57.             if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    58.             {   
    59.                 libnet_error(LIBNET_ERR_FATAL,   
    60.                     "Bad source IP address: %s\n", optarg);   
    61.             }   
    62.             break;   
    63.         }   
    64.     }   
    65.     if (!src_ip || !src_prt || !dst_ip || !dst_prt)   
    66.     {   
    67.         usage(argv[0]);   
    68.         exit(EXIT_FAILURE);   
    69.     }  
    70.   
    71.     /*  
    72.     * We're just going to build a TCP packet with no payload using the  
    73.     * raw sockets API, so we only need memory for a TCP header and an IP  
    74.     * header.  
    75.     */   
    76.     packet_size = LIBNET_IP_H + LIBNET_TCP_H;  
    77.   
    78.     /*  
    79.     * Step 1: Memory initialization (interchangable with step 2).  
    80.     */   
    81.     libnet_init_packet(packet_size, &packet);   
    82.     if (packet == NULL)   
    83.     {   
    84.         libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed\n");   
    85.     }  
    86.   
    87.     /*  
    88.     * Step 2: Network initialization (interchangable with step 1).  
    89.     */   
    90.     network = libnet_open_raw_sock(IPPROTO_RAW);   
    91.     if (network == -1)   
    92.     {   
    93.         libnet_error(LIBNET_ERR_FATAL, "Can't open network.\n");   
    94.     }  
    95.   
    96.     /*  
    97.     * Step 3: Packet construction (IP header).  
    98.     */   
    99.     libnet_build_ip(LIBNET_TCP_H, /* size of the packet sans IP header */   
    100.         IPTOS_LOWDELAY, /* IP tos */   
    101.         242, /* IP ID */   
    102.         0, /* frag stuff */   
    103.         48, /* TTL */   
    104.         IPPROTO_TCP, /* transport protocol */   
    105.         src_ip, /* source IP */   
    106.         dst_ip, /* destination IP */   
    107.         NULL, /* payload (none) */   
    108.         0, /* payload length */   
    109.         packet); /* packet header memory */  
    110.   
    111.     /*  
    112.     * Step 3: Packet construction (TCP header).  
    113.     */   
    114.     libnet_build_tcp(src_prt, /* source TCP port */   
    115.         dst_prt, /* destination TCP port */   
    116.         0xa1d95, /* sequence number */   
    117.         0x53, /* acknowledgement number */   
    118.         TH_SYN, /* control flags */   
    119.         1024, /* window size */   
    120.         0, /* urgent pointer */   
    121.         NULL, /* payload (none) */   
    122.         0, /* payload length */   
    123.         packet + LIBNET_IP_H); /* packet header memory */  
    124.   
    125.     /*  
    126.     * Step 4: Packet checksums (TCP header only).  
    127.     */   
    128.     if (libnet_do_checksum(packet, IPPROTO_TCP, LIBNET_TCP_H) == -1)   
    129.     {   
    130.         libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    131.     }  
    132.   
    133.     /*  
    134.     * Step 5: Packet injection.  
    135.     */   
    136.     c = libnet_write_ip(network, packet, packet_size);   
    137.     if (c < packet_size)   
    138.     {   
    139.         libnet_error(LN_ERR_WARNING,   
    140.             "libnet_write_ip only wrote %d bytes\n", c);   
    141.     }   
    142.     else   
    143.     {   
    144.         printf("construction and injection completed, wrote all %d bytes\n", c);   
    145.     }  
    146.   
    147.     /*  
    148.     * Shut down the interface.  
    149.     */   
    150.     if (libnet_close_raw_sock(network) == -1)   
    151.     {   
    152.         libnet_error(LN_ERR_WARNING,   
    153.             "libnet_close_raw_sock couldn't close the interface");   
    154.     }  
    155.   
    156.   
    157.     /*  
    158.     * Free packet memory.  
    159.     */   
    160.     libnet_destroy_packet(&packet);  
    161.   
    162.     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);   
    163. }  
    164.   
    165.   
    166. void usage(char *name)   
    167. {   
    168.     fprintf(stderr, "usage: %s -s s_ip.s_port -d d_ip.d_port\n", name);   
    169. }  

     

    例二:

    1. /* Example 2 [link layer api - ICMP_MASK] */  
    2. /* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x `libnet-config --libs` */  
    3.   
    4. #include <libnet.h>  
    5.   
    6. void usage(char *);  
    7.   
    8. u_char enet_src[6] = {0x0d, 0x0e, 0x0a, 0x0d, 0x00, 0x00};   
    9. u_char enet_dst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};  
    10.   
    11. int   
    12. main(int argc, char *argv[])   
    13. {   
    14.     int packet_size, /* size of our packet */   
    15.         c; /* misc */   
    16.     u_long src_ip, dst_ip; /* source ip, dest ip */   
    17.     u_char *packet; /* pointer to our packet buffer */   
    18.     char err_buf[LIBNET_ERRBUF_SIZE]; /* error buffer */   
    19.     u_char *device; /* pointer to the device to use */   
    20.     struct libnet_link_int *network; /* pointer to link interface struct */  
    21.   
    22.     printf("libnet example code:\tmodule 2\n\n");   
    23.     printf("packet injection interface:\tlink layer\n");   
    24.     printf("packet type:\t\t\tICMP net mask [no payload]\n");  
    25.   
    26.     device = NULL;   
    27.     src_ip = 0;   
    28.     dst_ip = 0;  
    29.   
    30.     while ((c = getopt(argc, argv, "i:d:s:")) != EOF)   
    31.     {   
    32.         switch (c)   
    33.         {   
    34.         case 'd':   
    35.             if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    36.             {   
    37.                 libnet_error(LIBNET_ERR_FATAL,   
    38.                     "Bad destination IP address: %s\n", optarg);  
    39.   
    40.             }   
    41.             break;   
    42.         case 'i':   
    43.             device = optarg;   
    44.             break;   
    45.         case 's':   
    46.             if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    47.             {   
    48.                 libnet_error(LIBNET_ERR_FATAL,   
    49.                     "Bad source IP address: %s\n", optarg);   
    50.             }   
    51.             break;   
    52.         default:   
    53.             exit(EXIT_FAILURE);   
    54.         }   
    55.     }  
    56.   
    57.     if (!src_ip || !dst_ip)   
    58.     {   
    59.         usage(argv[0]);   
    60.         exit(EXIT_FAILURE);   
    61.     }  
    62.   
    63.     /*  
    64.     * Step 1: Network Initialization (interchangable with step 2).  
    65.     */   
    66.     if (device == NULL)   
    67.     {   
    68.         struct sockaddr_in sin;   
    69.         /*  
    70.         * Try to locate a device.  
    71.         */   
    72.         if (libnet_select_device(&sin, &device, err_buf) == -1)   
    73.         {   
    74.             libnet_error(LIBNET_ERR_FATAL,   
    75.                 "libnet_select_device failed: %s\n", err_buf);   
    76.         }   
    77.         printf("device:\t\t\t\t%s\n", device);   
    78.     }  
    79.   
    80.     if ((network = libnet_open_link_interface(device, err_buf)) == NULL)   
    81.     {   
    82.         libnet_error(LIBNET_ERR_FATAL,   
    83.             "libnet_open_link_interface: %s\n", err_buf);   
    84.     }  
    85.   
    86.     /*  
    87.     * We're going to build an ICMP packet with no payload using the  
    88.     * link-layer API, so this time we need memory for a ethernet header  
    89.     * as well as memory for the ICMP and IP headers.  
    90.     */   
    91.     packet_size = LIBNET_IP_H + LIBNET_ETH_H + LIBNET_ICMP_MASK_H;  
    92.   
    93.   
    94.     /*  
    95.     * Step 2: Memory Initialization (interchangable with step 1).  
    96.     */   
    97.     if (libnet_init_packet(packet_size, &packet) == -1)   
    98.     {   
    99.         libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed\n");   
    100.     }  
    101.   
    102.   
    103.     /*  
    104.     * Step 3: Packet construction (ethernet header).  
    105.     */   
    106.     libnet_build_ethernet(enet_dst,   
    107.         enet_src,   
    108.         ETHERTYPE_IP,   
    109.         NULL,   
    110.         0,   
    111.         packet);  
    112.   
    113.     /*  
    114.     * Step 3: Packet construction (ICMP header).  
    115.     */   
    116.     libnet_build_icmp_mask(ICMP_MASKREPLY, /* type */   
    117.         0, /* code */   
    118.         242, /* id */   
    119.         0, /* seq */   
    120.         0xffffffff, /* mask */   
    121.         NULL, /* payload */   
    122.         0, /* payload_s */   
    123.         packet + LIBNET_ETH_H + LIBNET_IP_H);  
    124.   
    125.   
    126.     /*  
    127.     * Step 3: Packet construction (IP header).  
    128.     */   
    129.     libnet_build_ip(ICMP_MASK_H,   
    130.         0, /* IP tos */   
    131.         242, /* IP ID */   
    132.         0, /* Frag */   
    133.         64, /* TTL */   
    134.         IPPROTO_ICMP, /* Transport protocol */   
    135.         src_ip, /* Source IP */   
    136.         dst_ip, /* Destination IP */   
    137.         NULL, /* Pointer to payload (none) */   
    138.         0,   
    139.         packet + LIBNET_ETH_H); /* Packet header memory */  
    140.   
    141.     /*  
    142.     * Step 4: Packet checksums (ICMP header *AND* IP header).  
    143.     */   
    144.     if (libnet_do_checksum(packet + ETH_H, IPPROTO_ICMP, LIBNET_ICMP_MASK_H) == -1)   
    145.     {   
    146.         libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    147.     }   
    148.     if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1)   
    149.     {   
    150.         libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    151.     }  
    152.   
    153.   
    154.     /*  
    155.     * Step 5: Packet injection.  
    156.     */   
    157.     c = libnet_write_link_layer(network, device, packet, packet_size);   
    158.     if (c < packet_size)   
    159.     {   
    160.         libnet_error(LN_ERR_WARNING,   
    161.             "libnet_write_link_layer only wrote %d bytes\n", c);   
    162.     }   
    163.     else   
    164.     {   
    165.         printf("construction and injection completed, wrote all %d bytes\n", c);   
    166.     }  
    167.   
    168.   
    169.     /*  
    170.     * Shut down the interface.  
    171.     */   
    172.     if (libnet_close_link_interface(network) == -1)   
    173.     {   
    174.         libnet_error(LN_ERR_WARNING,   
    175.             "libnet_close_link_interface couldn't close the interface");   
    176.     }  
    177.   
    178.   
    179.     /*  
    180.     * Free packet memory.  
    181.     */   
    182.     libnet_destroy_packet(&packet);  
    183.   
    184.     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);   
    185. }  
    186.   
    187. void usage(char *name)   
    188. {   
    189.     fprintf(stderr, "usage: %s [-i interface] -s s_ip -d d_ip\n", name);   
    190. }  


    例三:

    1. /* Example 3 [raw socket api - ICMP_ECHO using an arena] */  
    2. /* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x \  
    3. `libnet-config --libs` */  
    4.   
    5. #include <libnet.h>  
    6.   
    7. void usage(char *);  
    8.   
    9.   
    10. int main(int argc, char **argv)   
    11. {   
    12.     int network, n, c, number_of_packets, packet_size;   
    13.     struct libnet_arena arena, *arena_p;   
    14.     u_char *packets[10];   
    15.     u_long src_ip, dst_ip;  
    16.   
    17.     printf("libnet example code:\tmodule 3\n\n");   
    18.     printf("packet injection interface:\tlink layer\n");   
    19.     printf("packet type:\t\t\tICMP_ECHO [no payload] using an arena\n");  
    20.   
    21.     src_ip = 0;   
    22.     dst_ip = 0;   
    23.     while((c = getopt(argc, argv, "d:s:")) != EOF)   
    24.     {   
    25.         switch (c)   
    26.         {   
    27.         case 'd':   
    28.             if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    29.             {   
    30.                 libnet_error(LIBNET_ERR_FATAL,   
    31.                     "Bad destination IP address: %s\n", optarg);   
    32.             }   
    33.             break;   
    34.         case 's':   
    35.             if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    36.             {   
    37.                 libnet_error(LIBNET_ERR_FATAL,   
    38.                     "Bad source IP address: %s\n", optarg);   
    39.             }   
    40.             break;   
    41.         }   
    42.     }   
    43.     if (!src_ip || !dst_ip)   
    44.     {   
    45.         usage(argv[0]);   
    46.         exit(EXIT_FAILURE);   
    47.     }  
    48.   
    49.     /*  
    50.     * We're just going to build an ICMP packet with no payload using the  
    51.     * raw sockets API, so we only need memory for a ICMP header and an IP  
    52.     * header.  
    53.     */   
    54.     packet_size = LIBNET_IP_H + LIBNET_ICMP_ECHO_H;  
    55.   
    56.     /*  
    57.     * Let's just build say, 10 packets.  
    58.     */   
    59.     number_of_packets = 10;  
    60.   
    61.     arena_p = &arena;   
    62.     if (libnet_init_packet_arena(&arena_p, number_of_packets, packet_size) == -1)   
    63.     {   
    64.         libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet_arena failed\n");   
    65.     }   
    66.     else   
    67.     {   
    68.         printf("Allocated an arena of %ld bytes..\n",   
    69.             LIBNET_GET_ARENA_SIZE(arena));   
    70.     }  
    71.   
    72.     network = libnet_open_raw_sock(IPPROTO_RAW);   
    73.     if (network == -1)   
    74.     {   
    75.         libnet_error(LIBNET_ERR_FATAL, "Can't open the network.\n");   
    76.     }  
    77.   
    78.     for (n = 0; n < number_of_packets; n++)   
    79.     {   
    80.         printf("%ld bytes remaining in arena\n",   
    81.             LIBNET_GET_ARENA_REMAINING_BYTES(arena));   
    82.         packets[n] = libnet_next_packet_from_arena(&arena_p, packet_size);   
    83.         if (!packets[n])   
    84.         {   
    85.             libnet_error(LIBNET_ERR_WARNING, "Arena is empty\n");   
    86.             continue;   
    87.         }  
    88.   
    89.         libnet_build_ip(ICMP_ECHO_H, /* Size of the payload */   
    90.             IPTOS_LOWDELAY | IPTOS_THROUGHPUT, /* IP tos */   
    91.             242, /* IP ID */   
    92.             0, /* frag stuff */   
    93.             48, /* TTL */   
    94.             IPPROTO_ICMP, /* transport protocol */   
    95.             src_ip, /* source IP */   
    96.             dst_ip, /* destination IP */   
    97.             NULL, /* pointer to payload */   
    98.             0, /* payload length */   
    99.             packets[n]); /* packet header memory */  
    100.   
    101.         libnet_build_icmp_echo(ICMP_ECHO, /* type */   
    102.             0, /* code */   
    103.             242, /* id */   
    104.             5, /* seq */   
    105.             NULL, /* pointer to payload */   
    106.             0, /* payload length */   
    107.             packets[n] + LIBNET_IP_H); /* packet header memory */  
    108.   
    109.         if (libnet_do_checksum(packets[n], IPPROTO_ICMP, LIBNET_ICMP_ECHO_H) == -1)   
    110.         {   
    111.             libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    112.         }  
    113.   
    114.         c = libnet_write_ip(network, packets[n], packet_size);   
    115.         if (c < packet_size)   
    116.         {   
    117.             libnet_error(LN_ERR_WARNING,   
    118.                 "libnet_write_ip only wrote %d bytes\n", c);   
    119.         }   
    120.         else   
    121.         {   
    122.             printf("construction and injection of packet %d of %d completed, wrote all %d bytes\n",  
    123.                 n + 1, number_of_packets, c);   
    124.         }   
    125.     }  
    126.   
    127.     libnet_destroy_packet_arena(&arena_p);   
    128.     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);   
    129. }  
    130.   
    131.   
    132. void usage(char *name)   
    133. {   
    134.     fprintf(stderr, "usage: %s -s source_ip -d destination_ip\n ", name);   
    135. }  


    例四:

    1. /* Example 4 [link-layer api - UDP packet using port list chaining] */  
    2. /* gcc -Wall `libnet-config --defines` libnet-example-x.c -o libnet-example-x \  
    3. `libnet-config --libs` */  
    4.   
    5. #include <libnet.h>  
    6.   
    7. #define MAX_PAYLOAD_SIZE 1024  
    8.   
    9. void usage(char *);  
    10.   
    11. u_char enet_src[6] = {0x0d, 0x0e, 0x0a, 0x0d, 0x00, 0x00};   
    12. u_char enet_dst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};  
    13.   
    14. int main(int argc, char *argv[])   
    15. {   
    16.     int packet_size, /* size of our packet */   
    17.         payload_size, /* size of our packet */   
    18.         c; /* misc */   
    19.     u_long src_ip, dst_ip; /* source ip, dest ip */   
    20.     u_short bport, eport; /* beginning and end ports */   
    21.     u_short cport; /* current port */   
    22.     u_char payload[MAX_PAYLOAD_SIZE]; /* packet payload */   
    23.     u_char *packet; /* pointer to our packet buffer */   
    24.     char err_buf[LIBNET_ERRBUF_SIZE]; /* error buffer */   
    25.     u_char *device; /* pointer to the device to use */   
    26.     struct libnet_link_int *network; /* pointer to link interface struct */   
    27.     struct libnet_plist_chain plist; /* plist chain */   
    28.     struct libnet_plist_chain *plist_p; /* plist chain pointer */  
    29.   
    30.     printf("libnet example code:\tmodule 4\n\n");   
    31.     printf("packet injection interface:\tlink layer\n");   
    32.     printf("packet type:\t\t\tUDP [with payload] using port list chaining\n");  
    33.   
    34.     plist_p = NULL;   
    35.     device = NULL;   
    36.     src_ip = 0;   
    37.     dst_ip = 0;  
    38.   
    39.     while ((c = getopt(argc, argv, "i:d:s:p:")) != EOF)   
    40.     {   
    41.         switch (c)   
    42.         {   
    43.         case 'd':   
    44.             if (!(dst_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    45.             {   
    46.                 libnet_error(LIBNET_ERR_FATAL,   
    47.                     "Bad destination IP address: %s\n", optarg);  
    48.   
    49.             }   
    50.             break;   
    51.         case 'i':   
    52.             device = optarg;   
    53.             break;   
    54.         case 's':   
    55.             if (!(src_ip = libnet_name_resolve(optarg, LIBNET_RESOLVE)))   
    56.             {   
    57.                 libnet_error(LIBNET_ERR_FATAL,   
    58.                     "Bad source IP address: %s\n", optarg);   
    59.             }   
    60.             break;   
    61.         case 'p':   
    62.             plist_p = &plist;   
    63.             if (libnet_plist_chain_new(&plist_p, optarg) == -1)   
    64.             {   
    65.                 libnet_error(LIBNET_ERR_FATAL,   
    66.                     "Could not build port list\n");   
    67.             }   
    68.             break;   
    69.         default:   
    70.             usage(argv[0]);   
    71.             exit(EXIT_FAILURE);   
    72.         }   
    73.     }  
    74.   
    75.     if (!src_ip || !dst_ip || !plist_p)   
    76.     {   
    77.         usage(argv[0]);   
    78.         exit(EXIT_FAILURE);   
    79.     }  
    80.   
    81.     c = argc - optind;   
    82.     if (c != 1)   
    83.     {   
    84.         usage(argv[0]);   
    85.         exit(EXIT_FAILURE);   
    86.     }   
    87.     memset(payload, 0, sizeof(payload));   
    88.     strncpy(payload, argv[optind], strlen(argv[optind]));  
    89.   
    90.   
    91.     /*  
    92.     * Step 1: Network Initialization (interchangable with step 2).  
    93.     */   
    94.     if (device == NULL)   
    95.     {   
    96.         struct sockaddr_in sin;   
    97.         /*  
    98.         * Try to locate a device.  
    99.         */   
    100.         if (libnet_select_device(&sin, &device, err_buf) == -1)   
    101.         {   
    102.             libnet_error(LIBNET_ERR_FATAL,   
    103.                 "libnet_select_device failed: %s\n", err_buf);   
    104.         }   
    105.         printf("device:\t\t\t\t%s\n", device);   
    106.     }   
    107.     if ((network = libnet_open_link_interface(device, err_buf)) == NULL)   
    108.     {   
    109.         libnet_error(LIBNET_ERR_FATAL,   
    110.             "libnet_open_link_interface: %s\n", err_buf);   
    111.     }  
    112.   
    113.     /*  
    114.     * Get the payload from the user. Hrm. This might fail on a Sparc  
    115.     * if byte alignment is off...  
    116.     */   
    117.     payload_size = strlen(payload);  
    118.   
    119.     /*  
    120.     * We're going to build a UDP packet with a payload using the  
    121.     * link-layer API, so this time we need memory for a ethernet header  
    122.     * as well as memory for the ICMP and IP headers and our payload.  
    123.     */   
    124.     packet_size = LIBNET_IP_H + LIBNET_ETH_H + LIBNET_UDP_H + payload_size;  
    125.   
    126.     /*  
    127.     * Step 2: Memory Initialization (interchangable with step 1).  
    128.     */   
    129.     if (libnet_init_packet(packet_size, &packet) == -1)   
    130.     {   
    131.         libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed\n");   
    132.     }  
    133.   
    134.   
    135.     /*  
    136.     * Step 3: Packet construction (ethernet header).  
    137.     */   
    138.     libnet_build_ethernet(enet_dst,   
    139.         enet_src,   
    140.         ETHERTYPE_IP,   
    141.         NULL,   
    142.         0,   
    143.         packet);  
    144.   
    145.     /*  
    146.     * Step 3: Packet construction (IP header).  
    147.     */   
    148.     libnet_build_ip(LIBNET_UDP_H + payload_size,   
    149.         0, /* IP tos */   
    150.         242, /* IP ID */   
    151.         0, /* Frag */   
    152.         64, /* TTL */   
    153.         IPPROTO_UDP, /* Transport protocol */   
    154.         src_ip, /* Source IP */   
    155.         dst_ip, /* Destination IP */   
    156.         NULL, /* Pointer to payload (none) */   
    157.         0,   
    158.         packet + LIBNET_ETH_H); /* Packet header memory */  
    159.   
    160.     while (libnet_plist_chain_next_pair(plist_p, &bport, &eport))   
    161.     {  
    162.   
    163.         while (!(bport > eport) && bport != 0)   
    164.         {   
    165.             cport = bport++;   
    166.             /*  
    167.             * Step 3: Packet construction (UDP header).  
    168.             */   
    169.             libnet_build_udp(242, /* source port */   
    170.                 cport, /* dest. port */   
    171.                 payload, /* payload */   
    172.                 payload_size, /* payload length */   
    173.                 packet + LIBNET_ETH_H + LIBNET_IP_H);  
    174.   
    175.             /*  
    176.             * Step 4: Packet checksums (ICMP header *AND* IP header).  
    177.             */   
    178.             if (libnet_do_checksum(packet + ETH_H, IPPROTO_UDP, LIBNET_UDP_H + payload_size) == -1)   
    179.             {   
    180.                 libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    181.             }   
    182.             if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1)   
    183.             {   
    184.                 libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");   
    185.             }  
    186.   
    187.             /*  
    188.             * Step 5: Packet injection.  
    189.             */   
    190.             c = libnet_write_link_layer(network, device, packet, packet_size);   
    191.             if (c < packet_size)   
    192.             {   
    193.                 libnet_error(LN_ERR_WARNING,   
    194.                     "libnet_write_link_layer only wrote %d bytes\n", c);   
    195.             }   
    196.             else   
    197.             {   
    198.                 printf("construction and injection completed, wrote all %d bytes, port %d\n",  
    199.                     c, cport);   
    200.             }   
    201.         }   
    202.     }   
    203.     /*  
    204.     * Shut down the interface.  
    205.     */   
    206.     if (libnet_close_link_interface(network) == -1)   
    207.     {   
    208.         libnet_error(LN_ERR_WARNING,   
    209.             "libnet_close_link_interface couldn't close the interface");   
    210.     }  
    211.   
    212.   
    213.     /*  
    214.     * Free packet memory.  
    215.     */   
    216.     libnet_destroy_packet(&packet);  
    217.   
    218.     return (c == -1 ? EXIT_FAILURE : EXIT_SUCCESS);   
    219. }  
    220.   
    221.   
    222. void usage(char *name)   
    223. {   
    224.     fprintf(stderr, "usage: %s [-i interface] -s s_ip -d d_ip -p port list payload\n", name);   
    225. }   


     例五:

    1. 给出一个综合应用libnet和libpcap的简单例程,其功能是在接收到一个来自特定主机的ARP请求报文之后,发出ARP回应报文,通知该主机请求的IP地址对应的MAC地址。这个程序实现了标准的ARP协议,但是却不同于操作系统内核中标准的实现方法:该程序利用了libpcap在数据链路层抓包,利用了libnet向数据链路层发包,是使用libnet和libpcap构造TCP/IP协议软件的一个例程。该程序很简单,但已经可以说明libnet和libpcap的综合使用方法:  
    2.   
    3. /* tell destination host with ip 'dstip' that the host with  
    4. * request ip 'srcip' is with mac address srcmac 
    5. * author: white cpf  2003.5.15. 
    6. * compile: gcc arp.c -lnet -lpcap -o arp 
    7. */  
    8. #include "/usr/include/libnet.h"  
    9. #include <pcap.h>  
    10. void usage(char * exename){  
    11.     printf(" tell dstip with dstmac that srcip is at srcmac. \n");  
    12.     printf(" usage: %s -d dstip -s srcip -D dstmac -S srcmac \n",exename);  
    13.     return ;  
    14. }  
    15. //程序输入:来自命令行参数  
    16. u_char ip_src[4],ip_dst[4];  
    17. u_char enet_src[6],enet_dst[6];  
    18. extern int mac_strtochar6(u_char * enet,char * macstr);  
    19. //将字符串格式的MAC地址转换为6字节类型r  
    20. int get_cmdline(int argc,char *argv[]);//命令行参数处理函数  
    21. int main(int argc, char *argv[]){  
    22.     libnet_t *l;  
    23.     libnet_ptag_t t;  
    24.     u_char *packet;  
    25.     u_long packet_s;  
    26.     char device[5]="eth0";  
    27.     char errbuf[LIBNET_ERRBUF_SIZE];  
    28.     char filter_str[100]="";  
    29.     struct bpf_program fp;      /* hold compiled program     */  
    30.     char *dev;  
    31.     pcap_t* descr;  
    32.     struct pcap_pkthdr hdr;     /* pcap.h    */  
    33.     u_char * packet;  
    34.     bpf_u_int32 maskp;          /* subnet mask               */  
    35.     bpf_u_int32 netp;           /* ip                        */  
    36.     int promisc=0;               /* set to promisc mode?        */  
    37.     int pcap_time_out=5;  
    38.     int c, ret;  
    39.     u_long i;  
    40.     if(get_cmdline(argc,argv)<=0){  
    41.         usage(argv[0]);  
    42.         exit(0);  
    43.     }  
    44.   
    45.     dev = pcap_lookupdev(errbuf);  
    46.     if(dev == NULL){   
    47.         fprintf(stderr,"%s\n",errbuf);  
    48.         return -1;  
    49.     }  
    50.     ret=pcap_lookupnet(dev,&netp,&maskp,errbuf);  
    51.     if(ret==-1){  
    52.         fprintf(stderr,"%s\n",errbuf);  
    53.         return -1;  
    54.     }  
    55.     descr = pcap_open_live(dev,BUFSIZ,promisc,pcap_time_out,errbuf);  
    56.     if(descr == NULL){  
    57.         printf("pcap_open_live(): %s\n",errbuf);  
    58.         return -1;   
    59.     }  
    60.     sprintf(filter_str,"arp and (src net %d.%d.%d.%d)",ip_dst[0],ip_dst[1],  
    61.         ip_dst[2],ip_dst[3]);  
    62.     if(pcap_compile(descr,&fp,filter_str,0,netp) == -1){  
    63.         printf("Error calling pcap_compile\n");   
    64.         return -1;  
    65.     }  
    66.     if(pcap_setfilter(descr,&fp) == -1){   
    67.         printf("Error setting filter\n");   
    68.         return -1;  
    69.     }  
    70.     while(1){  
    71.         printf("wait packet:filter:%s\n",filter_str);  
    72.         packet=pcap_next(descr, &hdr);  
    73.         if(packet == NULL){  
    74.             continue;  
    75.         }  
    76.         l = libnet_init(LIBNET_LINK_ADV,device,errbuf);   
    77.         if (l == NULL){  
    78.             fprintf(stderr, "libnet_init() failed: %s", errbuf);  
    79.             exit(EXIT_FAILURE);  
    80.         }  
    81.         t = libnet_build_arp(  
    82.             ARPHRD_ETHER,                           /* hardware addr */  
    83.             ETHERTYPE_IP,                           /* protocol addr */  
    84.             6,                                      /* hardware addr size */  
    85.             4,                                      /* protocol addr size */  
    86.             ARPOP_REPLY,                            /* operation type */  
    87.             enet_src,                               /* sender hardware addr */  
    88.             ip_src,                           /* sender protocol addr */  
    89.             enet_dst,                               /* target hardware addr */  
    90.             ip_dst,                           /* target protocol addr */  
    91.             NULL,                                   /* payload */  
    92.             0,                                      /* payload size */  
    93.             l,                                      /* libnet handle */  
    94.             0);                                     /* libnet id */  
    95.         if (t == -1){  
    96.             fprintf(stderr, "Can't build ARP header: %s\n", libnet_geterror(l));  
    97.             goto bad;  
    98.         }  
    99.         t = libnet_autobuild_ethernet(  
    100.             enet_dst,                               /* ethernet destination */  
    101.             ETHERTYPE_ARP,                          /* protocol type */  
    102.             l);                                     /* libnet handle */  
    103.         if (t == -1){  
    104.             fprintf(stderr, "Can't build ethernet header: %s\n", libnet_geterror(l));  
    105.             goto bad;  
    106.         }  
    107.         c = libnet_adv_cull_packet(l, &packet, &packet_s);  
    108.         if (c == -1){  
    109.             fprintf(stderr, "libnet_adv_cull_packet: %s\n", libnet_geterror(l));  
    110.             goto bad;  
    111.         }  
    112.         c = libnet_write(l);  
    113.         if (c == -1){  
    114.             fprintf(stderr, "Write error: %s\n", libnet_geterror(l));  
    115.             goto bad;  
    116.         }  
    117.         continue;  
    118. bad:  
    119.         libnet_destroy(l);  
    120.         return (EXIT_FAILURE);  
    121.     }  
    122.     libnet_destroy(l);  
    123.     return (EXIT_FAILURE);  
    124. }  
    125. int get_cmdline(int argc,char *argv[]){  
    126.     char c;  
    127.     char string[]="d:s:D:S:h";  
    128.     while((c = getopt(argc, argv, string)) != EOF){  
    129.         if(c=='d')  
    130.             *((unsigned int*)ip_dst)=(unsigned int)inet_addr(optarg);  
    131.         else if(c== 's')  
    132.             *((unsigned int*)ip_src)=(unsigned int)inet_addr(optarg);  
    133.         else if(c=='D')  
    134.             mac_strtochar6(enet_dst,optarg);  
    135.         else if(c=='S')  
    136.             mac_strtochar6(enet_dst,optarg);  
    137.         else if(c=='h')  
    138.             return 0;  
    139.         else  
    140.             return -1;  
    141.     }  
    142.     return 1;  
    143. }  


     例六:

    1. #include <win32/libnet.h>  
    2. #pragma comment(lib, "libnet.lib")  
    3.   
    4. void main()  
    5. {  
    6.     int packet_size;//存放数据包长度的变量  
    7.     libnet_t *l;//libnet句柄  
    8.     libnet_ptag_t protocol_tag;//协议块标记  
    9.     char *device = NULL;//设备名字,此时为NULL  
    10.     char error_information[LIBNET_ERRBUF_SIZE];//用来存放错误信息  
    11.     char *destination_ip_str = "192.168.0.2";//目的IP地址字符串变量,可以指定任意一个合法的IP地址  
    12.     char *source_ip_str = "192.168.0.3";//源IP地址字符串变量,可以指定任意一个合法的IP地址  
    13.   
    14.     u_char hardware_source[6] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};//源MAC地址,可以是任意指定  
    15.     u_char hardware_destination[6] ={0x06, 0x05, 0x04, 0x03, 0x02, 0x01};//目的MAC地址,可以是任意指定  
    16.   
    17.     u_long destination_ip;// 目的IP地址  
    18.     u_long source_ip;//源IP地址  
    19.   
    20.     l = libnet_init(  
    21.         LIBNET_LINK_ADV,//libnet类型 */  
    22.         device,//网络设备  
    23.         error_information);   
    24.   
    25.     destination_ip = libnet_name2addr4(l,destination_ip_str, LIBNET_RESOLVE);  
    26.     //把目的IP地址字符串形式转化成网络顺序字节形式的数据  
    27.     source_ip = libnet_name2addr4(l, source_ip_str, LIBNET_RESOLVE);  
    28.     //把源IP地址字符串形式转化成网络顺序字节形式的数据  
    29.   
    30.     protocol_tag = libnet_build_arp(  
    31.         //构造ARP协议块,函数的返回值是代表新生成的ARP协议块的一个协议块标记  
    32.         ARPHRD_ETHER,  
    33.         // 硬件地址类型,在这里是以太网  
    34.         ETHERTYPE_IP,  
    35.         //协议地址类型,在这里是IP协议  
    36.         6,  
    37.         //硬件地址长度,MAC地址的长度为6  
    38.         4,  
    39.         //协议地址长度,IP地址的长度为4  
    40.         ARPOP_REPLY,  
    41.         //操作类型,在这里是ARP应答类型  
    42.         hardware_source,  
    43.         //源硬件地址  
    44.         (u_int8_t*) &source_ip,  
    45.         //源IP地址  
    46.         hardware_destination,  
    47.         //目标硬件地址  
    48.         (u_int8_t*) &destination_ip,  
    49.         //目标协议地址  
    50.         NULL,  
    51.         //负载,此时为NULL  
    52.         0,  
    53.         //负载的长度,此时为0  
    54.         l,  
    55.         //libnet句柄,此句柄由libnet_init()函数生成  
    56.         0  
    57.         //协议块标记,此时为0,表示构造一个新的ARP协议块,而不是修改已经存在的协议块  
    58.         );  
    59.   
    60.     protocol_tag = libnet_autobuild_ethernet(  
    61.         // 以auto的形式构造一个以太网协议块,返回一个指向此协议块的标记  
    62.         hardware_destination,  
    63.         //目的硬件地址  
    64.         ETHERTYPE_ARP,  
    65.         //以太网上层协议类型,此时为ARP类型  
    66.         l //libnet句柄  
    67.         );  
    68.   
    69.     packet_size = libnet_write(l);//发送已经构造的ARP数据包  
    70.     printf("发送一个%d字节长度的ARP应答数据包 ", packet_size);//输出发送的ARP数据包的字节数  
    71.   
    72.     libnet_destroy(l);//销毁libnet  

    展开全文
  • libnet detection on FreeBSD

    2020-11-29 03:27:43
    I just realized, that it already has a system provided libnet version 1.1.6. But cmake isn't using it unless I didn't defined <code>LIBNET_INCLUDE_DIR=/usr/local/include/libnet11</code> ...
  • libnet和yersinia

    2013-10-16 13:16:16
    HDCP攻击工具以及各版本的libnet
  • 【实例简介】libnet源码。如果没有资源分的话,可以发邮件至yzj19870824@126.com。我会寄给你【实例截图】【核心代码】c92ede2c-71aa-49dd-b078-04d606c71f3a└── libnet├── acconfig.h├── acinclude.m4├─...
  • 我正在尝试使用 Libnet11 函数:int libnet_write_raw_ipv6 (libnet_t *l, u_int8_t *packet, u_int32_t size)在网络层注入IPv6数据包 . 我创建了IPv6数据包并使用Wireshark捕获它 . Wireshark报道:格式错误的...
  • vs2010编译生成libnet.dll libnet.lib 对应的libnet版本为1.2.3 对应库文件生成目录: libnet-libnet-1.2-rc3\libnet\src
  • libnet.tar.gz

    2017-04-12 00:43:02
    libnet.tar.gz
  • libnet-1.1.5.zip

    2019-08-14 14:35:17
    libnet 是一个小型的接口函数库,主要用 C 语言写成,提供了低层网络数据包的构造、处理和发送功能。
  • The Evolution of Libnet

    2012-10-25 15:29:40
    The Evolution of Libnet -- libnet手册
  • libnet-1.0.2.tar.gz

    2019-05-31 15:58:54
    libnet-1.0.2 源码,可以正常编译使用,一些程序 可能需要较低版本的libnet
  • libnet构造数据包

    2010-11-01 13:32:59
    libnet构造数据包,包括libnet的安装,基本函数介绍,程序开发流程等等!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 997
精华内容 398
关键字:

libnet