libnet/libnids库函数介绍

迈不过友情╰ 2021-11-27 07:34 512阅读 0赞

转自:http://forum.byr.edu.cn/pc/pccon.php?id=1117&nid=28538&s=all

在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);  
  
  
  
  
  
  
  
  
  
  
\---\[\[ libnids \]\]------------------------------------------  
  
一、简介  
  
    libnids的英文意思是 Network Intrusion Detect System library，即网络入侵监  
测系统函数库。它是在前面介绍的两种C函数接口库libnet和libpcap的基础上开发的，封  
装了开发NIDS所需的许多通用型函数。linids提供的接口函数监视流经本地的所有网络通  
信，检查数据包等。除此之外，还具有重组TCP数据段、处理IP分片包和监测TCP端口扫描  
的功能。利用libnids接口函数库，NIDS开发者不需要再编写底层的网络处理代码，只需  
专注于NIDS本身功能的实现即可。  
  
    libnids支持Linux、Solaris和\*BSD系统平台，目前最新版本为1.13。  
  
二、IP分片数据包  
  
    为了使libnids能接收所有的IP数据包(包括分片包、畸形包等)，程序员需要定义如  
下的回调函数：  
  
        void ip\_frag\_func(struct ip \* a\_packet)  
  
在调用nids\_init()函数初始化后，使用nids的函数进行注册：  
  
        nids\_register\_ip\_frag(ip\_frag\_func);  
  
这样回调函数ip\_frag\_func会在适当的时候由libnids调用，参数a\_packet指针将指向接  
收到的数据报。  
  
    类似地，如果仅接收目标主机会接受的数据包(如非碎片包、重组包或头部校验正确  
的数据包等)，需要定义如下回调函数：  
  
        void ip\_func(struct ip \* a\_packet)  
  
然后注册：  
  
        nids\_register\_ip(ip\_func);  
  
三、TCP数据流重组  
  
    要接收TCP流在交换的数据，必须定义如下回调函数：  
  
        void tcp\_callback(struct tcp\_stream \* ns, void \*\* param)  
  
tcp\_stream结构提供了一个TCP连接的所有信息。例如，它包含了客户端与服务器端的  
half\_stream结构。下文会对该结构的字段进行解释。  
  
    tcp\_stream结构有一个名为nids\_state的字段。此字段的数值将决定tcp\_callback的  
操作。  
  
      
  
    (a) ns->nids\_state==NIDS\_JUST\_EST时，ns表示一个刚刚建立的连接。  
  
        tcp\_callback可以据此决定是否对该连接的后续数据进行检查。如  
  
        需要检查，tcp\_callback回调函数将通知libnids它希望接收哪些  
  
        数据(如到客户端的数据、到服务器端的数据、到客户端的紧急数  
  
        据或到服务器端的紧急数据等)，然后返回。  
  
    (b) ns->nids\_state==NIDS\_DATA时，表示ns连接接收到新的数据。  
  
        half\_stream结构中的缓冲区用于存放这些数据。  
  
    (c) nids\_state字段为其它数值(NIDS\_CLOSE、NIDS\_RESET、  
  
        NIDS\_TIMEOUT)时，表示该连接已经关闭了。tcp\_callback函数应  
  
        释放相关资源。  
  
四、一个简单的实例  
  
    下面的源代码是一个非常简单的程序，它将libnids捕获的所有TCP连接交换的数据输  
出显示到标准输出设备上。  
  
\-----------------------BEGINING OF CODE--------------------------------  
  
\#include "nids.h"  
  
\#include <string.h>  
  
\#include <stdio.h>  
  
extern char \* inet\_ntoa(unsigned long);  
  
// tuple4结构包含了TCP连接两端的IP地址和端口，以下函数将它们转换为字符串  
  
// 格式，如10.0.0.1,1024, 10.0.0.2,23  
  
char \*  
  
adres (struct tuple4 addr)  
  
\{  
  
  static char buf\[256\];  
  
  strcpy (buf, inet\_ntoa (addr.saddr));  
  
  sprintf (buf + strlen (buf), ",%i,", addr.source);  
  
  strcat (buf, inet\_ntoa (addr.daddr));  
  
  sprintf (buf + strlen (buf), ",%i", addr.dest);  
  
  return buf;  
  
\}  
  
void  
  
tcp\_callback (struct tcp\_stream \*a\_tcp, void \*\* this\_time\_not\_needed)  
  
\{  
  
  char buf\[1024\];  
  
  strcpy (buf, adres (a\_tcp->addr)); // we put conn params into buf  
  
  if (a\_tcp->nids\_state == NIDS\_JUST\_EST)  
  
    \{  
  
    // a\_tcp所定义的连接已经建立。此处可视程序需要添加额外  
  
    // 的判断处理。如if (a\_tcp->addr.dest != 23) return;表  
  
    // 示不处理目标端口为23的数据包。  
  
    // 本例需要处理(显示)所有数据包，故：  
  
      a\_tcp->client.collect++; // 需要处理客户端接收的数据  
  
      a\_tcp->server.collect++; // 和服务器端接收的数据  
  
      a\_tcp->server.collect\_urg++; // 需要处理服务器端接收的紧急数据  
  
\#ifdef WE\_WANT\_URGENT\_DATA\_RECEIVED\_BY\_A\_CLIENT  
  
      a\_tcp->client.collect\_urg++; // 需要处理客户端接收的紧急数据  
  
                                   // (打开编译选项才有效)  
  
\#endif  
  
      fprintf (stderr, "%s established\\n", buf);  
  
      return;  
  
    \}  
  
  if (a\_tcp->nids\_state == NIDS\_CLOSE)  
  
    \{  
  
      // TCP连接正常关闭  
  
      fprintf (stderr, "%s closing\\n", buf);  
  
      return;  
  
    \}  
  
  if (a\_tcp->nids\_state == NIDS\_RESET)  
  
    \{  
  
      // TCP连接因RST数据包而关闭  
  
      fprintf (stderr, "%s reset\\n", buf);  
  
      return;  
  
    \}  
  
  if (a\_tcp->nids\_state == NIDS\_DATA)  
  
    \{  
  
      // 接收到新数据，下面判断决定是否显示  
  
      struct half\_stream \*hlf;  
  
      if (a\_tcp->server.count\_new\_urg)  
  
      \{  
  
        // 服务器端接收的紧急数据  
  
        strcat(buf,"(urgent->)");  
  
        buf\[strlen(buf)+1\]=0;  
  
        buf\[strlen(buf)\]=a\_tcp->server.urgdata;  
  
        write(1,buf,strlen(buf));  
  
        return;  
  
      \}  
  
\#ifdef WE\_WANT\_URGENT\_DATA\_RECEIVED\_BY\_A\_CLIENT  
  
      if (a\_tcp->client.count\_new\_urg)  
  
      \{  
  
        // 客户端接收的紧急数据  
  
        strcat(buf,"(urgent->)");  
  
        buf\[strlen(buf)+1\]=0;  
  
        buf\[strlen(buf)\]=a\_tcp->server.urgdata;  
  
        write(1,buf,strlen(buf));  
  
        return;  
  
      \}  
  
\#endif  
  
      if (a\_tcp->client.count\_new)  
  
        \{  
  
          // 客户端接收的数据  
  
          hlf = &a\_tcp->client; // 准备显示客户端接收的数据  
  
          strcat (buf, "(<-)"); // 指示数据流方向  
  
        \}  
  
      else  
  
        \{  
  
          hlf = &a\_tcp->server; // 准备显示服务器端接收的数据  
  
          strcat (buf, "(->)"); // 指示数据流方向  
  
        \}  
  
    fprintf(stderr,"%s",buf); // 首先输出显示连接双方的IP地址、端口  
  
                              // 和数据流方向  
  
   write(2,hlf->data,hlf->count\_new); // 输出显示接收到的新数据  
  
        
  
    \}  
  
  return ;  
  
\}  
  
int  
  
main ()  
  
\{  
  
  // 此处可自定义libnids的全局变量，如：  
  
  // nids\_params.n\_hosts=256;  
  
  if (!nids\_init () )  
  
  \{  
  
        fprintf(stderr,"%s\\n",nids\_errbuf);  
  
        exit(1);  
  
  \}  
  
  nids\_register\_tcp (tcp\_callback);  
  
  nids\_run ();  
  
  // NOT REACHED  
  
  return 0;  
  
\}  
  
\---------------------------END OF CODE------------------------------------    
  
五、libnids的数据结构及接口函数  
  
    libnids库的所有数据结构及接口函数都在"nids.h"头文件中声明。  
  
   struct tuple4 // TCP连接参数  
  
   \{  
  
   unsigned short source,dest; // 客户端和服务器端的端口号  
  
   unsigned long saddr,daddr;  // 客户端和服务器端的IP地址  
  
   \};  
  
   struct half\_stream // TCP连接一端的数据结构  
  
   \{  
  
   char state;            // 套接字状态(如TCP\_ESTABLISHED)  
  
   char collect;          // 如果大于0，则保存其数据到缓冲区中，否则忽略  
  
   char collect\_urg;      // 如果大于0，则保存紧急数据，否则忽略  
  
   char \* data;           // 正常数据的缓冲区  
  
   unsigned char urgdata; // 紧急数据缓冲区  
  
   int count;             // 自从连接建立以来保存到"data"缓冲区的数据字节  
  
                          // 数总和  
  
   int offset;            // 保存到"data"缓冲区的首字节数据偏移量  
  
   int count\_new;         // 最近一次接收到的数据字节数；如果为0，则无数  
  
                          // 到达  
  
   char count\_new\_urg;    // 如果非0，表示有新的紧急数据到达  
  
   ... // libnids库使用的辅助字段  
  
   \};  
  
   struct tcp\_stream  
  
   \{  
  
   struct tuple4 addr;   // TCP连接参数(saddr, daddr, sport, dport)  
  
   char nids\_state;                  // TCP连接的逻辑状态  
  
   struct half\_stream client,server; // 描述客户端与服务器端的数据结构  
  
   ...                               // libnids库使用的辅助字段  
  
   \};  
  
     在上面的实例程序中，回调函数tcp\_callback输出显示hlf->data缓冲区中的数据到  
标准输出设备上。这些数据在tcp\_callback函数返回后，由libnids自动释放这些数据所  
占用的内存空间。同时，hlf->offset字段将增加被丢弃数据的字节数，而新接收到的数  
据则存放到"data"缓冲区的起始处。  
  
    如果在其它应用中不进行如上例的操作(例如，数据处理过程至少需要N个字节的输入  
数据，而libnids只接收到的数据字节数count\_new<N)，则需要在tcp\_callback函数返回  
前调用如下函数：  
  
        void nids\_discard(struct tcp\_stream \* a\_tcp, int num\_bytes)  
  
此时，当回调函数tcp\_callback返回后linids将"data"缓冲区的前num\_bytes字节数据，  
同时计算调整offset字段的数值，并将剩余数据移动到缓冲区的起始处。  
  
     如果始终不调用nids\_discard()函数(如上面实例)，hlf->data缓冲区中将包含  
hlf-> count\_new字节数据。通常情况下，在hlf->data缓冲区中的数据字节数等于  
hlf->count - hlf->offset。  
  
    有了nids\_discard()函数，程序员就不必拷贝接收到的数据到另外的缓冲区中，   
hlf->data缓冲区将总是尽可能保存足够的数据。然后，有时会有保留数据包特定数据的  
需要。例如，我们希望能监测到针对wu-ftpd服务器的"CWD"溢出攻击，就需要跟踪检查   
ftp客户端发送的"CWD"命令。此时就需要tcp\_callback回调函数具有第二个参数了。此参  
数是某TCP连接私有数据的指针。处理过程如下：  
  
      
  
   void  
  
   tcp\_callback\_2 (struct tcp\_stream \* a\_tcp, struct conn\_param \*\*ptr)  
  
   \{  
  
   if (a\_tcp->nids\_state==NIDS\_JUST\_EST)  
  
   \{  
  
        struct conn\_param \* a\_conn;  
  
        if the connection is uninteresting, return;  
  
        a\_conn=malloc of some data structure  
  
        init of a\_conn  
  
        \*ptr=a\_conn // this value will be passed to tcp\_callback\_2 in future  
  
                    // calls  
  
        increase some of "collect" fields  
  
        return;  
  
   \}  
  
   if (a\_tcp->nids\_state==NIDS\_DATA)  
  
   \{  
  
        struct conn\_param \*current\_conn\_param=\*ptr;  
  
        using current\_conn\_param and the newly received data from the net  
  
        we search for attack signatures, possibly modyfying  
  
        current\_conn\_param    
  
        return ;  
  
   \}  
  
   ...  
  
   \}  
  
    nids\_register\_tcp和nids\_register\_ip\*函数可被任意次调用。在同一个TCP连接中  
使用两种不同的回调函数是允许的。  
  
    libnids库定义了一个全局变量结构nids\_params，其声明如下：  
  
      
  
   struct nids\_prm  
  
   \{  
  
   int n\_tcp\_streams; // 存放tcp\_stream结构的hash表大小。  
  
                      // 缺省值：1024  
  
   int n\_hosts;       // 存放IP分片信息的hash表大小  
  
                      // 缺省值：256  
  
   char \* device;     // libnids监听的接口设备名  
  
                      // 缺省值 == NULL，即由pcap\_lookupdev函数确定  
  
   int sk\_buff\_size;  // (Linux内核)sk\_buff结构大小  
  
                      // 缺省值：168  
  
   int dev\_addon;     // sk\_buff为网络接口保留的字节数  
  
                      // 如果dev\_addon==-1，则由nids\_init函数确定  
  
                      // 缺省值：-1  
  
   void (\*syslog)();  // 日志函数指针  
  
   int syslog\_level;  // 如果nids\_params.syslog==nids\_syslog，则此字段值  
  
                      // 将确定日志等级loglevel  
  
                      // 缺省值：LOG\_ALERT  
  
   int scan\_num\_hosts;// 存放端口扫描信息的hash表大小。  
  
                      // 如果为0，则关闭端口扫描监测功能。  
  
                      // 缺省值：256  
  
   int scan\_num\_ports;// 来自同一IP地址所扫描的TCP端口数上限  
  
                      // 缺省值：10  
  
   int scan\_delay;    // 在两次端口扫描中的间隔时间上限(毫秒)  
  
                      // 缺省值：3000  
  
   void (\*no\_mem)();  // 内存不足时被调用，此时应终止当前进程  
  
   int (\*ip\_filter)(struct ip\*);  // 当接收到一个IP数据包时调用。如返回值  
  
                                  // 非零，则处理该数据包，否则忽略。  
  
                                  // 缺省为(nids\_ip\_filter)且总返回1  
  
   char \*pcap\_filter; // 传递给pcap过滤器的字符串。  
  
                      // 缺省值：NULL  
  
   \} nids\_params;  
  
    nids\_params的syslog字段缺省时指向nids\_syslog函数，声明如下：  
  
        void nids\_syslog (int type, int errnum, struct ip \*iph, void \*data);  
  
    nids\_params.syslog函数用于记录异常情况，如端口扫描企图，无效TCP头标志 等。  
该字段应指向自定义的日志处理函数。nids\_syslog()仅作为一个例子。nids\_syslog()函  
数向系统守护服务syslogd发送日 志消息。  
  
    使用nids\_run有一个缺陷：应用程序将完全由数据包驱动(运行)。有时需要在没有数  
据包到达时也能处理一些任务，则作为nids\_run()函数的替代，程序员可使用如下函数：  
  
        int nids\_next()  
  
此函数将调用pcap\_next()函数(而不是pcap\_loop()函数)。(详细资料请参阅《网络安全  
工具开发函数库介绍之二 ――libpcap》。) nids\_next()函数成功时返回1，出错时返回  
0，且nids\_errbuf缓冲区存放相应错误消息。  
  
    典型地，当使用nids\_next()函数时，应用程序调用I/O复用函数select()阻塞，监听  
套接字fd在“读”描述字集合fd\_set中设置。该套接字可通过如下函数获得：  
  
        int nids\_getfd()  
  
成功时返回一个文件描述字，出错时返回-1，且nids\_errbuf缓冲区存放相应错误消息。  
  
\---\[\[ libnids应用实例 \]\]----------------------------------  
  
1、nids\_next()函数的应用  
  
============================ cut here ============================  
  
/\*  
  
This is an example how one can use nids\_getfd() and nids\_next() functions.  
  
You can replace printall.c's function main with this file.  
  
\*/  
  
\#include <sys/time.h>  
  
\#include <sys/types.h>  
  
\#include <unistd.h>  
  
int  
  
main ()  
  
\{  
  
  // here we can alter libnids params, for instance:  
  
  // nids\_params.n\_hosts=256;  
  
  int fd;  
  
  int time = 0;  
  
  fd\_set rset;  
  
  struct timeval tv;  
  
  if (!nids\_init ())  
  
  \{  
  
        fprintf(stderr,"%s\\n",nids\_errbuf);  
  
        exit(1);  
  
  \}  
  
  nids\_register\_tcp (tcp\_callback);  
  
  fd = nids\_getfd ();  
  
  for (;;)  
  
    \{  
  
      tv.tv\_sec = 1;  
  
      tv.tv\_usec = 0;  
  
      FD\_ZERO (&rset);  
  
      FD\_SET (fd, &rset);  
  
      // add any other fd we need to take care of  
  
      if (select (fd + 1, &rset, 0, 0, &tv))  
  
        \{  
  
                if (FD\_ISSET(fd,&rset)  // need to test it if there are other  
  
                                        // fd in rset  
  
                        if (!nids\_next ()) break;  
  
        \}  
  
      else  
  
        fprintf (stderr, "%i ", time++);  
  
    \}  
  
  return 0;  
  
\}  
  
============================ cut here ============================  
  
2、Simple sniffer  
  
============================ cut here ============================  
  
/\*  
  
   Copyright (c) 1999 Rafal Wojtczuk <nergal@avet.com.pl>. All rights   
reserved.  
  
   See the file COPYING for license details.  
  
\*/  
  
\#include <sys/types.h>  
  
\#include <sys/socket.h>  
  
\#include <netinet/in.h>  
  
\#include <netinet/in\_systm.h>  
  
\#include <arpa/inet.h>  
  
\#include <stdio.h>  
  
\#include <fcntl.h>  
  
\#include "nids.h"  
  
\#define LOG\_MAX 100  
  
\#define SZLACZEK "\\n--------------------------------------------------\\n"  
  
\#define int\_ntoa(x)     inet\_ntoa(\*((struct in\_addr \*)&x))  
  
char \*  
  
adres (struct tuple4 addr)  
  
\{  
  
  static char buf\[256\];  
  
  strcpy (buf, int\_ntoa (addr.saddr));  
  
  sprintf (buf + strlen (buf), ",%i,", addr.source);  
  
  strcat (buf, int\_ntoa (addr.daddr));  
  
  sprintf (buf + strlen (buf), ",%i : ", addr.dest);  
  
  return buf;  
  
\}  
  
int logfd;  
  
void  
  
do\_log (char \*adres\_txt, char \*data, int ile)  
  
\{  
  
  write (logfd, adres\_txt, strlen (adres\_txt));  
  
  write (logfd, data, ile);  
  
  write (logfd, SZLACZEK, strlen (SZLACZEK));  
  
\}  
  
void  
  
sniff\_callback (struct tcp\_stream \*a\_tcp, void \*\*this\_time\_not\_needed)  
  
\{  
  
  int dest;  
  
  if (a\_tcp->nids\_state == NIDS\_JUST\_EST)  
  
    \{  
  
      dest = a\_tcp->addr.dest;  
  
      if (dest == 21 || dest == 23 || dest == 110 || dest == 143 || dest ==   
513)  
  
        a\_tcp->server.collect++;  
  
      return;  
  
    \}  
  
  if (a\_tcp->nids\_state != NIDS\_DATA)  
  
    \{  
  
      // seems the stream is closing, log as much as possible  
  
      do\_log (adres (a\_tcp->addr), a\_tcp->server.data,  
  
              a\_tcp->server.count - a\_tcp->server.offset);  
  
      return;  
  
    \}  
  
  if (a\_tcp->server.count - a\_tcp->server.offset < LOG\_MAX)  
  
    \{  
  
      // we haven't got enough data yet; keep all of it  
  
      nids\_discard (a\_tcp, 0);  
  
      return;  
  
    \}  
  
      
  
  // enough data    
  
  do\_log (adres (a\_tcp->addr), a\_tcp->server.data, LOG\_MAX);  
  
  // Now procedure sniff\_callback doesn't want to see this stream anymore.  
  
  // So, we decrease all the "collect" fields we have previously increased.  
  
  // If there were other callbacks following a\_tcp stream, they would still  
  
  // receive data  
  
  a\_tcp->server.collect--;  
  
\}  
  
int  
  
main ()  
  
\{  
  
  logfd = open ("./logfile", O\_WRONLY | O\_CREAT | O\_TRUNC, 0600);  
  
  if (logfd < 0)  
  
    \{  
  
      perror ("opening ./logfile:");  
  
      exit (1);  
  
    \}  
  
  if (!nids\_init ())  
  
    \{  
  
      fprintf (stderr, "%s\\n", nids\_errbuf);  
  
      exit (1);  
  
    \}  
  
  nids\_register\_tcp (sniff\_callback);  
  
  nids\_run ();  
  
  return 0;  
  
\}  
  
============================ cut here ============================  
  
3、Wu-FTPd overflow attack detector  
  
============================ cut here ============================  
  
/\*  
  
Copyright (c) 1999 Rafal Wojtczuk <nergal@avet.com.pl>. All rights reserved.  
  
See the file COPYING for license details.  
  
\*/  
  
/\*  
  
This code attempts to detect attack against imapd (AUTHENTICATE hole) and  
  
wuftpd (creation of deep directory). This code is to ilustrate use of libnids;  
  
in order to improve readability, some simplifications were made, which enables  
  
an attacker to bypass this code (note, the below routines should be improved,  
  
not libnids)  
  
\*/    
  
\#include <sys/types.h>  
  
\#include <sys/socket.h>  
  
\#include <netinet/in.h>  
  
\#include <netinet/in\_systm.h>  
  
\#include <arpa/inet.h>  
  
\#include <stdio.h>  
  
\#include <stdlib.h>  
  
\#include <string.h>  
  
\#include <syslog.h>  
  
\#include "nids.h"  
  
\#define int\_ntoa(x)     inet\_ntoa(\*((struct in\_addr \*)&x))  
  
char \*  
  
adres (struct tuple4 addr)  
  
\{  
  
  static char buf\[256\];  
  
  strcpy (buf, int\_ntoa (addr.saddr));  
  
  sprintf (buf + strlen (buf), ",%i,", addr.source);  
  
  strcat (buf, int\_ntoa (addr.daddr));  
  
  sprintf (buf + strlen (buf), ",%i", addr.dest);  
  
  return buf;  
  
\}  
  
/\*  
  
if we find a pattern AUTHENTICATE \{an\_int\} in data stream sent to an imap  
  
server, where an\_int >1024, it means an buffer overflow attempt. We kill the  
  
connection.  
  
\*/  
  
\#define PATTERN "AUTHENTICATE \{"  
  
\#define PATLEN strlen(PATTERN)  
  
void  
  
detect\_imap (struct tcp\_stream \*a\_tcp)  
  
\{  
  
  char numbuf\[30\];  
  
  int i, j, datalen, numberlen;  
  
  struct half\_stream \*hlf;  
  
  if (a\_tcp->nids\_state == NIDS\_JUST\_EST)  
  
    \{  
  
      if (a\_tcp->addr.dest == 143)  
  
        \{  
  
          a\_tcp->server.collect++;  
  
          return;  
  
        \}  
  
      else  
  
        return;  
  
    \}  
  
  if (a\_tcp->nids\_state != NIDS\_DATA)  
  
    return;  
  
  hlf = &a\_tcp->server;  
  
  datalen = hlf->count - hlf->offset;  
  
  if (datalen < PATLEN)  
  
    \{  
  
      // we have too small amount of data to work on. Keep all data in buffer.  
  
      nids\_discard (a\_tcp, 0);  
  
      return;  
  
    \}  
  
  for (i = 0; i <= datalen - PATLEN; i++)  
  
    if (!memcmp (PATTERN, hlf->data + i, PATLEN)) //searching for a pattern  
  
      break;  
  
  if (i > datalen - PATLEN)  
  
    \{  
  
      // retain PATLEN bytes in buffer  
  
      nids\_discard (a\_tcp, datalen - PATLEN);  
  
      return;  
  
    \}  
  
  for (j = i + PATLEN; j < datalen; j++) // searching for a closing '\}'  
  
    if (\*(hlf->data + j) == '\}')  
  
      break;  
  
  if (j > datalen)  
  
    \{  
  
      if (datalen > 20)  
  
        \{  
  
          //number too long, perhaps we should log it, too  
  
        \}  
  
      return;  
  
    \}  
  
  numberlen = j - i - PATLEN;  
  
  memcpy (numbuf, hlf->data + i + PATLEN, numberlen); //numbuf contains  
  
                                                      // AUTH argument  
  
  numbuf\[numberlen\] = 0;  
  
  if (atoi (numbuf) > 1024)  
  
    \{  
  
      // notify admin  
  
      syslog(nids\_params.syslog\_level,  
  
      "Imapd exploit attempt, connection %s\\n",adres(a\_tcp->addr));  
  
      // kill the connection  
  
      nids\_killtcp (a\_tcp);  
  
    \}  
  
  nids\_discard (a\_tcp, datalen - PATLEN);  
  
  return;  
  
\}  
  
// auxiliary structure, needed to keep current dir of ftpd daemon  
  
struct supp  
  
\{  
  
  char \*currdir;  
  
  int last\_newline;  
  
\};  
  
// the below function adds "elem" string to "path" string, taking care of  
  
// ".." and multiple '/'. If the resulting path is longer than 768,  
  
// return value is 1, otherwise 0  
  
int  
  
add\_to\_path (char \*path, char \*elem, int len)  
  
\{  
  
int plen;  
  
char \* ptr;  
  
  if (len > 768)  
  
    return 1;  
  
  if (len == 2 && elem\[0\] == '.' && elem\[1\] == '.')  
  
    \{  
  
      ptr = rindex (path, '/');  
  
      if (ptr != path)  
  
        \*ptr = 0;  
  
    \}  
  
  else if (len > 0)  
  
    \{  
  
      plen = strlen (path);  
  
      if (plen + len + 1 > 768)  
  
        return 1;  
  
        if (plen==1)  
  
        \{  
  
        strncpy(path+1,elem,len);  
  
        path\[1+len\]=0;  
  
        \}  
  
        else  
  
        \{  
  
      path\[plen\] = '/';  
  
      strncpy (path + plen + 1, elem, len);  
  
      path\[plen + 1 + len\] = 0;  
  
        \}  
  
    \}  
  
return 0;  
  
\}  
  
void  
  
do\_detect\_ftp (struct tcp\_stream \*a\_tcp, struct supp \*\*param\_ptr)  
  
\{  
  
  struct supp \*p = \*param\_ptr;  
  
  int index = p->last\_newline + 1;  
  
  char \*buf = a\_tcp->server.data;  
  
  int offset = a\_tcp->server.offset;  
  
  int n\_bytes = a\_tcp->server.count - offset;  
  
  int path\_index, pi2, index2, remcaret;  
  
  for (;;)  
  
    \{  
  
      index2 = index;  
  
      while (index2 - offset < n\_bytes && buf\[index2 - offset\] != '\\n')  
  
        index2++;  
  
      if (index2 - offset >= n\_bytes)  
  
        break;  
  
      if (!strncasecmp (buf + index - offset, "cwd ", 4))  
  
        \{  
  
          path\_index = index + 4;  
  
          if (buf\[path\_index - offset\] == '/')  
  
            \{  
  
              strcpy (p->currdir, "/");  
  
              path\_index++;  
  
            \}  
  
          for (;;)  
  
            \{  
  
              pi2 = path\_index;  
  
              while (buf\[pi2 - offset\] != '\\n' && buf\[pi2 - offset\] != '/')  
  
                pi2++;  
  
                if (buf\[pi2-offset\]=='\\n' && buf\[pi2-offset-1\]=='\\r')  
  
                remcaret=1;  
  
                else remcaret=0;  
  
              if (add\_to\_path (p->currdir, buf + path\_index-offset, pi2 -   
path\_index-remcaret))  
  
                \{  
  
                  // notify admin  
  
                  syslog(nids\_params.syslog\_level,  
  
                  "Ftpd exploit attempt, connection %s\\n",adres(a\_tcp->addr));  
  
                  nids\_killtcp (a\_tcp);  
  
                  return;  
  
                \}  
  
              if (buf\[pi2 - offset\] == '\\n')  
  
                break;  
  
              path\_index = pi2 + 1;  
  
            \}  
  
        \}  
  
      index = index2 + 1;  
  
    \}  
  
  p->last\_newline = index - 1;  
  
  nids\_discard (a\_tcp, index - offset);  
  
\}  
  
void  
  
detect\_ftpd (struct tcp\_stream \*a\_tcp, struct supp \*\*param)  
  
\{  
  
  if (a\_tcp->nids\_state == NIDS\_JUST\_EST)  
  
    \{  
  
      if (a\_tcp->addr.dest == 21)  
  
        \{  
  
          struct supp \*one\_for\_conn;  
  
          a\_tcp->server.collect++;  
  
          one\_for\_conn = (struct supp \*) malloc (sizeof (struct supp));  
  
          one\_for\_conn->currdir = malloc (1024);  
  
          strcpy (one\_for\_conn->currdir, "/");  
  
          one\_for\_conn->last\_newline = 0;  
  
          \*param=one\_for\_conn;  
  
        \}  
  
      return;  
  
    \}  
  
  if (a\_tcp->nids\_state != NIDS\_DATA)  
  
    \{  
  
      free ((\*param)->currdir);  
  
      free (\*param);  
  
      return;  
  
    \}  
  
  do\_detect\_ftp (a\_tcp, param);  
  
\}  
  
int  
  
main ()  
  
\{  
  
  if (!nids\_init ())  
  
  \{  
  
        fprintf(stderr,"%s\\n",nids\_errbuf);  
  
        exit(1);  
  
  \}  
  
  nids\_register\_tcp (detect\_imap);  
  
  nids\_register\_tcp (detect\_ftpd);  
  
  nids\_run ();  
  
  return 0;  
  
\}

转载于:https://www.cnblogs.com/hnrainll/archive/2011/09/01/2162153.html