Loading... # nattimeout 项目技术解析 # 一、概述 ## 1. 简介 ### A. 是什么 nattimeout 是一个用 Go 语言编写的 NAT（网络地址转换）映射超时时间检测工具。它采用独特的反向探测架构，能够准确测量 NAT 设备的 UDP 和 TCP 连接空闲超时时间，而不会干扰被测量的 NAT 计时器。 ### B. 为什么学 - 深入理解 NAT 工作原理和超时机制 - 学习反向探测这种巧妙的网络测量技术 - 掌握 Go 语言网络编程的最佳实践 - 了解跨平台静态编译和分发策略 ### C. 学完能做什么 - 准确检测各类 NAT 设备的超时配置 - 理解网络协议设计中大端序编码的重要性 - 掌握并发网络编程和会话管理技巧 - 应用反向探测思想到其他网络测量场景 # 二、核心概念 ## 1. 基本术语 - NAT（Network Address Translation）：网络地址转换，允许多个设备共享一个公网 IP 地址 - NAT 映射：NAT 设备维护的内部地址到外部地址的转换记录 - 空闲超时：NAT 映射在无流量活动后被删除的时间 - 反向探测：由服务器主动向客户端发送探测包的测量方式 ## 2. 工作原理 ### 传统方式的问题 传统 NAT 超时检测存在根本性缺陷： ```mermaid sequenceDiagram participant C as Client participant N as NAT participant S as Server Note over C,S: 传统方式（错误） C->>N: [PROBE] 探测包 N->>S: [PROBE] 探测包 Note over N: 客户端发送刷新了<br/>NAT 空闲计时器！ ```   客户端的出站流量会刷新 NAT 映射的空闲计时器，导致无法测量真实的超时时间。 ### 反向探测方案 ```mermaid sequenceDiagram participant C as Client participant N as NAT participant S as Server Note over C,S: 反向探测（正确） C->>N: [ProbeStart] 请求探测 N->>S: [ProbeStart] 请求探测 S-->>N: [ProbeAck] 确认 N-->>C: [ProbeAck] 确认 Note over C: 客户端保持静默 S->>N: [Probe seq=1] 探测包 N->>C: [Probe seq=1] 探测包 Note over N: 服务器发送<br/>不刷新客户端 NAT 计时器 ```   **核心原理**：只有出站流量（客户端到服务器）会刷新 NAT 计时器，入站流量（服务器到客户端）不会。 ## 3. 探测模式 ### 递增模式 使用递增间隔探测，第 n 次探测等待 n × step 秒。 ```mermaid graph LR A[开始] --> B[等待 1×step] B --> C[等待 2×step] C --> D[等待 3×step] D --> E[...] E --> F[超时检测] ```   时间复杂度：O(n²)，适用于需要精确测量且时间不敏感的场景。 ### 并行模式 同时启动 N 个会话，每个会话使用固定的等待时间。 ```mermaid graph TB A[开始并行探测] --> B1[会话1 wait=start] A --> B2[会话2 wait=start+step] A --> B3[会话3 wait=start+2xstep] A --> B4[会话N wait=start+N-1xstep] B1 --> C1[结果1] B2 --> C2[结果2] B3 --> C3[结果3] B4 --> C4[结果N] C1 --> D[分析结果] C2 --> D C3 --> D C4 --> D D --> E[二分法精细探测可选] ```   时间复杂度：O(n)，适用于快速测量，可接受范围结果。支持可选的二分法精细探测提高精度。 # 三、架构设计 ## 1. 项目结构 ```mermaid graph TB Root[nattimeout] --> Cmd[cmd/nattimeout] Root --> Internal[internal] Root --> Build[build.sh] Cmd --> Main[main.go] Internal --> Protocol[protocol] Internal --> Server[server] Internal --> Client[client] Protocol --> UDP[udp.go] Protocol --> TCP[tcp.go] Server --> UDPHandler[udp_handler.go] Server --> TCPHandler[tcp_handler.go] Server --> Srv[server.go] Client --> Config[config.go] Client --> UDPProbe[udp_probe.go] Client --> TCPProbe[tcp_probe.go] Client --> Parallel[parallel_probe.go] ```   ## 2. 模块职责 ### 协议层（internal/protocol） 定义 UDP 和 TCP 数据包格式，提供编码解码功能。 - 协议版本 2：反向探测模式 - 大端序编码：确保跨平台兼容性 - 工厂函数模式：NewUDPProbeStartPacket、NewUDPProbePacket 等 - 验证方法：IsValid 检查版本和包类型 - JSON 负载：会话参数和探测数据编码为 JSON ### 服务器层（internal/server） 处理客户端探测请求，主动发送探测包。 - 会话管理：按客户端地址跟踪活动探测会话 - 主动探测：按配置间隔发送探测包 - 优雅关闭：使用 sync.Mutex 和通道实现线程安全 - 统计跟踪：ServerStats 跟踪数据包、连接、运行时间 - TTL 支持：可选的 TTL 检测功能 ### 客户端层（internal/client） 发起探测请求，接收并分析探测结果。 - 仅接收模式：初始握手后，客户端只接收 - 丢失阈值：配置连续丢失计数后声明超时 - 结果报告：ProbeResult 捕获成功失败和检测到的超时 - NAT 映射检测：MappingInfo 捕获客户端本地地址与服务端看到的地址 - 并行探测：ParallelProbe 协调多个固定等待会话 ## 3. 数据流 ```mermaid sequenceDiagram participant C as Client participant S as Server participant N as NAT Note over C,N: 1. 握手阶段 C->>N: ProbeStart(协议包) N->>S: ProbeStart S-->>N: ProbeAck N-->>C: ProbeAck Note over C,N: 2. 探测阶段（客户端静默） Note over S: 等待 step 秒 S->>N: Probe seq=1 N->>C: Probe seq=1 Note over C: 收到 seq=1 Note over S: 等待 step 秒 S->>N: Probe seq=2 N->>C: Probe seq=2 Note over C: 收到 seq=2 Note over S: 等待 step 秒 S->>N: Probe seq=3 Note over N: NAT 映射已过期 Note over C: 超时，未收到 seq=3 Note over C: 结论：NAT 超时在<br/>2×step 到 3×step 之间 ```   # 四、协议设计 ## 1. UDP 数据包格式 ``` +--------+--------+--------+--------+--------+--------+----------+----------+ | Offset | 0 | 1 | 2-5 | 6-13 | 14-15 | 16+ | +--------+--------+--------+--------+--------+--------+----------+----------+ | Field | Version| Type | SeqNum | Timestamp | PayloadLen| Payload | +--------+--------+--------+--------+--------+--------+----------+----------+ | Size | 1 byte | 1 byte | 4 bytes| 8 bytes| 2 bytes | variable | +--------+--------+--------+--------+--------+--------+----------+----------+ ``` **包类型定义**： | 类型值 | 名称 | 描述 | |--------|------|------| | 1 | ProbeStart | 客户端发起探测会话请求 | | 2 | ProbeAck | 服务器确认并开始探测 | | 3 | Probe | 服务器发送的周期性探测包 | | 4 | MappingInfoRequest | 请求 NAT 映射信息 | | 5 | MappingInfoResponse | 响应 NAT 映射详情 | ## 2. TCP 数据包格式 ``` +--------+--------+--------+--------+--------+----------+ | Offset | 0 | 1 | 2-5 | 6-7 | 8+ | +--------+--------+--------+--------+--------+----------+ | Field | Version| Type | SeqNum | PayloadLen | Payload | +--------+--------+--------+--------+--------+----------+ | Size | 1 byte | 1 byte | 4 bytes| 2 bytes | variable | +--------+--------+--------+--------+--------+----------+ ``` TCP 格式与 UDP 类似，但去掉了 Timestamp 字段（TCP 本身有时间戳机制）。 ## 3. 负载格式 ### ProbeStart 负载 ```json { "step": 10000000000, "max_time": 300000000000, "session_id": "a1b2c3d4e5f6g7h8", "probe_mode": "fixed", "fixed_wait": 30000000000, "group_id": "group123", "session_index": 3 } ``` - step：探测间隔（纳秒） - max_time：最大探测时长（纳秒） - session_id：唯一会话标识 - probe_mode：（可选）incremental（默认）或 fixed（并行模式） - fixed_wait：（可选）固定等待时间（纳秒），仅 fixed 模式 - group_id：（可选）并行会话组 ID - session_index：（可选）组内索引（从 1 开始） ### Probe 负载 ```json { "session_id": "a1b2c3d4e5f6g7h8", "seq_num": 5, "wait_duration": 10000000000, "total_wait": 50000000000 } ``` - session_id：会话标识 - seq_num：探测序号 - wait_duration：本次等待时长（纳秒） - total_wait：累计等待时长（纳秒） ### MappingInfo 负载 ```json { "client_local_ip": "192.168.1.100", "client_local_port": 54321, "server_remote_ip": "203.0.113.50", "server_remote_port": 45000, "ttl": 64, "timestamp": 1738368896000000000 } ``` ## 4. 编码设计要点 ### 大端序编码 所有多字节字段使用大端序（网络字节序）： ```go // UDP 包编码示例 buf := make([]byte, 16+len(p.Payload)) buf[0] = p.Version buf[1] = p.Type binary.BigEndian.PutUint32(buf[2:6], p.SeqNum) binary.BigEndian.PutUint64(buf[6:14], uint64(p.Timestamp)) binary.BigEndian.PutUint16(buf[14:16], uint16(len(p.Payload))) copy(buf[16:], p.Payload) ``` 这确保了不同架构平台（x86、ARM、MIPS 等）之间的兼容性。 ### 工厂函数模式 每个包类型都有对应的工厂函数： ```go // 递增模式探测开始包 func NewUDPProbeStartPacket(sessionID string, step, maxTime time.Duration) *UDPPacket // 固定模式探测开始包（并行探测） func NewUDPProbeStartPacketFixed(sessionID string, fixedWait time.Duration, groupID string, sessionIndex int) *UDPPacket // 探测确认包 func NewUDPProbeAckPacket(sessionID string) *UDPPacket // 探测包 func NewUDPProbePacket(seqNum uint32, sessionID string, waitDuration, totalWait time.Duration) *UDPPacket ``` # 五、实现细节 ## 1. 并行探测优化 ### 分批模式 某些 NAT 设备有并发连接数限制（如家用路由器限制 5-10 个并发连接），分批模式可避免此限制： ```go // 计算批次数 batchSize := p.config.BatchSize numBatches := (totalSessions + batchSize - 1) / batchSize // 向上取整 for batchIdx := 0; batchIdx < numBatches; batchIdx++ { // 启动当前批次的会话 for i := startIdx; i < endIdx; i++ { go func(index int) { fixedWait := p.config.StartTime + time.Duration(index)*p.config.Step result := p.runSingleSession(index+1, fixedWait) resultCh <- result }(i) } // 批次间延迟 if batchIdx < numBatches-1 && p.config.BatchDelay > 0 { time.Sleep(p.config.BatchDelay) } } ``` ### 二分法精细探测 并行探测确定范围后，可启用二分法进一步精确定位： ```go low := p.result.MinTimeout high := p.result.MaxTimeout for round := 1; round <= p.config.BinaryRounds; round++ { mid := (low + high) / 2 // 测试 mid 点是否收到探测包 if received { low = mid } else { high = mid } } p.result.PreciseTimeout = (low + high) / 2 ``` ## 2. 会话管理 ### 服务器端会话管理 ```go type Session struct { ID string ClientAddr string Step time.Duration MaxTime time.Duration ProbeMode string FixedWait time.Duration LastSeqNum uint32 CreatedAt time.Time } type UDPServer struct { sessions sync.Map //并发安全的会话存储 // ... } ``` 使用 sync.Map 实现并发安全的会话存储。 ### 客户端并发控制 ```go var wg sync.WaitGroup resultCh := make(chan *SessionResult, batchSize) for i := startIdx; i < endIdx; i++ { wg.Add(1) go func(index int) { defer wg.Done() result := p.runSingleSession(index+1, fixedWait) resultCh <- result }(i) } go func() { wg.Wait() close(resultCh) }() ``` 使用 WaitGroup 和通道协调并发会话。 ## 3. 错误处理 ### 网络超时处理 所有网络操作都设置超时： ```go conn.SetReadDeadline(time.Now().Add(p.config.Timeout)) n, _, err := conn.ReadFromUDP(buf) if err != nil { // 超时 = NAT 映射已过期 return false, nil } ``` ### 优雅降级 对于不支持新协议的旧服务器，客户端能够优雅降级： ```go if mapping, err := p.detectMapping(); err == nil { p.result.Mapping = mapping p.displayMappingInfo(mapping) } else { log.Printf("[WARNING] Failed to detect NAT mapping: %v", err) log.Printf("Continuing with parallel probe...") } ``` # 六、使用示例 ## 1. 服务器模式 ```bash # 同时启用 UDP 和 TCP 服务器 ./nattimeout -server -p 8080 # 仅启用 UDP ./nattimeout -server -p 8080 -tcp=false # 仅启用 TCP ./nattimeout -server -p 8080 -udp=false ``` ## 2. UDP 探测 ```bash # 递增模式（默认） ./nattimeout -m udp -s server:8080 # 自定义参数 ./nattimeout -m udp -s server:8080 -t 10m -step 30s ``` ## 3. TCP 探测 ```bash # 递增模式 ./nattimeout -m tcp -s server:8080 # 自定义参数 ./nattimeout -m tcp -s server:8080 -t 20m -step 60s ``` ## 4. 并行探测（推荐） ```bash # 使用 start/end 区间自动计算会话数 ./nattimeout -m udp -s server:8080 -start 1m45s -end 5m -step 15s # 并行模式 + 二分法精细探测 ./nattimeout -m udp -s server:8080 -start 1m45s -end 5m -step 15s -binary # 分批模式（避免 NAT 并发限制） ./nattimeout -m udp -s server:8080 -parallel 10 -batch-size 3 -batch-delay 1s ``` # 七、常见 NAT 超时时间 | NAT 类型 | UDP 超时 | TCP 超时 | |----------|----------|----------| | 家用路由器 | 30-60s | 2-5 分钟 | | 企业防火墙 | 60-120s | 5-15 分钟 | | 云 NAT | 30-60s | 3-10 分钟 | | 移动网络 | 30-90s | 5-10 分钟 | # 八、技术亮点 ## 1. 反向探测思想 巧妙利用 NAT 只对出站流量刷新计时器的特性，实现准确测量。 ## 2. 并行探测优化 将时间复杂度从 O(n²) 降到 O(n)，显著提升检测速度。 ## 3. 分批模式 考虑 NAT 设备并发限制，提供分批启动选项，兼顾速度和可靠性。 ## 4. 二分法精细探测 在粗粒度范围确定后，使用二分法精确定位超时值。 ## 5. 跨平台编译 支持 Linux、Windows、macOS 多种平台和架构，静态编译无需依赖。 *** ## 参考资料 1. [nattimeout GitHub 仓库](https://github.com/user/tools/nattimeout) 最后修改：2026 年 02 月 01 日 © 允许规范转载 赞 如果觉得我的文章对你有用，请随意赞赏