TCP会话重组.docx

libnids是网络安全方面的一个库，可以用来检测网络上的攻击行为。其中最有价值的部分是，它模拟了linux内核中3层和4层的协议栈。可以供我们进一步研究linux内核中的TCP/IP协议栈做一些有价值的参考。这里简单谈谈这个库中模拟3、4层协议的实现细节（在继续读下去之前，有必要复习一下TCP/IP协议相关理论，主要是滑动窗口协议）。这里送上一张网上到处都有的TCP状态转化图，算是开胃小菜：
基本概念
四元组：源IP地址、目的IP地址、源端口、目的端口。
五元组：源IP地址、目的IP地址、协议号、源端口、目的端口。
六元组：源MAC地址、源IP地址、源端口号、目的MAC地址、目的IP地址和目的IP地址。
七元组：源MAC地址、源IP地址、源端口号、目的MAC地址、目的IP地址和目的IP地址和协议号。

五元组确定一个会话还是四元组?
五元组通常是指由源IP地址，源端口，目的IP地址，目的端口和传输层协议号这五个量组成的一个集合。例如：192.168.0.1/10000/TCP/121.14.88.76/80就构成了一个五元组。其意义是，一个IP地址为192.168.1.1的终端通过端口10000，利用TCP协议，和IP地址为121.14.88.76，端口为80的终端进行连接通讯。
五元组能够唯一确定一个会话。

在TCP会话重组时，使用序列号确定TCP报文顺序可以解决数据报文不按顺序到达及其重传问题，并且利用二维链表对TCP会话就行还原。难点在于解决多连接问题、IP包乱序到达和TCP会话重传的问题。
原因：TCP协议是TCP/IP协议族中一个重要组成部分，TCP数据流的重组是高层协议分析系统设计和实现的基础。TCP协议是面向连接的可靠传输协议，而TCP下层的IP协议却是面向报文的不可靠协议，这回带来问题：IP不能保证TCP报文可靠的、顺序的传输。为了解决这个问题，TCP采取滑动窗口机制、字节流编号机制和快速重传算法机制等。这可以保证数据的可靠传输。
TCP会话(TCP_Session_IDT)可以通过四元组<源IP地址、目的IP地址、源端口号和目的端口号>唯一标识。
使用HASH表快速查找定位的特征，解决多个TCP会话同时处理的问题，快速处理多个会话问题。
在TCP头中Sequence Number是判断该数据包是否重传和包乱序的重要参数。在TCP连接刚建立时，会为后续TCP传输设置一个初始的SequenceNumber，每传送一个包含有效数据的TCP包，后续传送的TCP数据包的Sequence Number会作响应的修改，如果前一个包长度为N，则这个包的Sequence Number为前一个包Sequence Number加N。它是为保证TCP数据包按序传输来设计的，可以有效的实现TCP数据的完整传输，特别是当数据传输出现错误时可以有效进行错误纠正。
TCP重组数据文件写指针的SYN算法如下：
File_Init_Write_Pointer= Init_Sequence Number + 1;
File_write_Pointer= Current Sequence Number – File_init_Write_point;
检查TCP会话中是否存在空洞，可以来确定会话重组成功、失败和超时。
TCP建立连接需要3次握手，而终止一个连接需要4次握手。这是因为一个TCP连接时全双工的，每个方向必须单独的进行关闭。
规则1：六元组<源MAC地址、源IP地址、源端口号、目的MAC地址、目的IP地址和目的IP地址>，协议号是TCP，它应该是唯一的会话。
规则2：TCP头中4元组，它应该是唯一的，不唯一说明存在重传情况。

在TCP/IP协议栈中，3层对应的是IP层，4层对应TCP层，在这里，从3层到4层转化主要做了两件重要的事情：IP分片重组和TCP会话重组。本篇先分析其中TCP会话重组的部分（自顶向下嘛，哈哈）。
OK，先看下重要的数据结构，在tcp.h中：
[cpp] view plaincopyprint?
1. struct skbuff   
2. {  
3.   //万年不变的next和prev，这向我们昭示了这是一个双向队列。  
4.   //对于每个TCP会话（ip:端口<- ->ip:端口）都要维护两个skbuf队列（每个方向都有一个嘛）  
5.   //每个skbuf对应网络上的一个IP包，TCP流就是一个接一个的IP包嘛。  
6.   struct skbuff *next;  
7.   struct skbuff *prev;  
8.    
9.   void *data;  
10.   u_int len;  
11.   u_int truesize;  
12.   u_int urg_ptr;  
13.    
14.   char fin;  
15   char urg;  
16.   u_int seq;  
17.   u_int ack;  
18. };  
struct skbuff
{
//万年不变的next和prev，这向我们昭示了这是一个双向队列。
//对于每个TCP会话（ip:端口<- ->ip:端口）都要维护两个skbuf队列（每个方向都有一个嘛）
//每个skbuf对应网络上的一个IP包，TCP流就是一个接一个的IP包嘛。
struct skbuff *next;
struct skbuff *prev;

void *data;
u_int len;

u_int truesize;
u_int urg_ptr;

char fin;
char urg;
u_int seq;
u_int ack;
};
这个结构体就是模仿的内核中的sk_buff结构体，只不过比内核中的要小很多（你懂的，因为这里只做会话重组）。
下面是在nids.h中的
[cpp] view plaincopyprint?
1. struct tuple4  
2. {  
3.     u_short source;  
4.     u_short dest;  
5.     u_int saddr;  
6.     u_int daddr;  
7. };  
struct tuple4
{
    u_short source;
    u_short dest;
    u_int saddr;
    u_int daddr;
};
这是用来表示一个TCP连接的，不解释。
[cpp] view plaincopyprint?
1. struct half_stream  
2. {  
3.   char state;  
4.   char collect;  
5.   char collect_urg;  
6.    
7.   char *data; //这里存放着已经按顺序集齐排列好的数据  
8.   int offset;  
9.   int count; //这里存放data中数据的字节数  
10.   int count_new; //这里存放data中还没回调过的数据的字节数  
11.   int bufsize;  
12.   int rmem_alloc;  
13.    
14.   int urg_count;  
15.   u_int acked;  
16.   u_int seq;  
17.   u_int ack_seq;  
18.   u_int first_data_seq;  
19.   u_char urgdata;  
20.   u_char count_new_urg;  
21.   u_char urg_seen;  
22.   u_int urg_ptr;  
23.   u_short window;  
24.   u_char ts_on; //tcp时间戳选项是否打开  
25.   u_char wscale_on; //窗口扩展选项是否打开  
26.   u_int curr_ts;  
27.   u_int wscale;  
28.    
29.   //下面是ip包缓冲区  
30.   struct skbuff *list;  
31.   struct skbuff *listtail;  
32. }  
struct half_stream
{
char state;
char collect;
char collect_urg;

char *data; //这里存放着已经按顺序集齐排列好的数据
int offset;
int count; //这里存放data中数据的字节数
int count_new; //这里存放data中还没回调过的数据的字节数
int bufsize;
int rmem_alloc;

int urg_count;
u_int acked;
u_int seq;
u_int ack_seq;
u_int first_data_seq;
u_char urgdata;
u_char count_new_urg;
u_char urg_seen;
u_int urg_ptr;
u_short window;
u_char ts_on; //tcp时间戳选项是否打开
u_char wscale_on; //窗口扩展选项是否打开
u_int curr_ts;
u_int wscale;

//下面是ip包缓冲区
struct skbuff *list;
struct skbuff *listtail;
}

这个是用来表示“半个TCP会话”，其实就是一个方向上的TCP流。
还有
[cpp] view plaincopyprint?
1. struct tcp_stream  
2. {  
3.   struct tuple4 addr;  
4.   char nids_state;  
5.   struct lurker_node *listeners;  
6.   struct half_stream client;  
7.   struct half_stream server;  
8.   struct tcp_stream *next_node;  
9.   struct tcp_stream *prev_node;  
10.   int hash_index;  
11.   struct tcp_stream *next_time;  
12.   struct tcp_stream *prev_time;  
13.   int read;  
14.   struct tcp_stream *next_free;  
15.   void *user;  
16. };  
struct tcp_stream
{
struct tuple4 addr;
char nids_state;
struct lurker_node *listeners;
struct half_stream client;
struct half_stream server;
struct tcp_stream *next_node;
struct tcp_stream *prev_node;
int hash_index;
struct tcp_stream *next_time;
struct tcp_stream *prev_time;
int read;
struct tcp_stream *next_free;
void *user;
};
显然，这是用来表示一个完整的TCP会话了，最后是static struct tcp_stream **tcp_stream_table;一个TCP会话指针的数组，其实就是hash表了。
下面来看处理过程，先是初始化：
[cpp] view plaincopyprint?
1. int tcp_init(int size)  
2. {  
3.   ...  
4.   //初始化全局tcp会话哈希表  
5.   tcp_stream_table_size = size;  
6.   tcp_stream_table = calloc(tcp_stream_table_size, sizeof(char *));  
7.   if (!tcp_stream_table) {  
8.     nids_params.no_mem("tcp_init");  
9.     return -1;  
10.   }  
11.    
12.   //设置最大会话数，为了哈希的效率，哈希表的元素个数上限设为3/4表大小  
13.   max_stream = 3 * tcp_stream_table_size / 4;  
14.    
15.   //先将max_stream个tcp会话结构体申请好，放着（避免后面陆陆续续申请浪费时间）。  
16.   streams_pool = (struct tcp_stream *) malloc((max_stream + 1) * sizeof(struct tcp_stream));  
17.   if (!streams_pool) {  
18.     nids_params.no_mem("tcp_init");  
19.     return -1;  
20.   }  
21.    

22.   //ok，将这个数组初始化成链表  
23.   for (i = 0; i < max_stream; i++)  
24.     streams_pool[i].next_free = &(streams_pool[i + 1]);  
25.   streams_pool[max_stream].next_free = 0;  
26.   free_streams = streams_pool;  
27.    
28.   ...  
29.   return 0;  
30. }  
int tcp_init(int size)
{
..
//初始化全局tcp会话哈希表
tcp_stream_table_size = size;
tcp_stream_table = calloc(tcp_stream_table_size, sizeof(char *));
if (!tcp_stream_table) {
nids_params.no_mem("tcp_init");
return -1;
}

//设置最大会话数，为了哈希的效率，哈希表的元素个数上限设为3/4表大小
max_stream = 3 * tcp_stream_table_size / 4;

//先将max_stream个tcp会话结构体申请好，放着（避免后面陆陆续续申请浪费时间）。
streams_pool = (struct tcp_stream *) malloc((max_stream + 1) * sizeof(struct tcp_stream));
if (!streams_pool) {
nids_params.no_mem("tcp_init");
return -1;
}

//ok，将这个数组初始化成链表
for (i = 0; i < max_stream; i++)
streams_pool[i].next_free = &(streams_pool[i + 1]);
streams_pool[max_stream].next_free = 0;
free_streams = streams_pool;

...
return 0;
}

很简单，做了两件事：1.初始化tcp会话哈希表。2.初始化会话池。这个初始化函数只在库初始化时执行一次。
初始化完成之后，就进入了pcap_loop中了，nids中的回调函数是nids_pcap_handler，在这个函数里面做了些ip分片重组（等下篇再说）后（tcp包）便来到了process_tcp函数，这里tcp会话重组开始了。来看看。
[cpp] view plaincopyprint?
1. void process_tcp(u_char * data, int skblen){  
2.   //处理头，得到ip包和tcp包  
3.   struct ip *this_iphdr = (struct ip *)data;  
4.   struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl);  
5.    
6.   ...//此处忽略安检代码  
7.    

8.   //在哈希表里找找，如果没有此tcp会话则看看是不是要新建一个  
9.   if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) {  
10.     //这里判断此包是否是tcp回话周期中的第一个包（由客户端发出的syn包）  
11.     //如果是，说明客户端发起了一个连接，那就新建一个回话  
12.     if ((this_tcphdr->th_flags & TH_SYN) &&  
13.     !(this_tcphdr->th_flags & TH_ACK) &  
14.     !(this_tcphdr->th_flags & TH_RST))  
15.       add_new_tcp(this_tcphdr, this_iphdr);  
16.     //否则，果断忽略  
17.     return;  
18.   }  
19.    
20.   //如果找到会话，根据数据流向，将发送方（snd）和接收方（rcv）设置好  
21.   if (from_client) {  
22.     snd = &a_tcp->client;  
23.     rcv = &a_tcp->server;  
24.   }  
25.   else {  
26.     rcv = &a_tcp->client;  
27.     snd = &a_tcp->server;  
28.   }  
29.    
30.   //来了一个SYN包  
31.   if ((this_tcphdr->th_flags & TH_SYN)) {  
32.     //syn包是用来建立新连接的，所以，要么来自客户端且没标志（前面处理了），要么来自服务端且加ACK标志  
33.     //所以这里只能来自服务器，检查服务器状态是否正常，不正常的话果断忽略这个包  
34.     if (from_client || a_tcp->client.state != TCP_SYN_SENT ||  
35.       a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK))  
36.       return;  
37.    
38.     //忽略流水号错误的包  
39.     if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack))  
40.       return;  
41.    
42.     //自此，说明此包是服务端的第二次握手包，初始化连接（初始状态、流水号、窗口大小等等）  
43.     a_tcp->server.state = TCP_SYN_RECV;  
44.     a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1;  
45.     a_tcp->server.first_data_seq = a_tcp->server.seq;  
46.     a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack);  
47.     a_tcp->server.window = ntohs(this_tcphdr->th_win);  
48.    
49.     //下面处理tcp的一些附加选项  
50.     //先是时间戳选项  
51.     if (a_tcp->client.ts_on) {  
52.         a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts);  
53.     if (!a_tcp->server.ts_on)  
54.         a_tcp->client.ts_on = 0  
55.     } else a_tcp->server.ts_on = 0;  
56.     //再是窗口扩大选项  
57.     if (a_tcp->client.wscale_on) {  
58.         a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale);  
59.     if (!a_tcp->server.wscale_on) {  
60.         a_tcp->client.wscale_on = 0;  
61.         a_tcp->client.wscale  = 1;  
62.         a_tcp->server.wscale = 1;  
63.     }  
64.     } else {  
65.         a_tcp->server.wscale_on = 0;  
66.         a_tcp->server.wscale = 1;  
67.     }  
68.     //syn包处理完，返回  
69.     return;  
70.   }  
71.    
72.   if (  
73.     ! (  !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq )/*不是流水号正确且没数据的包*/  
74.     &&//而且这个包不再当前窗口之内  
75.     ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) || //流水号大于等于窗口右侧  
76.           before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq)  //数据包尾部小于窗口左侧  
77.         )  
78.      )  
79.      //这个包不正常，果断放弃  
80.      return;  
81.    
82.   //如果是rst包，ok，关闭连接  
83.   //将现有数据推给注册的回调方，然后销毁这个会话。  
84.   if ((this_tcphdr->th_flags & TH_RST)) {  
85.     if (a_tcp->nids_state == NIDS_DATA) {  
86.       struct lurker_node *i;  
87.    
88.       a_tcp->nids_state = NIDS_RESET;  
89.       //下面回调所有的钩子  
90.       for (i = a_tcp->listeners; i; i = i->next)  
91.     (i->item) (a_tcp, &i->data);  
92.     }  
93.     nids_free_tcp_stream(a_tcp);  
94.     return;  
95.   }  
96.    
97.   /* PAWS(防止重复报文)check 检查时间戳*/  
98.   if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) &&  
99.     before(tmp_ts, snd->curr_ts))  
100.   return;    
101.    
102.   //好的，ack包来了  
103.   if ((this_tcphdr->th_flags & TH_ACK)) {  
104.    
105.     //如果是从客户端来的，且两边都在第二次握手的状态上  
106.     if (from_client && a_tcp->client.state == TCP_SYN_SENT &&  
107.     a_tcp->server.state == TCP_SYN_RECV) {  
108.    
109.       //在此情况下，流水号又对得上，好的，这个包是第三次握手包，连接建立成功  
110.       if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) {  
111.     a_tcp->client.state = TCP_ESTABLISHED;//更新客户端状态  
112.     a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack);//更新ack序号  
113.     {  
114.       struct proc_node *i;  
115.       struct lurker_node *j;  
116.       void *data;  
117.    
118.       a_tcp->server.state = TCP_ESTABLISHED;//更新服务端状态  
119.       a_tcp->nids_state = NIDS_JUST_EST;//这个是安全方面的，这里无视之  
120.    
121.           //下面这个循环是回调所有钩子函数，告知连接建立  
122.       for (i = tcp_procs; i; i = i->next) {  
123.         char whatto = 0;  
124.         char cc = a_tcp->client.collect;  
125.         char sc = a_tcp->server.collect;  
126.         char ccu = a_tcp->client.collect_urg;  
127.         char scu = a_tcp->server.collect_urg;  
128.    
129.         (i->item) (a_tcp, &data);//回调  
130.         if (cc < a_tcp->client.collect)  
131.           whatto |= COLLECT_cc;  
132.         if (ccu < a_tcp->client.collect_urg)  
133.           whatto |= COLLECT_ccu;  
134.         if (sc < a_tcp->server.collect)  
135.           whatto |= COLLECT_sc;  
136.         if (scu < a_tcp->server.collect_urg)  
137.           whatto |= COLLECT_scu;  
138.         if (nids_params.one_loop_less) {  
139.                 if (a_tcp->client.collect >=2) {  
140.                     a_tcp->client.collect=cc;  
141.                     whatto&=~COLLECT_cc;  
142.                 }  
143.                 if (a_tcp->server.collect >=2 ) {  
144.                     a_tcp->server.collect=sc;  
145.                     whatto&=~COLLECT_sc;  
146.                 }  
147.         }  
148.         if (whatto) {  
149.           j = mknew(struct lurker_node);  
150.           j->item = i->item;  
151.           j->data = data;  
152.           j->whatto = whatto;  
153.           j->next = a_tcp->listeners;  
154.           a_tcp->listeners = j;  
155.         }  
156.       }  
157.       if (!a_tcp->listeners) {  
158.         nids_free_tcp_stream(a_tcp);  
159.         return;  
160.       }  
161.       a_tcp->nids_state = NIDS_DATA;  
162.     }  
163.       }  
164.       // return;  
165.     }  
166.   }  
167.   //自此，握手包处理完毕  
168.    
169.   //下面就是挥手包了  
170.   if ((this_tcphdr->th_flags & TH_ACK)) {  
171.    
172.     //先调用handle_ack更新ack序号  
173.     handle_ack(snd, ntohl(this_tcphdr->th_ack));  
174.    
175.     //更新状态，回调告知连接关闭，然后释放连接  
176.     if (rcv->state == FIN_SENT)  
177.       rcv->state = FIN_CONFIRMED;  
178.     if (rcv->state == FIN_CONFIRMED && snd->state == FIN_CONFIRMED) {  
179.       struct lurker_node *i;  
180.    
181.       a_tcp->nids_state = NIDS_CLOSE;  
182.       for (i = a_tcp->listeners; i; i = i->next)  
183.     (i->item) (a_tcp, &i->data);  
184.       nids_free_tcp_stream(a_tcp);  
185.       return;  
186.     }  
187.   }  
188.    
189.   //下面处理数据包，和初始的fin包  
190.   if (datalen + (this_tcphdr->th_flags & TH_FIN) > 0)  
191.     //就将数据更新到接收方缓冲区  
192.     tcp_queue(a_tcp, this_tcphdr, snd, rcv,  
193.           (char *) (this_tcphdr) + 4 * this_tcphdr->th_off,  
194.           datalen, skblen);  
195.   //更新窗口大小  
196.   snd->window = ntohs(this_tcphdr->th_win);  
197.    
198.   //如果缓存溢出（说明出了问题），果断释放连接  
199.   if (rcv->rmem_alloc > 65535)  
200.     prune_queue(rcv, this_tcphdr);  
201.   if (!a_tcp->listeners)  
202.     nids_free_tcp_stream(a_tcp);  
203. }  
void process_tcp(u_char * data, int skblen){
//处理头，得到ip包和tcp包
struct ip *this_iphdr = (struct ip *)data;
struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl);

...//此处忽略安检代码

//在哈希表里找找，如果没有此tcp会话则看看是不是要新建一个
if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_cli