隐私 · XB 现场笔记

DoT 与 DoH 保护通往已认证解析器的连接

Thu, 07 Oct 2027 00:00:00 +0000

DNS over TLS 和 DNS over HTTPS 保护其端点之间加密连接上的 DNS 流量。对于典型客户端，这条连接终止于选定解析器；解析器能够读取问题与回答，它随后发出的查询还可能使用不同传输。加密这一跳，不会自动加密整个递归过程，也不会让解析器失去记录所处理名称的能力。隐私范围应按真实连接边界说明，而不是笼统称为整个 DNS 都已保密。

坏掉的样子

加密套接字如果没有按预期验证证书，也可能连接到错误端点。应同时验证证书信任链和客户端期望的解析器身份；握手成功本身不能证明这两项检查已启用。失败时悄悄改用其他解析器或明文路径的配置，也会改变隐私契约。需要通过真实调用方了解这些行为，不能只看到配置文件中有一个 TLS 或 HTTPS 地址，就认定所有查询都符合预期。

DoH 使用 HTTPS，但四百四十三端口不会让它在所有网络中都无法识别、无法阻止或完全等同于任意网页流量。目的地址、连接时间和其他元信息仍可观察，TLS 终止点还可以检查明文 HTTP。选择解析器和传输策略时，应考虑这些边界，不能假定 HTTPS URL 会消除所有与 DNS 活动有关的信息暴露，也不能由加密推导解析器不会保存日志。

两种协议的消息边界也不同。DoT 通常使用八百五十三端口，在 TLS 内携带具有两字节 TCP 长度前缀的 DNS 消息。DoH 通常使用四百四十三端口上的 HTTPS 端点。标准 DoH 使用 application/dns-message 传递 DNS 线格式：POST 放在正文，GET 使用经 base64url 编码的 dns 参数。它不是任意 JSON 接口只要套上 HTTPS 就符合标准。

快速验证

将脚本保存为 check-encrypted-dns.py，准备 Docker 后执行 python3 check-encrypted-dns.py。固定 BIND 9.18.49 环境通过其 TLS 和 HTTP/2 库支持两种传输。脚本创建一次性证书，成功探测时显式信任它，并使用隔离回环端口八千五百三十一和八千四百四十三。实验不会向宿主系统安装新信任锚，生成的私钥也不作为文章内容输出：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
import socket,ssl,struct
def exact(stream,count):
 data=b''
 while len(data)<count:
 more=stream.recv(count-len(data));assert more,'unexpected EOF';data+=more
 return data
with TemporaryDirectory(prefix='xbcatm-dot-') as directory:
 root=Path(directory);certificate=root/'certificate.pem';key=root/'key.pem'
 run('openssl','req','-x509','-newkey','rsa:2048','-nodes','-days','2','-subj','/CN=resolver.lab.test',
 '-addext','subjectAltName=DNS:resolver.lab.test,IP:127.0.0.1','-keyout',str(key),'-out',str(certificate))
 zone=root/'zone';zone.write_text('$ORIGIN lab.test.\n$TTL 30\n@ IN SOA ns.lab.test. hostmaster.lab.test. (1 60 60 3600 30)\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\nservice IN A 127.0.0.2\n')
 config=f'''tls local-tls {{ key-file "{key}"; cert-file "{certificate}"; }};
http local-http {{ endpoints {{ "/dns-query"; }}; }};
options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}};
listen-on port 8531 tls local-tls {{127.0.0.1;}};
listen-on port 8443 tls local-tls http local-http {{127.0.0.1;}};
listen-on-v6 {{none;}}; recursion no; dnssec-validation no; notify no;
pid-file "{root}/named.pid"; session-keyfile none; max-cache-size 8m; }};
controls {{}}; zone "lab.test" {{ type primary; file "{zone}"; }};
'''
 with named_process(root,config):
 context=ssl.create_default_context(cafile=str(certificate));context.set_alpn_protocols(['dot'])
 with socket.create_connection(('127.0.0.1',8531),timeout=2) as raw,context.wrap_socket(raw,server_hostname='resolver.lab.test') as stream:
 q=dns.message.make_query('service.lab.test.','A');wire=q.to_wire();stream.sendall(struct.pack('!H',len(wire))+wire)
 count=struct.unpack('!H',exact(stream,2))[0];response=dns.message.from_wire(exact(stream,count))
 assert response.id==q.id and values(response)==['127.0.0.2'];tls_version=stream.version();alpn=stream.selected_alpn_protocol()
 failures={}
 for name,ctx,hostname in [('untrusted',ssl.create_default_context(),'resolver.lab.test'),('wrong_name',context,'different.lab.test')]:
 try:
 with socket.create_connection(('127.0.0.1',8531),timeout=2) as raw,ctx.wrap_socket(raw,server_hostname=hostname):pass
 raise AssertionError('certificate validation unexpectedly succeeded')
 except ssl.SSLCertVerificationError as error:failures[name]=error.verify_code
 https={}
 for mode in ('https-get','https-post'):
 output=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+'+mode,'+tls-ca='+str(certificate),
 '+tls-hostname=resolver.lab.test','+short','+tries=1','+time=2').stdout
 assert output.strip()=='127.0.0.2',output;https[mode]=output.strip()
 doh_rejections={}
 for label,verification in [('untrusted',['+tls-ca','+tls-hostname=resolver.lab.test']),
 ('wrong_name',['+tls-ca='+str(certificate),'+tls-hostname=different.lab.test'])]:
 rejected=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+https-get',*verification,'+short','+tries=1','+time=2',check=False)
 diagnostic=rejected.stdout+rejected.stderr
 assert 'TLS peer certificate verification' in diagnostic and 'failed:' in diagnostic,(label,diagnostic)
 assert not re.search(r'^127\.0\.0\.2$',diagnostic,re.M)
 doh_rejections[label]={'exit':rejected.returncode,'diagnostic':diagnostic.strip(),'no_DNS_answer':True}
 wrong_path=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+https=/wrong',
 '+tls-ca='+str(certificate),'+tls-hostname=resolver.lab.test','+tries=1','+time=2',check=False)
 assert wrong_path.returncode!=0
 print(json.dumps({'DoT':{'answer':values(response),'TLS_version':tls_version,'ALPN':alpn},'certificate_rejections':failures,
 'DoH_verified_TLS':https,'DoH_certificate_rejections':doh_rejections,'wrong_DoH_path_exit':wrong_path.returncode,
 'wrong_DoH_path_diagnostic':wrong_path.stdout+wrong_path.stderr},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)

Python DoT 客户端认证 resolver.lab.test，实测协商 TLS 1.3 与 ALPN dot，再发送具有长度前缀的 DNS 问题。它读取完整响应，核对消息标识，取得 service.lab.test 的 A 地址 127.0.0.2。连接地址使用回环，而期望 TLS 主机名独立指定，使端点位置与认证身份保持清晰，不会因为直接连接某个 IP 就自动跳过名称检查。

两个 DoT 对照都无法通过证书验证：一个只使用系统信任库，没有加入一次性证书；另一个虽然信任证书，却要求不同主机名。这分别验证信任与名称检查。程序捕获明确的证书验证异常，而不是把任意套接字故障都当成“证书检查有效”的证据。只有失败原因与测试条件相符，负向案例才真正证明预期边界。

DoH 部分使用 dig，对 /dns-query 分别进行 HTTPS GET 与 POST，并明确设置 CA 和主机名验证。两者都返回 127.0.0.2。不可信证书和错误名称对照会输出证书校验失败且没有 DNS 回答，但这个版本的退出码仍为零，因此断言检查诊断与回答，不能只依赖退出码。使用有效信任设置请求 /wrong 也失败，说明经过认证的 HTTPS 仍需要正确端点路径。

错误路径诊断表示交换失败，不是 NXDOMAIN，也不能证明 service.lab.test 消失。本例没有从该诊断提取具体 HTTP 状态，而是保留传输或端点失败，与完整 DNS 响应携带 DNS 状态码之间的区别。不能把通用命令失败当成权威否定回答，否则会把修复端点配置的问题误导成反复修改域名记录。

明确解析器与引导配置

客户端连接加密解析器前，需要先知道它的地址。部署可以提供引导地址或其他文档规定的发现路径。本例直接给出回环地址，避免依赖同一解析器形成循环。生产中应验证实际客户端如何处理引导、证书续期、端点变化和连接失败。加密链路建立之前的发现过程，以及失败后的处理方式，都属于完整行为契约的一部分。

确认应用查询实际经过已配置的加密连接。其他进程可能使用系统解析器、另一套浏览器配置或现有缓存。一次成功 DoH 命令只证明这条命令的路径，不代表整机策略已经生效。应观察目标应用和它们的失败行为，再说明哪些名称查询具有相同传输保护。否则局部探测成功，可能掩盖真正业务仍走另一条路径的事实。

最后，DNSSEC 与加密 DNS 处理不同属性。DNSSEC 可以沿信任链认证签名数据，TLS 则保护并认证所选传输端点，两者不会自动提供对方保证。服务契约需要时可以同时使用，但证书验证、实际加密查询、解析器信任和 DNS 数据验证，应保留各自证据。按真实机制说明保护范围，才能避免把一种成功扩大成全部安全属性都已成立。

来源

RFC 7858 DNS over TLS，TLS 传输、专用端口与连接消息边界，已核验 2026-09-12。
RFC 8484 DNS over HTTPS，DoH GET、POST 映射与 application/dns-message，已核验 2026-09-12。
BIND 9.18.49 tools，dig 加密传输与显式证书验证，已核验 2026-09-12。

顺序标识会透露分配规律

Sat, 29 May 2027 00:00:00 +0000

顺序标识让相邻的值很容易被猜到。看到第四千号订单，观察者就知道可以从附近的编号继续探测；持续收集编号，也可能看出分配活动的大致变化。但这不代表系统恰好有四千张订单，不代表每个编号都对应成功购买，也不代表最大编号最后提交。想得出这些结论，还需要序列本身没有记录的业务事实。

坏掉的样子

PostgreSQL 序列取值不会跟随普通事务回滚而退回。一次最终放弃的插入，也可能永久消耗一个号码。删除记录、缓存预留区间、显式修改序列以及多个并发写者，都会进一步拉开计数器与当前行数的距离。因此，用最大编号充当客户数或销售数量，即使没有攻击者参与，也会生成错误的经营报表。号码可以提供线索，却不能直接当作精确统计结果。

分配顺序同样不等于提交顺序。事务甲可能先取得较小编号，随后停在那里；事务乙取得较大编号后，反而先完成提交。如果消费者把递增主键当作完整的已提交事件流，就可能先处理较大的行并推进位置，而较小的行此时还不可见。等它后来提交，消费者已经越过了它。数字主键不能直接替代变更捕获位置，也不能证明所有业务事件的先后关系。

随机标识让逐个递增枚举变得困难，却不会自动实施访问控制。UUID 仍可能出现在日志、分享链接或其他接口返回值里，拿到它的人仍须通过对象权限检查。第四版 UUID 使用随机位；第七版在开头放置毫秒时间戳，目标之一是支持时间排序，因此不能把它的前缀说成随机位，也不能把其中的时间当作数据库提交时间。降低可猜测性与确认谁有权读取，是两项不同职责。

快速验证

准备一个可丢弃的 PostgreSQL 18 数据库，打开两个管理员 psql 会话，分别称为甲和乙。这里要求第十八版，是因为使用了 uuidv7() 以及第七版 UUID 的时间提取；信息提取函数本身在第十七版已经存在。确认实验模式名和两个角色名尚未使用，初始保持自动提交，隔离级别采用通常的读已提交。先在乙中建立数据：

CREATE SCHEMA article_ids;
CREATE ROLE article_id_alice NOLOGIN;
CREATE ROLE article_id_bob NOLOGIN;
SET search_path=article_ids,public;
CREATE TABLE objects (
 id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
 public_id uuid NOT NULL DEFAULT gen_random_uuid() UNIQUE,
 owner text NOT NULL,
 label text NOT NULL
);

在甲中取出第一个编号，但暂时不要提交：

SET search_path=article_ids,public;
BEGIN;
INSERT INTO objects (owner,label) VALUES ('article_id_alice','allocated first') RETURNING id;

然后在乙中插入第二行并观察当前可见数据：

INSERT INTO objects (owner,label) VALUES ('article_id_bob','committed first') RETURNING id;
SELECT array_agg(id ORDER BY id) FROM objects;

乙返回编号二，此时只能看到 {2}。甲明明已经取得编号一，但那一行尚未提交，乙不能读取。这直接区分了“先拿到号码”与“先成为其他事务可见的数据”。现在回到甲完成提交：

COMMIT;

接着在乙中制造一个回滚缺口，并检查两种 UUID：

SELECT array_agg(id ORDER BY id) FROM objects;
BEGIN;
INSERT INTO objects (owner,label) VALUES ('article_id_alice','rolled back') RETURNING id;
ROLLBACK;
INSERT INTO objects (owner,label) VALUES ('article_id_alice','after gap') RETURNING id;
SELECT max(id),count(*) FROM objects;
SELECT bool_and(uuid_extract_version(public_id)=4) FROM objects;
WITH sample AS MATERIALIZED (SELECT uuidv7() AS value)
SELECT uuid_extract_version(value),uuid_extract_timestamp(value) IS NOT NULL FROM sample;

结果依次包含 {1,2}、随后放弃的编号三、新插入的编号四，以及 4|3。最后一项说明最大编号是四，真实行数却只有三。UUID 检查确认表中默认值属于第四版，第七版示例返回 7|t，说明版本为七且可以提取时间戳。每次生成的具体 UUID 都会变化，不应把某次随机值写成固定预期，也不应从这个小样本推导碰撞概率。

仍在乙中，把鲍勃的公开 UUID 保存为客户端变量。在尚未设置行策略时，切换成爱丽丝进行查询：

SELECT public_id AS bob_id FROM objects WHERE owner='article_id_bob' \gset
GRANT USAGE ON SCHEMA article_ids TO article_id_alice,article_id_bob;
GRANT SELECT ON objects TO article_id_alice,article_id_bob;
SET ROLE article_id_alice;
SELECT count(*) FROM objects WHERE public_id=:'bob_id'::uuid;
RESET ROLE;

爱丽丝得到一条记录，说明知道随机编号后，普通表级读取权限依然允许她访问别人的对象。接着启用按所属角色过滤的策略，再运行相同查找：

ALTER TABLE objects ENABLE ROW LEVEL SECURITY;
CREATE POLICY owner_only ON objects FOR SELECT USING (owner=current_user);
SET ROLE article_id_alice;
SELECT count(*) FROM objects WHERE public_id=:'bob_id'::uuid;
SELECT array_agg(id ORDER BY id) FROM objects;
RESET ROLE;
SET ROLE article_id_bob;
SELECT count(*) FROM objects WHERE public_id=:'bob_id'::uuid;
RESET ROLE;

现在爱丽丝按鲍勃的 UUID 查询得到零条，查看自己的数据只能看到编号一和四；鲍勃查询同一编号则得到一条。结果变化来自真实执行的权限策略，不是因为我们重新生成了 UUID。实验角色既不是表所有者，也不是超级用户；具有绕过行策略权限的角色不适合作为这项检查的观察者。确认甲已提交后，在乙中清理本次创建的对象：

DROP SCHEMA article_ids CASCADE;
DROP ROLE article_id_alice;
DROP ROLE article_id_bob;

分开选择标识与权限方案

内部使用序列、公开使用随机标识，可以同时保留内部连接的便利与较难猜测的 URL，但也会多出唯一索引以及两套编号的维护成本。是否值得，应由具体枚举压力和信息披露要求决定。按时间排列的 UUID 在部分工作负载下有利于插入局部性，同时会暴露时间信息；不能仅凭格式就承诺所有数据库、所有索引都变快。

无论接口接受哪种编号，都应结合已认证的主体与目标对象检查权限，其他查找入口也要遵循同样规则。本实验为了看清效果，把用户对应到数据库角色；实际应用必须建立可信身份上下文，不能直接相信请求者提交的所属用户名。统计数量应查询正确的业务口径；要求跨并发提交不丢事件时，应采用有明确完整性契约的事件位置或复制位置，而不是把主键增长误当作提交日志。

来源

PostgreSQL 18 CREATE SEQUENCE，序列缺口与分配语义，已核验 2026-09-10。
RFC 9562，第四版随机位和第七版时间戳布局，已核验 2026-09-12。
PostgreSQL 18 UUID 函数，实验使用的生成与信息提取函数，已核验 2026-09-12。
PostgreSQL 18 行安全，所属策略与特权角色绕过规则，已核验 2026-09-12。
PostgreSQL 17 UUID 函数，已有提取函数及第七版 UUID 的版本边界，已核验 2026-10-15。

Referrer-Policy 决定发送多少来源地址信息

Wed, 24 Mar 2027 00:00:00 +0000

HTTP 的 Referer 请求头可以告诉接收方，这次请求由哪个页面发起。它保留了历史拼写，与控制来源信息范围的 Referrer-Policy 并不完全同名。根据策略和目标地址，值可能包含源页面的路径与查询参数，也可能只剩来源部分，或者完全省略。现代浏览器的默认行为并不是向每一个外部目标发送完整地址，不能沿用这种错误前提解释所有来源信息泄露。

当前通常采用的默认策略是严格的跨源仅来源策略：同源请求可以发送路径和查询信息，安全级别合适的跨源请求只发送来源，遇到从 HTTPS 到 HTTP 等安全降级则不发送引用来源。主动设置策略，仍有助于让团队审阅明确的预期行为。只暴露来源虽然少于完整地址，但主机名称本身仍然可能带有业务含义，不能未经判断就把来源级信息一概称为无敏感性的统计数据。

区分几种策略的具体选择

不发送引用来源的策略会省略整个请求头，同源策略只对同源目标保留较完整的值，而不安全地址策略会更广泛地披露来源、路径和查询参数，包括一些严格策略本来会抑制的场景。地址片段会从引用来源计算中移除，因此地址栏里的片段不应出现在接收方的 Referer 中。但这并不表示片段对页面脚本或浏览器状态保密，它只是没有通过这个请求头传送。

文档策略可以通过响应头设置，在合适场景下也可以使用名称为 referrer 的 HTML meta 元素。不能把自造的 http-equiv=“Referrer-Policy” 标签当成同等语法。部分元素以及 fetch 请求还支持单次请求自己的引用来源策略，因此单看文档响应头不一定能解释每一个实际请求。观察到不同结果时，应检查请求由什么上下文发起，以及它是否明确指定了自己的策略。

坏掉的样子

应用如果依赖收到完整 Referer 路径，可能在策略收紧或浏览器隐私行为减少信息后突然失效。引用来源并不是可靠的认证凭据，也不能代替明确的应用参数。同样，修改这项策略不会授予读取跨源响应的 CORS 权限，也不会删除已经写入目标地址的访问令牌。它只控制请求中的一种元数据，不能被当成同时处理全部信息流动的开关。

另一个错误是把跨源与跨站混为一谈。同一主机上的不同端口已经属于不同来源，足以改变本例的策略结果。同源请求也仍然可能把敏感路径或查询信息交给该来源上的另一个接口。需要核对每个接收者实际需要什么；当观察到的值与文档看起来采用的默认值不一致时，还要检查重定向链及资源自己的策略，不能只依据域名相似就认定浏览器表现异常。

快速验证

保存脚本为 referrer-policy.py，执行 python3 referrer-policy.py –serve。在打印出的页面地址后追加 ?policy=strict-origin-when-cross-origin&demo=visible#fragment-not-sent 并打开。本次使用 Python 3.14.4 与 Chrome 152，两个临时回环服务分别提供页面和跨源接收端。页面实际请求同源接口与跨源接口，由接口返回自己收到的 Referer 值，结束后按控制键加 C 关闭两个服务。

import json
import sys
from http.server import BaseHTTPRequestHandler, HTTPServer
from threading import Event, Thread
from urllib.parse import parse_qs, urlsplit
from urllib.request import urlopen

policies = {"strict-origin-when-cross-origin", "no-referrer", "same-origin", "unsafe-url"}


class Receiver(BaseHTTPRequestHandler):
 def log_message(self, *args):
 pass

 def do_GET(self):
 body = json.dumps({"referer": self.headers.get("Referer")}).encode()
 self.send_response(200)
 self.send_header("Content-Type", "application/json")
 self.send_header("Content-Length", str(len(body)))
 self.send_header("Access-Control-Allow-Origin", app_origin)
 self.send_header("Cache-Control", "no-store")
 self.end_headers()
 self.wfile.write(body)


class App(Receiver):
 def do_GET(self):
 url = urlsplit(self.path)
 if url.path == "/collect":
 return super().do_GET()
 policy = parse_qs(url.query).get("policy", ["strict-origin-when-cross-origin"])[0]
 assert policy in policies
 body = ("""<!doctype html><meta charset="utf-8"><title>Referrer policy lab</title>
<h1>What did the receiver see?</h1><pre id="result">Running...</pre><script>
const receiver=""" + json.dumps(receiver_origin) + """;
async function run() {
 const same=await (await fetch('/collect')).json();
 const cross=await (await fetch(receiver+'/collect')).json();
 window.labResult={page:location.href,same:same.referer,cross:cross.referer};
 document.getElementById('result').textContent=JSON.stringify(window.labResult,null,2);
}
run().catch(error=>{window.labError=String(error);});
</script>""").encode()
 self.send_response(200)
 self.send_header("Content-Type", "text/html; charset=utf-8")
 self.send_header("Content-Length", str(len(body)))
 self.send_header("Referrer-Policy", policy)
 self.send_header("Cache-Control", "no-store")
 self.end_headers()
 self.wfile.write(body)


receiver = HTTPServer(("127.0.0.1", 0), Receiver)
app = HTTPServer(("127.0.0.1", 0), App)
receiver_origin = f"http://127.0.0.1:{receiver.server_port}"
app_origin = f"http://127.0.0.1:{app.server_port}"
threads = [Thread(target=server.serve_forever, daemon=True) for server in (receiver, app)]
for thread in threads:
 thread.start()
try:
 for policy in sorted(policies):
 with urlopen(app_origin + "/page?policy=" + policy + "&demo=visible", timeout=5) as response:
 assert response.headers["Referrer-Policy"] == policy
 response.read()
 print(json.dumps({"app_url": app_origin + "/page", "wire_policies": sorted(policies)}), flush=True)
 if "--serve" in sys.argv:
 Event().wait()
except KeyboardInterrupt:
 pass
finally:
 for server in (receiver, app):
 server.shutdown()
 server.server_close()
 for thread in threads:
 thread.join(timeout=5)

使用严格默认策略时，同源结果应包含页面路径、策略参数和演示查询值，跨源结果只包含页面来源及结尾斜杠，两者都没有片段。将策略参数改成 no-referrer 后，两个结果都为空；改成 same-origin 后，只保留同源结果；改成 unsafe-url 后，两边都能收到源路径与查询信息。这四种情况均经过实际浏览器验证，不是通过 Python 手工组装请求头来代替浏览器的计算行为。

不带服务参数运行 Python 时，只检查策略响应头，不会验证浏览器怎样计算引用来源。本例使用安全级别相同的本机 HTTP 来源，没有执行 HTTPS 降级、重定向、外部样式表或全部浏览器隐私设置的检查，这些情况需要在真实上下文中另行验证。生产策略选定后，应以接收端实际得到的信息为准，而不是从地址栏猜测请求头；如果敏感值在其他位置继续留存也构成问题，就仍然不应该把它放进地址中。

来源

MDN Referrer-Policy，策略值、当前默认行为与 HTML 集成方式，已核验 2026-09-13。
W3C Referrer Policy，引用来源计算、来源边界与地址过滤，已核验 2026-09-13。

Cache-Control：private 还是 shared

Fri, 23 Oct 2026 00:00:00 +0000

存储范围不是身份系统。Cache-Control: private 要求遵守协议的共享缓存不存储这条响应，却不会教会浏览器识别正文属于哪个应用账户。当一个人退出登录，另一个账户在同一浏览器中登录，然后访问相同网址时，这个区别就会变成实际的数据隔离问题，不能只凭响应头里出现 private 就判定安全。

有资格被缓存不代表能共享

不带字段名参数的 private 允许单用户缓存保存响应，但仍受其他缓存条件约束。浏览器是常见实现，并不是唯一实现。public 则明确允许某些原本可能受到限制的响应进入缓存，例如满足条件的带授权请求响应。已经符合缓存条件的普通响应不一定需要 public；出现 public 也不意味着所有缓存都必须保存它，存储许可和实际是否存储是不同事实。

不带参数的 no-cache 与 no-store 回答的是另一个问题。前者允许存储，但每次复用前必须成功验证；后者禁止私有和共享 HTTP 缓存存储及随后复用该响应。它们都不是加密、访问控制检查，也不承诺清除应用日志或用户之前保存的副本。本文讨论不带字段名参数的形式，不把实现支持较弱的按字段限定形式混进实验。

新鲜度还需要单独判断。错误的个人响应如果按共享键保存，即使只给五秒钟有效期，也可能有五秒钟把数据交给另一个人。缩短 max-age 不能修复身份边界。反过来，s-maxage 只是控制共享缓存的新鲜度，并不是 private 的另一种写法。先决定响应可在哪一层保存，再讨论可直接复用多久，才能避免用性能参数代替安全条件。

坏掉的样子

HTTP 的通用规则不会因为请求里有 Cookie 就自动禁止共享缓存。Authorization 确实有专门的共享缓存限制，但 public 等指令能够明确允许存储。为了提高命中率而添加 public，可能恰好撤掉应用之前依赖的限制。修改指令前应检查实际响应体和认证路径，不能只查看页面看起来是不是一份普通文档。

Vary 细化的是请求匹配条件，不授予存储许可。增加 Vary: Cookie 不会让 private 响应变得可以进入共享缓存。在私有缓存内，它可以区分不同 Cookie 字段，但这仍然只是字段匹配，不是授权判断。假设令牌文本没有变化，而账户权限已经被撤销，仅凭请求字段仍匹配，不能证明当前用户继续有权读取旧内容。

敏感账户数据需要明确的响应策略和账户切换测试，至少覆盖退出登录、同一浏览器配置中切换账户、权限发生变化。诊断记录也不应该包含真实凭据。只在源站检查到正确的 Cache-Control，还不能证明沿途每一个代理都遵守了它，部署后的响应正文与源站访问记录仍是必要证据。

快速验证

准备 Node.js 与 npm；本次实际使用 Node 26.0.0 和 http-cache-semantics 4.2.0。将固定版本安装到临时目录，然后使用 NODE_PATH="$cache_lab/node_modules" node 执行下面的 JavaScript。安装需要网络，实验本身不会发请求；其中的 Cookie 和 Authorization 值均为虚构文本，不对应任何真实账户或令牌。

cache_lab=$(mktemp -d)
npm install --prefix "$cache_lab" --ignore-scripts --no-audit --no-fund --package-lock=false http-cache-semantics@4.2.0

const assert = require("node:assert/strict");
const CachePolicy = require("http-cache-semantics");

const request = {
 url: "https://example.test/account",
 method: "GET",
 headers: { cookie: "account=alpha" },
};
const cases = [
 ["private, max-age=300", [false, false], [true, true]],
 ["public, max-age=300", [true, true], [true, true]],
 ["no-cache, max-age=300", [true, false], [true, false]],
 ["no-store, max-age=300", [false, false], [false, false]],
];
for (const [directive, sharedResult, privateResult] of cases) {
 for (const shared of [true, false]) {
 const policy = new CachePolicy(request, {
 status: 200,
 headers: { "cache-control": directive },
 }, { shared });
 const result = [policy.storable(),
 policy.storable() && policy.satisfiesWithoutRevalidation(request)];
 assert.deepEqual(result, shared ? sharedResult : privateResult);
 console.log(shared ? "shared" : "private", directive, result);
 }
}

const authorized = { ...request, headers: { authorization: "Bearer example" } };
for (const [directive, expected] of [
 ["max-age=300", false], ["public, max-age=300", true],
]) {
 const policy = new CachePolicy(authorized, {
 headers: { "cache-control": directive },
 }, { shared: true });
 assert.equal(policy.storable(), expected);
 console.log("authorized shared:", directive, expected);
}

const otherAccount = { ...request, headers: { cookie: "account=beta" } };
for (const vary of [false, true]) {
 const headers = { "cache-control": "private, max-age=300" };
 if (vary) headers.vary = "Cookie";
 const policy = new CachePolicy(request, { headers }, { shared: false });
 assert.equal(policy.satisfiesWithoutRevalidation(otherAccount), !vary);
 console.log("different cookie, Vary enabled:", vary, "reuse:", !vary);
}

每组结果依次表示“有资格存储”和“无需验证即可复用”。private 在共享模式下得到两项 false，在私有模式下得到两项 true；public 在两种模式中都得到两项 true。no-cache 可以存储但不能直接复用，no-store 则两项都不允许。代码有意先检查存储资格，调用方不能先把禁止存储的条目插入缓存，再希望后续查找逻辑补救这个错误。

Authorization 两项检查说明，明确加入 public 后，共享存储资格从 false 变成 true，但这不证明任何真实个人响应适合公开共享。最后两项只改变虚构 Cookie：没有 Vary 时，私有缓存中的旧条目仍能匹配；启用 Vary 后则不能匹配。这是 private 本身不会隔离应用账户的具体反例，而不是建议仅靠一个 Vary 字段完成安全设计。

本实验验证策略库，不代表已经验证浏览器、CDN 或退出登录实现。生产验收仍应使用两个不同账户，观察真实路径上的源站请求，并断言最终正文属于正确账户。先确定这项验收，再调整新鲜度或统计命中率，才能知道性能改善有没有越过数据边界。

来源

RFC 9111：响应缓存指令，存储范围、授权例外及带字段名参数的形式，已核验 2026-09-07。
MDN：Cache-Control，private、public、no-cache 与 no-store，已核验 2026-09-07。
http-cache-semantics 4.2.0，共享与私有模式、存储检查及请求匹配，已核验 2026-09-07。

隐私 · XB 现场笔记

DoT 与 DoH 保护通往已认证解析器的连接

坏掉的样子

快速验证

明确解析器与引导配置

延伸阅读

来源

顺序标识会透露分配规律

坏掉的样子

快速验证

分开选择标识与权限方案

来源

Referrer-Policy 决定发送多少来源地址信息

区分几种策略的具体选择

坏掉的样子

快速验证

延伸阅读

来源

Cache-Control：private 还是 shared

有资格被缓存不代表能共享

坏掉的样子

快速验证

延伸阅读

来源