libnids-TCP流重组

1.  void process_tcp(u_char * data, int skblen) 
2.  { 
3.    
4.    struct ip *this_iphdr = (struct ip *)data; 
5.    /*tcphdr 的头*/ 
6.    struct tcphdr *this_tcphdr = (struct tcphdr *)(data + 4 * this_iphdr->ip_hl); 
7.    int datalen, iplen; 
8.    int from_client = 1; /*客户发送数据*/ 
9.    unsigned int tmp_ts; 
10.      
11.   /*流分为客户端服务端*/ 
12.   struct tcp_stream *a_tcp; 
13.   struct half_stream *snd, *rcv; 
14.   
15.   ugly_iphdr = this_iphdr; 
16.   iplen = ntohs(this_iphdr->ip_len); 
17.      
18.   if ((unsigned)iplen < 4 * this_iphdr->ip_hl + sizeof(struct tcphdr)) { 
19.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); 
20.     return; 
21.   } // ktos sie bawi 

22.   /*tcp 数据长度*/ 
23.   datalen = iplen - 4 * this_iphdr->ip_hl - 4 * this_tcphdr->th_off; 
24.   if (datalen < 0) { 
25.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); 
26.     return; 
27.   } // ktos sie bawi 
28.   
29.   /*源和目的地址都存在*/ 
30.   if ((this_iphdr->ip_src.s_addr | this_iphdr->ip_dst.s_addr) == 0) { 
31.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); 
32.     return; 
33.   } 
34.   
35.   /*如果没有th_ack 包，则进行扫描是否有攻击包*/ 
36.   if (!(this_tcphdr->th_flags & TH_ACK)) 
37.     detect_scan(this_iphdr); 
38.  
39.   /* 表示有扫描攻击发生 */ 
40.   if (!nids_params.n_tcp_streams) return; 
41.     
42.   /*tcp 头的长度，iplen -4*this_iphdr->ip_hl, 进行包头的校验*/ 
43.   if (my_tcp_check(this_tcphdr, iplen - 4 * this_iphdr->ip_hl, 
44.            this_iphdr->ip_src.s_addr, this_iphdr->ip_dst.s_addr)) { 
45.     nids_params.syslog(NIDS_WARN_TCP, NIDS_WARN_TCP_HDR, this_iphdr, this_tcphdr); 
46.     return; 
47.   } 
48.     
49. #if 0 
50.   check_flags(this_iphdr, this_tcphdr); 
51. #endif 
52.   
53. /*查找添加流*/ 
54.   
55. /* 
56.     ************* 三次握手的第一次握手***************************************** 
57. */ 
58.   
59.   if (!(a_tcp = find_stream(this_tcphdr, this_iphdr, &from_client))) { 
60.   /*是三次握手的第一个包*/ 
61.   /*tcp里流不存在时:且tcp数据包里的(syn=1 && ack==0 && rst==0)时,添加一条tcp流*/ 
62.  /*tcp第一次握手*/ 
63.     if ((this_tcphdr->th_flags & TH_SYN) && 
64.     !(this_tcphdr->th_flags & TH_ACK) && 
65.     !(this_tcphdr->th_flags & TH_RST)) 
66.     /*并且没有收到th_rest 包*/ 
67.       add_new_tcp(this_tcphdr, this_iphdr);/*节点加入链表中*/ 
68.    /*第一次握手完毕返回*/ 
69.     return; 
70.   } 
71.   
72.   if (from_client) { /*从client -->server的包*/ 
73.     snd = &a_tcp->client; 
74.     rcv = &a_tcp->server; 
75.   } else {/* server --> client的包 */ 
76.     rcv = &a_tcp->client; 
77.     snd = &a_tcp->server; 
78.   } 
79. /********************************************************************** 
80.                 三次握手的第二次握手 
81. ************************************************************************/ 
82.   
83.   /*tcp 三次握手， SYN ==1，ACK==1,tcp第二次握手(server -> client的同步响应)*/ 
84.   if ((this_tcphdr->th_flags & TH_SYN)) { 
85.     if (from_client || a_tcp->client.state != TCP_SYN_SENT || 
86.       a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK)) 
87.       return; 
88.   
89. /*第二次回应包的ACK 值为第一个包的序列号+1,在初始化的时候已经加1*/ 
90.     if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack)) 
91.       return; 
92.     /*第二个包服务端赋值*/ 
93.     /*a_tcp 中服务端赋值，*/ 
94.     a_tcp->server.state = TCP_SYN_RECV; 
95.     a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1; 
96.     a_tcp->server.first_data_seq = a_tcp->server.seq; 
97.     a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack); 
98.     a_tcp->server.window = ntohs(this_tcphdr->th_win); 
99.   
100.          
101.          /*对于tcp 选项的赋值*/ 
102.          //初始化客户端和服务器的时间截 
103.            if (a_tcp->client.ts_on) { 
104.                a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts); 
105.            if (!a_tcp->server.ts_on) 
106.                a_tcp->client.ts_on = 0; 
107.            } else a_tcp->server.ts_on = 0; 
108.          
109.          
110.        //初始化窗口大小 
111.            if (a_tcp->client.wscale_on) { 
112.                a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale); 
113.            if (!a_tcp->server.wscale_on) { 
114.                a_tcp->client.wscale_on = 0; 
115.                a_tcp->client.wscale = 1; 
116.                a_tcp->server.wscale = 1; 
117.            } 
118.            } else { 
119.                a_tcp->server.wscale_on = 0; 
120.                a_tcp->server.wscale = 1; 
121.            } 
122.         /*第二次握手完毕，返回*/ 
123.            return; 
124.          } 
125.          
126.           /* 
127.                (如果有数据存在或者修列号不等于确认号的)并且 
128.                序列号在窗口之外 
129.                已经确认过的序号 
130.           */ 
131.            
132.          if ( 
133.            ! ( !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq ) 
134.            && 
135.            /*th_seq- (ack_seq+ wscale) > 0 或者th_seq+datalen - ack_sql < 0*/ 
136.            ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) || 
137.                  before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq) 
138.                ) 
139.             ) 
140.             return; 
141.          
142.          /*发送th_rst 重新开启一个连接*/ 
143.          if ((this_tcphdr->th_flags & TH_RST)) { 
144.            /*是tcp 数据*/ 
145.            if (a_tcp->nids_state == NIDS_DATA) { 
146.              struct lurker_node *i; 
147.              a_tcp->nids_state = NIDS_RESET; 
148.              for (i = a_tcp->listeners; i; i = i->next) 
149.                 i->item) (a_tcp, &i->data); 
150.             } 
151.            nids_free_tcp_stream(a_tcp); 
152.            return; 
153.          } 
154.          
155.          /*PAWS check */ 
156.          if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) && 
157.            before(tmp_ts, snd->curr_ts)) 
158.          return; 
159.          
160.        /* ********************************************************************** 
161.                                第三次握手包 
162.           ********************************************************************** 
163.        */ 
164.          
165.          /* 从client -->server的包 
166.           是从三次握手的第三个包分析开始的，进行一部分数据分析，和初始化 
167.           连接状态 
168.          */ 
169.          if ((this_tcphdr->th_flags & TH_ACK)) { 
170.            if (from_client && a_tcp->client.state == TCP_SYN_SENT && 
171.            a_tcp->server.state == TCP_SYN_RECV) { 
172.              if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) { 
173.            a_tcp->client.state = TCP_ESTABLISHED; 
174.            a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack); 
175.            { 
176.              struct proc_node *i; 
177.              struct lurker_node *j; 
178.              void *data; 
179.                 
180.              a_tcp->server.state = TCP_ESTABLISHED; 
181.              a_tcp->nids_state = NIDS_JUST_EST; 
182.              /*开始全双工传输，clientserver 连接已经建立起来了*/ 
183.          
184.              /*三次握手tcp ip 连接建立*/ 
185.              for (i = tcp_procs; i; i = i->next) { 
186.                char whatto = 0; 
187.                char cc = a_tcp->client.collect; 
188.                char sc = a_tcp->server.collect; 
189.                char ccu = a_tcp->client.collect_urg; 
190.                char scu = a_tcp->server.collect_urg; 
191.          
192.                /*进入回调函数处理*/ 
193.          
194.                /* 如果在相应端口出现 
195.                 client.collect ++ ; 
196.                测审计次数据 
197.                对应用来说tcp 连接已经建立 
198.               */ 
199.                (i->item) (a_tcp, &data); 
200.          
201.               /**/ 
202.                if (cc < a_tcp->client.collect) 
203.                  whatto |= COLLECT_cc; 
204.                if (ccu < a_tcp->client.collect_urg) 
205.                  whatto |= COLLECT_ccu; 
206.                if (sc < a_tcp->server.collect) 
207.                  whatto |= COLLECT_sc; 
208.                if (scu < a_tcp->server.collect_urg) 
209.                  whatto |= COLLECT_scu; 
210.                if (nids_params.one_loop_less) { 
211.                        if (a_tcp->client.collect >=2) { 
212.                            a_tcp->client.collect=cc; 
213.                            whatto&=~COLLECT_cc; 
214.                        } 
215.                        if (a_tcp->server.collect >=2 ) { 
216.                            a_tcp->server.collect=sc; 
217.                            whatto&=~COLLECT_sc; 
218.                        } 
219.                } 
220.                      
221.               /*加入监听队列，开始数据接收*/ 
222.                if (whatto) { 
223.                  j = mknew(struct lurker_node); 
224.                  j->item = i->item;/*放入监听队列*/ 
225.                  j->data = data; 
226.                  j->whatto = whatto; 
227.                     
228.                  j->next = a_tcp->listeners; 
229.                  a_tcp->listeners = j; 
230.                } 
231.                   
232.              } 
233.                 
234.                 
235.              /*不存在监听着*/{ 
236.                nids_free_tcp_stream(a_tcp); 
237.                return; 
238.              } 
239.              if (!a_tcp->listeners) 
240.                 
241.              a_tcp->nids_state = NIDS_DATA; 
242.            } 
243.              } 
244.              //return; 

245.         
246.            } 
247.          } 
248.        /* 
249.        ************************************************************ 
250.                        挥手过程 
251.        ************************************************************* 
252.        */ 
253.        /*数据结束的包的判断*/ 
254.        if ((this_tcphdr->th_flags & TH_ACK)) { 
255.          /* 从数据传输过程不断更新服务器客户端的ack_seq 
256.            一直到接收到fin 包，数据传输结束
257.           */ 
258.            handle_ack(snd, ntohl(this_tcphdr->th_ack)); 
259.            if (rcv->state == FIN_SENT) 
260.              rcv->state = FIN_CONFIRMED; 
261.            if (rcv->state == FIN_CONFIRMED && snd->state == FIN_CONFIRMED) { 
262.              struct lurker_node *i; 
263.              a_tcp->nids_state = NIDS_CLOSE; 
264.              for (i = a_tcp->listeners; i; i = i->next) 
265.            (i->item) (a_tcp, &i->data); 
266.              nids_free_tcp_stream(a_tcp); 
267.              return; 
268.            } 
269.          } 
270.         /* 
271.        ************************************************************* 
272.                                数据处理过程 
273.        ************************************************************* 
274.         */ 
275.          if (datalen + (this_tcphdr->th_flags & TH_FIN) > 0) 
276.          /* 
            a_tcp-----a_tcp 客户端连接包 
277.            this_tcphdrtcp 包头 
278.            snd-----发送包 
279.            rcv-----接收包 
280.            (char*) (this_tcphdr) + 4 * this_tcphdr->th_off -----数据包内容 
281.            datalen---------数据包长度 
282.           */ 
283.            tcp_queue(a_tcp, this_tcphdr, snd, rcv, (char *) (this_tcphdr) + 4 * this_tcphdr->th_off, datalen, skblen); 
284.             
285.          snd->window = ntohs(this_tcphdr->th_win); 
286.             
287.          if (rcv->rmem_alloc > 65535) 
288.               prune_queue(rcv, this_tcphdr); 
289.          if (!a_tcp->listeners) 
290.            nids_free_tcp_stream(a_tcp); 
291.        } 
292.         
293.        static void tcp_queue(
294.        struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr, 
295.              struct half_stream * snd, struct half_stream* rcv, 
296.              char *data, int datalen, int skblen 
297.              ) 
298.        { 
299.          
300.          u_intthis_seq = ntohl(this_tcphdr->th_seq); 
301.             
302.          struct skbuff *pakiet, *tmp; 
303.          
304.          
305.         /* #defineEXP_SEQ (snd->first_data_seq + rcv->count + rcv->urg_count) 
306.            EXP_SEQ> this_seq 
307.          */ 
308.          
309.          /* 如果this_seq <= EXP_SEQ*/ 
310.          if ( !after(this_seq, EXP_SEQ) ) { 
311.            /*this_seq+ datalen + (this_tcphdr->th_flags & TH_FIN)> EXP_SEQ*/ 
312.            /*有重叠数据存在(重叠数据怎么处理呢) */ 
313.               
314.            if ( after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ) ) { 
315.              /*the packet straddles our window end */ 
316.              get_ts(this_tcphdr, &snd->curr_ts); 
317.                 
318.              add_from_skb(a_tcp, rcv, snd, data, datalen, this_seq, 
319.                   (this_tcphdr->th_flags & TH_FIN), 
320.                   (this_tcphdr->th_flags & TH_URG), 
321.                           ntohs(this_tcphdr->th_urp) + this_seq - 1); 
322.          
323.             /*从头节点释放节点*/ 
324.              pakiet = rcv->list; 
325.              while (pakiet) { 
326.             /* 期望的序列号小于该包的序列号则直接返回 */ 
327.            if (after(pakiet->seq, EXP_SEQ)) 
328.              break; 
329.               
330.            /*  对失序队列数据包的处理 
331.               如果包序列号加上长度还小于期望序列号 
332.               则把该包添加到数据区，并在失序队列中删除该包 
333.            */ 
334.            if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) { 
335.              add_from_skb(a_tcp, rcv, snd, pakiet->data, 
336.                       pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg, 
337.                       pakiet->urg_ptr + pakiet->seq - 1); 
338.                } 
339.                 rcv->rmem_alloc -= pakiet->truesize; 
340.               
341.                /*从头节点释放链表*/ 
342.            if (pakiet->prev) 
343.              pakiet->prev->next = pakiet->next; 
344.            else 
345.              rcv->list = pakiet->next; 
346.            if (pakiet->next) 
347.              pakiet->next->prev = pakiet->prev; 
348.            else 
349.              rcv->listtail = pakiet->prev; 
350.            tmp = pakiet->next; 
351.            free(pakiet->data); 
352.            free(pakiet); 
353.            pakiet = tmp; 
354.              } 
355.            } 
356.            else 
357.              return; 
358.          } 
359.          
360.             
361.        /*提前到达数据的加入失去顺序队列中链表*/ 
362.        //序列号大于我们期望的序列号，则把该包添加到list双向链表中 
363.        /*链表加入节点 */ 
364.          else { 
365.            /*初始化*/ 
366.            struct skbuff *p = rcv->listtail; 
367.               /*pakiet 加入rcv->listtal 链表中 */ 
368.               /* pakiet节点的初始化 */ 
369.            pakiet = mknew(struct skbuff); 
370.            pakiet->truesize = skblen; 
371.            rcv->rmem_alloc += pakiet->truesize; 
372.          
373.            /*数据包填充pakiet->data 中*/ 
374.            pakiet->len = datalen; 
375.            pakiet->data = malloc(datalen); 
376.            if (!pakiet->data) 
377.            nids_params.no_mem("tcp_queue"); 
378.            memcpy(pakiet->data, data, datalen); 
379.          
380.            /*是否是结束包*/ 
381.            pakiet->fin = (this_tcphdr->th_flags & TH_FIN); 
382.              /* 
383.                 硬件接收一个tcp 终止的链接， 
384.                 即使包在一个结束包的时候丢失，并且不再重传， 
385.                 处理这种方法就是引入时间机制处理 
386.              */ 
387.                 
388.            if (pakiet->fin) { 
389.              snd->state = TCP_CLOSING; 
390.              if (rcv->state == FIN_SENT || rcv->state == FIN_CONFIRMED) 
391.            add_tcp_closing_timeout(a_tcp); 
392.            } 
393.               
394.             /* seq,urg,urg_ptr 赋值 */ 
395.            pakiet->seq = this_seq; 
396.            pakiet->urg = (this_tcphdr->th_flags & TH_URG); 
397.            pakiet->urg_ptr = ntohs(this_tcphdr->th_urp); 
398.               
399.            for (;;) { 
400.                   
401.              if (!p || !after(p->seq, this_seq)) 
402.            break; 
403.              p = p->prev; 
404.        } 
405.               
406.            if (!p) { 
407.        /*建立首节点*/ 
408.              pakiet->prev = 0; 
409.              pakiet->next = rcv->list; 
410.              if (rcv->list) 
411.                 rcv->list->prev = pakiet; 
412.                 
413.              rcv->list = pakiet; 
414.              if (!rcv->listtail) 
415.            rcv->listtail = pakiet; 
416.            } 
417.          
418.        /*链表后插入*/ 
419.            else { 
420.              pakiet->next = p->next; 
421.              p->next = pakiet; 
422.              pakiet->prev = p; 
423.              if (pakiet->next) 
424.            pakiet->next->prev = pakiet; 
425.              else 
426.            rcv->listtail = pakiet; 
427.            } 
428.               
429.          } 
430.             
431.        } 
432.        /* 
433.        分配空间，数据保存rcv->data 中 
434.        长度为:rcv->count 
435.        新数据为date 
436.        长度为datalen 
437.        接收到新数据，重新分配空间，要根据收到的数据的大小 
438.        buffersize重分配的空间 
439.        */ 
440.        static void add2buf(struct half_stream * rcv, char *data, int datalen) 
441.        { 
442.          
443.          int toalloc; 
444.          
445.          /*datalen+ rcv->count - rcv->offset 如果大于buffersize 需要重新分配空间*/ 
446.             
447.          if (datalen + rcv->count - rcv->offset > rcv->bufsize) { 
448.            /*如果rcv->data 不存在*/ 
449.            if (!rcv->data) { 
450.              if (datalen < 2048) 
451.            toalloc = 4096; 
452.              else 
453.            toalloc = datalen * 2; 
454.          
455.              /*数据分配空间,bufsize 为分配空间的大小*/ 
456.              rcv->data = malloc(toalloc); 
457.              rcv->bufsize = toalloc; 
458.            } 
459.           /*第一次分配空间，如果空间不够重新分配*/ 
460.            else { 
461.              if (datalen < rcv->bufsize) 
462.                toalloc = 2 * rcv->bufsize; 
463.              else 
464.                toalloc = rcv->bufsize + 2*datalen; 
465.                 
466.              rcv->data = realloc(rcv->data, toalloc); 
467.              rcv->bufsize = toalloc; 
468.            } 
469.            if (!rcv->data) 
470.              nids_params.no_mem("add2buf"); 
471.          } 
472.          
473.          
474.          memcpy(rcv->data + rcv->count - rcv->offset, data, datalen); 
475.             
476.          rcv->count_new = datalen; 
477.             
478.          rcv->count += datalen; /*count累加为收到的数据之和，从流开始建立*/ 
479.          
480.        } 
481.         
482.        /* 通知服务器或者客户端接受数据 */ 
483.        static void notify(struct tcp_stream * a_tcp, struct half_stream * rcv) 
484.        { 
485.          
486.        /* 监听节点 */ 
487.          struct lurker_node *i, **prev_addr; 
488.          char mask; 
489.        /* 紧急数据 */ 
490.          if (rcv->count_new_urg) { 
491.            if (!rcv->collect_urg) 
492.              return; 
493.            if (rcv == &a_tcp->client) 
494.              mask = COLLECT_ccu; 
495.            else 
496.              mask = COLLECT_scu; 
497.               
498.            ride_lurkers(a_tcp, mask); 
499.            goto prune_listeners; 
500.          } 
501.          
502.          
503.        /* 常规数据 */ 
504.          if (rcv->collect) { 
505.            if (rcv == &a_tcp->client) 
506.              mask = COLLECT_cc; 
507.            else 
508.              mask = COLLECT_sc; 
509.          
510.          /* 不断读取数据，一直到读取到数据结束 */ 
511.           do { 
512.                    int total; 
513.                /*a_tcp 为为收到的datalen， total = dalalen; */ 
514.                a_tcp->read = rcv->count - rcv->offset; 
515.                total = a_tcp->read; 
516.                   
517.                /*处理监听节点上报信息*/ 
518.                ride_lurkers(a_tcp, mask); 
519.                if (a_tcp->read > total-rcv->count_new) 
520.                    rcv->count_new = total-a_tcp->read; 
521.                   
522.                if (a_tcp->read > 0) { 
523.                       
524.                /*已经读过的数据部再读，把没有读的数据放在rcv->data 中， 继续循环，hlf->data 指向新数据 rcv->count_new 为新数据的长度  */ 
525.                memmove(rcv->data, rcv->data + a_tcp->read, rcv->count - rcv->offset - a_tcp->read); 
526.          
527.                  /*rcv->ofset最终== rcv->count*/ 
528.                  rcv->offset += a_tcp->read; 
529.                } 
530.            }while (nids_params.one_loop_less && a_tcp->read>0 && rcv->count_new); 
531.        // we know thatif one_loop_less!=0, we have only one callback to notify 

532.         
533.          
534.        /* rcv->count_new初始化为0 */ 
535.           rcv->count_new=0; 
536.          } 
537.          
538.             
539.         prune_listeners: 
540.          prev_addr = &a_tcp->listeners; 
541.          i = a_tcp->listeners; 
542.          while (i) 
543.            if (!i->whatto) { 
544.              *prev_addr = i->next; 
545.              free(i); 
546.              i = *prev_addr; 
547.            } 
548.            else { 
549.              prev_addr = &i->next; 
550.              i = i->next; 
551.            } 
552.               
553.        }