libnids中TCP/IP栈实现细节分析（上）——TCP会话重组

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

在TCP/IP协议栈中，3层对应的是IP层，4层对应TCP层，在这里，从3层到4层转化主要做了两件重要的事情：IP分片重组和TCP会话重组。本篇先分析其中TCP会话重组的部分（自顶向下嘛，哈哈）。

OK，先看下重要的数据结构，在tcp.h中：

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中的

struct tuple4
{
    u_short source;
    u_short dest;
    u_int saddr;
    u_int daddr;
};

这是用来表示一个TCP连接的，不解释。

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流。

还有

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表了。

下面来看处理过程，先是初始化：

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会话重组开始了。来看看。

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_client))) {
    //这里判断此包是否是tcp回话周期中的第一个包（由客户端发出的syn包）
    //如果是，说明客户端发起了一个连接，那就新建一个回话
    if ((this_tcphdr->th_flags & TH_SYN) &&
    !(this_tcphdr->th_flags & TH_ACK) &&
    !(this_tcphdr->th_flags & TH_RST))
      add_new_tcp(this_tcphdr, this_iphdr);
    //否则，果断忽略
    return;
  }
 
  //如果找到会话，根据数据流向，将发送方（snd）和接收方（rcv）设置好
  if (from_client) {
    snd = &a_tcp->client;
    rcv = &a_tcp->server;
  }
  else {
    rcv = &a_tcp->client;
    snd = &a_tcp->server;
  }
 
  //来了一个SYN包
  if ((this_tcphdr->th_flags & TH_SYN)) {
    //syn包是用来建立新连接的，所以，要么来自客户端且没标志（前面处理了），要么来自服务端且加ACK标志
    //所以这里只能来自服务器，检查服务器状态是否正常，不正常的话果断忽略这个包
    if (from_client || a_tcp->client.state != TCP_SYN_SENT ||
      a_tcp->server.state != TCP_CLOSE || !(this_tcphdr->th_flags & TH_ACK))
      return;
 
    //忽略流水号错误的包
    if (a_tcp->client.seq != ntohl(this_tcphdr->th_ack))
      return;
 
    //自此，说明此包是服务端的第二次握手包，初始化连接（初始状态、流水号、窗口大小等等）
    a_tcp->server.state = TCP_SYN_RECV;
    a_tcp->server.seq = ntohl(this_tcphdr->th_seq) + 1;
    a_tcp->server.first_data_seq = a_tcp->server.seq;
    a_tcp->server.ack_seq = ntohl(this_tcphdr->th_ack);
    a_tcp->server.window = ntohs(this_tcphdr->th_win);
 
    //下面处理tcp的一些附加选项
    //先是时间戳选项
    if (a_tcp->client.ts_on) {
        a_tcp->server.ts_on = get_ts(this_tcphdr, &a_tcp->server.curr_ts);
    if (!a_tcp->server.ts_on)
        a_tcp->client.ts_on = 0;
    } else a_tcp->server.ts_on = 0;
    //再是窗口扩大选项
    if (a_tcp->client.wscale_on) {
        a_tcp->server.wscale_on = get_wscale(this_tcphdr, &a_tcp->server.wscale);
    if (!a_tcp->server.wscale_on) {
        a_tcp->client.wscale_on = 0;
        a_tcp->client.wscale  = 1;
        a_tcp->server.wscale = 1;
    }
    } else {
        a_tcp->server.wscale_on = 0;
        a_tcp->server.wscale = 1;
    }
    //syn包处理完，返回
    return;
  }
 
  if (
    ! (  !datalen && ntohl(this_tcphdr->th_seq) == rcv->ack_seq )/*不是流水号正确且没数据的包*/
    &&//而且这个包不再当前窗口之内
    ( !before(ntohl(this_tcphdr->th_seq), rcv->ack_seq + rcv->window*rcv->wscale) || //流水号大于等于窗口右侧
          before(ntohl(this_tcphdr->th_seq) + datalen, rcv->ack_seq)  //数据包尾部小于窗口左侧
        )
     )
     //这个包不正常，果断放弃
     return;
 
  //如果是rst包，ok，关闭连接
  //将现有数据推给注册的回调方，然后销毁这个会话。
  if ((this_tcphdr->th_flags & TH_RST)) {
    if (a_tcp->nids_state == NIDS_DATA) {
      struct lurker_node *i;
 
      a_tcp->nids_state = NIDS_RESET;
      //下面回调所有的钩子
      for (i = a_tcp->listeners; i; i = i->next)
    (i->item) (a_tcp, &i->data);
    }
    nids_free_tcp_stream(a_tcp);
    return;
  }
 
  /* PAWS(防止重复报文)check 检查时间戳*/
  if (rcv->ts_on && get_ts(this_tcphdr, &tmp_ts) &&
    before(tmp_ts, snd->curr_ts))
  return;  
 
  //好的，ack包来了
  if ((this_tcphdr->th_flags & TH_ACK)) {
 
    //如果是从客户端来的，且两边都在第二次握手的状态上
    if (from_client && a_tcp->client.state == TCP_SYN_SENT &&
    a_tcp->server.state == TCP_SYN_RECV) {
 
      //在此情况下，流水号又对得上，好的，这个包是第三次握手包，连接建立成功
      if (ntohl(this_tcphdr->th_ack) == a_tcp->server.seq) {
    a_tcp->client.state = TCP_ESTABLISHED;//更新客户端状态
    a_tcp->client.ack_seq = ntohl(this_tcphdr->th_ack);//更新ack序号
    {
      struct proc_node *i;
      struct lurker_node *j;
      void *data;
 
      a_tcp->server.state = TCP_ESTABLISHED;//更新服务端状态
      a_tcp->nids_state = NIDS_JUST_EST;//这个是安全方面的，这里无视之
 
          //下面这个循环是回调所有钩子函数，告知连接建立
      for (i = tcp_procs; i; i = i->next) {
        char whatto = 0;
        char cc = a_tcp->client.collect;
        char sc = a_tcp->server.collect;
        char ccu = a_tcp->client.collect_urg;
        char scu = a_tcp->server.collect_urg;
 
        (i->item) (a_tcp, &data);//回调
        if (cc < a_tcp->client.collect)
          whatto |= COLLECT_cc;
        if (ccu < a_tcp->client.collect_urg)
          whatto |= COLLECT_ccu;
        if (sc < a_tcp->server.collect)
          whatto |= COLLECT_sc;
        if (scu < a_tcp->server.collect_urg)
          whatto |= COLLECT_scu;
        if (nids_params.one_loop_less) {
                if (a_tcp->client.collect >=2) {
                    a_tcp->client.collect=cc;
                    whatto&=~COLLECT_cc;
                }
                if (a_tcp->server.collect >=2 ) {
                    a_tcp->server.collect=sc;
                    whatto&=~COLLECT_sc;
                }
        }
        if (whatto) {
          j = mknew(struct lurker_node);
          j->item = i->item;
          j->data = data;
          j->whatto = whatto;
          j->next = a_tcp->listeners;
          a_tcp->listeners = j;
        }
      }
      if (!a_tcp->listeners) {
        nids_free_tcp_stream(a_tcp);
        return;
      }
      a_tcp->nids_state = NIDS_DATA;
    }
      }
      // return;
    }
  }
  //自此，握手包处理完毕
 
  //下面就是挥手包了
  if ((this_tcphdr->th_flags & TH_ACK)) {
 
    //先调用handle_ack更新ack序号
    handle_ack(snd, ntohl(this_tcphdr->th_ack));
 
    //更新状态，回调告知连接关闭，然后释放连接
    if (rcv->state == FIN_SENT)
      rcv->state = FIN_CONFIRMED;
    if (rcv->state == FIN_CONFIRMED && snd->state == FIN_CONFIRMED) {
      struct lurker_node *i;
 
      a_tcp->nids_state = NIDS_CLOSE;
      for (i = a_tcp->listeners; i; i = i->next)
    (i->item) (a_tcp, &i->data);
      nids_free_tcp_stream(a_tcp);
      return;
    }
  }
 
  //下面处理数据包，和初始的fin包
  if (datalen + (this_tcphdr->th_flags & TH_FIN) > 0)
    //就将数据更新到接收方缓冲区
    tcp_queue(a_tcp, this_tcphdr, snd, rcv,
          (char *) (this_tcphdr) + 4 * this_tcphdr->th_off,
          datalen, skblen);
  //更新窗口大小
  snd->window = ntohs(this_tcphdr->th_win);
 
  //如果缓存溢出（说明出了问题），果断释放连接
  if (rcv->rmem_alloc > 65535)
    prune_queue(rcv, this_tcphdr);
  if (!a_tcp->listeners)
    nids_free_tcp_stream(a_tcp);
}

好了，tcp包的基本处理流程就这些了，主要做了连接的建立、释放、状态迁移这些工作，下面看看连接的缓冲区是如何维护的（主要就是如何更新的）。来看tcp_queue函数：

static void
tcp_queue(struct tcp_stream * a_tcp, struct tcphdr * this_tcphdr,
      struct half_stream * snd, struct half_stream * rcv,
      char *data, int datalen, int skblen
      )
{
  u_int this_seq = ntohl(this_tcphdr->th_seq);
  struct skbuff *pakiet, *tmp;
 
  /*
   * Did we get anything new to ack?
   */
  //EXP_SEQ是目前已集齐的数据流水号，我们希望收到从这里开始的数据
  //先判断数据是不是在EXP_SEQ之前开始
  if (!after(this_seq, EXP_SEQ)) {
    //再判断数据长度是不是在EXP_SEQ之后，如果是，说明有新数据，否则是重发的包，无视之
    if (after(this_seq + datalen + (this_tcphdr->th_flags & TH_FIN), EXP_SEQ)) {
      /* the packet straddles our window end */
      get_ts(this_tcphdr, &snd->curr_ts);
      //ok，更新集齐的数据区，值得一提的是add_from_skb函数一旦发现集齐了一段数据之后
      //便立刻调用notify函数，在notify函数里面将数据推给回调方
      add_from_skb(a_tcp, rcv, snd, (u_char *)data, datalen, this_seq,
           (this_tcphdr->th_flags & TH_FIN),
           (this_tcphdr->th_flags & TH_URG),
           ntohs(this_tcphdr->th_urp) + this_seq - 1);
      /*
       * Do we have any old packets to ack that the above
       * made visible? (Go forward from skb)
       */
      //此时EXP_SEQ有了变化了，看看缓冲区里的包有没有符合条件能用同样的方法处理掉的
      //有就处理掉，然后释放
      pakiet = rcv->list;
      while (pakiet) {
    if (after(pakiet->seq, EXP_SEQ))
      break;
    if (after(pakiet->seq + pakiet->len + pakiet->fin, EXP_SEQ)) {
      add_from_skb(a_tcp, rcv, snd, pakiet->data,
               pakiet->len, pakiet->seq, pakiet->fin, pakiet->urg,
               pakiet->urg_ptr + pakiet->seq - 1);
        }
    rcv->rmem_alloc -= pakiet->truesize;
    if (pakiet->prev)
      pakiet->prev->next = pakiet->next;
    else
      rcv->list = pakiet->next;
    if (pakiet->next)
      pakiet->next->prev = pakiet->prev;
    else
      rcv->listtail = pakiet->prev;
    tmp = pakiet->next;
    free(pakiet->data);
    free(pakiet);
    pakiet = tmp;
      }
    }
    else
      return;
  }
  //这里说明现在这个包是个乱序到达的（数据开始点超过了EXP_SEQ），放到缓冲区等待处理，注意保持缓冲区有序
  else {
    struct skbuff *p = rcv->listtail;
 
    pakiet = mknew(struct skbuff);
    pakiet->truesize = skblen;
    rcv->rmem_alloc += pakiet->truesize;
    pakiet->len = datalen;
    pakiet->data = malloc(datalen);
    if (!pakiet->data)
      nids_params.no_mem("tcp_queue");
    memcpy(pakiet->data, data, datalen);
    pakiet->fin = (this_tcphdr->th_flags & TH_FIN);
    /* Some Cisco - at least - hardware accept to close a TCP connection
     * even though packets were lost before the first TCP FIN packet and
     * never retransmitted; this violates RFC 793, but since it really
     * happens, it has to be dealt with... The idea is to introduce a 10s
     * timeout after TCP FIN packets were sent by both sides so that
     * corresponding libnids resources can be released instead of waiting
     * for retransmissions which will never happen.  -- Sebastien Raveau
     */
    if (pakiet->fin) {
      snd->state = TCP_CLOSING;
      if (rcv->state == FIN_SENT || rcv->state == FIN_CONFIRMED)
    add_tcp_closing_timeout(a_tcp);
    }
    pakiet->seq = this_seq;
    pakiet->urg = (this_tcphdr->th_flags & TH_URG);
    pakiet->urg_ptr = ntohs(this_tcphdr->th_urp);
    for (;;) {
      if (!p || !after(p->seq, this_seq))
    break;
      p = p->prev;
    }
    if (!p) {
      pakiet->prev = 0;
      pakiet->next = rcv->list;
      if (rcv->list)
         rcv->list->prev = pakiet;
      rcv->list = pakiet;
      if (!rcv->listtail)
    rcv->listtail = pakiet;
    }
    else {
      pakiet->next = p->next;
      p->next = pakiet;
      pakiet->prev = p;
      if (pakiet->next)
    pakiet->next->prev = pakiet;
      else
    rcv->listtail = pakiet;
    }
  }
}