Libnet核心数据结构

比眉伴天荒 2024-04-19 13:45 1阅读 0赞

[Libnet核心数据结构][Libnet]

[http://blog.chinaunix.net/u3/114769/showart\_2236587.html][Libnet]

Libnet入门学习

[http://blog.chinaunix.net/u3/114769/showart\_2236590.html][http_blog.chinaunix.net_u3_114769_showart_2236590.html]

利用libnet创建新的网络包结构  
[http://blog.chinaunix.net/u3/114769/showart\_2236592.html][http_blog.chinaunix.net_u3_114769_showart_2236592.html]

** **

libnet是一个小型的接口函数库，  
　　主要用C语言写成，  
　　提供了低层网络数据包的构造、处理和发送功能。  
　　libnet的开发目的是：  
　　建立一个简单统一的网络编程接口以屏蔽不同操作系统底层网络编程的差别，  
　　使得程序员将精力集中在解决关键问题上。  
　　它的主要特点是：  
　　高层接口：libnet主要用C语言写成  
　　可移植性：libnet目前可以在Linux、FreeBSD、Solaris、WindowsNT等操作系统上运行，并且提供了统一的接口  
　　数据包构造：libnet提供了一系列的TCP/IP数据报文的构造函数以方便用户使用  
　　数据包的处理：libnet提供了一系列的辅助函数，利用这些辅助函数，帮助用户简化那些烦琐的事务性的编程工作  
　　数据包发送：libnet允许用户在两种不同的数据包发送方法中选择。

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);

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

“ linux下，对link层的访问都是基于AF\_PACKET socket的，与BSD的bpf使用设备/dev/pf有所不同，不管是pcap和libnet的实现都是如此。另外libnet和pcap都存在 windows版本，不要将两者与winpcap混淆，还有就是libnet只能发包，pcap只能抓包，winpcap则是收发都能做到。当然 libnet和pcap在windows中与winpcap的底层都所以一样的。”

libpcap 与libnet可以说是，网络TCP/IP协议族数据包处理的一阴一阳，一个用于抓取数据包，一个用于产生和发送数据包。一个数据包的建立一般分为以下几步：

一.libnet\_init()

建立libnet上下文，以下的所有构造数据包的操作基本上都是围绕它进行的。

二.libnet\_built\_xxx()。在libnet中，建立一个完整的数据包是分步，由高层到低层进行的。如图所示，

建立一个udp数据包并封装成以太网帧，要经过三个步骤，其实也就是要依次调用：

1. libnet\_build\_udp()  
2. libnet\_build\_ipv4()  
3. libnet\_build\_ethernet()

以上每一个函数都在pblock链表中建立对应协议的pblock（协议块）。  
在每一个libnet\_built\_xxx()中依次调用了三个函数：

1.libnet\_pblock\_probe()，根据协议块标签ptag数据是否为0调用libnet\_pblock\_new()来创建新的协议块或者调用lib\_pblock\_find()来更新已经存在的标签为ptag的协议块。

2.libnet\_pblock\_append()，将协议头数据挂载到协议块的buf中，修改copied字段，指明已经使用的buf

3.libnet\_pblock\_update()，获取ptag，填充协议块的其他字段。

三.libnet\_write()

此函数调用了libnet\_pblock\_coalesce()，将所有协议块组建为一个可以发送的数据包（数据帧）。根据开始时设置的发送模式调用不同的socket发送数据。

有些问题笔者没有了解清楚，比如在创建arp数据包的时候为什么要多次调用libnet\_pblock\_append()，只是完成组建一个arp 头，这样效率就会很低，完全可以组建好整个数据包头以后，一次挂载即可。这里只是笔者的猜测。另外为什么在使用高级模式的时候要调用两次 libnet\_pblock\_coalesce()。所以这里只能是蜻蜓点水。

详细的讲解请看libnet作者写的 :The Evolution of libnet这篇文章。

** **

转载于:https://my.oschina.net/alphajay/blog/5508

[Libnet]: http://blog.chinaunix.net/u3/114769/showart_2236587.html
[http_blog.chinaunix.net_u3_114769_showart_2236590.html]: http://blog.chinaunix.net/u3/114769/showart_2236590.html
[http_blog.chinaunix.net_u3_114769_showart_2236592.html]: http://blog.chinaunix.net/u3/114769/showart_2236592.html