应如何正确计算 TCP 序号？

Godbach

听各位高手授课，受益匪浅啊。

Godbach

另外，你拍的很不错，洗了很多张

白金兄什么时候可以上小弟们看一下啊

platinum

原帖由 Au_Hank 于 2008-10-30 19:01 发表
你可能有多次的数据修改，这样一来你需要记住多个的 (ORI_SEQ，N)偶对。如何消除旧的(ORI_SEQ，N)偶对是个问题。我觉得原则是已经被ACK过的ORI_SEQ可以被删除，但是如何知道 ACK被另外一端收到了是个问题（因为ACK可能被你的设备收到了，但是RELAY给接收方的时候丢失了）。

还有一个难办的是selective ack，要崩溃了。我觉得还不如在用户空间socket转接算了，简单多了，但是性能差了。

我在想，内核代码中有 NAT 代码，NAT 部分是重新计算 TCP 的 SEQ 和 WIN 的，能否直接利用他们的东西呢？
不同的是，我是桥，不是 NAT
kernel/net/netfilter/nf_conntrack_proto_tcp.c

1. 
   
2. /* TCP connection tracking based on 'Real Stateful TCP Packet Filtering
   
3.    in IP Filter' by Guido van Rooij.
   
4. 
   
5.    [url]http://www.nluug.nl/events/sane2000/papers.html[/url]
   
6.    [url]http://www.iae.nl/users/guido/papers/tcp_filtering.ps.gz[/url]
   
7. 
   
8.    The boundaries and the conditions are changed according to RFC793:
   
9.    the packet must intersect the window (i.e. segments may be
   
10.    after the right or before the left edge) and thus receivers may ACK
    
11.    segments after the right edge of the window.
    
12. 
    
13.         td_maxend = max(sack + max(win,1)) seen in reply packets
    
14.         td_maxwin = max(max(win, 1)) + (sack - ack) seen in sent packets
    
15.         td_maxwin += seq + len - sender.td_maxend
    
16.                         if seq + len > sender.td_maxend
    
17.         td_end    = max(seq + len) seen in sent packets
    
18. 
    
19.    I.   Upper bound for valid data:     seq <= sender.td_maxend
    
20.    II.  Lower bound for valid data:     seq + len >= sender.td_end - receiver.td_maxwin
    
21.    III. Upper bound for valid ack:      sack <= receiver.td_end
    
22.    IV.  Lower bound for valid ack:      ack >= receiver.td_end - MAXACKWINDOW
    
23. 
    
24.    where sack is the highest right edge of sack block found in the packet.
    
25. 
    
26.    The upper bound limit for a valid ack is not ignored -
    
27.    we doesn't have to deal with fragments.
    
28. */
    
29. 
    
30. static inline __u32 segment_seq_plus_len(__u32 seq,
    
31.                                          size_t len,
    
32.                                          unsigned int dataoff,
    
33.                                          struct tcphdr *tcph)
    
34. {
    
35.         /* XXX Should I use payload length field in IP/IPv6 header ?
    
36.          * - YK */
    
37.         return (seq + len - dataoff - tcph->doff*4
    
38.                 + (tcph->syn ? 1 : 0) + (tcph->fin ? 1 : 0));
    
39. }
    
40. 
    
41. /* Fixme: what about big packets? */
    
42. #define MAXACKWINCONST                  66000
    
43. #define MAXACKWINDOW(sender)                                            \
    
44.         ((sender)->td_maxwin > MAXACKWINCONST ? (sender)->td_maxwin     \
    
45.                                               : MAXACKWINCONST)
    

复制代码

1. 
   
2. static int tcp_in_window(struct nf_conn *ct,
   
3.                          struct ip_ct_tcp *state,
   
4.                          enum ip_conntrack_dir dir,
   
5.                          unsigned int index,
   
6.                          const struct sk_buff *skb,
   
7.                          unsigned int dataoff,
   
8.                          struct tcphdr *tcph,
   
9.                          int pf)
   
10. {
    
11.         struct ip_ct_tcp_state *sender = &state->seen[dir];
    
12.         struct ip_ct_tcp_state *receiver = &state->seen[!dir];
    
13.         struct nf_conntrack_tuple *tuple = &ct->tuplehash[dir].tuple;
    
14.         __u32 seq, ack, sack, end, win, swin;
    
15.         int res;
    
16. 
    
17.         /*
    
18.          * Get the required data from the packet.
    
19.          */
    
20.         seq = ntohl(tcph->seq);
    
21.         ack = sack = ntohl(tcph->ack_seq);
    
22.         win = ntohs(tcph->window);
    
23.         end = segment_seq_plus_len(seq, skb->len, dataoff, tcph);
    
24. 
    
25.         if (receiver->flags & IP_CT_TCP_FLAG_SACK_PERM)
    
26.                 tcp_sack(skb, dataoff, tcph, &sack);
    
27. 
    
28.         pr_debug("tcp_in_window: START\n");
    
29.         pr_debug("tcp_in_window: ");
    
30.         NF_CT_DUMP_TUPLE(tuple);
    
31.         pr_debug("seq=%u ack=%u sack=%u win=%u end=%u\n",
    
32.                  seq, ack, sack, win, end);
    
33.         pr_debug("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i "
    
34.                  "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
    
35.                  sender->td_end, sender->td_maxend, sender->td_maxwin,
    
36.                  sender->td_scale,
    
37.                  receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
    
38.                  receiver->td_scale);
    
39. 
    
40.         if (sender->td_end == 0) {
    
41.                 /*
    
42.                  * Initialize sender data.
    
43.                  */
    
44.                 if (tcph->syn && tcph->ack) {
    
45.                         /*
    
46.                          * Outgoing SYN-ACK in reply to a SYN.
    
47.                          */
    
48.                         sender->td_end =
    
49.                         sender->td_maxend = end;
    
50.                         sender->td_maxwin = (win == 0 ? 1 : win);
    
51. 
    
52.                         tcp_options(skb, dataoff, tcph, sender);
    
53.                         /*
    
54.                          * RFC 1323:
    
55.                          * Both sides must send the Window Scale option
    
56.                          * to enable window scaling in either direction.
    
57.                          */
    
58.                         if (!(sender->flags & IP_CT_TCP_FLAG_WINDOW_SCALE
    
59.                               && receiver->flags & IP_CT_TCP_FLAG_WINDOW_SCALE))
    
60.                                 sender->td_scale =
    
61.                                 receiver->td_scale = 0;
    
62.                 } else {
    
63.                         /*
    
64.                          * We are in the middle of a connection,
    
65.                          * its history is lost for us.
    
66.                          * Let's try to use the data from the packet.
    
67.                          */
    
68.                         sender->td_end = end;
    
69.                         sender->td_maxwin = (win == 0 ? 1 : win);
    
70.                         sender->td_maxend = end + sender->td_maxwin;
    
71.                 }
    
72.         } else if (((state->state == TCP_CONNTRACK_SYN_SENT
    
73.                      && dir == IP_CT_DIR_ORIGINAL)
    
74.                    || (state->state == TCP_CONNTRACK_SYN_RECV
    
75.                      && dir == IP_CT_DIR_REPLY))
    
76.                    && after(end, sender->td_end)) {
    
77.                 /*
    
78.                  * RFC 793: "if a TCP is reinitialized ... then it need
    
79.                  * not wait at all; it must only be sure to use sequence
    
80.                  * numbers larger than those recently used."
    
81.                  */
    
82.                 sender->td_end =
    
83.                 sender->td_maxend = end;
    
84.                 sender->td_maxwin = (win == 0 ? 1 : win);
    
85. 
    
86.                 tcp_options(skb, dataoff, tcph, sender);
    
87.         }
    
88. 
    
89.         if (!(tcph->ack)) {
    
90.                 /*
    
91.                  * If there is no ACK, just pretend it was set and OK.
    
92.                  */
    
93.                 ack = sack = receiver->td_end;
    
94.         } else if (((tcp_flag_word(tcph) & (TCP_FLAG_ACK|TCP_FLAG_RST)) ==
    
95.                     (TCP_FLAG_ACK|TCP_FLAG_RST))
    
96.                    && (ack == 0)) {
    
97.                 /*
    
98.                  * Broken TCP stacks, that set ACK in RST packets as well
    
99.                  * with zero ack value.
    
100.                  */
     
101.                 ack = sack = receiver->td_end;
     
102.         }
     
103. 
     
104.         if (seq == end
     
105.             && (!tcph->rst
     
106.                 || (seq == 0 && state->state == TCP_CONNTRACK_SYN_SENT)))
     
107.                 /*
     
108.                  * Packets contains no data: we assume it is valid
     
109.                  * and check the ack value only.
     
110.                  * However RST segments are always validated by their
     
111.                  * SEQ number, except when seq == 0 (reset sent answering
     
112.                  * SYN.
     
113.                  */
     
114.                 seq = end = sender->td_end;
     
115. 
     
116.         pr_debug("tcp_in_window: ");
     
117.         NF_CT_DUMP_TUPLE(tuple);
     
118.         pr_debug("seq=%u ack=%u sack =%u win=%u end=%u\n",
     
119.                  seq, ack, sack, win, end);
     
120.         pr_debug("tcp_in_window: sender end=%u maxend=%u maxwin=%u scale=%i "
     
121.                  "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
     
122.                  sender->td_end, sender->td_maxend, sender->td_maxwin,
     
123.                  sender->td_scale,
     
124.                  receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
     
125.                  receiver->td_scale);
     
126. 
     
127.         pr_debug("tcp_in_window: I=%i II=%i III=%i IV=%i\n",
     
128.                  before(seq, sender->td_maxend + 1),
     
129.                  after(end, sender->td_end - receiver->td_maxwin - 1),
     
130.                  before(sack, receiver->td_end + 1),
     
131.                  after(ack, receiver->td_end - MAXACKWINDOW(sender)));
     
132. 
     
133.         if (before(seq, sender->td_maxend + 1) &&
     
134.             after(end, sender->td_end - receiver->td_maxwin - 1) &&
     
135.             before(sack, receiver->td_end + 1) &&
     
136.             after(ack, receiver->td_end - MAXACKWINDOW(sender))) {
     
137.                 /*
     
138.                  * Take into account window scaling (RFC 1323).
     
139.                  */
     
140.                 if (!tcph->syn)
     
141.                         win <<= sender->td_scale;
     
142. 
     
143.                 /*
     
144.                  * Update sender data.
     
145.                  */
     
146.                 swin = win + (sack - ack);
     
147.                 if (sender->td_maxwin < swin)
     
148.                         sender->td_maxwin = swin;
     
149.                 if (after(end, sender->td_end))
     
150.                         sender->td_end = end;
     
151.                 /*
     
152.                  * Update receiver data.
     
153.                  */
     
154.                 if (after(end, sender->td_maxend))
     
155.                         receiver->td_maxwin += end - sender->td_maxend;
     
156.                 if (after(sack + win, receiver->td_maxend - 1)) {
     
157.                         receiver->td_maxend = sack + win;
     
158.                         if (win == 0)
     
159.                                 receiver->td_maxend++;
     
160.                 }
     
161. 
     
162.                 /*
     
163.                  * Check retransmissions.
     
164.                  */
     
165.                 if (index == TCP_ACK_SET) {
     
166.                         if (state->last_dir == dir
     
167.                             && state->last_seq == seq
     
168.                             && state->last_ack == ack
     
169.                             && state->last_end == end
     
170.                             && state->last_win == win)
     
171.                                 state->retrans++;
     
172.                         else {
     
173.                                 state->last_dir = dir;
     
174.                                 state->last_seq = seq;
     
175.                                 state->last_ack = ack;
     
176.                                 state->last_end = end;
     
177.                                 state->last_win = win;
     
178.                                 state->retrans = 0;
     
179.                         }
     
180.                 }
     
181.                 res = 1;
     
182.         } else {
     
183.                 res = 0;
     
184.                 if (sender->flags & IP_CT_TCP_FLAG_BE_LIBERAL ||
     
185.                     nf_ct_tcp_be_liberal)
     
186.                         res = 1;
     
187.                 if (!res && LOG_INVALID(IPPROTO_TCP))
     
188.                         nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
     
189.                         "nf_ct_tcp: %s ",
     
190.                         before(seq, sender->td_maxend + 1) ?
     
191.                         after(end, sender->td_end - receiver->td_maxwin - 1) ?
     
192.                         before(sack, receiver->td_end + 1) ?
     
193.                         after(ack, receiver->td_end - MAXACKWINDOW(sender)) ? "BUG"
     
194.                         : "ACK is under the lower bound (possible overly delayed ACK)"
     
195.                         : "ACK is over the upper bound (ACKed data not seen yet)"
     
196.                         : "SEQ is under the lower bound (already ACKed data retransmitted)"
     
197.                         : "SEQ is over the upper bound (over the window of the receiver)");
     
198.         }
     
199. 
     
200.         pr_debug("tcp_in_window: res=%i sender end=%u maxend=%u maxwin=%u "
     
201.                  "receiver end=%u maxend=%u maxwin=%u\n",
     
202.                  res, sender->td_end, sender->td_maxend, sender->td_maxwin,
     
203.                  receiver->td_end, receiver->td_maxend, receiver->td_maxwin);
     
204. 
     
205.         return res;
     
206. }
     

复制代码

1. 
   
2. #ifdef CONFIG_NF_NAT_NEEDED
   
3. /* Update sender->td_end after NAT successfully mangled the packet */
   
4. /* Caller must linearize skb at tcp header. */
   
5. void nf_conntrack_tcp_update(struct sk_buff *skb,
   
6.                              unsigned int dataoff,
   
7.                              struct nf_conn *conntrack,
   
8.                              int dir)
   
9. {
   
10.         struct tcphdr *tcph = (void *)skb->data + dataoff;
    
11.         struct ip_ct_tcp_state *sender = &conntrack->proto.tcp.seen[dir];
    
12.         struct ip_ct_tcp_state *receiver = &conntrack->proto.tcp.seen[!dir];
    
13.         __u32 end;
    
14. 
    
15.         end = segment_seq_plus_len(ntohl(tcph->seq), skb->len, dataoff, tcph);
    
16. 
    
17.         write_lock_bh(&tcp_lock);
    
18.         /*
    
19.          * We have to worry for the ack in the reply packet only...
    
20.          */
    
21.         if (after(end, conntrack->proto.tcp.seen[dir].td_end))
    
22.                 conntrack->proto.tcp.seen[dir].td_end = end;
    
23.         conntrack->proto.tcp.last_end = end;
    
24.         write_unlock_bh(&tcp_lock);
    
25.         pr_debug("tcp_update: sender end=%u maxend=%u maxwin=%u scale=%i "
    
26.                  "receiver end=%u maxend=%u maxwin=%u scale=%i\n",
    
27.                  sender->td_end, sender->td_maxend, sender->td_maxwin,
    
28.                  sender->td_scale,
    
29.                  receiver->td_end, receiver->td_maxend, receiver->td_maxwin,
    
30.                  receiver->td_scale);
    
31. }
    
32. EXPORT_SYMBOL_GPL(nf_conntrack_tcp_update);
    
33. #endif
    

复制代码

根据提示，我找到了这个文档，里面详细讲了应如何计算 SEQ 和 WIN
没想到这样的问题会导致像自己做一个 TCP 栈一样……
内核目前有这些，我能否利用他们呢？能力有限没能滤清思路……

platinum

原帖由 Godbach 于 2008-10-30 19:42 发表


白金兄什么时候可以上小弟们看一下啊

好，回头给你看

Au_Hank

IP FILTER/NAT里面，并没有对用户数据进行修改，比如插入或者删除数据。被修改的是协议数据，比如IP地址和TCP/UDP端口。要进行重新计算的只是校验和，而SEQ/ACK并不需要进行修改啊。我的理解是这样的，呆会做个NAT的测试看看是否SEQ/ACK变化了。

另外你给的那篇文章，里面只谈到如何根据SEQ/ACK进行状态跟踪，并没有对SEQ/ACK进行修改操作。也证明IP FILTER其实是不需要对SEQ/ACK修改的。

如果要借用代码，我觉得还是到TCP SOCKET那里去找比较好，它拥有对TCP SESSION管理的全套功能。我曾经也有做TCP SESSION重建的想法，思路就是在TCP SOCKET管理那里做，无奈没有时间和精力去弄。

platinum

原帖由 Au_Hank 于 2008-10-31 07:34 发表
IP FILTER/NAT里面，并没有对用户数据进行修改，比如插入或者删除数据。被修改的是协议数据，比如IP地址和TCP/UDP端口。要进行重新计算的只是校验和，而SEQ/ACK并不需要进行修改啊。我的理解是这样的，呆会做个 ...

不，内容也修改了的
NAT 功能里有针对 FTP 被动模式的透传功能，它根据 RFC959 修改了 FTP command channel 里的请求数据，地址变化了
但唯一不同的是，他是 NAT 模式，而我是桥模式

kernel/net/netfilter/nf_conntrack_ftp.c
kernel/net/ipv4/netfilter/nf_nat_ftp.c

Au_Hank

原帖由 platinum 于 2008-10-31 08:56 发表

不，内容也修改了的
NAT 功能里有针对 FTP 被动模式的透传功能，它根据 RFC959 修改了 FTP command channel 里的请求数据，地址变化了
但唯一不同的是，他是 NAT 模式，而我是桥模式

kernel/net/netfilt ...

有道理，FTP是比较特殊，我没有考虑到。这样你可以把对应的SEQ管理的那部分代码抓过来用了

Godbach

听各位讨论，越讨论越深入了。白金兄要做的是什么功能啊？ 要对TCP做这么大动作，呵呵

platinum

原帖由 Godbach 于 2008-10-31 10:31 发表
听各位讨论，越讨论越深入了。白金兄要做的是什么功能啊？ 要对TCP做这么大动作，呵呵

是一个桥设备，用来篡改 client ---- server 之间传输的数据，看上去像是不好的用途

Au_Hank

比如说你在网上给白金转帐100，白金通过这个手段把金额改成10000