协议 · XB 现场笔记

Gossip 收敛需要明确前提

Mon, 20 Sep 2027 00:00:00 +0000

流言协议通过反复联系对等节点来传播信息。一部分交换丢失时，只要仍有节点保留该状态，后续联系就可能再次传播它。但最终收敛需要前提：有关节点必须最终可达，更新不能提前消失，合并规则也必须能够处理实际产生的状态。随机选择伙伴本身，并不保证所有节点在某个固定截止时间之前达成一致。

区分传播与状态调和

节点可以主动推送状态、拉取对方状态，也可以双向交换。这是协议设计选择，并非每条流言消息都必须具有对称结构。在连通良好的成员集合中，每个节点每轮只联系少量伙伴，就可能让一条小更新快速扩散。常见的对数级传播估计属于特定概率模型，不能用一次网络来回耗时直接推导最坏收敛期限，也不能把每轮联系几个节点误解成整份状态的传输成本恒定。

成员流言也不会自动让应用写入一致。Dynamo 使用流言维护成员信息，用向量时钟表达对象版本，再用 Merkle 树反熵修复副本差异。这些机制承担不同职责。成员协议中的 incarnation 编号用于区分同一个成员的状态代次，并不是任意业务数据都可以直接采用的因果版本。理解职责分离，比把所有最终一致行为统称为流言更有助于定位故障。

下面的模型明确假定每个键只有一个写者，版本严格递增。对它播种的单条更新，保留更大版本已经足够。如果相同版本却包含不同内容，当前规则只保留先看到的一方，结果就会依赖合并顺序。真实系统必须说明如何处理并发、重复投递、删除和重启身份，不能用传播最终到达的证据替代这些合并契约。

坏掉的样子

持续的网络分区会阻止更新跨越互不连通的组件。每一侧继续重复内部交换，也无法补上不存在的通信路径。恢复连接后，只有所需状态仍然存在，调和才有机会继续。删除同样需要明确表示和保留期限：墓碑过早到期，可能让旧副本重新带回被删除内容。版本向量描述版本关系，墓碑记录删除事实，两者作用不同，也不会自动保证所有业务写入都被完整保留。

运行缓慢或暂停的节点可能看起来已经故障。SWIM 将故障检测与感染式传播分开，并通过怀疑阶段给被怀疑成员一个使用较新代次进行反驳的机会。这是在其假设下减少误判，并非在任意长延迟下都能精确判断死亡。数据重新复制和归属迁移属于外围系统的策略，不能说每次传播怀疑都会必然触发一次重新分片或自动撤销已经完成的迁移。

修复本身也消耗资源。全量状态交换、过于频繁的轮次，以及大量节点同时重返集群，都可能压满链路或接收端。限制扇出、增量交换和控制恢复速率能够帮助减压，但开销还取决于状态大小，不能只数每轮联系了几台机器。重启版本必须遵守具体实现的身份规则：计数器归零可能让新声明显得陈旧，或造成相同身份的歧义；较小版本不会因为“重启过”就自然覆盖较大版本。

快速验证

保存为 check_gossip.py，使用 python3 check_gossip.py 执行。它只使用 Python 标准库，不打开网络连接。二十个字典代表节点，每次扫描顺序访问节点，并做双向合并。固定种子使当前运行时的选择可复现；一条消息可以在同一次扫描中经过多个连续联系，因此这不是所有节点同步发送、同步接收的真实网络轮次模拟器。

import random

NODES, ROUNDS, SEED = 20, 12, 7

def merge(a, b):
 # One writer per key, with strictly increasing versions in this fixture.
 merged = dict(a)
 for key, (version, value) in b.items():
 if key not in merged or version > merged[key][0]:
 merged[key] = (version, value)
 return merged

def spread(peer_for, nodes=None):
 rng = random.Random(SEED)
 if nodes is None:
 nodes = [{} for _ in range(NODES)]
 nodes[0]["config"] = (1, "blue")
 history = []
 for _ in range(ROUNDS):
 # Sequential contacts: knowledge can travel several hops in one sweep.
 for i in range(NODES):
 peer = peer_for(i, rng)
 if peer == i:
 continue
 united = merge(nodes[i], nodes[peer])
 nodes[i], nodes[peer] = dict(united), dict(united)
 history.append(sum(state.get("config") == (1, "blue") for state in nodes))
 return nodes, history

random_peer = lambda i, rng: rng.randrange(NODES)
nodes, history = spread(random_peer)
assert history[-1] == NODES
assert all(a <= b for a, b in zip(history, history[1:]))
print("random contacts:", history)

# A fixed hub is connected; fixed contacts do not inherently prevent convergence.
_, hub = spread(lambda i, rng: 0)
assert hub[0] == NODES
print("fixed hub after one sweep:", hub[0])

# Two disconnected peer sets retain different views until contacts can cross.
partitioned, split = spread(lambda i, rng: (i // 10) * 10 + rng.randrange(10))
assert split[-1] == 10 and all(not node for node in partitioned[10:])
_, healed = spread(random_peer, partitioned)
assert healed[-1] == NODES
print("partition:", split[-1], "after healing:", healed[-1])

# Dissemination alone cannot repair an ambiguous concurrent-write merge rule.
a, b = {"config": (2, "red")}, {"config": (2, "green")}
assert merge(a, b) != merge(b, a)
print("equal-version conflict is order-dependent: not a multi-writer merge")
print("PASS: dissemination, topology, partition, and merge controls")

随机联系产生的知情节点数依次为五、十四、十九，第四次扫描达到二十，后续保持不变。这复现了原先记录于 macOS、CPython 3.12 的单更新结果，但只能说明这个输入和调度，不是其他随机种子或线上集群的收敛概率界限。当前模型补充明确的反例，不再仅凭一次成功就推断任意拓扑和故障条件下的可靠性。

如果所有节点都联系同一个仍然工作的中心伙伴，一次扫描就能让二十个节点全部得知更新。因此，固定伙伴本身不必然导致停滞，关键在于通信是否连通以及如何调度。分区对照将节点分为两个十人集合，只允许组内联系，于是第二组始终不知情。恢复跨组联系后，本次确定性运行又能传播到所有节点，这才直接展示连通性恢复的作用。

最后，把同版本的红色与绿色状态按相反顺序合并，得到不同结果。这个断言暴露单写者模型的限制，而不是悄悄把先到先得称作通用冲突解决。实验没有实现网络丢包、怀疑超时、墓碑生命周期、带宽预算或真实成员管理。选择线上传播目标时，应分别验证这些条件，并记录尚未恢复连通或仍有冲突的状态，不能把模型中的十二次扫描当成生产服务的时间承诺。

来源

Dynamo：亚马逊高可用键值存储，基于流言的成员关系与带版本调和的反熵，已核验 2026-09-12。
SWIM：可扩展弱一致感染式进程组成员协议，故障检测中的 suspicion 机制与 incarnation 编号，已核验 2026-09-12。
Cassandra 节点间通信（gossip），带版本号的点对点状态交换，已核验 2026-09-12。

TCP 握手建立序列号空间，不是同步两台机器的时钟

Fri, 10 Sep 2027 00:00:00 +0000

TCP 三次握手建立字节流的两个方向。每端提供自己的初始序列号，并确认另一端的序列号。这是两个独立序列空间，不是共享墙上时钟；应用建立连接不需要两台机器时钟同步。之后的序列号用于标识字节，支持连接内部的排序、重复处理、确认和重传。把序列号与时间混为一谈，会误解握手真正建立的协议状态。

坏掉的样子

客户端发送带初始序列号的 SYN，服务器回复 SYN-ACK，给出自己的初始序列号并确认客户端 SYN，客户端再确认服务器响应。即使没有应用数据，SYN 也占用序列空间中的一个位置，所以对应确认号增加一。将这些数值当成时间戳，会错误解释报文，还可能把排障引向无关的时钟同步问题，忽略真正缺失的确认或路由。

两端不会在完全相同的时刻改变状态。客户端收到 SYN-ACK 后，connect 可能成功返回，但最后一个确认在到达服务器前丢失。服务器仍可能停留在 SYN-RECEIVED，Linux 工具显示为 SYN-RECV。后续携带适当确认的数据也能完成交换，因此单独第三个报文缺失，并不必然导致永久失败，不能把抓包中的固定三包模式当成唯一合法过程。

TCP 建立成功也不代表应用健康或对端身份可信。服务可能接受连接却无法生成有效响应，代理可能完成客户端这一侧连接，却无法建立另一个独立上游连接。初始序列号选择有助于区分连接实例、抵御预测攻击，但不是身份认证协议，也不会加密字节流。传输状态、应用结果和安全身份需要各自对应的验证，不能由一项成功代替全部。

快速验证

将脚本保存为 check-tcp-handshake.py，准备 Docker 后运行 python3 check-tcp-handshake.py。一次性容器使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套网络命名空间。客户端和目标由新建 veth 相连，不移动宿主接口或发布端口：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 server_code=r'''
import socketserver
class Handler(socketserver.StreamRequestHandler):
 def handle(self):
 data=self.rfile.readline();self.wfile.write(b'echo:'+data);self.wfile.flush()
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
server=Server(('192.0.2.2',18080),Handler);print('ready',flush=True);server.serve_forever()
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='ready'
 tap,path=capture(stack,root,'client','c0','tcp port 18080','handshake')
 normal=ns('client','python3','-c',
 'import socket; s=socket.socket();s.settimeout(2);s.bind(("192.0.2.1",40100));s.connect(("192.0.2.2",18080));s.sendall(b"normal\\n");print(s.makefile("rb").readline().decode().strip());s.close()')
 assert normal.stdout.strip()=='echo:normal'
 nft('client','''table ip missing_ack {
 chain output { type filter hook output priority 0; policy accept;
 tcp dport 18080 tcp flags & (syn|ack|rst|fin) == ack counter drop comment "missing_final_ack"
 }
}
''')
 client_code=r'''
import json,socket,sys
s=socket.socket();s.settimeout(.25);s.bind(('192.0.2.1',40101));s.connect(('192.0.2.2',18080))
print(json.dumps({'connect_returned':True}),flush=True);s.sendall(b'deferred\n')
try:s.recv(64);raise AssertionError('unexpected application response')
except TimeoutError:print(json.dumps({'application_timeout':True}),flush=True)
assert sys.stdin.readline().strip()=='restore';s.settimeout(5)
received=b''
while not received.endswith(b'\n'):
 chunk=s.recv(64);assert chunk,'premature EOF';received+=chunk
assert received==b'echo:deferred\n',received
print(json.dumps({'recovered':received.decode().strip()}),flush=True);s.close()
'''
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code])
 connected=json.loads(line(client));failure=json.loads(line(client));assert connected['connect_returned'] and failure['application_timeout']
 pending=ns('target','ss','-nHt','state','syn-recv').stdout;assert '192.0.2.1:40101' in pending,pending
 blocked=counters('client');assert blocked['missing_final_ack']>0
 nft('client','delete table ip missing_ack');client.stdin.write('restore\n');client.stdin.flush()
 recovery=json.loads(line(client,6));assert recovery['recovered']=='echo:deferred'
 client.wait(timeout=2);assert client.returncode==0
 observed=packets(tap,path);flow=[p for p in observed if 40100 in (p['sport'],p['dport'])]
 syn=next(p for p in flow if p['flags']&0x12==0x02)
 synack=next(p for p in flow if p['flags']&0x12==0x12)
 third=next(p for p in flow if p['sport']==40100 and p['flags']&0x12==0x10)
 assert synack['ack']==(syn['seq']+1)%2**32
 assert third['seq']==(syn['seq']+1)%2**32 and third['ack']==(synack['seq']+1)%2**32
 print(json.dumps({'three_messages':[syn,synack,third],'normal_reply':normal.stdout.strip(),
 'client_connect_returned':connected['connect_returned'],'application_timeout':failure['application_timeout'],
 'server_still_syn_recv':pending.strip(),'drop_counters':blocked,'after_ack_filter_removed':recovery}))
"""
name='xbcatm-tcpflow-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

第一条连接使用客户端端口 40100 和目标端口 18080，发送换行结束的请求，收到预期回显。抓包提供真实 SYN、SYN-ACK 和最终 ACK 数值。断言检查服务器确认号等于客户端序列号加一，第三条消息确认号等于服务器序列号加一，并对三十二位序列空间使用取模运算。这样验证的是协议关系，而不是要求每次随机数相同。

第二条连接使用客户端端口 40101。客户端命名空间输出规则丢弃带 ACK、但不带 SYN、FIN 或 RST 的报文，包含最后确认与后续数据。阻断后续数据很重要，否则新的数据段可能确认 SYN-ACK，修复刻意丢失的第三条消息。实验由此稳定暴露两端不同状态，而不是依赖短暂时序巧合，或错误地假定一个 ACK 丢失后永远无法恢复。

客户端报告 connect 已成功返回，但读取应用响应直到截止时间仍失败。同一观察点，服务器套接字列表显示该客户端四元组处于 SYN-RECV，规则计数器也确认发生丢弃。三个独立观察分别对应客户端本地 API 结果、服务器协议状态和应用交换失败，证明它们不能混成同一项“连接正常”。故障归因需要同时保存这些上下文。

移除规则后，同一连接可以继续完成交换并交付已排队请求。客户端收到 echo:deferred，没有新建替代套接字来掩盖原连接失败。带边界的读取会累积响应，不假定一次 recv 总能返回完整应用消息。测试同时验证临时失败，以及受控原因移除之后的恢复；恢复来自 TCP 后续传输与确认，不是应用重开连接造成的另一个成功样本。

分别诊断建立过程和有效服务

记录四元组、命名空间、捕获位置与两端状态。重置、反复 SYN、反复 SYN-ACK，以及握手完成后的应用超时，会指向不同的下一步检查。条件允许时捕获两个方向：本地看到一个确认离开，不代表远端已经收到。本例通过规则计数和远端状态补足这个缺口，避免只看单侧包迹就宣布服务器一定进入已建立状态。

验证服务时，应在传输连接之后发送有意义的请求并检查响应。验证身份和机密性时，应使用 TCP 上层适当的认证协议。本例覆盖没有 Fast Open 或同时打开的普通连接，不声称每个合法连接都以三个分离可见的报文开始。关键是序列号与状态的关系，而不是简单数包，更不能把握手成功当作业务操作已经完成的证明。

来源

RFC 9293 TCP，序列号、连接状态与三次握手，已核验 2026-09-12。
Linux tcp(7)，TCP 套接字行为与 Linux 控制选项，已核验 2026-09-12。
Linux ss(8)，查看已建立与 SYN-RECV 套接字，已核验 2026-09-12。

Well-known 路径提供的是发现约定

Tue, 22 Jun 2027 00:00:00 +0000

Well-known URI 为软件发现某个源站的信息提供约定位置。保留的 /.well-known/ 前缀，减少了不同协议各自设计路径时发生名称冲突的机会；注册后缀则指向定义它的具体规范。这个前缀是一种命名机制，不是自动实现，更不是内容可信的保证。服务器仍需正确路由所支持的端点，客户端也必须按照该端点自己的契约解释响应。

按具体后缀的规范实现

RFC 8615 为支持的 URI 方案保留这一命名空间，不要求每个网站发布所有已注册资源，也没有给所有后缀定义统一响应格式。确定媒体类型、认证、跳转处理、缓存或传输条件之前，应查看 IANA 注册及其引用规范。路径看起来熟悉，不能替代协议规则；不同自动化客户端也不会因为共用前缀，就自然采用相同的读取和验证方式。

对于通过网站发布漏洞联系信息，RFC 9116 规定 security.txt 位于 /.well-known/security.txt，并要求通过 HTTPS 获取。旧位置 /security.txt 可以重定向到标准位置。文档使用 UTF-8 纯文本和规定字段，包括至少一个 Contact 以及唯一的 Expires 字段。Contact 提供报告渠道，不代表邮箱一定有人值守，更不能证明某份报告已经被接收或处理。

文档中的 Expires 字段用时间戳限制信息的新鲜度，它与 HTTP 响应中的 Expires 头不是同一个东西。传输层返回二百，不会让已经过期的联系信息重新变得有效。地址和政策需要持续维护，并在内容过时之前更新。使用 Canonical、Policy 等可选字段时，也应遵守各自规则，不能把文档里任意一个网址都当成已经验证的可信声明。

坏掉的样子

宽泛的应用回退路由可能对任何未知地址都返回首页或登录页，并统一使用二百状态。浅层健康检查认为路径可达，真正的协议客户端却得不到可用文档。因此要保留准确路由，同时检查媒体类型与内容。意外跳转到另一个源站，还可能改变信任上下文，而不只是移动一个文件。仅检查最终状态成功，可能遗漏这些协议层面的错误。

命名空间本身不会认证内容。HTTPS 校验帮助建立到目标主机的连接，文档验证及协议要求的其他检查，才进一步判断内容是否可用。存在安全联系信息，不等于授权外部人员扫描或攻击服务。部署也不能因为一个标准资源计划公开，就不加区分地暴露整个目录。应围绕实际支持的资源配置路由和权限，而不是把前缀当成自动开放所有内容的规则。

对没有实现的后缀返回四零四，与悄悄生成一份通用成功文档，是不同选择。每个受支持端点都应有维护者和适合其协议的检查。注册表描述的是约定，既不能证明某个源站已经实现，也不能证明当前响应已经验收。协议发现减少的是查找位置的不确定性，并没有取消维护、格式检查与可信性判断这些后续工作。

快速验证

保存为 well-known.py，使用 Python 3.14 执行 python3 well-known.py。实验仅提供回环 HTTP 服务，联系地址使用明确虚构的 example.invalid。它验证路由及选定文档字段；由于没有使用 HTTPS，不能把它视为完整 RFC 9116 部署或传输安全测试。代码不会发送邮件，也不会连接真实的漏洞接收系统。

from datetime import datetime, timedelta, timezone
from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from threading import Thread
import json

now = datetime.now(timezone.utc)
future = (now + timedelta(days=30)).isoformat().replace('+00:00', 'Z')
past = (now - timedelta(days=1)).isoformat().replace('+00:00', 'Z')
content = {'text': f'Contact: mailto:security@example.invalid\nExpires: {future}\n'}


class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 status = 200 if self.path == '/.well-known/security.txt' else 301 if self.path == '/security.txt' else 404
 data = content['text'].encode() if status == 200 else b''
 self.send_response(status)
 if status == 301:
 self.send_header('Location', '/.well-known/security.txt')
 self.send_header('Content-Type', 'text/plain; charset=utf-8')
 self.send_header('Cache-Control', 'no-store')
 self.send_header('Content-Length', str(len(data)))
 self.end_headers()
 self.wfile.write(data)

 def log_message(self, *args):
 pass


def check_contact_and_expiry(text):
 fields = dict(line.split(': ', 1) for line in text.splitlines())
 if not fields.get('Contact', '').startswith('mailto:'):
 raise ValueError('missing demonstration contact')
 expires = datetime.fromisoformat(fields['Expires'])
 if expires <= now:
 raise ValueError('expired metadata')


server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)
thread = Thread(target=server.serve_forever)
thread.start()
try:
 def fetch(path):
 connection = HTTPConnection('127.0.0.1', server.server_port, timeout=5)
 try:
 connection.request('GET', path)
 response = connection.getresponse()
 return {'status': response.status, 'body': response.read().decode(),
 'location': response.getheader('Location'),
 'content_type': response.getheader('Content-Type')}
 finally:
 connection.close()

 valid = fetch('/.well-known/security.txt')
 assert valid['status'] == 200 and valid['content_type'] == 'text/plain; charset=utf-8'
 check_contact_and_expiry(valid['body'])
 legacy = fetch('/security.txt')
 assert legacy['status'] == 301 and legacy['location'] == '/.well-known/security.txt'
 assert fetch('/.well-known/unimplemented')['status'] == 404
 rejected = []
 for text in (content['text'].replace(future, past), f'Expires: {future}\n'):
 content['text'] = text
 response = fetch('/.well-known/security.txt')
 assert response['status'] == 200
 try:
 check_contact_and_expiry(response['body'])
 except ValueError as error:
 rejected.append(str(error))
 assert rejected == ['expired metadata', 'missing demonstration contact']
 print(json.dumps({'valid_status': valid['status'], 'legacy_status': legacy['status'],
 'unimplemented_status': 404, 'rejected_200_documents': rejected,
 'https_transport_tested': False}))
finally:
 server.shutdown()
 thread.join()
 server.server_close()

标准路径第一次返回二百、预期纯文本类型、联系字段，以及三十天后的到期时间。旧路径返回三零一，指向标准位置；未实现的后缀返回四零四。随后脚本在同一成功路由上提供两份无效文档：一份已经过期，另一份缺少联系字段。它们的 HTTP 状态仍然是二百，却都被字段检查拒绝。这说明地址可达与元数据可用必须分别验证。

这里的解析器刻意只处理已知演示格式，没有实现通用客户端需要的全部重复字段、签名、Canonical 检查、跳转与 URI 校验。通过两个字段检查，不等于整份文档完全符合标准，也没有验证联系渠道真实可用。应该用这个实验区分位置、HTTP 成功与可用元数据，再根据选定协议的完整要求验证实际部署，最后才发布真实端点。

来源

RFC 8615: Well-Known URIs，保留命名空间与注册模型，已核验 2026-09-13。
RFC 9116: security.txt，规定路径、HTTPS 传输、联系字段与到期规则，已核验 2026-09-13。
IANA: Well-Known URIs registry，已注册后缀及其定义规范，已核验 2026-09-13。

UDP 回答被截断时，DNS 需要可工作的 TCP 路径

Thu, 19 Nov 2026 00:00:00 +0000

DNS 同时支持 UDP 和 TCP。服务器因可用消息空间而截断响应时，会设置 TC 标志。客户端收到该标志，需要处理结果不完整的情况，通常通过 TCP 重新查询。这涉及当前使用的 DNS 响应限制，并不直接证明物理网络无法承载任何更大的 UDP 数据报。排障时应先确认协议层发生了什么，再讨论传输路径的实际容量。

坏掉的样子

允许 UDP 五十三端口却阻止 TCP 五十三端口的网络，可能小查询正常，大回答失败。DNSSEC 数据和较大记录集容易暴露这种差异，但 TCP 并不只用于这些特殊情况。通用 DNS 实现需要支持 TCP，客户端也可以直接选择它。因此，一次小型 UDP 查询成功，不能证明整个 DNS 服务的传输路径完整，尤其不能代替对 TCP 监听和访问规则的检查。

被截断的回答仍可能包含部分记录。如果忽略 TC，把这些记录当成完整集合，就可能漏掉有效目的地或必需数据。NOERROR 不会抵消截断标志。当应用看到的记录比另一种传输方式下的权威查询少时，应保留完整问题、响应标志和记录数量，不要只提取一个地址或文本值。仅凭有内容返回，并不能判断这次 DNS 交换已经完整结束。

TCP 也没有取消所有 DNS 消息大小限制。TCP 流中，每个 DNS 消息之前都有两字节长度字段，因此单个消息最多六万五千五百三十五字节；区域传送可以由多个消息组成。流读取可能拆开长度字段或正文，程序应循环读取所需字节数，不能假定一次 recv 就返回整个回答。传输可靠与应用消息边界明确，是两项不同责任。

快速验证

将脚本保存为 check-dns-tcp.py，准备 Docker 后执行 python3 check-dns-tcp.py。固定 BIND 9.18.49 环境在隔离容器中提供包含四条记录的 TXT 集合。第一次查询明确关闭 EDNS，以观察传统五百一十二字节 UDP 限制。之后程序使用真实 TCP 连接，并建立一个有意只提供 UDP 的中继端点；不修改现有防火墙或公共解析器：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
import dns.flags,socket,struct,threading
texts=[f'{i}-'+('x'*200) for i in range(4)]
records='small 30 IN A 127.0.0.2\n'+'\n'.join('large 30 IN TXT "'+s+'"' for s in texts)
def exact(stream,size):
 data=b''
 while len(data)<size:
 part=stream.recv(size-len(data));assert part,'unexpected TCP EOF';data+=part
 return data
def description(response):return {'wire_bytes':len(response.to_wire()),'TC':bool(response.flags&dns.flags.TC),'answer_records':sum(len(rr) for rr in response.answer)}
with lab(records) as (_,update,cache,queries):
 q=dns.message.make_query('large.lab.test.','TXT',use_edns=False)
 udp=dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
 assert udp.flags&dns.flags.TC and len(udp.to_wire())<=512
 tcp=dns.query.tcp(q,'127.0.0.1',port=1053,timeout=2)
 assert not tcp.flags&dns.flags.TC and set(values(tcp,'TXT'))=={'"'+s+'"' for s in texts}
 assert len(tcp.to_wire())>512
 with socket.create_connection(('127.0.0.1',1053),timeout=2) as stream:
 lengths=[]
 for name,kind in [('large.lab.test.','TXT'),('small.lab.test.','A')]:
 request=dns.message.make_query(name,kind);wire=request.to_wire();stream.sendall(struct.pack('!H',len(wire))+wire)
 size=struct.unpack('!H',exact(stream,2))[0];reply=dns.message.from_wire(exact(stream,size));assert reply.id==request.id and reply.rcode()==0
 assert values(reply,kind);lengths.append(size)
 with socket.socket() as reservation,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as relay:
 reservation.bind(('127.0.0.1',0));port=reservation.getsockname()[1];relay.bind(('127.0.0.1',port));relay.settimeout(3)
 errors=[]
 def one_datagram():
 try:
 data,peer=relay.recvfrom(4096);answer=dns.query.udp(dns.message.from_wire(data),'127.0.0.1',port=1053,timeout=2);relay.sendto(answer.to_wire(),peer)
 except Exception as error:errors.append(type(error).__name__)
 thread=threading.Thread(target=one_datagram);thread.start()
 limited=dns.query.udp(q,'127.0.0.1',port=port,timeout=2);assert limited.flags&dns.flags.TC
 thread.join(timeout=4);assert not thread.is_alive() and not errors
 try:dns.query.tcp(q,'127.0.0.1',port=port,timeout=1);raise AssertionError('UDP-only endpoint unexpectedly accepted TCP')
 except OSError as error:failure=type(error).__name__
 print(json.dumps({'UDP':description(udp),'TCP':description(tcp),'two_messages_one_connection_lengths':lengths,
 'UDP_only_path':{'TC_received':True,'TCP_error':failure}},sort_keys=True))
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

实测 UDP 响应四百六十二字节，设置 TC，只带回四条 TXT 中的两条。TCP 响应八百九十二字节，TC 清除，并包含全部四个预期值。脚本比较完整记录内容，不是看到字节数变大就认定缺失数据已经恢复。这一结果还直接表明：截断响应可能保留部分有用数据，但调用方不能把部分集合当成权威完整结果使用。

接着程序只打开一个 TCP 连接，先查询较大的 TXT，再查询一个小 A 回答。每次都读取两字节长度和对应正文，记录中的消息长度分别为八百九十二与四十八，并检查响应标识。两次交换使用同一条流，证明每个查询不必重新握手。长度字段不计入所描述的 DNS 消息正文大小，也不会因为 TCP 分段方式改变而失去作用。

另一个端点只转发一次 UDP 问题到真实权威，并返回截断回答。在相同端点编号上，保留一个已绑定但未监听的 TCP 套接字，使那里确实没有 TCP 服务。UDP 查询带 TC 成功返回，TCP 尝试则得到 ConnectionRefusedError。这个对照复现了传输方式不匹配，不依赖无关公网服务是否偶然失败，也不需要改变共享网络策略。

分开诊断截断与连接失败

检查响应标志、存在时的 EDNS 宣告容量、TCP 建连结果及最终 DNS 内容。先收到 TC 再连接被拒绝，与 UDP 完全无响应或权威返回 NXDOMAIN，原因不同。中继有意只支持一次交换，是受控失败实验，不是可部署的通用 DNS 代理。读者应提取它展示的传输边界，而不是把实验代码的范围误认为生产服务的完整能力。

让客户端、解析器、服务器监听及中间访问规则共同允许所需 TCP 路径，并根据负载选择连接截止时间和资源限制。复用可以减少重复建立连接的工作，但空闲连接、连接上限和服务器行为仍然重要。不能把一次新连接多出的握手，转换成每一次 TCP 查询都必须支付的固定延迟。实际成本应结合复用策略和真实请求序列测量。

EDNS 能允许更大的 UDP 回答，在不少场景中避免截断，却不会消除 TCP 需求。更大数据报可能先遭遇路径 MTU 或分片问题，客户端甚至收不到有效 TC 提示。应同时验证配置的 UDP 大小和完整 TCP 交换，不要把特别大的宣告容量当成第二条传输路径已经可用。协议宣告与沿途能否交付数据，是两个检查维度。

最后，TCP 提供可靠字节流，不直接提供 DNS 保密性或记录数据认证。普通 TCP DNS 仍是明文，加密 DNS 传输与 DNSSEC 分别处理另外的安全属性。本实验的证据限定在截断处理、完整记录恢复、流消息边界、连接复用，以及只有 UDP 时的具体失败。描述结果时保留这些边界，才能避免把一种传输方式的成功扩大成全部 DNS 能力已验证。

来源

RFC 7766 DNS over TCP，TCP 支持、连接复用与 DNS 传输要求，已核验 2026-09-12。
RFC 1035 domain names，TC、传统 UDP 大小与两字节 TCP 长度前缀，已核验 2026-09-12。
RFC 5936 AXFR，跨多个 DNS 消息的区域传送，已核验 2026-09-12。

IPv6 先用 ICMPv6 解析邻居，TCP 才能正常通信

Mon, 16 Nov 2026 00:00:00 +0000

以太网链路上的 IPv6 主机，需要先取得邻居的链路层目的地址，才能发送相应帧。邻居发现通过 ICMPv6 的邻居请求和邻居通告完成地址解析，同时还涵盖路由器发现、邻居可达性检测等超出 IPv4 ARP 的功能。把它简单理解为“地址更长的 ARP”，会掩盖配置 IPv6 网络时必须考虑的依赖关系，尤其是控制报文与应用通信之间的联系。

坏掉的样子

拥有有效 IPv6 地址和路由，不代表能够解析下一跳的以太网地址。如果必要的请求或通告被过滤，TCP 服务可以一直正常监听，客户端却在交换应用数据前就失败。只开放应用 TCP 端口，无法修复这个较低层依赖。排查时应把邻居表、相关 ICMPv6 流量和服务监听一起观察，不能只从端口是否开放判断整条路径。

缓存状态还可能隐藏错误。已有可用邻居条目的主机，在破坏性规则安装后可能继续通信；新客户端或条目失效之后，故障才暴露。反过来，STALE 状态也不自动意味着损坏：邻居发现可以利用已有链路地址，随后再检查可达性。应理解状态转换，不能要求每个正常条目永远显示 REACHABLE，否则会把正常缓存生命周期误判为故障。

另一类混淆，是在本地以太网段上解析远端应用服务器地址。目的地位于链路之外时，主机通常解析选中的下一跳路由器，而不是远端服务器。判断邻居表应出现哪个地址之前，需要先确认选路。捕获接口错误，或者已有缓存使本次无需重新发送请求，也能解释空白抓包结果，不能据此证明邻居发现根本没有发生。

快速验证

将脚本保存为 check-neighbor-discovery.py，准备 Docker 后运行 python3 check-neighbor-discovery.py。此前 Linux 实验使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3；本轮没有重跑网络实验，以下结果保留为历史观察。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间和临时 proc 挂载。两个端点通过新建 veth 相连，不修改宿主邻居表或防火墙规则：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def captured(process,path,ascii=False):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 result=run('tcpdump','-nn','-vv',*(['-A'] if ascii else []),'-r',str(path))
 return result.stdout

with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30','2001:db8:1::1/64'],['192.0.2.2/30','2001:db8:1::2/64'])
 server(stack,'target','2001:db8:1::2')
 ip('client','-4','neigh','flush','dev','c0');ip('target','-4','neigh','flush','dev','t0')
 arp_process,arp_file=capture(stack,root,'client','c0','arp','arp')
 ns('client','ping','-4','-n','-c','1','-W','1','192.0.2.2')
 arp=captured(arp_process,arp_file);assert 'ARP,' in arp and 'Request who-has' in arp and 'Reply' in arp,arp
 ip('client','-6','neigh','flush','dev','c0');ip('target','-6','neigh','flush','dev','t0')
 nd_process,nd_file=capture(stack,root,'client','c0','icmp6 or arp','nd')
 ns('client','ping','-6','-n','-c','1','-W','1','2001:db8:1::2')
 nd=captured(nd_process,nd_file)
 assert 'neighbor solicitation' in nd and 'neighbor advertisement' in nd and 'ARP,' not in nd,nd
 mac=json.loads(ip('target','-j','link','show','t0').stdout)[0]['address']
 neighbors=json.loads(ip('client','-6','-j','neigh','show','2001:db8:1::2').stdout)
 assert len(neighbors)==1 and neighbors[0]['lladdr']==mac
 healthy=request('client','2001:db8:1::2');assert healthy['ok']
 setting('client','net.ipv6.neigh.c0.retrans_time_ms',200);setting('client','net.ipv6.neigh.c0.mcast_solicit',3)
 nft('client','''table inet block_nd {
 chain input { type filter hook input priority 0; policy accept;
 icmpv6 type nd-neighbor-advert counter drop comment "blocked_advertisements"
 }
}
''')
 ip('client','-6','neigh','flush','dev','c0')
 failed=ns('client','ping','-6','-n','-c','1','-W','1','2001:db8:1::2',check=False);assert failed.returncode!=0
 broken=request('client','2001:db8:1::2');assert not broken['ok']
 blocked=counters('client');assert blocked['blocked_advertisements']>0
 failed_neighbors=json.loads(ip('client','-6','-j','neigh','show','2001:db8:1::2').stdout)
 assert failed_neighbors and all('lladdr' not in entry for entry in failed_neighbors)
 nft('client','delete table inet block_nd');ip('client','-6','neigh','flush','dev','c0')
 recovered=request('client','2001:db8:1::2');assert recovered['ok']
 print(json.dumps({'ipv4_arp_capture':arp,'ipv6_capture':nd,'resolved_neighbor':neighbors,'target_mac':mac,
 'healthy_http':healthy,'blocked_ping_exit':failed.returncode,'blocked_http':broken,'blocked_counters':blocked,
 'unresolved_neighbor':failed_neighbors,'recovered_http':recovered}))
"""
name='xbcatm-netpath-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

脚本为两端配置 IPv4 与 IPv6 文档保留地址。首先捕获一次真实 IPv4 ARP 请求和回复，作为抓包配置有效的正向对照；然后清理客户端 IPv6 邻居缓存并发送 IPv6 echo 请求。第二段捕获包含邻居请求、邻居通告以及 echo 往返，没有 ARP 帧。这样的比较比“没有抓到 ARP，所以 IPv6 一定正常”更完整。

针对 2001:db8:1::2 的请求发往被请求节点组播地址 ff02::1:ff00:2。回复提供目标链路层地址，脚本将其与目标接口真实 MAC 以及客户端邻居条目比较。随后 HTTP 请求返回预期服务器身份。这把控制消息、学到的信息与应用结果连接起来，而不只是展示一组配置命令。MAC 由本次虚拟接口产生，不要求所有运行得到相同数值。

接着，客户端丢弃收到的邻居通告。它的缓存被清理，避免旧映射隐藏变更。为让测试在有限时间内结束，发现重传设置仅在客户端网络命名空间内缩短。此时 ping 失败，HTTP 得到 Linux EHOSTUNREACH，错误号一百一十三；邻居条目进入 FAILED，且没有解析出的链路地址。过滤计数器增长，证明通告确实到达丢弃规则。

删除该规则并清理失败条目后，HTTP 恢复成功。整个对照中，目标服务和地址保持不变，因此可以将结果归因于地址解析，而不是应用停止或缺少 TCP 放行规则。具体等待时间与报文数量受发现重试参数影响，所以示例检查失败状态和恢复结果，不把某一次执行时间规定成所有系统通用的超时。调整参数与清缓存都限定在实验环境内。

区分邻居发现、地址配置和身份验证

脚本使用静态 IPv6 地址，并在设置时关闭重复地址检测。它验证的是邻居解析，没有验证无状态地址自动配置、路由器通告处理或重复地址检测。这些功能需要各自的观测和策略审阅。通过这个小实验，不能证明生产网络的所有 ICMPv6 依赖都已经满足；RFC 4890 提供了更广泛运行环境中的过滤要求，配置策略时仍须结合实际角色。

通告携带一个 MAC 地址，也不应被当作经过认证的地址归属证明。协议中的本地链路检查限制了消息来源范围，却不会使同一链路上的每个节点都可信。诊断时记录接口、选中的下一跳、邻居状态、过滤规则及对应应用结果，才能把未解析邻居与无关服务故障区分开。解决控制层依赖之后，仍应通过实际应用请求确认通信已经恢复。

来源

RFC 4861 Neighbor Discovery，请求、通告、地址解析与可达性状态，已核验 2026-10-15。
Linux ip-neighbour(8)，查看与清理 IPv6 邻居条目，已核验 2026-10-15。
RFC 4890 ICMPv6 filtering，保留 IPv6 网络依赖的 ICMPv6 功能，已核验 2026-10-15。

UDP 保留数据报边界，恢复和时效由应用负责

Wed, 11 Nov 2026 00:00:00 +0000

UDP 在传输端点之间携带独立数据报，八字节首部包含来源端口、目的端口、长度和校验和字段。它不会加入 TCP 的可靠有序字节流或拥塞控制行为，让应用可以选择自己的交付策略，但不承诺所有负载下延迟都更低。应用确实需要某条内容时，丢失的数据报可能比建立连接的开销更昂贵，必须按完整请求过程评估。

坏掉的样子

发送成功不证明目标应用已经收到或处理消息。UDP 没有内建确认、重传、去重或顺序保证，因此超时不能告诉支付客户端操作是否发生。允许重试时，应用需要能够处理重复请求和结果不确定的协议，不能把没有响应直接解释成业务失败。消息是否到达、动作是否执行、结果是否持久化，也应具有不同含义。

即使本地路径健康，接收缓冲区也能制造失败。数据报大于本次调用提供的缓冲区时，内容可能截断，缺失后缀不会像字节流那样留给下一次读取。Linux 的 recvmsg 可以通过 MSG_TRUNC 报告这一情况。如果把缩短的字节当成完整命令或测量值，就可能在没有明显进程错误的情况下改变业务含义，因此必须检测协议要求的完整性。

UDP 没有内建拥塞控制，意味着应用承担责任，并不意味着可以无限制发送。需要根据部署选择发送节奏、拥塞行为、消息大小和截止时间。分片可能降低大数据报的交付稳健性，过了截止时间的数据也可能已经没有价值。QUIC 等协议能够在 UDP 之上提供可靠流，说明底层载体本身不能决定全部应用可靠性。

快速验证

将脚本保存为 check-udp.py，准备 Docker 后运行 python3 check-udp.py。固定 Python 3.11.16 Linux 容器没有外部网络路径和宿主端口发布。第一部分检查真实套接字接收语义；第二部分使用刻意编写的中继扣留、重复和重排消息，不声称测量自然发生的网络丢包。实验的每个故障输入都在代码中明确可见：

import json,subprocess,uuid
image="python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84"
program=r"""
import json,socket

with socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as sender,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as receiver:
 receiver.bind(('127.0.0.1',0));receiver.settimeout(.25);sender.settimeout(1);target=receiver.getsockname()
 sender.connect(target)
 for body in [b'A',b'BC',b'']:sender.send(body)
 boundaries=[receiver.recvfrom(16)[0] for _ in range(3)]
 assert boundaries==[b'A',b'BC',b'']
 sender.send(b'abcdefgh');data,ancillary,flags,peer=receiver.recvmsg(3)
 assert data==b'abc' and flags&socket.MSG_TRUNC
 try:receiver.recvfrom(16);raise AssertionError('truncated suffix survived')
 except TimeoutError:tail='discarded'
 sender.send(b'next');assert receiver.recvfrom(16)[0]==b'next'

 # A deliberate application relay changes delivery; this is not measured network loss.
 received=[];applied=[];seen=set();forwarded=[]
 with socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as relay,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as output:
 relay.bind(('127.0.0.1',0));relay.settimeout(1);output.settimeout(1)
 sender.connect(relay.getsockname())
 for seq in [1,2,3]:sender.send(str(seq).encode())
 inputs=[relay.recvfrom(16)[0] for _ in range(3)]
 for index in [2,0,0]:
 output.sendto(inputs[index],target);forwarded.append(int(inputs[index]))
 value=int(receiver.recvfrom(16)[0]);received.append(value)
 if value not in seen:seen.add(value);applied.append(value)
 assert received==[3,1,1] and applied==[3,1] and 2 not in seen
 try:receiver.recvfrom(16);raise AssertionError('missing message arrived by itself')
 except TimeoutError:no_retransmit=True
 print(json.dumps({'datagram_lengths':[len(x) for x in boundaries],'empty_datagram_is_message':boundaries[2]==b'',
 'short_buffer':data.decode(),'truncation_flag':bool(flags&socket.MSG_TRUNC),'unread_tail':tail,
 'relay_inputs':[int(x) for x in inputs],'relay_outputs':forwarded,'receiver':received,'deduplicated':applied,
 'missing_sequence':2,'no_automatic_retransmission_during_deadline':no_retransmit}))
"""
name='xbcatm-socket-'+uuid.uuid4().hex[:10]
try:
 result=subprocess.run(['docker','run','--rm','-i','--name',name,'--network','none',
 '--memory','128m','--pids-limit','64',image,'python3','-'],input=program,
 capture_output=True,text=True,timeout=60)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),ensure_ascii=False,sort_keys=True))
finally:
 subprocess.run(['docker','rm','-f',name],capture_output=True,text=True,timeout=10)

三次发送分别包含 A、BC 和空载荷，三次接收得到长度一、二和零。每次读取消费一条数据报，没有把相邻发送合并成字节流。空结果是合法零长度消息，不代表发送方关闭连接。发送套接字使用 UDP connect 选定对端，这个接口调用不会把 UDP 变成 TCP，也不会凭空增加确认和重传机制。

接着发送八字节 abcdefgh，接收方只提供三字节缓冲区，得到 abc 和 MSG_TRUNC。之后读取超时，没有拿到 defgh；再发送新的 next 数据报，接收方能够取得完整新消息。这个正向对照说明旧尾部已经被丢弃，而不是接收套接字在第一次调用后完全失效。截断与后续新消息属于不同数据报生命周期。

中继先收到序号一、二、三，再有意转发三、一、一，省略二。下游真实套接字收到这个选定序列。应用用一个小集合过滤重复值，最终执行序号三和一，却没有恢复原始顺序，也没有重建缺失消息。去重只解决其中一项问题，不能把它当成完整可靠传输或业务事务协议。所需语义必须逐项明确。

之后接收方等待下一条数据报，直到达到截止时间，UDP 没有自动重传序号二。这里缺失由中继制造，不能把结果写成某条网络的可靠性统计。它提供可复现的输入模式，用来观察应用面对传输契约没有排除的交付情况时如何反应。程序行为、故障注入与实际网络测量，需要在结果解释中保持区分。

有意识地补上所需语义

实时测量可能丢弃旧样本并显示最新序号，文件传输则需要恢复缺失内容。应用确认可以表示已经收到，也可以表示操作结果已经持久化，但含义必须由协议定义。对有副作用动作增加重试前，应明确标识符范围、重试截止时间、去重保留期和进程重启行为。本例没有实现这些更完整的事务机制，不能直接承担相应承诺。

同时规划接收能力和单条数据报大小，并把截断、应用发现的缺失与格式错误分别记录。增加套接字队列，无法修复单次接收缓冲区太小的问题；提高发送速率也可能加重拥塞，而不是改善信息新鲜度。应测量多少有用消息在截止时间前到达，而不只统计本地发送调用接受了多少字节。两种数字反映的结果不同。

当消息模型符合所建协议，且缺失的保证都有明确负责机制时，UDP 才是合理选择。以真实端到端时延、失败恢复和资源消耗判断性能，而不是仅凭省略握手就宣称更快。保留边界能简化部分解析，但完整数据报始终不到达、重复到达或到得太迟时，应用仍须具有定义清楚且经过验证的行为。

来源

RFC 768 User Datagram Protocol，UDP 首部与交付属性，已核验 2026-09-12。
RFC 8085 UDP usage guidelines，拥塞控制、消息大小及应用责任，已核验 2026-09-12。
Linux udp(7)，数据报接收、截断及已连接 UDP 套接字，已核验 2026-09-12。

EDNS 宣告 UDP 容量，不保证沿途网络交付

Wed, 28 Oct 2026 00:00:00 +0000

EDNS 通过 OPT 伪记录扩展 DNS，其中一项作用是让请求发送方宣告自己准备接收的 UDP 载荷大小，从而允许回答超过传统五百一十二字节 DNS 限制。这是 DNS 交换中的容量宣告，不是网络路径 MTU 发现协议，也不承诺所有中间设备都会交付相同大小的数据报。理解这一区别，才能准确解释大回答为何仍可能失败。

坏掉的样子

客户端宣告四千零九十六字节，不会强迫服务器发送同样大小的响应。服务器可以实施更小的发送上限；需要的回答放不下时，可以返回 TC，客户端仍需可工作的 TCP 路径。增加客户端数字，不能修复服务器有意采用较小预算的策略。应查看两端实际配置与返回内容，而不是把请求里出现的大数值当成双方已承诺一定使用的大小。

反过来，即使回答没有超过宣告容量，也可能在途中丢失。分片、隧道、包过滤和本地网络约束，与 DNS 参与者宣告的能力是不同因素。客户端若根本没有收到响应，也就可能看不到 TC 提示。载荷配置需要按互通性验证，不能当作越大越好的统一性能参数。一次超时无法仅凭宣告值就归因于某一台服务器或某个固定网络环节。

EDNS 还承载不能当作普通缓存记录解释的信息。OPT 是描述本次交换的伪记录，其字段编码载荷容量、版本、扩展响应码和标志；外形对应 TTL 的字段，并不是普通记录寿命。DNSSEC OK 标志 DO 用于请求相关 DNSSEC 数据，却不证明任何一方完成了验证。诊断工具若丢弃这些元信息，可能把不同故障简化成相同空回答。

快速验证

将脚本保存为 check-edns.py，准备 Docker 后执行 python3 check-edns.py。固定 BIND 9.18.49 权威运行在隔离回环网络，明确把 edns-udp-size 和 max-udp-size 都设为一千二百三十二。区域中分别准备四条和八条 TXT 的记录集，以便独立观察容量与截断。实验不依赖公网默认值，也不修改现有解析器的载荷策略：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
import dns.flags
records='\n'.join(f'{name} 30 IN TXT "{i}-'+('x'*200)+'"' for name,count in [('medium',4),('large',8)] for i in range(count))
def ask(name,payload=None,version=0,flags=0):
 q=dns.message.make_query(name+'.lab.test.','TXT',use_edns=False)
 if payload is not None:q.use_edns(edns=version,ednsflags=flags,payload=payload)
 return dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
def description(response):return {'wire_bytes':len(response.to_wire()),'TC':bool(response.flags&dns.flags.TC),
 'rcode':dns.rcode.to_text(response.rcode()),'EDNS_version':response.edns,'advertised_payload':response.payload,
 'DO':bool(response.ednsflags&dns.flags.DO),'AD':bool(response.flags&dns.flags.AD),'answer_records':sum(len(rr) for rr in response.answer)}
with lab(records,extra='edns-udp-size 1232; max-udp-size 1232;') as (_,update,cache,queries):
 classic=ask('medium');extended=ask('medium',1232);capped=ask('large',4096);do=ask('medium',1232,flags=dns.flags.DO);version=ask('medium',1232,version=1)
 assert classic.flags&dns.flags.TC and len(classic.to_wire())<=512 and classic.edns==-1
 assert not extended.flags&dns.flags.TC and 512<len(extended.to_wire())<=1232 and len(values(extended,'TXT'))==4
 assert extended.edns==0 and extended.opt is not None
 assert capped.flags&dns.flags.TC and len(capped.to_wire())<=1232
 assert do.ednsflags&dns.flags.DO and not do.flags&dns.flags.AD
 assert not any(rr.rdtype==dns.rdatatype.RRSIG for rr in do.answer)
 assert version.rcode()==dns.rcode.BADVERS and version.edns==0
 full=dns.query.tcp(dns.message.make_query('large.lab.test.','TXT'),'127.0.0.1',port=1053,timeout=2)
 assert len(values(full,'TXT'))==8 and len(full.to_wire())>1232
 print(json.dumps({'without_EDNS':description(classic),'EDNS_1232':description(extended),'client_4096_server_1232':description(capped),
 'DO_on_unsigned_zone':description(do),'unsupported_version':description(version),'TCP_full':description(full)},sort_keys=True))
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

不使用 EDNS 时，中等集合查询得到四百六十三字节的截断回答，只包含两条 TXT；宣告一千二百三十二字节后，四条完整记录以九百零四字节返回，TC 清除。脚本检查记录数量、消息长度和 EDNS 存在，证明这个具体回答跨过传统限制，同时仍在所选 UDP 预算内。它不是只看查询成功，就假定完整集合已经到达。

对于更大集合，客户端宣告四千零九十六，但服务器仍限制在一千二百三十二。实测响应只有四十三字节，设置 TC，没有回答记录；随后 TCP 查询取得全部八条，共一千七百五十二字节。截断回答不一定填满允许的缓冲区，记录分组和响应构造可能产生很短的“还需要完整交换”信号。因此响应短也不能直接等同于完整数据很少。

程序还对这个未签名区域发出带 DO 的查询。回答保留 DO，却没有 RRSIG，也没有表示认证数据的 AD 标志。这符合预期：请求 DNSSEC 数据不会凭空产生签名或信任链。实验分别记录各标志，不把出现 DO 的交换称为验证成功。需要判断认证状态时，应检查实际验证路径，而不是只找到了某个听起来与安全有关的位。

最后，查询宣告 EDNS 版本一，服务器返回 BADVERS，并指示支持版本零。库从完整消息中解码扩展响应码。这个失败对照将不支持的扩展版本，与名称不存在或普通成功空回答区分开，也说明解释扩展相关错误时应保留 OPT。仅查看基础响应头的一部分，可能无法还原服务器真正表达的错误种类。

测量实际交换，不假定统一默认值

记录客户端真实宣告、服务器配置、响应大小、标志和传输方式。不同软件版本和运维策略可能采用不同载荷值，一千二百三十二或四千零九十六都不是标准保证的统一默认。本例的较小值是明确实验配置。回环结果没有测量分片、远端路径 MTU 或公共解析性能，不能把局部可交付性直接外推到所有客户端网络。

诊断大回答失败时，通过同一预期端点比较小查询、较大 EDNS 查询和完整 TCP 查询。区分错误类别：TC 表示还需取得完整数据，BADVERS 表示扩展版本不一致，超时则不能直接指出哪一环丢包。保留足够响应信息，避免把这些不同故障压成“DNS 挂了”。只有分类准确，下一步检查的配置和网络路径才有明确对象。

使用部署实现支持的大小与重试策略，再从重要客户端网络验证。即使大多数观察到的回答都能放入 UDP，也应保留 TCP 访问。EDNS 改善扩展能力，并可能减少部分截断重试，但完整交付仍依赖传输行为、服务器限制和客户端对实际回答的处理。选择值之后，应通过真实结果确认效果，而不是只以配置项存在作为完成依据。

来源

RFC 6891 extension mechanisms for DNS，OPT、载荷容量宣告、扩展错误与 EDNS 版本处理，已核验 2026-09-12。
RFC 7766 DNS over TCP，TCP 仍然是必需的 DNS 传输方式，已核验 2026-09-12。
BIND 9.18.49 reference，edns-udp-size 与 max-udp-size 配置，已核验 2026-09-12。

HTTP/2 消除 HTTP 响应顺序阻塞

Tue, 15 Sep 2026 00:00:00 +0000

这里的“消除队头阻塞”，指解除同一条连接上的 HTTP 响应顺序约束，而不是消除 TCP 队头阻塞。较晚发起的响应可以在较早的处理函数仍然等待时完成，但共享的传输容量、连接级流控和应用瓶颈，依然可能把不同流的进度关联起来。先说明这一层边界，才能区分应用协议的顺序约束与底层传输等待。

分清两种排队

HTTP/1.1 本来就支持持久连接，并非一个请求必须新建一条连接。多个请求可以顺序复用套接字；流水线还允许同时存在多个未完成请求，服务器也可以并行处理安全方法，但同一条连接上的响应必须按照请求顺序发送。因此，第一份响应过慢，会延迟后续响应的交付。客户端经常通过多开连接缓解这个限制。

HTTP/2 给帧关联流标识，在同一条连接上交错传递消息。服务器可以发送已经准备好的响应，不必先完成另一份无关响应。这是 HTTP 层的独立推进能力，不代表每个处理函数获得独占处理器、数据库、带宽或无限调度机会，也不意味着应用的共享资源自动变成互不影响。

TCP 仍然提供一个有序字节流。某段字节缺失时，后面已经收到的字节可能必须等待补齐缺口，才能交付应用，其中也可能包含其他 HTTP/2 流的帧。此前已经交付的字节并不会被收回。QUIC 则在每条流内保持有序，不要求不同流之间统一排序；不能把它解释成普通流数据可以任意乱序交付，也不能据此忽略共享的拥塞控制和流控预算。

并发仍然受到预算约束

对端通过 SETTINGS_MAX_CONCURRENT_STREAMS 限制活动流数量。DATA 帧还同时消耗流级和连接级的流控额度。每条流拥有单独窗口，不等于无限独立：连接额度耗尽时，其他流的 DATA 也可能停住。接收方如何消费正文、何时更新窗口，以及共享工作池、锁和上游连接是否紧张，都会改变实际推进情况。

应检查所测那一跳真正协商出的协议。浏览器到代理使用 HTTP/2，不能证明代理到源站也是如此；TLS 握手成功也不足以证明使用了 HTTP/2。Go 配置自定义 TLS 参数后，可能需要 ForceAttemptHTTP2 才会尝试 HTTP/2，但最终证据仍是响应协议和协商出的 h2，而不是配置字段已经存在。

坏掉的样子

快请求先完成，可能只是客户端另开了一条 TCP 连接；单连接 HTTP/1.1 客户端则可能在请求抵达服务器之前，就已经让它等待。应同时核对服务端接受的连接数量和客户端获取连接的事件，再判断排队发生在哪里。仅凭两条访问日志的结束时间，无法区分这些情况。

增加流并发量，不能修复过载数据库，也不能修复未读数据造成的共享窗口紧张。应记录正文完成情况、活动流、共享资源等待以及逐跳协议。不要把每次慢请求都称为 TCP 队头阻塞，更不要把升级协议直接写成已经实测的页面提速；性能结论需要独立的负载与网络测量支持。

快速验证

保存为 queue_probe.go，使用 Go 1.23 或更新版本运行 go run queue_probe.go。实验分别建立本地 HTTP/1.1 和 HTTP/2 服务，均使用经过验证的 TLS 1.3，每个 transport 最多允许一条 TCP 连接。通道让慢处理函数保持等待，GetConn 事件则确认快请求已经开始尝试获取连接。

package main

import (
 "context"
 "crypto/tls"
 "fmt"
 "io"
 "net"
 "net/http"
 "net/http/httptest"
 "net/http/httptrace"
 "runtime"
 "sync"
 "sync/atomic"
 "time"
)

type connectionKey struct{}

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func exercise(h2 bool) {
 slowEntered, releaseSlow, stop := make(chan struct{}), make(chan struct{}), make(chan struct{})
 var connections atomic.Int64
 var slowPassed atomic.Bool
 var orderMu sync.Mutex
 var order []string
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 if r.URL.Path == "/slow" {
 close(slowEntered)
 select {
 case <-releaseSlow:
 slowPassed.Store(true)
 case <-r.Context().Done():
 return
 case <-stop:
 return
 }
 }
 orderMu.Lock()
 order = append(order, r.URL.Path)
 orderMu.Unlock()
 w.Header().Set("X-Connection-ID", fmt.Sprint(r.Context().Value(connectionKey{})))
 fmt.Fprint(w, r.URL.Path)
 }))
 server.Config.ConnContext = func(ctx context.Context, _ net.Conn) context.Context {
 return context.WithValue(ctx, connectionKey{}, connections.Add(1))
 }
 server.EnableHTTP2 = h2
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()
 defer close(stop)
 config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{TLSClientConfig: config, ForceAttemptHTTP2: h2, MaxConnsPerHost: 1}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 protocol := "HTTP/1.1"
 if h2 {
 protocol = "HTTP/2.0"
 }
 call := func(route string, trace *httptrace.ClientTrace) string {
 request, err := http.NewRequest(http.MethodGet, server.URL+route, nil)
 must(err)
 if trace != nil {
 request = request.WithContext(httptrace.WithClientTrace(request.Context(), trace))
 }
 response, err := client.Do(request)
 must(err)
 body, readError := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(readError)
 must(closeError)
 check(response.StatusCode == 200 && response.Proto == protocol, "wrong HTTP response or protocol")
 check(response.Header.Get("X-Connection-ID") == "1", "requests must share the first TCP connection")
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
 if h2 {
 check(response.TLS.NegotiatedProtocol == "h2", "HTTP/2 must be negotiated")
 }
 return string(body)
 }
 slowDone, fastDone := make(chan string, 1), make(chan string, 1)
 go func() { slowDone <- call("/slow", nil) }()
 <-slowEntered
 fastAttempted := make(chan struct{}, 1)
 trace := &httptrace.ClientTrace{GetConn: func(string) {
 select {
 case fastAttempted <- struct{}{}:
 default:
 }
 }}
 go func() { fastDone <- call("/fast", trace) }()
 <-fastAttempted
 wantFirst := "/slow"
 if h2 {
 check(<-fastDone == "/fast" && !slowPassed.Load(), "fast stream must finish while slow is gated")
 close(releaseSlow)
 check(<-slowDone == "/slow", "wrong slow response")
 wantFirst = "/fast"
 } else {
 close(releaseSlow)
 check(<-slowDone == "/slow" && <-fastDone == "/fast", "wrong sequential responses")
 }
 orderMu.Lock()
 defer orderMu.Unlock()
 check(len(order) == 2 && order[0] == wantFirst && order[1] != wantFirst, "wrong handler response order")
 check(connections.Load() == 1, "fixture must use exactly one TCP connection")
 fmt.Println(protocol, order, "one TCP connection")
}

func main() {
 exercise(false)
 exercise(true)
 fmt.Println("gated ordering test; no packet-loss or speedup measurement")
 fmt.Println(runtime.Version())
}

HTTP/1.1 输出顺序为 [/slow /fast]，HTTP/2 则为 [/fast /slow]。两组都断言服务端只接受一条 TCP 连接、响应正文完整、HTTP 版本符合预期且证书验证成功。HTTP/2 还核对 h2 协商结果，并确认快响应的正文读完时，慢处理函数尚未获准继续。

对照组严格限定为 Go 不使用流水线的 HTTP/1.1 transport，加上单连接上限；它不能证明所有 HTTP/1.1 服务器都必须串行执行流水线请求。两组释放通道的时机也不同：HTTP/1.1 在快请求开始获取连接后释放，HTTP/2 在快响应完成后释放。因此这是受控的顺序实验，不是公平的延迟性能基准。

已核验的 macOS、Go 1.27.0 运行通过全部断言。每次请求限时两秒，清理时释放等待中的处理函数并关闭本地资源。实验没有注入丢包、耗尽流控窗口、记录浏览器瀑布图或测量吞吐量；前文关于 TCP 与 QUIC 的边界来自规范，不能写成这里已经完成了相应网络实验。

来源

RFC 9112：HTTP/1.1，持久连接与流水线响应顺序，已核验 2026-09-09。
RFC 9113：HTTP/2，多路复用、TCP 边界、流并发和两级流控，已核验 2026-09-09。
RFC 9000：QUIC，流内有序交付与共享传输限制，已核验 2026-09-09。
Go net/http，transport 连接上限与 HTTP/2 配置，已核验 2026-09-09。
Go net/http/httptrace，获取连接事件及其观察边界，已核验 2026-09-09。
Go net/http/httptest，本地 TLS 测试服务与 HTTP/2 设置，已核验 2026-09-09。

协议 · XB 现场笔记

Gossip 收敛需要明确前提

区分传播与状态调和

坏掉的样子

快速验证

延伸阅读

来源

TCP 握手建立序列号空间，不是同步两台机器的时钟

坏掉的样子

快速验证

分别诊断建立过程和有效服务

来源

Well-known 路径提供的是发现约定

按具体后缀的规范实现

坏掉的样子

快速验证

来源

UDP 回答被截断时，DNS 需要可工作的 TCP 路径

坏掉的样子

快速验证

分开诊断截断与连接失败

延伸阅读

来源

IPv6 先用 ICMPv6 解析邻居，TCP 才能正常通信

坏掉的样子

快速验证

区分邻居发现、地址配置和身份验证

来源

UDP 保留数据报边界，恢复和时效由应用负责

坏掉的样子

快速验证

有意识地补上所需语义

来源

EDNS 宣告 UDP 容量，不保证沿途网络交付

坏掉的样子

快速验证

测量实际交换，不假定统一默认值

延伸阅读

来源

HTTP/2 消除 HTTP 响应顺序阻塞

分清两种排队

并发仍然受到预算约束

坏掉的样子

快速验证

延伸阅读

来源