1
 0      7 8     15 16    23 24    31
2
+--------+--------+--------+--------+
3
|     源端口      |    目的端口     |
4
+--------+--------+--------+--------+
5
|      长度       |     校验和      |
6
+--------+--------+--------+--------+
7
|              数据 ...              |
8
+-----------------------------------+

1
#!/usr/bin/env python3
2
"""UDP 校验和计算演示"""
3
import struct
4
import socket
5

6
def udp_checksum(src_ip, dst_ip, src_port, dst_port, payload):
7
    """计算 UDP 校验和"""
8
    # 构造伪头部
9
    src_addr = socket.inet_aton(src_ip)
10
    dst_addr = socket.inet_aton(dst_ip)
11
    protocol = 17  # UDP 协议号
12
    udp_length = 8 + len(payload)
13

14
    pseudo_header = struct.pack(
15
        '!4s4sBBH',
16
        src_addr, dst_addr, 0, protocol, udp_length
17
    )
18

19
    # 构造 UDP 头部（校验和字段填 0）
20
    udp_header = struct.pack('!HHHH', src_port, dst_port, udp_length, 0)
21

22
    # 拼接所有数据
23
    data = pseudo_header + udp_header + payload
24

25
    # 如果数据长度为奇数，补一个零字节
26
    if len(data) % 2:
27
        data += b'\x00'
28

29
    # 按 16 位字求和
30
    total = 0
31
    for i in range(0, len(data), 2):
32
        word = (data[i] << 8) + data[i + 1]
33
        total += word
34

35
    # 回卷进位
36
    while total >> 16:
37
        total = (total & 0xFFFF) + (total >> 16)
38

39
    # 取反
40
    return ~total & 0xFFFF
41

42
# 示例：计算一个 DNS 查询的校验和
43
src_ip = "192.168.1.100"
44
dst_ip = "8.8.8.8"
45
src_port = 52840
46
dst_port = 53
47
payload = b'\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00' \
48
          b'\x06google\x03com\x00\x00\x01\x00\x01'
49

50
checksum = udp_checksum(src_ip, dst_ip, src_port, dst_port, payload)
51
print(f"UDP 校验和: 0x{checksum:04x}")

1
# 抓取 UDP 流量
2
sudo tshark -i eth0 -f "udp" -c 10
3

4
# 典型输出：
5
# 1 0.000 192.168.1.100 → 8.8.8.8   UDP 62 52840 → 53 Len=30
6
# 2 0.032 8.8.8.8       → 192.168.1.100 UDP 78 53 → 52840 Len=46
7
# 3 0.105 192.168.1.100 → 192.168.1.1  UDP 54 34567 → 53 Len=22
8

9
# 过滤特定端口的 UDP
10
sudo tshark -i eth0 -f "udp port 53" -Y "dns"
11

12
# 显示 UDP 头部详细信息
13
sudo tshark -i eth0 -f "udp" -T fields \
14
  -e ip.src -e ip.dst -e udp.srcport -e udp.dstport \
15
  -e udp.length -e udp.checksum
16

17
# 统计 UDP 流量
18
sudo tshark -i eth0 -z conv,udp -c 1000

1
# 查看常见 UDP 服务端口
2
grep -i udp /etc/services | head -20
3

4
# 典型输出：
5
# domain          53/tcp          nameserver      # name-domain server
6
# domain          53/udp          nameserver
7
# bootps          67/udp                          # BOOTP/DHCP server
8
# bootpc          68/udp                          # BOOTP/DHCP client
9
# tftp            69/udp                          # Trivial File Transfer
10
# ntp             123/udp                         # Network Time Protocol
11
# snmp            161/udp                         # Simple Net Mgmt Protocol
12
# snmptrap        162/udp                         # Traps for SNMP
13
# syslog          514/udp                         # BSD syslog
14

15
# 查询特定端口的注册信息
16
getent services 53
17
# domain 53/tcp udp

1
# UDP 端口扫描（需要 root 权限）
2
sudo nmap -sU -p 53,67,68,123,161,514 192.168.1.1
3

4
# 典型输出：
5
# PORT    STATE         SERVICE
6
# 53/udp  open          domain
7
# 67/udp  open|filtered dhcps
8
# 68/udp  open|filtered dhcpc
9
# 123/udp open          ntp
10
# 161/udp open          snmp
11
# 514/udp open          syslog
12

13
# 全 UDP 端口扫描（非常慢，因为 UDP 无响应可能是过滤也可能是开放）
14
sudo nmap -sU -p 1-65535 --max-retries 1 192.168.1.1
15

16
# 快速扫描常见 UDP 端口
17
sudo nmap -sU -F --version-intensity 0 192.168.1.1

1
# 用 dig 抓取 DNS 查询的 UDP 包
2
sudo tshark -i eth0 -f "udp port 53" -w dns_capture.pcap &
3
dig @8.8.8.8 google.com A
4
sudo kill %1
5

6
# 分析抓包结果
7
tshark -r dns_capture.pcap -Y "dns" -T fields \
8
  -e frame.time_relative -e ip.src -e ip.dst \
9
  -e dns.qry.name -e dns.a
10

11
# 典型输出：
12
# 0.000  192.168.1.100 → 8.8.8.8  google.com
13
# 0.032  8.8.8.8       → 192.168.1.100  google.com  142.250.80.46
14

15
# 观察 UDP 长度
16
tshark -r dns_capture.pcap -Y "dns" -T fields \
17
  -e udp.length -e dns.qry.name
18
# 典型：查询 40 字节，响应 56 字节

1
# 查看 UDP 套接字统计
2
ss -u -a -n
3

4
# 典型输出：
5
# State   Recv-Q  Send-Q  Local Address:Port  Peer Address:Port
6
# UNCONN  0       0       *:53                *:*
7
# UNCONN  128     0       *:514               *:*
8
#          ↑ 接收缓冲区中待读取的数据量
9

10
# 查看 UDP 缓冲区默认大小
11
cat /proc/sys/net/core/rmem_default
12
# 212992 (208KB)
13

14
cat /proc/sys/net/core/rmem_max
15
# 212992 (208KB)
16

17
# 调整 UDP 接收缓冲区（高流量 DNS 服务器可能需要）
18
sudo sysctl -w net.core.rmem_max=8388608    # 8MB
19
sudo sysctl -w net.core.rmem_default=2097152 # 2MB
20

21
# 查看 UDP 统计信息（缓冲区溢出导致的丢包）
22
cat /proc/net/snmp | grep Udp
23
# Udp: InDatagrams NoPorts InErrors OutDatagrams RcvbufErrors SndbufErrors
24
# Udp: 1234567    234     56       987654       12           0
25
#                                    ↑ 接收缓冲区溢出次数
26

27
# 另一个关键指标
28
netstat -s | grep "buffer errors"
29
# 12 receive buffer errors
30
# 0 send buffer errors

1
# 使用 stunclient 测试 NAT 类型
2
sudo apt install stun-client
3
stun stun.l.google.com:19302
4

5
# 典型输出：
6
# MappedAddress = 203.0.113.5:20001
7
# ChangedAddress = 209.85.217.190:19302
8
# NAT Type = Port Restricted NAT
9

10
# 用 Python 实现简单的 STUN 绑定请求
11
python3 -c "
12
import socket, struct
13

14
# STUN Binding Request (RFC 5389)
15
# Type: 0x0001 (Binding Request), Length: 0, Magic Cookie: 0x2112A442
16
req = struct.pack('!HHI12s', 0x0001, 0, 0x2112A442, b'\x00' * 12)
17

18
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
19
sock.settimeout(3)
20
sock.sendto(req, ('stun.l.google.com', 19302))
21
data, addr = sock.recvfrom(1024)
22

23
# 解析 XOR-MAPPED-ADDRESS (Type 0x0020)
24
msg_type, msg_len, magic, txn_id = struct.unpack('!HHI12s', data[:20])
25
# 找到 XOR-MAPPED-ADDRESS 属性
26
offset = 20
27
while offset < len(data):
28
    attr_type, attr_len = struct.unpack('!HH', data[offset:offset+4])
29
    if attr_type == 0x0020:
30
        family = data[offset+5]
31
        x_port = struct.unpack('!H', data[offset+6:offset+8])[0]
32
        port = x_port ^ (0x2112A442 >> 16)
33
        if family == 0x01:  # IPv4
34
            x_ip = struct.unpack('!I', data[offset+8:offset+12])[0]
35
            ip = socket.inet_ntoa(struct.pack('!I', x_ip ^ 0x2112A442))
36
        print(f'公网映射: {ip}:{port}')
37
        break
38
    offset += 4 + attr_len
39
"

1
#!/usr/bin/env python3
2
"""UDP 回声服务器"""
3
import socket
4

5
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
6
server.bind(('0.0.0.0', 9999))
7
print("UDP 服务器监听 0.0.0.0:9999")
8

9
while True:
10
    data, addr = server.recvfrom(4096)
11
    print(f"收到来自 {addr} 的数据: {data!r} ({len(data)} 字节)")
12
    server.sendto(data, addr)  # 回声
13

14
# --------------------------------------------------
15
#!/usr/bin/env python3
16
"""UDP 客户端"""
17
import socket
18
import time
19

20
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
21
client.settimeout(2.0)
22
server_addr = ('127.0.0.1', 9999)
23

24
for i in range(5):
25
    msg = f"Hello UDP #{i}".encode()
26
    start = time.time()
27
    client.sendto(msg, server_addr)
28
    try:
29
        data, addr = client.recvfrom(4096)
30
        rtt = (time.time() - start) * 1000
31
        print(f"收到回声: {data!r}, RTT: {rtt:.1f}ms")
32
    except socket.timeout:
33
        print(f"请求 #{i} 超时（UDP 不保证交付）")
34

35
client.close()

1
# 启动 iperf3 服务端
2
iperf3 -s
3

4
# 客户端 UDP 带宽测试（默认 1Mbps）
5
iperf3 -c 127.0.0.1 -u
6

7
# 典型输出：
8
# [ ID] Interval       Transfer     Bitrate         Jitter    Lost/Total
9
# [  5] 0.00-1.00 sec   128 KBytes  1.05 Mbits/sec  0.023 ms  0/89 (0%)
10
# [  5] 1.00-2.00 sec   128 KBytes  1.05 Mbits/sec  0.019 ms  0/89 (0%)
11

12
# 加大带宽到 100Mbps，观察丢包
13
iperf3 -c 127.0.0.1 -u -b 100M
14

15
# 典型输出（高带宽下丢包明显）：
16
# [  5] 0.00-1.00 sec  11.2 MBytes  94.0 Mbits/sec  0.156 ms  12/8200 (0.15%)
17
# [  5] 1.00-2.00 sec  11.0 MBytes  92.3 Mbits/sec  0.201 ms  45/8100 (0.56%)
18

19
# 测试不同包大小的影响
20
iperf3 -c 127.0.0.1 -u -b 50M -l 64    # 64 字节小包
21
iperf3 -c 127.0.0.1 -u -b 50M -l 1400   # 1400 字节大包（接近 MTU）
22
iperf3 -c 127.0.0.1 -u -b 50M -l 9000   # 9000 字节巨帧（需要 Jumbo Frame 支持）
23

24
# 反向测试（服务端发送到客户端）
25
iperf3 -c 127.0.0.1 -u -b 50M -R

1
# 抓取 UDP 流量并保存
2
sudo tshark -i eth0 -f "udp" -w udp_capture.pcap -a duration:30
3

4
# 分析 UDP 统计
5
tshark -r udp_capture.pcap -z conv,udp
6

7
# 典型输出：
8
# UDP Conversations
9
# Filter:udp
10
#            <-->               A    B    A<->B
11
# 192.168.1.100:52840 <-> 8.8.8.8:53     15   15     630     890
12
# 192.168.1.100:123   <-> 162.159.200.1:123  5    5     250     250
13

14
# 过滤 DNS over UDP
15
tshark -r udp_capture.pcap -Y "udp.port == 53" -T fields \
16
  -e frame.time -e ip.src -e ip.dst -e dns.qry.name -e dns.flags.rcode
17

18
# 检查 UDP 校验和错误
19
tshark -r udp_capture.pcap -Y "udp.checksum_bad.expert"
20

21
# 导出 UDP 数据
22
tshark -r udp_capture.pcap -Y "udp.port == 9999" \
23
  -T fields -e data | xxd -r -p > udp_payload.bin