连接跟踪TCP序号检查

连接的每个方向定义了如下的3个值：

1）td_maxend为最大序号，其由反方向的回复报文计算而来，即最大确认序号SACK+窗口值。
2）td_maxwin为最大窗口，其由本方向的发送报文计算而来，即报文TCP头部通告的窗口值+乱序报文使用的空间值。
如果当前的报文结束序号超过最大序号td_maxend，需将超出部分累计到最大窗口值中。
3）td_end为结束序号，其由发送报文计算而来，即报文的开始序号加上数据长度。

连接跟踪的TCP序号检查，包含以下4个标准。

   I.   Upper bound for valid data: seq <= sender.td_maxend有效SEQ数据上限（右边界）：序号 <= sender.td_maxend，即序号值不能大于发送端最大的数据序号。II.  Lower bound for valid data: seq + len >= sender.td_end - receiver.td_maxwin有效SEQ数据下限（左边界）：序号 + 长度 >= sender.td_end - receiver.td_maxwinIII. Upper bound for valid (s)ack:   sack <= receiver.td_end有效ACK序号上限：sack <= receiver.td_end，既确认序号不能大于发送端发送的最大数据序号。IV.  Lower bound for valid (s)ack:   sack >= receiver.td_end - MAXACKWINDOW有效ACK序号下限：sack >= receiver.td_end - MAXACKWINDOW

对于第II个标准，数据的结束序号，应当大于接收端窗口的左边界。假设发送端的结束序号（sender.td_end）所表示的数据，致使接收端的窗口缓存满，以此作为接收端窗口的右边界，减去最大的接收端窗口，即为接收端窗口的左边界。

对于第IV个标准，要求ACK序号大于发送端窗口的左边界。假设接收端的结束序号(receiver.td_end)所表示的数据，致使发送端的窗口缓存满，以此作为发送端窗口的右边界，减去最大的发送端窗口就是左边界了。

宏MAXACKWINDOW将发送端最大窗口值td_maxwin限定在不小于MAXACKWINCONST（66000），但是，如果ACK确认的是一个大于66000的报文，标准IV将会出错。

/* Fixme: what about big packets? */
#define MAXACKWINCONST          66000
#define MAXACKWINDOW(sender)                        \((sender)->td_maxwin > MAXACKWINCONST ? (sender)->td_maxwin \: MAXACKWINCONST)

TCP序号检查

如下函数tcp_in_window对报文的序号，ACK序号进行检查，并更新相应窗口信息。

static bool tcp_in_window(const struct nf_conn *ct,struct ip_ct_tcp *state,enum ip_conntrack_dir dir,unsigned int index,const struct sk_buff *skb,unsigned int dataoff,const struct tcphdr *tcph)
{struct net *net = nf_ct_net(ct);struct nf_tcp_net *tn = nf_tcp_pernet(net);struct ip_ct_tcp_state *sender = &state->seen[dir];struct ip_ct_tcp_state *receiver = &state->seen[!dir];const struct nf_conntrack_tuple *tuple = &ct->tuplehash[dir].tuple;__u32 seq, ack, sack, end, win, swin;u16 win_raw;s32 receiver_offset;bool res, in_recv_win;

首先，获取报文中的TCP序号、ACK序号、以及窗口大小，和结束序号（根据数据长度等计算得出）。

    /** Get the required data from the packet.*/seq = ntohl(tcph->seq);ack = sack = ntohl(tcph->ack_seq);win_raw = ntohs(tcph->window);win = win_raw;end = segment_seq_plus_len(seq, skb->len, dataoff, tcph);

如果接收方向协商了SACK选项，获取SACK序号块中最大的序号值，备用。

    if (receiver->flags & IP_CT_TCP_FLAG_SACK_PERM)tcp_sack(skb, dataoff, tcph, &sack);

修正ACK序号偏移量，如果此连接执行了NAT，对于一些协议（FTP等）很可能需要调整ACK序号。当前的ACK序号调整，起因是反方向上调整过序号，因此查询反方向上的序号偏移量，据此修正当前方向的ACK序号。

    /* Take into account NAT sequence number mangling */receiver_offset = nf_ct_seq_offset(ct, !dir, ack - 1);ack -= receiver_offset;sack -= receiver_offset;pr_debug("tcp_in_window: START\n");pr_debug("tcp_in_window: ");nf_ct_dump_tuple(tuple);pr_debug("seq=%u ack=%u+(%d) sack=%u+(%d) win=%u end=%u\n",seq, ack, receiver_offset, sack, receiver_offset, win, end);pr_debug("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i ""receiver end=%u maxend=%u maxwin=%u scale=%i\n",sender->td_end, sender->td_maxend, sender->td_maxwin,sender->td_scale,receiver->td_end, receiver->td_maxend, receiver->td_maxwin,receiver->td_scale);

以下处理发送端td_maxwin等于零的情况，表明CONNTRACK没有记录其最大窗口值，即没有收到过此发送者的报文。对于TCP握手的第一个报文，没有必要检查其序号的合法性，没有调用此函数处理。所以，报文如果设置了SYN标志，应当为SYN-ACK报文，或者两端同时发起握手的情况下，另一端的SYN报文。

1）将td_maxend初始化为当前报文的结束序号end。
2）将td_maxwin初始化为当前报文TCP头部中的窗口字段的值（最小为1）。
3）tcp_options函数主要解析报文TCP选项中的窗口系数，将其值赋予td_scale。另外，查看TCP选项中是否通告了SACK能力，设置标志IP_CT_TCP_FLAG_SACK_PERM（参见以上的使用）。
4）TCP两端必须同时通告窗口系数选项，否者，将两者的td_scale设置为零。

如果此报文为SYN报文，为设置ACK标志，为两端同时握手的情况，结束处理。否者，对于SYN-ACK报文，继续处理。

    if (sender->td_maxwin == 0) {/* Initialize sender data.*/if (tcph->syn) {/* SYN-ACK in reply to a SYN* or SYN from reply direction in simultaneous open.*/sender->td_end =sender->td_maxend = end;sender->td_maxwin = (win == 0 ? 1 : win);tcp_options(skb, dataoff, tcph, sender);/** RFC 1323:* Both sides must send the Window Scale option* to enable window scaling in either direction.*/if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE&& receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE))sender->td_scale =receiver->td_scale = 0;if (!tcph->ack)return true; /* Simultaneous open */

与以上情况相反，在报文未设置SYN标志的情况下，应为连接的中间报文。可能丢失了连接的SYN-ACK报文，以及随后的其它报文。只能由此报文获得发送端的相关信息了。

1）将当前报文的结束序号赋值给td_end；
2）将报文中的窗口值左移窗口系数，作为最大窗口值td_maxwin；
3）将结束序号与最大窗口值之和，作为最大序号td_maxend；

如果此报文的接收端最大窗口td_maxwin等于零，表明至此还没有看到接收端的任何报文。sack为发送端接收到的最大的序号值，将其赋值与接收端的td_end和td_maxend。否则，如果接收端td_maxwin不为零，并且sack等于接收端的最大序号+1，将接收端的最大序号td_end递增一，否则对于正常的keepalive报文，标准III通不过。

        } else {/* We are in the middle of a connection,* its history is lost for us.* Let's try to use the data from the packet.*/sender->td_end = end;swin = win << sender->td_scale;sender->td_maxwin = (swin == 0 ? 1 : swin);sender->td_maxend = end + sender->td_maxwin;if (receiver->td_maxwin == 0) {/* We haven't seen traffic in the other* direction yet but we have to tweak window* tracking to pass III and IV until that happens.*/receiver->td_end = receiver->td_maxend = sack;} else if (sack == receiver->td_end + 1) {/* Likely a reply to a keepalive. Needed for III.*/receiver->td_end++;}}

如果当前报文发送端的td_maxwin不为零，表明相关连接信息已经初始化。但是，如果此报文为当前方向的第一个报文，判断方法为：对于原始方向，连接状态为SYN_SENT；对于回复方向，状态为SYN_RECV；表明TCP连接进行了重新初始化。此时，重新初始化发送端序号和窗口信息。

    } else if (((state->state == TCP_CONNTRACK_SYN_SENT&& dir == IP_CT_DIR_ORIGINAL)|| (state->state == TCP_CONNTRACK_SYN_RECV&& dir == IP_CT_DIR_REPLY))&& after(end, sender->td_end)) {/** RFC 793: "if a TCP is reinitialized ... then it need* not wait at all; it must only be sure to use sequence* numbers larger than those recently used."*/sender->td_end =sender->td_maxend = end;sender->td_maxwin = (win == 0 ? 1 : win);tcp_options(skb, dataoff, tcph, sender);}

如果报文TCP头部ACK标志未设置，假设ACK序号的值为接收端曾经发送的最大序号值。否则，报文设置了TCP的ACK标志，但是ACK序号值为零，并且设置了RST标志，同样假设ACK序号等于接收端曾经发送的最大序号值（CONNTRACK看到的最大序号值）。

    if (!(tcph->ack)) {/** If there is no ACK, just pretend it was set and OK.*/ack = sack = receiver->td_end;} else if (((tcp_flag_word(tcph) & (TCP_FLAG_ACK|TCP_FLAG_RST)) ==(TCP_FLAG_ACK|TCP_FLAG_RST))&& (ack == 0)) {/** Broken TCP stacks, that set ACK in RST packets as well* with zero ack value.*/ack = sack = receiver->td_end;}

对于回复SYN报文的RST报文，序号为零的情况下，将序号设置为记录的发送端结束序号。

    if (tcph->rst && seq == 0 && state->state == TCP_CONNTRACK_SYN_SENT)/* RST sent answering SYN.*/seq = end = sender->td_end;pr_debug("tcp_in_window: ");nf_ct_dump_tuple(tuple);pr_debug("seq=%u ack=%u+(%d) sack=%u+(%d) win=%u end=%u\n",seq, ack, receiver_offset, sack, receiver_offset, win, end);pr_debug("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i ""receiver end=%u maxend=%u maxwin=%u scale=%i\n",sender->td_end, sender->td_maxend, sender->td_maxwin,sender->td_scale,receiver->td_end, receiver->td_maxend, receiver->td_maxwin,receiver->td_scale);

如果接收端td_maxwin为零（未知），或者报文的结束序号大于接收端窗口的左边界，判断符合标准II。以下打印4个判定标准的结果。

    /* Is the ending sequence in the receive window (if available)? */in_recv_win = !receiver->td_maxwin ||after(end, sender->td_end - receiver->td_maxwin - 1);pr_debug("tcp_in_window: I=%i II=%i III=%i IV=%i\n",before(seq, sender->td_maxend + 1),(in_recv_win ? 1 : 0),before(sack, receiver->td_end + 1),after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1));

如果报文的序号符合4个标准，更新发送端和接收端的信息。

    if (before(seq, sender->td_maxend + 1) &&in_recv_win &&before(sack, receiver->td_end + 1) &&after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1)) {/** Take into account window scaling (RFC 1323).*/if (!tcph->syn)win <<= sender->td_scale;

发送端的最大窗口值，等于报文中通告的窗口值与（sack-ack）之和，其中最大的SACK序号减去当前报文ACK序号，表明发送端正常接收了这些乱序的数据，并且这些数据没有超出发送端窗口大小。

如果报文的结束序号大于记录的td_end，更新后者，这种情况下，发送了新的数据，这些数据接收端未确认。

如果发送端最大ACK序号没有设置，此处进行初始化。反之，如果曾经设置过，在当前报文的ACK序号大于设置的最大值时，将其更新。

        /* Update sender data.*/swin = win + (sack - ack);if (sender->td_maxwin < swin)sender->td_maxwin = swin;if (after(end, sender->td_end)) {sender->td_end = end;sender->flags |= IP_CT_TCP_FLAG_DATA_UNACKNOWLEDGED;}if (tcph->ack) {if (!(sender->flags & IP_CT_TCP_FLAG_MAXACK_SET)) {sender->td_maxack = ack;sender->flags |= IP_CT_TCP_FLAG_MAXACK_SET;} else if (after(ack, sender->td_maxack))sender->td_maxack = ack;}

接收端的最大窗口值td_maxwin不为零，并且报文的结束序号大于发送端最大序号td_maxend时，增加发送端最大窗口值，增加量为（end-sender->td_maxend），假定发送端遵照接收端的通告窗口，不会发送大于接收端窗口大小的数据。

接收端最大序号值，等于报文中最大序号与窗口之和，不能缩小。当窗口win等于零时，递增td_maxend的值，以防发送keepalive保活报文。

如果报文的ACK序号等于接收端的结束序号，表明数据都得到了确认。

        /* Update receiver data.*/if (receiver->td_maxwin != 0 && after(end, sender->td_maxend))receiver->td_maxwin += end - sender->td_maxend;if (after(sack + win, receiver->td_maxend - 1)) {receiver->td_maxend = sack + win;if (win == 0)receiver->td_maxend++;}if (ack == receiver->td_end)receiver->flags &= ~IP_CT_TCP_FLAG_DATA_UNACKNOWLEDGED;

如果报文的方向、序号、ACK序号、结束序号（报文长度）和通过的窗口值，都是相同的，说明是重传报文。否者，更新记录值。

        /* Check retransmissions.*/if (index == TCP_ACK_SET) {if (state->last_dir == dir&& state->last_seq == seq&& state->last_ack == ack&& state->last_end == end&& state->last_win == win_raw)state->retrans++;else {state->last_dir = dir;state->last_seq = seq;state->last_ack = ack;state->last_end = end;state->last_win = win_raw;state->retrans = 0;}}res = true;

最后，如果报文不合标准。打印出错信息。

    } else {res = false;if (sender->flags & IP_CT_TCP_FLAG_BE_LIBERAL ||tn->tcp_be_liberal)res = true;if (!res) {nf_ct_l4proto_log_invalid(skb, ct,"%s",before(seq, sender->td_maxend + 1) ?in_recv_win ?before(sack, receiver->td_end + 1) ?after(sack, receiver->td_end - MAXACKWINDOW(sender) - 1) ? "BUG": "ACK is under the lower bound (possible overly delayed ACK)": "ACK is over the upper bound (ACKed data not seen yet)": "SEQ is under the lower bound (already ACKed data retransmitted)": "SEQ is over the upper bound (over the window of the receiver)");}}

函数最后，打印发送端和接收端序号和窗口相关信息。

    pr_debug("tcp_in_window: res=%u sender end=%u maxend=%u maxwin=%u ""receiver end=%u maxend=%u maxwin=%u\n",res, sender->td_end, sender->td_maxend, sender->td_maxwin,receiver->td_end, receiver->td_maxend, receiver->td_maxwin);return res;

TCP结束序号计算

如下函数segment_seq_plus_len，开始序号加上TCP数据的长度即为结束序号的值。具体为，报文的总长度减去TCP头部的偏移，再减去TCP报文的头部长度（包括选项）即为TCP数据的长度。另外SYN标志和FIN标志额外占用一个序号。

static inline __u32 segment_seq_plus_len(__u32 seq,size_t len,unsigned int dataoff,const struct tcphdr *tcph)
{/* XXX Should I use payload length field in IP/IPv6 header ?* - YK */return (seq + len - dataoff - tcph->doff*4+ (tcph->syn ? 1 : 0) + (tcph->fin ? 1 : 0));
}

SACK最大序号

TCP头部最大60个字节，减去固定长度的tcphdr，其它为选项数据的最大长度。TCP的doff表示实际的头部长度，减去固定长度tcphdr，即为实际的选项数据的长度。由于报文通常只包含TIMESTAMP选项，这里优先处理这种情况。

static void tcp_sack(const struct sk_buff *skb, unsigned int dataoff,const struct tcphdr *tcph, __u32 *sack)
{unsigned char buff[(15 * 4) - sizeof(struct tcphdr)];int length = (tcph->doff*4) - sizeof(struct tcphdr);if (!length) return;ptr = skb_header_pointer(skb, dataoff + sizeof(struct tcphdr), length, buff);BUG_ON(ptr == NULL);/* Fast path for timestamp-only option */if (length == TCPOLEN_TSTAMP_ALIGNED&& *(__be32 *)ptr == htonl((TCPOPT_NOP << 24)| (TCPOPT_NOP << 16)| (TCPOPT_TIMESTAMP << 8)| TCPOLEN_TIMESTAMP))return;

发现并遍历SACK选项数据，找到所有块中最大的序号，每个SACK块首先是开始序号，其次是结束序号。这里取每一块中的结束序号。

    while (length > 0) {int opcode = *ptr++;switch (opcode) {case TCPOPT_EOL:return;case TCPOPT_NOP:    /* Ref: RFC 793 section 3.1 */length--;continue;default:if (length < 2)return;opsize = *ptr++;if (opsize < 2) /* "silly options" */return;if (opsize > length)return; /* don't parse partial options */if (opcode == TCPOPT_SACK&& opsize >= (TCPOLEN_SACK_BASE + TCPOLEN_SACK_PERBLOCK)&& !((opsize - TCPOLEN_SACK_BASE) % TCPOLEN_SACK_PERBLOCK)) {for (i = 0;i < (opsize - TCPOLEN_SACK_BASE);i += TCPOLEN_SACK_PERBLOCK) {tmp = get_unaligned_be32((__be32 *)(ptr+i)+1);if (after(tmp, *sack)) *sack = tmp;}return;

TCP窗口系数和SACK选项

在函数tcp_options中，检测SACK_PERM选项，并设置相应的标志位IP_CT_TCP_FLAG_SACK_PERM。以及获取窗口系数。

static void tcp_options(const struct sk_buff *skb, unsigned int dataoff,const struct tcphdr *tcph, struct ip_ct_tcp_state *state)
{unsigned char buff[(15 * 4) - sizeof(struct tcphdr)];int length = (tcph->doff*4) - sizeof(struct tcphdr);if (!length) return;ptr = skb_header_pointer(skb, dataoff + sizeof(struct tcphdr), length, buff);BUG_ON(ptr == NULL);state->td_scale = state->flags = 0;while (length > 0) {int opcode=*ptr++;switch (opcode) {case TCPOPT_EOL:return;case TCPOPT_NOP:    /* Ref: RFC 793 section 3.1 */length--;continue;default:if (length < 2)return;opsize=*ptr++;if (opsize < 2) /* "silly options" */return;if (opsize > length)return; /* don't parse partial options */if (opcode == TCPOPT_SACK_PERM && opsize == TCPOLEN_SACK_PERM)state->flags |= IP_CT_TCP_FLAG_SACK_PERM;else if (opcode == TCPOPT_WINDOW && opsize == TCPOLEN_WINDOW) {state->td_scale = *(u_int8_t *)ptr;if (state->td_scale > TCP_MAX_WSCALE)state->td_scale = TCP_MAX_WSCALE;state->flags |= IP_CT_TCP_FLAG_WINDOW_SCALE;

TCP协议栈序号判断

在TCP协议栈中，由于有准确的接收窗口信息[s_win, e_win]，有以下三个判断条件，报文序号等于窗口左边界；报文开始和结束序号和窗口有交集；最后，以上都不符合，只有序号等于右边界的无数据的ACK报文符合要求了。协议栈处理函数tcp_in_window只是检测了报文序号，并没有检测ACK序号。

static bool tcp_in_window(u32 seq, u32 end_seq, u32 s_win, u32 e_win)
{if (seq == s_win)return true;if (after(end_seq, s_win) && before(seq, e_win))return true;return seq == e_win && seq == end_seq;
}

内核版本 5.10