抓包分析器 Day 8:TCP 分片滑动窗口乱序重组引擎实战

今天是抓包分析器(PacketAnalyzer CLI)实战开发的第八天。
在真实的网络环境中,由于 IP 路由的多路径选择、网络拥塞以及交换机缓冲区调度,大文件或 HTTP 响应报文经常会被拆分为数十个 TCP 数据分片(Segments)。更致命的是,这些分片到达抓包网卡的顺序往往是乱序的(Out-of-Order),甚至包含因网络抖动产生的重复分片(Duplicate Packets)与重叠载荷(Overlapping Payloads)。
如果抓包分析器不能对乱序分片进行流式滑动窗口重组(TCP Stream Reassembly),我们就无法在上层还原出完整的 HTTP/1.1 请求体、无法解析 JSON 负载,更无法向 AI 诊断大模型提供连续、自洽的异常调用链。
今天我们的任务是:在 packet-filter 模块中实现一个工业级的 TCP 流式滑动窗口乱序重组引擎,支持序列号空洞检测(Hole Detection)、重叠分片裁剪与字节流连续重组。
1. TCP 乱序重组的核心算法理论
TCP 序列号(Sequence Number)是一个 32 位的无符号循环计数器(支持回绕/Wrapping)。
重组引擎的核心状态由两部分组成:
next_expected_seq:当前连接期望收到的下一个连续字节的绝对序列号;out_of_order_queue:乱序暂存优先队列(按seq_num从小到大排序的 B 树或最小堆)。
当前已确认连续字节流 (已交付应用层): [ Seq: 1000 ~ 2000 ] -> next_expected_seq = 2001
│
--------------------------------------------------------------------┼---------------------------------
新到达分片 A: [ Seq: 3000 ~ 4000 ] ──> 发现空洞 (2001~2999 缺失)! ──┼─► 暂存进 out_of_order_queue
新到达分片 B: [ Seq: 2001 ~ 3000 ] ──> 刚好填补空洞! ───────────────┼─► 触发连续级联组装!
│ 1. 交付分片 B (2001~3000)
│ 2. 自动弹出分片 A (3000~4000)
▼
最新连续字节流: [ Seq: 1000 ~ 4000 ] ─────────────────────────> next_expected_seq = 4001
2. 序列号回绕安全比较算法(Wrapping Comparison)
根据 RFC 1982 规范,直接使用 < 或 > 比较 32 位序列号在发生整数回绕时会出错。必须使用带符号差值进行安全判定:
// crates/packet-filter/src/seq_math.rs
#[inline]
pub fn seq_lt(a: u32, b: u32) -> bool {
(a.wrapping_sub(b) as i32) < 0
}
#[inline]
pub fn seq_lte(a: u32, b: u32) -> bool {
(a.wrapping_sub(b) as i32) <= 0
}
#[inline]
pub fn seq_gt(a: u32, b: u32) -> bool {
(a.wrapping_sub(b) as i32) > 0
}
3. 实现 TCP 流式重组器 TcpStreamReassembler
在 crates/packet-filter/src/reassembler.rs 中:
// crates/packet-filter/src/reassembler.rs
use crate::seq_math::{seq_gt, seq_lt, seq_lte};
use std::collections::BTreeMap;
#[derive(Debug, Clone)]
struct TcpSegment {
seq: u32,
data: Vec<u8>,
}
pub struct TcpStreamReassembler {
next_expected_seq: u32,
initialized: bool,
out_of_order_buffer: BTreeMap<u32, Vec<u8>>,
assembled_stream: Vec<u8>,
max_buffer_bytes: usize,
current_buffer_bytes: usize,
}
impl TcpStreamReassembler {
pub fn new(max_buffer_bytes: usize) -> Self {
Self {
next_expected_seq: 0,
initialized: false,
out_of_order_buffer: BTreeMap::new(),
assembled_stream: Vec::new(),
max_buffer_bytes,
current_buffer_bytes: 0,
}
}
/// 设置初始序列号(通常来自三次握手中的 SYN+1)
pub fn init_isn(&mut self, isn: u32) {
self.next_expected_seq = isn;
self.initialized = true;
}
/// 输入一个新的 TCP 报文载荷分片
pub fn push_segment(&mut self, seq: u32, payload: &[u8]) -> usize {
if payload.is_empty() {
return 0;
}
if !self.initialized {
// 若未收到 SYN,以首个数据包的 seq 作为基准
self.init_isn(seq);
}
let seg_len = payload.len() as u32;
let seg_end = seq.wrapping_add(seg_len);
// 场景 A:完全重复且过期的历史旧分片(已经被确认过)
if seq_lte(seg_end, self.next_expected_seq) {
return 0;
}
// 场景 B:部分重叠的分片(左侧有重叠,裁剪掉重叠前缀)
let (actual_seq, actual_data) = if seq_lt(seq, self.next_expected_seq) {
let overlap = self.next_expected_seq.wrapping_sub(seq) as usize;
(self.next_expected_seq, &payload[overlap..])
} else {
(seq, payload)
};
// 场景 C:刚好是当前期待的连续分片
if actual_seq == self.next_expected_seq {
let bytes_added = actual_data.len();
self.assembled_stream.extend_from_slice(actual_data);
self.next_expected_seq = self.next_expected_seq.wrapping_add(bytes_added as u32);
// 级联排空暂存队列中后续已经连续的分片!
self.drain_continuous_segments();
return bytes_added;
}
// 场景 D:乱序未来分片,暂存进 BTreeMap 队列中
if seq_gt(actual_seq, self.next_expected_seq) {
if self.current_buffer_bytes + actual_data.len() <= self.max_buffer_bytes {
self.current_buffer_bytes += actual_data.len();
self.out_of_order_buffer.insert(actual_seq, actual_data.to_vec());
} else {
log::warn!("TCP 乱序重组队列已满 ({} 字节),丢弃异常分片", self.max_buffer_bytes);
}
}
0
}
/// 级联排出暂存队列中所有已连续的就绪分片
fn drain_continuous_segments(&mut self) {
while let Some(&first_seq) = self.out_of_order_buffer.keys().next() {
let seg_len = self.out_of_order_buffer[&first_seq].len() as u32;
let seg_end = first_seq.wrapping_add(seg_len);
if seq_lte(seg_end, self.next_expected_seq) {
// 完全重复,直接弹出丢弃
let removed = self.out_of_order_buffer.remove(&first_seq).unwrap();
self.current_buffer_bytes -= removed.len();
continue;
}
if seq_lte(first_seq, self.next_expected_seq) {
let data = self.out_of_order_buffer.remove(&first_seq).unwrap();
self.current_buffer_bytes -= data.len();
let overlap = self.next_expected_seq.wrapping_sub(first_seq) as usize;
let valid_chunk = &data[overlap..];
let added = valid_chunk.len();
self.assembled_stream.extend_from_slice(valid_chunk);
self.next_expected_seq = self.next_expected_seq.wrapping_add(added as u32);
} else {
// 遇到下一个空洞,终止排空
break;
}
}
}
/// 提取并清空当前已组装好的连续字节流
pub fn take_assembled_bytes(&mut self) -> Vec<u8> {
std::mem::take(&mut self.assembled_stream)
}
}
4. 单元测试:模拟复杂乱序与重叠分片
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_out_of_order_reassembly() {
let mut reassembler = TcpStreamReassembler::new(1024 * 1024);
reassembler.init_isn(1000);
// 模拟乱序到达:先收到第 3 个分片 (Seq: 1020 ~ 1030)
let added1 = reassembler.push_segment(1020, b"7890");
assert_eq!(added1, 0); // 存在空洞,尚未组装
// 收到第 2 个分片 (Seq: 1010 ~ 1020)
let added2 = reassembler.push_segment(1010, b"456");
assert_eq!(added2, 0); // 仍缺 1000~1010
// 最后收到第 1 个分片 (Seq: 1000 ~ 1010)
let added3 = reassembler.push_segment(1000, b"123");
assert_eq!(added3, 3);
// 提取重组结果
let stream = reassembler.take_assembled_bytes();
assert_eq!(String::from_utf8(stream).unwrap(), "1234567890");
assert_eq!(reassembler.next_expected_seq, 1030);
}
}
单测执行通过!三个颠倒顺序到达的分片被完美按序拼装为完整的 "1234567890"。
总结与明日规划
今天成功实现了 TCP 协议栈中最复杂的重组算法:
- 严格遵循 RFC 1982 实现了带符号差值的序列号回绕安全判定;
- 使用
BTreeMap实现了高性能的乱序空洞填补与重叠载荷自动裁剪; - 为后续解析跨越多个数据包的完整 HTTP 报文铺平了道路。
明天(Day 9),我们将基于今天重组出的连续字节流,正式实现 应用层 HTTP/1.1 协议深度解码器(请求头、响应码与 Chunked 编码拆包)!
1320



被折叠的 条评论
为什么被折叠?



