TLS · XB 现场笔记

SNI 让一个 IP 承载多个 HTTPS 站点

Mon, 07 Feb 2028 00:00:00 +0000

Server Name Indication（简称 SNI）在 TLS 握手中把目标主机名发给服务器，使同一个 IP 地址能够承载多张证书、多个站点。没有 SNI 时，分配不同地址是一种办法，却不是唯一办法：一张包含多个主体备用名称（SAN）的证书，或覆盖相应名字的通配符证书，也可以供多个站点共用。问题在于先后顺序：在不使用 early data 的完整证书型 HTTPS 握手中，服务器选证书发生在收到标识应用站点的加密 HTTP 请求之前，不能等读到 Host 再为这次握手换证书。

本文关注 nginx 的配置边界：哪个 server 块提供证书，名字没有匹配时采取什么策略，以及诊断命令究竟证明了什么。选中证书、客户端验证身份、把请求送到应用，是三个需要分别检查的决定，不能把其中一项成功当作另外两项也成功。

名字最先报出

客户端在 ClientHello 中携带 SNI，nginx 据此选择 TLS 服务配置。这个扩展使用已有的握手报文，不需要额外发送一次请求来询问站点。不过，把全过程说成“发生在加密之前”并不准确：TLS 1.3 在 ServerHello 之后加密证书报文。这里重要的是名字在证书选择时已经可用，而不是证书或整个握手始终明文传输。

客户端必须发送 SNI，服务器才能在这个阶段按名字选择站点。不带 SNI 时，nginx 从对应监听地址与端口的缺省服务配置开始处理；该配置可能提供证书，也可能拒绝握手。若收到证书，客户端仍需检查信任链以及自己预期的身份。收到一张证书不等于接受它，也不等于已经知道后续请求会进入哪个应用。

用 server_name 匹配

nginx 在相关监听地址和端口的 server_name 条目中匹配 SNI：精确名优先，然后是最长的前置星号通配名、最长的后置星号通配名，最后是配置顺序中第一个匹配的正则表达式。证书和私钥配置可以继承，也可以由多个站点共用；并不存在每个名字必须单独持有一张证书的规则。

把预期主机名、证书 SAN、server_name 规则和应用路由放在同一份清单里。尤其要区分 nginx 的通配符匹配与证书的通配符匹配：两者覆盖范围不同，配置规则匹配成功，并不能证明证书也覆盖这个名字。检查新增站点时应逐项对应，避免只看到 server_name 中有通配符，就推断客户端一定会接受证书。

证书选对也不等于请求一定到对的应用。nginx 还可能在处理 HTTP 请求行和 Host 头时重新选择服务配置。SNI 指向甲站、Host 指向乙站，不会替换已经用于握手的证书；TLS 也不为响应的业务含义背书。应明确哪些跨名字路由是允许的，再分别检查握手选择和应用层路由，不能把证书有效描述成“响应签名正确”，更不能据此认定租户授权已经成立。

把缺省回退控制好

对每个监听地址与端口，用 default_server 明确指定缺省块；没有显式指定时，该监听器的第一个 server 块才是缺省。无 SNI 与无法匹配的 SNI 都需要明确处理策略，不能仅凭文件排列就断言未知名字一定收到第一张证书。显式指定缺省块，也能避免单纯调整配置顺序改变这个选择。

缺省块可以提供合适的证书，也可以通过 nginx 1.19.4 起提供的 ssl_reject_handshake 拒绝 TLS 握手。中性 HTTP 落地页或 return 444 则是后续 HTTP 阶段的行为；如果客户端因证书不匹配而停止握手，就不会继续发送请求去看到那一页。这两种处理层次不能互相代替。未知名字和完全不带 SNI 的情况也应分别检查，按事先选定的策略解释结果。

坏掉的样子

新增主机名却收到意外证书时，先检查监听地址、配置引用、server_name 拼写和证书分配。nginx -T 成功只表示本次读取的配置通过检查并被打印出来，不能证明运行中的工作进程已经加载同一版本。下面经过筛选和截断的片段还可能遗漏相关指令或错误，不能当作完整配置。应结合未截断输出与重载结果判断，再定位名字匹配问题；不要把配置文件存在误当作变更已经生效。

没有 Encrypted Client Hello（ECH）时，普通 ClientHello 中的 SNI 对网络观察者可见，单独使用 TLS 1.3 不会隐藏它。成功协商 ECH 可以保护内部 ClientHello，包括目标主机名，但不意味着所有流量特征都被隐藏。本文没有测量某个站点的 ECH 部署或隐私效果，也不依据证书有效与否推断这些能力已经启用。

TLS 名称先于 HTTP 到达。静态机制示意；未建立 TLS 连接或运行文章命令。

快速验证

以下是未在此执行的诊断模板，不是已验证的部署示例。使用前须把文档示例地址和主机名替换为自己获准测试的环境中的目标：

nginx -T 2>&1 | grep -B2 -A4 'server_name\|ssl_certificate ' | head -n 40
openssl s_client -connect 203.0.113.10:443 -servername shop.example.com </dev/null 2>/dev/null | openssl x509 -noout -subject -issuer
openssl s_client -connect 203.0.113.10:443 -servername unknown.invalid </dev/null 2>/dev/null | openssl x509 -noout -subject

这些管道打印证书的 subject 或 issuer 字段，既不显示 SAN 覆盖范围，也不能据此认定主机名与信任链验证通过。命令还隐藏了诊断信息；s_client 通常会在验证出错后继续，除非另行配置。没有输出可能来自连接失败、握手失败或下游证书解析失败，不能单独证明服务器按策略拒绝了未知名字。

应依据所安装 OpenSSL 版本的验证选项，另外核对 SAN 身份、信任链、有效期以及验证失败的处理。在自己的授权环境里，分别确认已知名字的证书选择、未知名字和无 SNI 的策略，以及最终应用路由。不同名字共用覆盖其身份的证书是合理结果；未知名字可以收到配置指定的缺省证书，也可以被拒绝。本文没有执行这些检查，更没有把模板输出当作已经通过的断言。

来源

以下官方资料于 2026-10-18 访问，用于核对上述表述，不代表运行验证。

nginx HTTPS 服务配置，共享 SAN 或通配符证书及证书配置继承，已核验 2026-10-18。
nginx 名字匹配与服务配置选择阶段，名称匹配优先级及 TLS、请求行、Host 的不同选择阶段，已核验 2026-10-18。
nginx 请求处理与缺省配置，监听地址与端口范围内的显式缺省配置及后续 HTTP 请求处理，已核验 2026-10-18。
nginx 握手拒绝指令，TLS 握手拒绝策略及 nginx 1.19.4 引入该指令的版本边界，已核验 2026-10-18。
nginx 命令行参数，配置检查与打印操作和独立的重载操作之间的区别，已核验 2026-10-18。
RFC 6066 第 3 节：服务名称指示，ClientHello 中的服务名称指示及未识别名称的处理，已核验 2026-10-18。
RFC 8446：TLS 1.3 握手，握手消息加密及完整握手与早期数据的适用边界，已核验 2026-10-18。
RFC 9849：加密客户端问候，内部 ClientHello 名称保护及仍可能暴露的信息，已核验 2026-10-18。
OpenSSL s_client 诊断与验证，SNI 选择与验证错误处理选项，已核验 2026-10-18。
OpenSSL x509 证书信息输出，subject、issuer、SAN 信息查看与身份及信任链验证的区别，已核验 2026-10-18。
OpenSSL 验证选项，主机名或 IP 身份验证与信任策略控制，已核验 2026-10-18。

OCSP 装订按客户端策略交付状态证据

Mon, 06 Dec 2027 00:00:00 +0000

OCSP 装订让 TLS 服务端在握手过程中发送签名的证书状态响应。对于原本需要在线查询 OCSP 的客户端，它可能省去一次单独请求。收益取决于客户端的吊销策略：并非每个浏览器每次连接都查询 OCSP，也不是每个证书颁发机构仍然提供这种服务。装订只是传递状态证据的一种方式，不能代替完整证书验证，更不能把“握手收到了一段数据”当作信任已经成立。

传递证据并不转移信任责任

服务器从颁发机构或获得授权的应答方取回响应，并为适用握手缓存它。客户端仍须检查响应签名、签名者权限、证书标识、状态和可接受时间范围。服务器把响应附在握手里，不会让它自动可信。OCSP 的 good 状态也不能证明主机名匹配、证书仍在有效期内，或整条证书链已经连接到受信任根。这些验证职责必须分别保留。

线上表示还取决于 TLS 版本。TLS 1.2 使用状态请求扩展与 CertificateStatus 握手消息；TLS 1.3 则把响应放在对应 Certificate 条目的扩展中。把两者统称为 certificate_status 扩展，会混淆实际协议结构。普通网络攻击者不能随意剥离受认证握手消息，同时仍让 Finished 校验成功。讨论吊销检查被绕过时，应明确攻击能力和客户端策略，而不是虚构一种可以无痕删除握手数据的能力。

先核对支持范围，再决定启用

运维者首先需要确认颁发方提供可用响应，并检查服务端及客户端是否支持预期策略。Let’s Encrypt 已在二〇二五年八月六日结束 OCSP 服务，改用证书吊销列表。因此，对于没有 OCSP 支持的证书，缺少装订不自动意味着刷新任务损坏。应查当前颁发方文档，而不是把“所有站点都应该打开装订”当成不需要前提的清单步骤。

对于仍提供 OCSP 的颁发方，应在缓存过期之前留出刷新余量，并覆盖证书轮换。需要检查响应对应哪张证书、新鲜度及边缘实际交付内容，而不只是缓存是否存在。不同服务进程可能持有不同结果；控制面抓取成功也不证明全部已更新。缓存中的 good 响应仍可能在可接受窗口内，而较新的吊销信息已经出现，因此装订不能提供瞬时吊销知识。

坏掉的样子

缺失、过期、无效和已吊销是不同状态。客户端可能拒绝连接、查询其他机制，或应用明确的软失败策略。缺少响应不保证触发直连颁发机构，已经提供但无效的响应也不保证仅仅增加延迟。描述时应说明具体校验器的行为，不要承诺所有握手都会继续，更不能把“没有报错”直接解释为吊销状态已经得到确认。

TLS Feature 扩展通常被称为 Must-Staple；支持并执行它的客户端，可以要求服务器提供状态证据，但它不能强迫不支持的客户端执行同样检查。依赖这个要求之前，服务端需要处理冷启动、续期及应答服务中断。服务中断并不会立刻使仍在可接受窗口内的缓存失效，但剩余新鲜度窗口会限制它还能保护多久。是否失败必须结合实际缓存与客户端规则判断。

时钟异常也会改变接受结果。thisUpdate 和 nextUpdate 描述状态时间，producedAt 描述响应生成时间；真实校验器还会采用自己的最大年龄和时钟容差规则，有些协议响应也可以不带 nextUpdate。这些实现差异应明确写出。程序里一个名叫“签名正确”的布尔值，只是输入假设，不能作为真实密码学验签的证据。

OCSP 证据交付：机制与证据边界。

快速验证

保存为 stapling_policy.py，使用 Python 3.9 或更新版本执行 python3 stapling_policy.py。独立模型使用虚构的验证后输入，明确要求两个时间边界，并对已经提供但无效的证据采取严格拒绝策略。它不访问网络，不解析证书，不实现签名算法，也不运行 TLS 服务或浏览器，因此不能用于证明任何真实证书可信。

"""Post-verification policy model. Booleans are fixtures, not cryptography."""
from dataclasses import dataclass, replace
from datetime import datetime, timedelta, timezone

@dataclass(frozen=True)
class Response:
 cert_id: str
 status: str
 signature_ok: bool
 signer_authorized: bool
 this_update: datetime
 next_update: datetime

def decide(response, now, cert_id, require_staple):
 if response is None:
 return "reject-missing" if require_staple else "consult-other-policy"
 if response.cert_id != cert_id:
 return "reject-wrong-certificate"
 if not (response.signature_ok and response.signer_authorized):
 return "reject-untrusted"
 if not response.this_update <= now < response.next_update:
 return "reject-time"
 if response.status == "revoked":
 return "reject-revoked"
 if response.status != "good":
 return "reject-unknown"
 return "status-good-only"

now = datetime(2026, 10, 15, 12, tzinfo=timezone.utc)
good = Response("synthetic-cert", "good", True, True,
 now - timedelta(hours=1), now + timedelta(hours=1))
cases = [
 (good, False, "status-good-only"),
 (None, False, "consult-other-policy"),
 (None, True, "reject-missing"),
 (replace(good, status="revoked"), False, "reject-revoked"),
 (replace(good, status="unknown"), False, "reject-unknown"),
 (replace(good, signature_ok=False), False, "reject-untrusted"),
 (replace(good, signer_authorized=False), False, "reject-untrusted"),
 (replace(good, cert_id="another-cert"), False, "reject-wrong-certificate"),
 (replace(good, next_update=now), False, "reject-time"),
 (replace(good, this_update=now + timedelta(minutes=1)), False, "reject-time"),
]
for response, required, expected in cases:
 actual = decide(response, now, "synthetic-cert", required)
 assert actual == expected, (actual, expected)
 print(actual)
assert decide(good, now + timedelta(hours=2), "synthetic-cert", False) == "reject-time"
print("PASS: 11 explicit policy cases; no certificate or TLS validation performed")

十一项检查区分可接受状态、缺失、已吊销、未知状态、错误证书、未授权签名者、错误签名、过期和未来日期。最后把观察时间向后移动，验证这个模型的严格时间区间。可选装订缺失时返回 consult-other-policy，它不是接受结论，也不表示已经向外查询过任何服务。这一分支有意保留后续策略决定。

成功结果特意命名为 status-good-only，提醒读者其余证书验证仍在函数之外。保留的 Python 3.12.14 记录报告这些精确示例通过运行；本次源码审阅没有重跑。必须启用断言，不使用 -O 或 PYTHONOPTIMIZE。真正线上验证仍须核对颁发方、签名响应、TLS 交付、客户端策略、证书轮换和刷新失败，不能从模型分支推导整个部署已经可靠。

来源

RFC 6960，响应授权、证书绑定、状态和时间语义，已核验 2026-10-15。
RFC 6066，TLS 1.2 状态请求与证书状态消息，已核验 2026-10-15。
RFC 8446，TLS 1.3 证书条目状态扩展和握手认证，已核验 2026-10-15。
RFC 7633，TLS Feature 要求与客户端支持，已核验 2026-10-15。
Let’s Encrypt OCSP retirement，颁发方在二〇二五年八月六日结束 OCSP 服务，已核验 2026-10-15。
Python assert 语句，优化模式会移除断言及其表达式，已核验 2026-10-18。

证书透明度让签发可被观察

Wed, 03 Nov 2027 00:00:00 +0000

证书透明度 CT 让公开 TLS 证书的签发变得可观察，但它不判断域名持有者是否授权了某次签发，不代替证书链验证，也不保证世界上所有证书都已经进入日志。一张错误签发的证书也可能带有有效的透明度证据。真正的价值是留下公共线索，供监控方和受影响的持有者调查。

承诺不等于包含证明

SCT 即签名证书时间戳，是日志对已提交证书或预证书作出的签名承诺：在最大合并延迟 MMD 以内把它纳入树中。SCT 不是另一张证书，也不是证明条目已经存在于树中的包含证明。它的时间戳记录日志作出声明的时刻，不一定就是证书实际签发的精确时刻。

默克尔包含证明把某个已经序列化的叶节点，连接到特定大小的树及其根哈希。验证者需要通过相应的已签名日志声明和可信日志公钥认证这个根。如果无条件接受不可信证明一起附带的根，攻击者完全可以自己构造另一棵树；计算结果相同，也没有建立任何有用的外部事实。

一致性证明回答的是另一个问题：后来的树是否在保持既有前缀不变的情况下扩展了早先的树。一次包含证明不能说明全部历史。签名检查点、一致性验证，以及独立观察者之间对不同视图的比较，有助于发现日志向不同人讲述不同历史。哈希让修改可以被这些检查发现，不是物理上禁止运营者改写数据。

Chrome 对公开受信任的 TLS 证书执行自己的 CT 策略，考虑 SCT 的交付方式、日志状态、数量与运营者多样性。这不是每次打开页面都到公共日志里搜索，也不是判断持有者是否申请过证书。RFC 9162 定义了第二版协议并废止 RFC 6962，但规范发布并不能直接证明某个已部署日志实际支持哪一版。

坏掉的样子

SCT 的签名即使有效，如果对应日志不被接受、数量不足或交付方式不符合目标客户端策略，仍然可能无法通过检查。反过来，符合 CT 也修复不了过期、不受信任或名称不匹配的证书。普通 TLS 验证、CT 合规和签发是否获准，是需要分别确认的三个决定。

域名监控也需要结合业务背景解释。新记录可能来自获准接入的 CDN、通配符证书或正常续签；升级告警之前应核对签发者、名称、指纹与内部签发清单。无法解释的签发应进入调查和纠正流程，不能假定“已经写进日志”就代表它被阻止或被确认合法。

公开日志可能暴露证书中的名称，因此不应仅为做实验就提交私有证书或敏感内部命名。监控覆盖不全、数据过旧，也不能证明某次签发不存在。运营上的监控要声明范围和更新时间，不能把一次空搜索结果当成所有日志、所有时间都没有相关证书的保证。

快速验证

保存为 ct_probe.go，使用 Go 1.23 或更新版本运行 go run ct_probe.go。程序离线使用 RFC 6962 的 SHA-256 默克尔构造，输入是三个合成字符串，不是真实证书，也不是已经按 CT 协议序列化的叶节点。它只验证这个固定三叶树中下标为一的中间叶节点，不是通用验证器。

package main

import (
 "crypto/sha256"
 "fmt"
 "runtime"
)

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

func leaf(data string) [32]byte {
 return sha256.Sum256(append([]byte{0}, []byte(data)...))
}

func branch(left, right [32]byte) [32]byte {
 var data [65]byte
 data[0] = 1
 copy(data[1:33], left[:])
 copy(data[33:], right[:])
 return sha256.Sum256(data[:])
}

// Only verifies index 1 of a three-leaf fixture; not a general CT verifier.
func middleOfThree(data string, proof [][32]byte, root [32]byte) bool {
 return len(proof) == 2 && branch(branch(proof[0], leaf(data)), proof[1]) == root
}

func main() {
 a, b, c := leaf("fixture-A"), leaf("fixture-B"), leaf("fixture-C")
 root := branch(branch(a, b), c)
 check(fmt.Sprintf("%x", root) == "111b905d16e9388f6e9079aaec820ab176d649b9daecabcdb3aca45fe4b6b646", "root differs from independent fixture vector")
 check(fmt.Sprintf("%x", leaf("")) == "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d", "empty leaf vector differs")
 check(leaf("") != sha256.Sum256(nil), "an empty tree and an empty leaf are different")
 proof := [][32]byte{a, c}
 check(middleOfThree("fixture-B", proof, root), "correct inclusion proof must pass")
 check(!middleOfThree("fixture-X", proof, root), "altered entry must fail")
 badProof := append([][32]byte(nil), proof...)
 badProof[0][0] ^= 1
 check(!middleOfThree("fixture-B", badProof, root), "altered sibling must fail")
 check(!middleOfThree("fixture-B", [][32]byte{c, a}, root), "sibling order matters")
 check(!middleOfThree("fixture-B", proof[:1], root), "short proof must fail")
 check(!middleOfThree("fixture-B", append(proof, b), root), "extra proof element must fail")
 badRoot := root
 badRoot[0] ^= 1
 check(!middleOfThree("fixture-B", proof, badRoot), "wrong trusted root must fail")
 nextRoot := branch(branch(a, b), branch(c, leaf("fixture-D")))
 check(nextRoot != root, "appending an entry changes this fixture root")
 check(!middleOfThree("fixture-B", proof, nextRoot), "old proof must not verify against the new root")
 fmt.Println("correct proof accepted; altered entry, sibling, order, length, and root rejected")
 fmt.Println("empty tree differs from empty leaf; fourth entry changes root; old proof fails")
 fmt.Printf("three-leaf fixture root: %x\n", root)
 fmt.Println(runtime.Version())
}

叶子哈希先放值为 0 的前缀字节，再放数据；内部节点先放值为 1 的前缀字节，再连接左右子节点哈希。这些前缀把两类输入分开。三个叶节点时，左子树包含 A 与 B，右边单独放 C，不需要把它补成四个节点。空树和只有一个空叶节点的树，也应得到不同哈希。

正确证明只需要 A 与 C 的哈希。把它们与 B 重新组合，会得到预期根；该固定结果还用 Python hashlib 独立交叉核验过。修改 B、相邻节点、证明顺序、长度或预期根，都必须失败。追加 D 会改变本例的树根，旧的三叶树证明也不能再用来匹配这个新根。

文章使用三个合成字符串与 RFC 6962 哈希前缀。B 的固定证明包含 A、C 哈希，重建 branch(branch(A, B), C)。硬编码根仅在实验中视为可信；没有验证 SCT 签名、在线日志公钥、一致性证明、浏览器策略或签发授权。

保留原文记述了 macOS、Go 1.27.0 上全部断言通过的结果；本轮没有重跑该 Go 夹具。硬编码测试根只在本例中代表已经可信的三叶检查点，程序没有实现 SCT 签名、真实日志公钥验证、证书编码、网络查询、通用包含证明或一致性证明。特别是，观察到根变化本身不能证明日志只追加；浏览器策略执行与在线错误签发监控，仍是没有在本例中验证的独立操作。

来源

RFC 6962：证书透明度，第一版默克尔哈希、SCT 承诺与不同证明，已核验 2026-09-09。
RFC 9162：第二版证书透明度，协议范围、错误签发边界与版本沿革，已核验 2026-09-09。
Chrome 证书透明度策略，客户端特定的 SCT 与日志接受条件，已核验 2026-09-09。

TLS ECDHE 的前向保密边界

Wed, 27 Oct 2027 00:00:00 +0000

前向保密限制的是长期认证密钥日后泄露造成的影响。对于经过正确认证的临时 Diffie-Hellman 交换，攻击者仅取得长期认证私钥，不能据此恢复先前的会话机密。前提是临时机密没有一起被获取；它不会让已经被攻破的端点、导出的密钥日志或保存下来的明文突然变得安全。

新鲜协商、身份认证和密钥派生各司其职。前向保密只限制特定的长期签名私钥日后泄露场景，并不保护已经暴露的会话机密或被攻破的端点。

两类密钥承担不同职责

ECDHE 中，双方分别生成临时私钥并交换公开份额。每一方把本地私钥与对方公开份额组合，得到相同的共享机密。旁观者虽然能看到公开份额，但在算法的安全假设成立时，缺少重现计算所需的私有值。新鲜的交换材料并不是双方在网络上公开商量出的一段秘密口令。

TLS 也不会把原始 ECDH 输出直接当成应用加密密钥。密钥调度还会派生不同的握手与应用流量机密，绑定握手上下文，并区分方向和用途。临时交换只提供其中一项关键材料，不能用“双方算出相同字节”替代整个传输协议，也不能略过后续派生和认证步骤。

证书按照信任规则把身份绑定到公钥，实际签署握手材料的是对应的私钥，不是证书这个数据对象自己在签名。TLS 1.3 的证书认证路径通过 CertificateVerify 认证握手记录。如果没有身份认证，主动中间人可以替换公开份额，分别和两端建立自己的共享机密；仅仅看到加密正常，并不能排除这种攻击。

RSA 或 Ed25519 认证密钥可以与临时交换并存，签名算法和密钥交换组是不同选择。TLS 1.3 还定义了仅使用 PSK 的恢复模式，后者不具备 DHE 带来的这项前向保密；PSK 配合 DHE 则会加入新的交换材料。可选 early data 的保证更弱，因此不能单凭 TLS 版本或证书算法标签，就推断所有阶段的流量都有相同保护。

坏掉的样子

长期重复使用同一个交换私钥，会削弱原本希望建立的泄露边界。随机数不足、临时私有值暴露、崩溃转储或 TLS 密钥日志，都可能泄露前向保密假设中不能被攻击者取得的材料。日后泄露流量机密，与日后泄露证书签名私钥，不是同一个威胁场景，不能混用结论。

会话进行时攻破端点，可能直接取得明文。长期认证私钥失窃后，能够拦截未来连接的攻击者也可能冒充服务器。前向保密保护的是特定的历史录制流量场景，并不会撤销泄露凭据，也不会修复仍在持续的入侵；这些问题仍需要独立的凭据轮换与事件处置。

机密销毁更是实现层面的问题，不能仅靠一句“用完就丢弃”来保证。把 Go 变量设为 nil，不证明内存、交换空间或诊断材料中的所有副本都已消失。应避免把机密写进日志，并把凭据失窃的处置与历史流量是否仍受保护的判断分开，不能用概念上的前向保密替代真实的数据暴露调查。

快速验证

保存为 ecdhe_probe.go，使用 Go 1.23 或更新版本运行 go run ecdhe_probe.go。程序在内存中调用标准库的 X25519 与 Ed25519。签名公钥在这个实验里代表已经可信的身份；被签署的消息明确不是 TLS 握手记录。这是一项密码原语层面的实验，不是另一套 TLS 实现，也不能作为上线加密通道的配方。

package main

import (
 "bytes"
 "crypto/ecdh"
 "crypto/ed25519"
 "crypto/rand"
 "fmt"
 "runtime"
)

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

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

func main() {
 identity, signingKey, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 curve := ecdh.X25519()
 var previous []byte
 for round := 1; round <= 2; round++ {
 client, err := curve.GenerateKey(rand.Reader)
 must(err)
 server, err := curve.GenerateKey(rand.Reader)
 must(err)
 message := []byte("ECDH learning probe; not a TLS transcript\x00")
 message = append(message, client.PublicKey().Bytes()...)
 message = append(message, server.PublicKey().Bytes()...)
 signature := ed25519.Sign(signingKey, message)
 check(ed25519.Verify(identity, message, signature), "trusted signature must verify")
 altered := append([]byte(nil), message...)
 altered[len(altered)-1] ^= 1
 check(!ed25519.Verify(identity, altered, signature), "altered share must fail authentication")

 clientSecret, err := client.ECDH(server.PublicKey())
 must(err)
 serverSecret, err := server.ECDH(client.PublicKey())
 must(err)
 check(bytes.Equal(clientSecret, serverSecret), "peers must agree")
 if previous != nil {
 check(!bytes.Equal(previous, clientSecret), "fresh exchange must produce a different observed secret")
 }
 previous = clientSecret
 fmt.Println("round", round, "agrees; altered share fails signature verification")
 }
 _, err = curve.NewPublicKey(make([]byte, 31))
 check(err != nil, "wrong-length X25519 key must fail parsing")
 zero, err := curve.NewPublicKey(make([]byte, 32))
 must(err)
 client, err := curve.GenerateKey(rand.Reader)
 must(err)
 _, err = client.ECDH(zero)
 check(err != nil, "all-zero shared result must be rejected")
 fmt.Println("two fresh exchanges differ with one signing identity; malformed and low-order inputs rejected")
 fmt.Println(runtime.Version())
}

每一轮中，双方计算出的共享机密必须相同；两轮都生成新的交换密钥，因此本次观察到的两个共享结果必须不同，而认证签名始终使用同一对身份密钥。篡改已签署公开份额消息中的一个字节，会使签名验证失败，说明交换材料与身份认证不能各做各的、互不关联。

反向测试还覆盖了公钥输入边界：三十一字节的 X25519 公钥在解析时就被拒绝；长度正确但全零的输入可以通过长度检查，却会在 ECDH 阶段因全零结果而失败。不能把“公钥对象创建成功”当成共享机密一定可用，后续算法调用的错误仍然需要检查和处理。

保留原文记述了 macOS、Go 1.27.0 上全部断言通过的结果；本轮没有重跑该 Go 夹具。只输出结果标签。程序为了对照，刻意保留了前一轮共享机密，所以它没有证明安全擦除，也没有通过穷举证明密码学难度。比较观察到的两组结果，不能扩大成对所有随机输出永不重复的数学承诺。

实验分别观察了密钥协商、一轮一换、签名认证和非法输入处理，但没有执行真实 TLS 握手记录、证书链验证、流量密钥派生、报文加密、会话恢复或生产密钥销毁。实际通信应交给持续维护的 TLS 实现，并核验协商模式；把这些原语拼到一起，还不足以构成安全的传输协议。

来源

RFC 8446：TLS 1.3，CertificateVerify、密钥调度、PSK 模式与前向保密边界，已核验 2026-09-09。
Go crypto/ecdh，X25519 协商与非法公钥行为，已核验 2026-09-09。
Go crypto/ed25519，签名与验证操作，已核验 2026-09-09。

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

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

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

分别观察加密边界与认证证据。853/443 为常用协议端口；8531/8443 属于文章的回环实验。证书失败诊断不能被零退出码掩盖。本图仅依据来源制作：加密 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。

客户端证书认证私钥控制能力

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

双向 TLS 在验证服务器身份的同时，也认证客户端是否能够使用证书对应的私钥。但它并不天然证明某台物理设备的身份。可复制的软件私钥可以被带到别处使用；硬件绑定和设备证明需要额外机制。注册和签发策略可以把密钥关联到设备，但 TLS 本身不会自动建立或验证这项硬件关联。

mTLS 认证私钥控制能力。应用根据已验证身份另行授权，因此有效凭据仍可能得到 403。物理设备身份与凭据生命周期还需要额外控制。

完成认证仍然需要授权

TLS 1.3 的证书式客户端认证中，服务器请求证书，客户端通过 CertificateVerify 证明自己能够使用对应私钥。只发送一份公开证书文件并不够。双方都必须应用各自的信任规则，检查证书链和适当用途；客户端还要验证服务器名称，不能因为自己提交了凭据就放弃验证对端。

服务端信任哪些客户端 CA，与客户端信任哪些服务器 CA，是两个方向的决定。应只接受预期签发者，并明确使用哪个已验证证书字段表示工作负载身份。URI SAN 可以存放应用标识，但谁有资格拿到这个标识，取决于签发者的注册规则。证书里出现了名字，不代表它自动拥有所有 API 权限。

“要求必须提供证书”也不同于“请求对方有的话就提供”。Go 的 RequireAndVerifyClientCert 要求有效客户端证书，而可选模式可能允许没有证书的连接通过。认证之后仍需根据已验证身份执行授权，因此合法访客可以得到 HTTP 403，而获准读取的客户端得到 HTTP 200，这两个结果不矛盾。

坏掉的样子

没有证书、签发者不受信任、凭据过期或扩展用途不合适，都可能阻止客户端认证。把服务端改为任意证书都接受，或者关闭客户端对服务器的验证，只是隐藏边界，不是在修复凭据问题。应区分握手失败和应用层拒绝，让排查人员能定位到实际负责的那一层。

私钥需要受控存储、签发、轮换和事件响应。续签证书并不必然更换私钥；被盗且仍被接受的私钥可能用于冒充，不能把等待过期当作唯一处置方式。Go 的证书 Verify 不执行吊销检查，因此发布了一条吊销记录，也不等于每个调用方已经应用它，接受策略必须另行核实。

TLS 终止位置还决定了身份在哪里被建立。后端收到调用方自行填写的身份 Header，不代表后端就验证了调用方证书。受信任的身份传递需要自己的认证边界和防伪造规则；凭据或权限变化时，既有连接、恢复会话如何处理，也必须有明确的生命周期策略。

快速验证

保存为 mtls_probe.go，使用 Go 1.23 或更新版本运行 go run mtls_probe.go。程序在内存中生成客户端 CA 和凭据，把 notBefore 回拨一分钟，并把 notAfter 设为生成时刻之后一小时。回环服务端使用 httptest 自带的测试服务器证书，配套测试客户端信任这张证书。两侧信任库都不安装到系统全局，也不打印或写出私钥。

package main

import (
 "crypto/ed25519"
 "crypto/rand"
 "crypto/tls"
 "crypto/x509"
 "crypto/x509/pkix"
 "errors"
 "fmt"
 "io"
 "log"
 "math/big"
 "net/http"
 "net/http/httptest"
 "net/url"
 "runtime"
 "sync/atomic"
 "time"
)

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

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

func authority(serial int64) (*x509.Certificate, ed25519.PrivateKey) {
 public, private, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(serial), Subject: pkix.Name{CommonName: fmt.Sprint("fixture-ca-", serial)},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 IsCA: true, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCertSign,
 }
 der, err := x509.CreateCertificate(rand.Reader, template, template, public, private)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return certificate, private
}

func credential(serial int64, identity string, usage x509.ExtKeyUsage, ca *x509.Certificate, signer ed25519.PrivateKey) tls.Certificate {
 public, private, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 name, err := url.Parse("urn:example:" + identity)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(serial), URIs: []*url.URL{name},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{usage},
 }
 der, err := x509.CreateCertificate(rand.Reader, template, ca, public, signer)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: private, Leaf: certificate}
}

func main() {
 ca, signer := authority(1)
 foreignCA, foreignSigner := authority(2)
 reader := credential(3, "reader", x509.ExtKeyUsageClientAuth, ca, signer)
 guest := credential(4, "guest", x509.ExtKeyUsageClientAuth, ca, signer)
 foreign := credential(5, "reader", x509.ExtKeyUsageClientAuth, foreignCA, foreignSigner)
 serverOnly := credential(6, "reader", x509.ExtKeyUsageServerAuth, ca, signer)
 roots := x509.NewCertPool()
 roots.AddCert(ca)
 options := x509.VerifyOptions{Roots: roots, KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth}}
 _, err := foreign.Leaf.Verify(options)
 var unknown x509.UnknownAuthorityError
 check(errors.As(err, &unknown), "foreign issuer fixture must fail trust")
 _, err = serverOnly.Leaf.Verify(options)
 var invalid x509.CertificateInvalidError
 check(errors.As(err, &invalid) && invalid.Reason == x509.IncompatibleUsage, "server-only fixture must fail client usage")

 var handled atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 check(len(r.TLS.VerifiedChains) > 0, "handler requires a verified client chain")
 identities := r.TLS.VerifiedChains[0][0].URIs
 if len(identities) != 1 || identities[0].String() != "urn:example:reader" {
 http.Error(w, "forbidden", http.StatusForbidden)
 return
 }
 fmt.Fprintln(w, "reader allowed")
 }))
 server.Config.ErrorLog = log.New(io.Discard, "", 0)
 server.TLS = &tls.Config{
 MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13,
 ClientAuth: tls.RequireAndVerifyClientCert, ClientCAs: roots, SessionTicketsDisabled: true,
 }
 server.StartTLS()
 defer server.Close()
 request := func(certificate *tls.Certificate) (int, error) {
 config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 check(!config.InsecureSkipVerify, "server identity verification must remain enabled")
 config.MinVersion = tls.VersionTLS13
 if certificate != nil {
 config.GetClientCertificate = func(*tls.CertificateRequestInfo) (*tls.Certificate, error) {
 return certificate, nil
 }
 }
 transport := &http.Transport{TLSClientConfig: config, DisableKeepAlives: true}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 request, err := http.NewRequest(http.MethodGet, server.URL, nil)
 must(err)
 request.Header.Set("X-Client-ID", "urn:example:reader")
 response, err := client.Do(request)
 if err != nil {
 return 0, err
 }
 defer response.Body.Close()
 _, err = io.Copy(io.Discard, response.Body)
 must(err)
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "client requires a verified TLS 1.3 server")
 return response.StatusCode, nil
 }
 for _, test := range []struct {
 name string
 certificate *tls.Certificate
 status int
 }{
 {"reader", &reader, 200}, {"guest", &guest, 403},
 {"missing", nil, 0}, {"foreign issuer", &foreign, 0},
 {"wrong usage", &serverOnly, 0}, {"reader again", &reader, 200},
 } {
 status, err := request(test.certificate)
 if test.status == 0 {
 check(err != nil && status == 0, "invalid client must fail before HTTP")
 } else {
 must(err)
 check(status == test.status, "wrong authorization result")
 }
 fmt.Println(test.name, "HTTP status:", status)
 }
 check(handled.Load() == 3, "only reader, guest, and reader again may reach HTTP")
 fmt.Println("three TLS rejections; authenticated guest denied despite claimed reader header")
 fmt.Println(runtime.Version())
}

reader 返回 200；同一个可信 CA 签发的 guest 返回 403，即使它在 X-Client-ID 中声称自己是 reader。授权使用已验证证书中的精确 URI SAN，不使用这个 Header。本例的 URN 只是应用身份标签，不是网络地址，固定规则只允许 urn:example:reader。

缺少凭据、外部 CA 签发的证书、仅允许服务端认证用途的证书，都在进入 HTTP 之前失败。此时打印的零只是“没有 HTTP 响应”的内部标记，不是一个真实 HTTP 状态码。独立的 X.509 检查还确认了两种非法证书分别触发 UnknownAuthorityError 和 IncompatibleUsage。最后再次请求 reader 应恢复成功，总共只有三次请求进入 handler。

证书回调刻意返回每次指定的凭据，包括外部 CA 的证书，而不是根据服务器公布的 CA 偏好默默选成“没有证书”。这样才能覆盖服务端拒绝不可信证书的路径；生产中的证书选择仍应遵守证书请求。本例每次都使用新的 transport，设置两秒超时，并关闭 HTTP 连接复用与会话票据。

保留原文记述了 macOS、Go 1.27.0 上全部断言通过的结果；本轮没有重跑该 Go 夹具。这验证了真实双向 TLS 和一条明确的应用授权规则，不是硬件身份或生产 PKI 的验收。实验没有测试吊销分发、自动续期、过期客户端在握手中的行为、恢复会话、反向代理身份传递，或既有连接上的权限变化。这些事项仍需在实际部署边界单独检查。

来源

RFC 8446：TLS 1.3，证书请求与私钥控制能力证明，已核验 2026-09-09。
Go crypto/tls，客户端认证模式、信任池和证书选择，已核验 2026-09-09。
Go crypto/x509，客户端认证用途、验证链与吊销检查边界，已核验 2026-09-09。
Go net/http/httptest，隔离 TLS 服务和可信测试客户端，已核验 2026-09-09。

TLS 1.3 会话恢复复用认证状态

Sun, 08 Aug 2027 00:00:00 +0000

“省一次往返”需要结合协议版本和 early data 模式理解。TLS 1.3 的普通完整握手，以及不携带 early data 的恢复握手，通常都需要一次 TLS 往返。恢复仍然可以减少证书传输和身份认证开销，但开启票据并不意味着每个 HTTPS 请求都能提前一个 RTT 开始。

TLS 1.3 会话恢复在新连接上复用认证状态，并派生新的流量密钥。普通恢复不保证省一次往返；可选早期数据还需要单独处理重放、前向保密与拒绝边界。

新连接仍要派生新的流量密钥

TLS 会话恢复使用先前握手派生的 PSK，为一条新连接建立安全上下文。NewSessionTicket 提供的是与恢复状态关联的不透明标识，不是让后续连接直接沿用原来的流量密钥。新的握手仍会根据自身上下文派生密钥。服务器可以用密码学方法保护票据状态，也可以在不透明标识后保存服务端状态；应用不应把票据解析成一种通用登录凭据。

服务器接受 PSK 认证时，不再发送自己的 Certificate 和 CertificateVerify 消息。恢复可以结合一次新的临时 Diffie-Hellman 交换，获得相应的前向保密；协议也允许仅使用 PSK 的模式，后者没有这项保护。因此，“拿到了票据”既不能证明实际选用了哪种密钥交换，也不能独自证明节省了多少网络等待。

可选的零往返模式允许符合条件的应用数据跟随 ClientHello 一起发送，这与普通会话恢复是两件事。early data 不具有前向保密，并可能跨连接被重放；某条连接后来完成握手，也不能消除另一条连接上已经发生或可能发生的重放。HTTP 服务需要按资源的实际副作用决定能否接受重放风险，并正确处理拒绝，包括规范要求的 425 Too Early 响应。

坏掉的样子

客户端可能根本没有启用票据缓存，可能在处理握手后票据之前就关闭连接，也可能每次请求都重建并丢弃缓存。服务器重启、密钥轮换或票据过期后，也可能不再接受原来的恢复状态。一次恢复尝试最终走完整握手，不自动等于 TLS 服务不可用；恢复比例和建连成功率应该分别观察。

HTTP 连接复用还会让测试混淆。多个请求若沿用同一条已建立连接，根本不会重新握手。验证会话恢复时，必须有意创建新的 TCP 连接，再检查双方报告的协商状态，不能只根据第二次请求耗时较短就下结论。总耗时里还混有调度、传输建连、服务端业务处理和其他缓存效果。

票据及客户端缓存属于敏感状态，应限制适用范围和存续时间，协调服务器密钥轮换，并在认证策略变化时重新审视缓存状态。Go 的 VerifyPeerCertificate 不会在恢复连接上调用，而 VerifyConnection 会覆盖包括恢复在内的所有连接。必须每次检查的自定义策略应放在后者路径上；这并不是关闭标准证书验证的理由，更不能让缓存绕过刚刚收紧的授权规则。

快速验证

将代码保存为 resumption_probe.go，用 Go 1.23 或更新版本运行 go run resumption_probe.go。服务端和客户端都限定 TLS 1.3，测试证书仅在本地测试客户端中受信任。实验禁用 HTTP/1.1 的持久连接复用，但让前两个独立 transport 共享容量为四的 TLS 会话缓存；第三个 transport 刻意不配置缓存。

package main

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

type connectionKey struct{}

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

func main() {
 var serial, verified atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 id := r.Context().Value(connectionKey{}).(int64)
 w.Header().Set("X-Connection-ID", strconv.FormatInt(id, 10))
 w.Header().Set("X-Resumed", strconv.FormatBool(r.TLS.DidResume))
 fmt.Fprintln(w, "ok")
 }))
 server.Config.ConnContext = func(ctx context.Context, connection net.Conn) context.Context {
 return context.WithValue(ctx, connectionKey{}, serial.Add(1))
 }
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()

 base := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 base.MinVersion, base.MaxVersion = tls.VersionTLS13, tls.VersionTLS13
 check(!base.InsecureSkipVerify, "certificate verification must stay enabled")
 base.VerifyConnection = func(state tls.ConnectionState) error {
 if len(state.VerifiedChains) == 0 {
 return fmt.Errorf("verified certificate chain required")
 }
 verified.Add(1)
 return nil
 }
 request := func(cache tls.ClientSessionCache) (int64, bool) {
 config := base.Clone()
 config.ClientSessionCache = cache
 transport := &http.Transport{
 TLSClientConfig: config,
 DisableKeepAlives: true,
 }
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 response, err := client.Get(server.URL)
 check(err == nil, fmt.Sprint(err))
 defer response.Body.Close()
 body, err := io.ReadAll(response.Body)
 check(err == nil, fmt.Sprint(err))
 check(response.StatusCode == 200 && string(body) == "ok\n", "unexpected HTTP reply")
 check(response.ProtoMajor == 1 && response.ProtoMinor == 1, "HTTP/1.1 required")
 check(response.TLS.HandshakeComplete && response.TLS.Version == tls.VersionTLS13, "TLS 1.3 required")
 id, err := strconv.ParseInt(response.Header.Get("X-Connection-ID"), 10, 64)
 check(err == nil, fmt.Sprint(err))
 resumed := response.TLS.DidResume
 check(response.Header.Get("X-Resumed") == strconv.FormatBool(resumed), "peers disagree")
 return id, resumed
 }

 cache := tls.NewLRUClientSessionCache(4)
 firstID, first := request(cache)
 secondID, second := request(cache)
 thirdID, third := request(nil)
 check(firstID == 1 && secondID == 2 && thirdID == 3, "three new TCP connections required")
 check(!first && second && !third, "expected full, resumed, full")
 check(verified.Load() == 3, "VerifyConnection must run for all three handshakes")
 fmt.Printf("new TCP connections: %d %d %d; DidResume: %t %t %t\n",
 firstID, secondID, thirdID, first, second, third)
 fmt.Println("both peers agree; VerifyConnection ran three times; no early data was sent")
 fmt.Println(runtime.Version())
}

每次完整读取响应，让这个测试服务器发出的握手后票据在下一次连接前得到处理。服务端为每条实际接受的 TCP 连接分配独立编号，预期顺序是一、二、三，而 DidResume 依次为 false、true、false。响应头还携带服务器自己看到的恢复状态，必须与客户端一致，不能只检查一端或凭耗时猜测。

VerifyConnection 的计数必须为三，说明恢复连接也经过这个回调，同时标准证书验证始终开启。恢复时保留的已验证证书链状态，关联的是先前认证的会话，并不意味着本次握手重新传输了一份证书消息。会话状态仅保留在内存缓存中；程序不打印票据、私钥和流量机密，也不将它们写入磁盘，不把测试证书安装到机器的全局信任库。

保留原文记述了 macOS、Go 1.27.0 上全部断言通过的结果；本轮没有重跑该 Go 夹具。实验直接证明：缓存会话可以在新的传输连接上被接受，没有缓存时则进行完整协商。它没有发送 early data、统计报文往返、基准测试握手 CPU，也没有验证负载均衡集群之间的票据共享与轮换。预估生产提速前，必须分别验证这些条件；本机第二次请求较快，不能代替其中任何一项证据。

来源

RFC 8446：TLS 1.3，第 2.2、2.3、4.6.1、8 节：PSK、票据、early data 与重放，已核验 2026-09-09。
RFC 8470：在 HTTP 中使用 Early Data，重放敏感操作与 425 响应，已核验 2026-09-09。
Go crypto/tls，ClientSessionCache、DidResume 与验证回调，已核验 2026-09-09。
Go net/http/httptest，隔离的回环 HTTPS 测试服务，已核验 2026-09-09。

TLS 握手会拉长延迟，但可以缩小

Mon, 28 Jun 2027 00:00:00 +0000

HTTPS 延迟由多个阶段组成，重复访问可以跳过其中一些阶段，却不一定是加密运算本身变快了。DNS、获取连接、TCP 建连、TLS 认证、服务端处理和响应传输，各自有不同的计时边界。分析前应先确认哪些阶段真的执行过；单看一次请求总耗时，无法区分复用既有连接与新连接上的 TLS 会话恢复。

消息会按批次传输

TLS 握手虽然包含多条消息，但并不是每条消息都需要单独一次往返，多条消息可以在同一批次中发送。通常的 TLS 1.3 完整握手在普通客户端应用数据之前需要一次 TLS 往返，HelloRetryRequest 会再增加一次。TCP 建连和之后的应用请求、响应，还属于另外的成本。

不使用 early data 的普通 TLS 1.3 会话恢复，通常也需要一次 TLS 往返。它能减少证书传输与认证工作，却仍可能执行新的临时密钥交换；恢复时派生的是新流量密钥，不是原封不动继续使用旧加密密钥。可选零往返数据有额外的重放安全限制，不能把一次快速重复请求直接叫作零往返。

HTTP 连接复用则跳过了建立另一条连接的步骤，因此该请求没有新的 TLS 握手。HTTP/2 多路复用也可以让多个流共享已建立连接。相反，关闭空闲连接再重新连接，即使缓存票据允许 TLS 恢复，仍然需要重新完成传输层建立，不能把两种节省混成同一个动作。

坏掉的样子

正常请求若每次创建新的 transport，就会丢掉连接池。响应正文没有读完或关闭，也可能妨碍复用。空闲超时、入口变化或并发需求都可能增加新连接数量，因此在把延迟变化归因于证书算法之前，应先按真实复用情况和握手事件分类，确认自己比较的是同一种路径。

尝试恢复后仍发生完整握手，并不必然意味着服务故障。票据可能过期或被拒绝，客户端也可能没有可用缓存。应保留普通证书验证，并观察最终选择的行为；为赢得性能数字而减少认证检查，改变的是安全约定，不是在同一个操作下获得了免费优化。

计时名称也要有定义。首字节时间包含的不只有 TLS，总时间还包括消费响应内容。跟踪回调可能来自不同协程，收集器必须正确同步。应比较有代表性的分布及连接类别，不能拿几次回环请求的微秒数去预测公网加速，也不能把偶然更快的一次执行写成稳定性能承诺。

快速验证

保存为 latency_probe.go，使用 Go 1.23 或更新版本运行 go run latency_probe.go。实验固定使用经过验证的 TLS 1.3 和 HTTP/1.1，服务端为接受的 TCP 连接编号。第一个 transport 同时保留 HTTP 连接池和 TLS 会话缓存，另一个独立 transport 刻意不配置会话缓存。

package main

import (
 "context"
 "crypto/tls"
 "fmt"
 "io"
 "net"
 "net/http"
 "net/http/httptest"
 "net/http/httptrace"
 "runtime"
 "strconv"
 "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 main() {
 var connections atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 w.Header().Set("X-Connection-ID", fmt.Sprint(r.Context().Value(connectionKey{})))
 w.Header().Set("X-Resumed", strconv.FormatBool(r.TLS.DidResume))
 fmt.Fprint(w, "ok")
 }))
 server.Config.ConnContext = func(ctx context.Context, _ net.Conn) context.Context {
 return context.WithValue(ctx, connectionKey{}, connections.Add(1))
 }
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()
 base := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 base.MinVersion, base.MaxVersion = tls.VersionTLS13, tls.VersionTLS13
 check(!base.InsecureSkipVerify, "certificate verification must stay enabled")
 cached := base.Clone()
 cached.ClientSessionCache = tls.NewLRUClientSessionCache(4)
 transport := &http.Transport{TLSClientConfig: cached}
 defer transport.CloseIdleConnections()
 fresh := &http.Transport{TLSClientConfig: base.Clone()}
 defer fresh.CloseIdleConnections()
 probe := func(label string, transport *http.Transport, wantID int64, wantReuse, wantResume bool) {
 started := time.Now()
 var mu sync.Mutex
 var handshakeStarted time.Time
 var handshakeError error
 var observation struct {
 got, starts, done, first int
 reused bool
 tlsTime, ttfb time.Duration
 }
 trace := &httptrace.ClientTrace{
 GotConn: func(info httptrace.GotConnInfo) {
 mu.Lock()
 defer mu.Unlock()
 observation.got++
 observation.reused = info.Reused
 },
 TLSHandshakeStart: func() {
 mu.Lock()
 defer mu.Unlock()
 handshakeStarted = time.Now()
 observation.starts++
 },
 TLSHandshakeDone: func(_ tls.ConnectionState, err error) {
 mu.Lock()
 defer mu.Unlock()
 observation.done++
 observation.tlsTime = time.Since(handshakeStarted)
 handshakeError = err
 },
 GotFirstResponseByte: func() {
 mu.Lock()
 defer mu.Unlock()
 observation.first++
 observation.ttfb = time.Since(started)
 },
 }
 request, err := http.NewRequest(http.MethodGet, server.URL, nil)
 must(err)
 request = request.WithContext(httptrace.WithClientTrace(request.Context(), trace))
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 response, err := client.Do(request)
 must(err)
 body, err := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(err)
 must(closeError)
 total := time.Since(started)
 check(response.StatusCode == 200 && string(body) == "ok", "wrong response")
 check(response.Proto == "HTTP/1.1", "fixture requires HTTP/1.1")
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
 id, err := strconv.ParseInt(response.Header.Get("X-Connection-ID"), 10, 64)
 must(err)
 check(id == wantID && response.TLS.DidResume == wantResume, "wrong connection or resumption")
 check(response.Header.Get("X-Resumed") == strconv.FormatBool(wantResume), "peers disagree on resumption")
 mu.Lock()
 observed, tlsError := observation, handshakeError
 mu.Unlock()
 must(tlsError)
 wantHandshakes := 1
 if wantReuse {
 wantHandshakes = 0
 }
 check(observed.got == 1 && observed.first == 1 && observed.reused == wantReuse, "wrong request trace")
 check(observed.starts == wantHandshakes && observed.done == wantHandshakes, "wrong handshake count")
 check(total >= observed.ttfb && observed.ttfb > 0, "invalid response timing")
 fmt.Printf("%s: conn=%d reused=%t handshakes=%d connection_resumed=%t tls_us=%d ttfb_us=%d total_us=%d\n",
 label, id, observed.reused, observed.done, response.TLS.DidResume,
 observed.tlsTime.Microseconds(), observed.ttfb.Microseconds(), total.Microseconds())
 }
 probe("cold", transport, 1, false, false)
 probe("reuse", transport, 1, true, false)
 transport.CloseIdleConnections()
 probe("resume", transport, 2, false, true)
 probe("no cache", fresh, 3, false, false)
 check(connections.Load() == 3, "four requests must use three TCP connections")
 fmt.Println("timings are observations, not a speedup or wire-RTT assertion")
 fmt.Println(runtime.Version())
}

不随运行耗时变化的结果如下：

请求	TCP 编号	复用连接	新握手次数	DidResume
cold	1	false	1	false
reuse	1	true	0	false
resume	2	false	1	true
no cache	3	false	1	false

第二次请求仍使用连接一。第三次请求前关闭空闲连接，会强制建立另一条 TCP 连接，但不丢弃 TLS 缓存，因此可以恢复会话。第四个请求使用没有缓存的 transport，重新执行完整握手。双方报告的恢复标志必须一致，四个 HTTP 请求总共只使用三条已接受的 TCP 连接。

文章中四个请求使用 TCP 编号 1、1、2、3。reuse 没有新 TLS 握手事件；resume 新建 TCP 2 并恢复握手；no cache 新建 TCP 3 并完整握手。DidResume 属于连接状态。这些分类不代表公网加速、抓包 RTT 或 early data 测量。

DidResume 描述的是这条连接最初如何建立，不代表当前 HTTP 请求又触发了一次恢复。如果复用的连接最初通过会话恢复建立，后续响应仍可能报告 true，却没有新握手。因此要把这个连接级标志与当前请求的复用和握手事件一起读，不能把每个 true 响应都计为一次新的恢复连接。

TLS 耗时从 TLSHandshakeStart 计到 TLSHandshakeDone；TTFB 从发起请求前开始，计到响应头首字节可用；总耗时则计到正文读完并关闭。复用那一行的 TLS 耗时为零，是因为没有观察到新握手事件，不代表握手异常快，更不是已经发送 TLS 零往返数据。

已核验的 macOS、Go 1.27.0 运行通过全部断言。程序消费并关闭响应正文，以互斥锁保护跟踪状态，每次请求限时两秒。会话状态只留在内存，不打印票据、私钥或流量机密。恢复连接中的已验证证书链状态属于已认证会话，不能据此推断网络上刚刚又传输了一份新证书。

程序故意不对“加速多少”作断言，计时数字也会随运行变化。它没有数包或测量线上的 RTT、DNS、HTTP/2 或 HTTP/3、early data、集群票据轮换、单独握手 CPU，或者生产延迟分布。跟踪类别可以帮助组织后续测量，但不能把这个本地实验当成那些测量已经完成的结果。

来源

RFC 8446：TLS 1.3，握手批次、会话恢复与 early data 边界，已核验 2026-09-09。
Go net/http/httptrace，请求钩子、握手事件、计时边界和并发，已核验 2026-09-09。
Go net/http，transport 复用与响应正文生命周期，已核验 2026-09-09。
Go crypto/tls，会话缓存与协商后的恢复状态，已核验 2026-09-09。
Go net/http/httptest，隔离 TLS 服务和可信测试客户端，已核验 2026-09-09。

Caddy 自动管理 HTTPS 证书的签发与续期

Thu, 21 Jan 2027 00:00:00 +0000

Caddy 可以自动获取并续签受管理的证书，不需要运维人员手工实现 ACME 协议。自动化省去了重复操作，却没有取消签发前提，也不能代替对失败的监控。今天证书有效，不证明下次续期仍能完成，更不证明整条链路中的每一跳都使用同一张证书。应先明确服务名称、验证路径、持久存储和 TLS 终止位置，再判断自动化覆盖到哪里。

先让自动 HTTPS 知道服务名称

当配置让 Caddy 知道符合条件的主机名或地址时，自动 HTTPS 才会按规则启用，同时还要考虑文档列出的例外与显式覆盖。Caddyfile 中的站点地址包含主机名，是常见触发方式。file_server 指令负责提供文件，本身并不等于为某个尚未指定的域名申请公开证书，不能把文件服务功能与证书管理的启用条件混在一起。

命令行区别很明确：不带参数的 caddy file-server 默认监听八十端口；提供 --domain 后，才会尝试为指定主机名启用 HTTPS，并将默认监听端口改为四百四十三。无论命令怎样拼写，都不能单独证明 DNS、端口转发或证书授权已经正确。显式 HTTP 配置、手动加载的证书等条件，也可能改变自动行为，应该检查实际生效配置。

本地开发还有不同的信任边界。对于内部名称，Caddy 可以使用自己的本地证书机构。客户端需要通过适当流程信任该机构；某台机器能够正常访问，不代表这张证书已经获得公网客户端的普遍信任。更不能为了修复客户端信任问题，把私有 CA 的签名密钥发给所有客户端。信任根分发与私钥保管是两项不同工作。

让挑战方式与真实路径匹配

Caddy 默认同时启用 HTTP-01 与 TLS-ALPN-01。前者通过公网八十端口验证，后者通过四百四十三端口上的特殊 TLS 握手验证；Caddy 可以在可用方式之间选择。某次 HTTP 挑战失败，并不说明 DNS 验证就是唯一替代方案。应先从日志确认实际失败的是哪种挑战，再检查该方式的入口、转发和防火墙规则。

代理或 CDN 可能干扰这些路径，但它们的存在不会自动使签发变得不可能。即使普通 HTTPS 在 CDN 终止，HTTP 挑战请求也可能被正确转发。DNS-01 则通过 TXT 记录证明控制权，不要求申请证书的服务器接收入站验证流量，但需要受支持的服务商集成和范围适当的 DNS 凭据。选择方式应依据真实路由和权限，而不是凭拓扑名称猜测。

坏掉的样子

陈旧的 A 或 AAAA 记录、端口阻断、错误转发或 CDN 规则变化，都可能让首次签发成功之后的验证失败。应同时检查两个地址族，并读取日志中的具体挑战错误。反复清空存储再重试，不是有效诊断：这样会丢掉本可复用的证书状态，还可能增加不必要的签发尝试，消耗正常业务需要的配额。

实例替换时应保留 Caddy 的数据存储，并保护其中的敏感密钥材料。多个实例需要符合 Caddy 协调语义的存储安排；几台机器上恰好有同名目录，并不表示它们共享了状态。应验证这套配置如何恢复，同时避免把私钥打印到日志、复制进报告或提交到版本库。自动管理证书并不会免除持久化与访问控制责任。

现有证书仍然可用时，续期自动化就可能已经失败。应监控续期错误，以及客户端实际收到的证书到期时间，为处置留下足够提前量。源站续签成功，不能证明 CDN 对外证书已经更新；CDN 对访客启用 TLS，也不会取消对另一条 HTTPS 源站连接的安全和身份检查。这两个终止位置需要分别验收。

签发实验应使用预发签发者，避免把不受公开信任的测试证书带到生产。DNS 凭据轮换后，也需要受控的验证检查。告警提前量应按响应能力与证书寿命选择，不能把一个固定三十天的算术示例当成 Caddy 的续期调度规范，更不能因脚本输出正常就断言真实证书一定会自动更新。

Caddy 证书生命周期：机制与证据边界。

快速验证

保存为 expiry_alert.py 并运行 python3 expiry_alert.py，须启用断言，不使用 -O 或 PYTHONOPTIMIZE；只需要 Python 标准库。程序使用固定 UTC 观察时刻，三十天阈值是本例运维告警的自主选择，不是 Caddy 内部策略。它不会联系域名或证书机构，不启动监听器，不创建密钥，也不修改系统信任设置，适合单独验证日期边界。

from datetime import datetime, timedelta, timezone

# An operator-chosen alert threshold, not Caddy's renewal scheduler.
ALERT_BEFORE = timedelta(days=30)
NOW = datetime(2026, 10, 15, 12, tzinfo=timezone.utc)


def expiry_alert(not_after, now):
 for value in (not_after, now):
 if value.tzinfo is None or value.utcoffset() is None:
 raise ValueError("timezone-aware timestamps required")
 remaining = not_after - now
 if remaining <= timedelta(0):
 return "expired"
 if remaining <= ALERT_BEFORE:
 return "warning"
 return "ok"


for name, days, expected in [
 ("fresh", 80, "ok"), ("due", 20, "warning"),
 ("boundary", 30, "warning"), ("expired", -1, "expired"),
]:
 not_after = NOW + timedelta(days=days)
 actual = expiry_alert(not_after, NOW)
 assert actual == expected
 print(f"{name}: remaining={days}d alert={actual}")
assert expiry_alert(NOW, NOW) == "expired"
try:
 expiry_alert(NOW.replace(tzinfo=None), NOW)
except ValueError:
 print("naive timestamp rejected")
else:
 raise AssertionError("missing timezone accepted")
print("PASS: expiry alert boundaries; no certificate issuance tested")

四个打印案例依次得到正常、警告、警告和过期。恰好剩余三十天也进入警告范围，到期瞬间则单独归为过期。负例传入的是缺少时区的到期时间；函数也检查观察时刻，但本例没有单独测试第二个参数缺少时区的分支。断言验证的是这套明确的告警规则，不依赖执行当天，也不假设所有证书都拥有相同总寿命。

保留的精确记录覆盖这份未变的算术夹具；本轮源码复核没有重跑。该实验没有运行 Caddy、获取证书或观察真实续期。部署验收仍需要检查客户端实际收到的证书、已经配置的挑战路径，并在预期持久存储条件下观察续期成功。应把这些运行证据与这份可重复的小型日期算术检查分开记录，才能知道哪一部分已经证明，哪一部分仍需要实际环境验证。

来源

Python assert statement，优化模式省略断言及其内部调用，已核验 2026-10-18。
Caddy 自动 HTTPS，启用条件、本地信任、挑战选择及存储，已核验 2026-10-15。
Caddy file-server 命令，默认监听端口与 domain 参数，已核验 2026-10-15。
Let’s Encrypt 挑战类型，验证端口、DNS 自动化及受限凭据，已核验 2026-10-15。
Let’s Encrypt 速率限制，实验使用预发环境与签发失败，已核验 2026-10-15。

检查 HTTPS,而不只是那把锁

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

HTTPS 保护一条连接，并按照客户端的信任规则认证对端。但它不会证明网站意图、业务正确性或服务可用性。地址栏的安全指示既不只是“字节已加密”的标签，也不是完整健康报告。有效检查应分别判断 TLS 连接、HTTP 响应，以及服务实际应该提供的行为，不能把三个问题合成一个模糊的绿灯。

分别提出具体问题

首先确认目标与身份。连接预期入口的同时，应按照证书 SAN 和可接受的信任链验证预期主机名。IP 地址正确，或者能够打印证书主题，都不足以完成身份验证。为了让探针通过而关闭验证，只会移除原本想取得的证据，并不能证明对端已经变得正确。

接着检查有效时间和协商协议。叶证书的到期日期仍在未来，不代表整条证书链可用；一次 TLS 协商成功，也只说明这个客户端实际选中了哪个版本和套件，并没有枚举服务端可能接受的全部配置。配置或库升级之后，仍应另外验证明确的允许和拒绝策略，不能用一次成功连接概括全部安全条件。

最后定义应用成功的条件。HTTP 状态、预期内容、重定向和相关依赖各自回答不同问题。静态站也可能提供有效证书，却返回不存在的页面、旧版本内容或上游错误。即使应用只负责发送文件，TLS 也不是整段访问的全部，更不能替代页面和发布结果的检查。

坏掉的样子

HTTP 库收到一个可正常读取的 503 响应时，未必会把它当成传输错误。若探针只检查 err 是否为空，就可能把不可用服务判断为健康。同样，HTTP 200 也可能来自错误虚拟主机、登录页面或被缓存的错误文档，因此应核验稳定、属于目标服务自身的响应约定。

自动跟随重定向可能隐藏真正被检查的入口。最初的 HTTPS 响应可能指向 HTTP 或非预期地址，最终只看到一个 200 就会丢失中途发生的变化。应依据明确策略检查跳转链，不能为了把请求跑通，就顺手把凭据转发到新的目标地址。

TLS 终止位置同样重要。CDN 证书验证通过，认证的是客户端到 CDN 的这一跳，并不自动认证之后到源站的每一跳。公共访问路径和相关上游路径需要分别监控。诊断应保留目标及观察时间，区分证书故障与 HTTP 故障，同时避免把凭据和私有请求数据写进输出。

快速验证

保存为 health_probe.go，使用 Go 1.23 或更新版本运行 go run health_probe.go。本地 TLS 1.3 服务提供四种应用响应，另一个明文服务充当重定向目标。客户端使用 httptest 提供的配置来信任测试服务器证书，不改变全局信任库，也不访问任何公共入口。

package main

import (
 "crypto/tls"
 "crypto/x509"
 "errors"
 "fmt"
 "io"
 "log"
 "net/http"
 "net/http/httptest"
 "runtime"
 "sync/atomic"
 "time"
)

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

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

func main() {
 var handled, redirectHits atomic.Int64
 target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 redirectHits.Add(1)
 fmt.Fprint(w, "not followed")
 }))
 defer target.Close()
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 switch r.URL.Path {
 case "/ready":
 fmt.Fprint(w, "ready")
 case "/wrong":
 fmt.Fprint(w, "different service")
 case "/down":
 http.Error(w, "unavailable", http.StatusServiceUnavailable)
 case "/redirect":
 http.Redirect(w, r, target.URL+"/landing", http.StatusFound)
 default:
 http.NotFound(w, r)
 }
 }))
 server.Config.ErrorLog = log.New(io.Discard, "", 0)
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()
 probe := func(route, name string) (int, bool, error) {
 config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 config.MinVersion = tls.VersionTLS13
 config.ServerName = name
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{TLSClientConfig: config, DisableKeepAlives: true}
 defer transport.CloseIdleConnections()
 client := &http.Client{
 Transport: transport, Timeout: 2 * time.Second,
 CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse },
 }
 response, err := client.Get(server.URL + route)
 if err != nil {
 return 0, false, err
 }
 defer response.Body.Close()
 body, err := io.ReadAll(response.Body)
 must(err)
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
 if response.StatusCode == http.StatusFound {
 check(response.Header.Get("Location") == target.URL+"/landing", "wrong redirect target")
 }
 return response.StatusCode, response.StatusCode == http.StatusOK && string(body) == "ready", nil
 }
 for _, test := range []struct {
 path string
 status int
 healthy bool
 }{
 {"/ready", 200, true}, {"/wrong", 200, false},
 {"/down", 503, false}, {"/redirect", 302, false},
 } {
 status, healthy, err := probe(test.path, "")
 must(err)
 check(status == test.status && healthy == test.healthy, "wrong health classification")
 fmt.Println(test.path, "verified TLS; HTTP", status, "healthy:", healthy)
 }
 _, _, err := probe("/ready", "wrong.example.test")
 var nameError x509.HostnameError
 check(errors.As(err, &nameError), "wrong TLS name must fail")
 check(handled.Load() == 4, "wrong name must not reach HTTP")
 status, healthy, err := probe("/ready", "")
 must(err)
 check(status == 200 && healthy && handled.Load() == 5, "trusted health probe must recover")
 check(redirectHits.Load() == 0, "HTTP redirect destination must remain unvisited")
 fmt.Println("wrong name rejected before HTTP; redirect not followed; healthy request succeeds again")
 fmt.Println(runtime.Version())
}

最初四次请求都通过 TLS 验证，但只有 /ready 满足本例的健康约定：HTTP 200，且正文精确等于 ready。/wrong 同样返回 200，却包含另一种服务内容；/down 返回 503。两者都不能判断为健康，即使 HTTP 层面的交换已经成功完成，也不能省略对业务响应的判断。

/redirect 返回 302，并在 Location 中指向明文地址。ErrUseLastResponse 让调用方取得这个响应而不继续跳转，因此目标服务的计数始终为零。本例刻意拒绝所有自动重定向，并不是完整的跳转链审计器。实际监控在跟随跳转之前，仍需先定义可接受的目标范围和传输要求。

文章中的前四份响应均通过 TLS 1.3 验证。本例仅把 HTTP 200 且正文精确等于 ready 视为健康。302 响应的明文 Location 不被跟随，目标未收到请求。此本地实验不检查公网边缘、上游链路或吊销。

故意提供错误 TLS 名称时，客户端得到 HostnameError，不会新增一次 HTTP handler 调用。随后再次使用正确配置请求 /ready，必须恢复成功，使应用请求总数为五。每次尝试都使用独立 transport，保留普通证书验证，并设置两秒客户端超时，让错误身份测试不受已认证连接复用的影响。

这里的两秒是整个客户端请求的截止时间，包含建立连接和读取正文，不是仅限制 TLS 握手；即使收到响应头，正文读取仍受它约束。这个实验没有刻意注入超时，不能把设置超时本身算作超时行为验收。

已核验的 macOS、Go 1.27.0 运行通过全部断言。这用真实本地连接区分了传输身份、协议交换成功和应用健康，但没有枚举公网套件、检查所有边缘节点、验证吊销或浏览器策略，也没有检查上游链路或运行生产负载。正文 ready 只是实验约定，不是所有服务健康判断都应该照抄的固定答案。

来源

RFC 9110：HTTP 语义，响应状态与重定向语义，已核验 2026-09-09。
Go net/http，非成功状态响应、重定向控制和客户端超时，已核验 2026-09-09。
Go crypto/tls，对端验证与协商连接状态，已核验 2026-09-09。
Go crypto/x509，主机名验证与证书链检查，已核验 2026-09-09。

SNI 根据请求主机名选择 TLS 证书

Sun, 08 Nov 2026 00:00:00 +0000

服务器名称指示 SNI 在 TLS 服务器选择握手参数和证书时，提供客户端希望访问的主机名。本文讨论的是证书认证且没有 early data 的路径，因此选择发生在普通 HTTP 字节发送之前，不是网络上任何字节都还没出现的时候。SNI 只是帮助选择，客户端仍然必须验证返回的证书身份。

同一个地址上的不同决策

客户端把 server_name 放在 ClientHello 中，托管多个名称的服务器可以据此选择证书或安全配置。TLS 1.3 在 ServerHello 之后加密证书消息，所以“选证书和传证书都在加密开始之前完成”不是准确描述。应区分先收到选择提示，和随后如何保护证书及其他握手消息。

SNI 中的 DNS 主机名不等于建立连接时使用的目标 IP，填写名称也不要求实验域名真的经过公共 DNS 解析。RFC 6066 不允许在 HostName 字段直接放入 IPv4、IPv6 字面地址，并规定 DNS 主机名比较不区分大小写。客户端直接按 IP 访问时，可以不发送 DNS SNI，转而验证对应的 IP 身份。

多个站点也不一定要使用多张证书。一张证书可以覆盖多个 SAN，服务器没有收到 SNI 时也可以选择默认证书。客户端是否接受，取决于预期访问名称和信任规则；并不是缺少 SNI 就绝对无法建立安全连接。SNI 的作用是帮助选择，不是凭空建立信任，更不证明请求方拥有该主机名。

坏掉的样子

客户端即使连到了正确 IP，仍可能因为没有传递正确名称而拿到其他站点的默认证书。关闭主机名验证只会隐藏这类问题。应分别检查目标地址、预期 TLS 名称、返回证书的 SAN、信任链和有效期，不能把“地址没错”当成身份已经正确的证据。

HTTP Host 或 HTTP/2 的 authority 属于应用层，修改它们不会重新进行 TLS 握手或替换证书。ALPN 则单独协商 HTTP/2 等应用协议，不验证主机名，也不授权租户。证书选择、客户端对服务端身份的验证、协议协商与应用路由，需要分别检查；不能因为其中一项成功，就宣布其他边界也已经正确。

未知 SNI 可能被服务器拒绝，也可能获得默认证书，具体取决于配置；缺少 SNI 并不总会失败。未使用 ECH 时，普通 ClientHello 中的 SNI 在网络上可见，单纯采用 TLS 1.3 不会把它隐藏。ECH 需要额外的部署支持，也不能消除全部流量特征，因此不能把名称隐私当成无需验证就存在的能力。

SNI 证书选择：机制与证据边界。

快速验证

保存为 sni_probe.go，用 Go 1.23 或更新版本运行 go run sni_probe.go。程序在内存中生成一个短期测试 CA 和两张叶证书，只有本地测试客户端信任这个 CA。所有请求都连接同一个回环 IP，通过 ServerName 提供预期 TLS 名称，无需让测试域名经过公共 DNS；实验不复用 TLS 会话或 HTTP 连接。

测试 CA 与叶证书一小时后过期，这是隔离实验的选择，不是生产证书续期策略。生成了证书，不代表其他客户端就会信任它；本例明确配置的信任根池，才为这些请求建立了验证基础。需要把证书生成、服务端选择和客户端信任分开检查，不能把它们合并成一个含糊的“证书可用”。

package main

import (
 "crypto/ed25519"
 "crypto/rand"
 "crypto/tls"
 "crypto/x509"
 "errors"
 "fmt"
 "io"
 "log"
 "math/big"
 "net/http"
 "net/http/httptest"
 "runtime"
 "strings"
 "sync/atomic"
 "time"
)

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

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

func leaf(name string, serial int64, ca *x509.Certificate, signer ed25519.PrivateKey) tls.Certificate {
 public, private, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(serial), DNSNames: []string{name},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 KeyUsage: x509.KeyUsageDigitalSignature,
 ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
 }
 der, err := x509.CreateCertificate(rand.Reader, template, ca, public, signer)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return tls.Certificate{Certificate: [][]byte{der}, PrivateKey: private, Leaf: certificate}
}

func main() {
 public, private, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(1), IsCA: true, BasicConstraintsValid: true,
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 KeyUsage: x509.KeyUsageCertSign,
 }
 der, err := x509.CreateCertificate(rand.Reader, template, template, public, private)
 must(err)
 ca, err := x509.ParseCertificate(der)
 must(err)
 roots := x509.NewCertPool()
 roots.AddCert(ca)
 alpha := leaf("alpha.example.test", 2, ca, private)
 beta := leaf("beta.example.test", 3, ca, private)
 certificates := map[string]*tls.Certificate{
 "alpha.example.test": &alpha, "beta.example.test": &beta,
 }

 var handled, rejected atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 fmt.Fprintf(w, "%s|%s", r.TLS.ServerName, r.Host)
 }))
 server.Config.ErrorLog = log.New(io.Discard, "", 0)
 server.TLS = &tls.Config{
 MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13,
 Certificates: []tls.Certificate{alpha}, SessionTicketsDisabled: true,
 GetCertificate: func(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {
 certificate, ok := certificates[strings.ToLower(hello.ServerName)]
 if !ok {
 rejected.Add(1)
 return nil, fmt.Errorf("unknown fixture SNI")
 }
 return certificate, nil
 },
 }
 server.StartTLS()
 defer server.Close()

 request := func(name, host string) (string, error) {
 config := &tls.Config{RootCAs: roots, ServerName: name, MinVersion: tls.VersionTLS13}
 transport := &http.Transport{TLSClientConfig: config, DisableKeepAlives: true}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 request, err := http.NewRequest(http.MethodGet, server.URL, nil)
 must(err)
 request.Host = host
 response, err := client.Do(request)
 if err != nil {
 return "", err
 }
 defer response.Body.Close()
 body, err := io.ReadAll(response.Body)
 if err != nil {
 return "", err
 }
 check(response.StatusCode == 200, "unexpected HTTP status")
 check(response.TLS.Version == tls.VersionTLS13 && len(response.TLS.VerifiedChains) > 0, "verified TLS 1.3 required")
 check(string(body) == name+"|"+host, "handler must observe separate SNI and Host")
 certificate := response.TLS.PeerCertificates[0]
 must(certificate.VerifyHostname(name))
 return certificate.DNSNames[0], nil
 }

 for _, name := range []string{"alpha.example.test", "beta.example.test"} {
 selected, err := request(name, name)
 must(err)
 check(selected == name, "SNI must select its matching certificate")
 fmt.Println("SNI", name, "selected", selected)
 }
 selected, err := request("ALPHA.EXAMPLE.TEST", "alpha.example.test")
 must(err)
 check(selected == "alpha.example.test", "DNS name selection must be case-insensitive")
 selected, err = request("alpha.example.test", "beta.example.test")
 must(err)
 check(selected == "alpha.example.test", "HTTP Host must not change the TLS certificate")
 _, err = request("missing.example.test", "missing.example.test")
 check(err != nil && rejected.Load() == 1, "unknown SNI must be rejected by fixture policy")
 _, err = request("", "alpha.example.test")
 var nameError x509.HostnameError
 check(errors.As(err, &nameError), "without DNS SNI, default certificate must fail IP identity")
 check(handled.Load() == 4, "only four verified requests may reach the handler")
 fmt.Println("uppercase name selects alpha; Host override keeps alpha; unknown SNI and IP-name mismatch rejected")
 fmt.Println(runtime.Version())
}

alpha 和 beta 分别选中自己的证书，大写的 alpha 名称也应选中同一张 alpha 证书。客户端保持标准信任链和主机名验证，实验还额外检查了实际返回的证书。四个通过验证的请求进入回显 handler，其中一个刻意使用 alpha SNI 和 beta Host；它认证的仍然是 alpha，证明两个字段是不同输入，并不表示可以据此访问另一个租户的数据。

未知 SNI 被这个测试服务的固定名称策略拒绝。当 ServerName 为空时，请求地址中的 IP 不产生 DNS SNI，服务器选择的默认 alpha 证书又没有对应的 IP 身份，因此主机名验证失败。即使 HTTP Host 填写 alpha，也不能提前改变这个 TLS 验证结果。两个反向测试都没有进入 HTTP handler。

这里的 handler 有意回显两种名称，方便观察它们的差别，不是可直接投入生产的虚拟主机路由器。真实入口仍应按照既定策略解释 HTTP authority 和租户访问权限，不能根据 TLS 握手成功就忽略后续路由与授权检查，也不能把实验中允许的字段差异扩大成任意跨租户请求都可以处理。

保留证据能够确认 Go 1.24.4 编译通过，而握手执行仍被阻断；旧文的 macOS、Go 1.27.0 成功说法，在这里没有对应的留存运行记录。本次源码审阅没有执行 TLS 实验。源码表明私钥只用于样本，不安装到全局信任库；ECH、ALPN 协商、通配符、国际化名称、HTTP/2 合并、会话恢复与真实入口，仍需分别测试。

来源

RFC 6066：TLS 扩展，server_name、名称格式与服务端选择，已核验 2026-09-09。
RFC 8446：TLS 1.3，ServerHello 之后的加密握手消息，已核验 2026-09-09。
Go crypto/tls，ServerName、GetCertificate 与显式 ECH 配置，已核验 2026-09-09。
Go crypto/x509，测试证书生成与基于 SAN 的名称验证，已核验 2026-09-09。
Go net/http/httptest，临时回环 TLS 服务，已核验 2026-09-09。
RFC 7301：ALPN，应用协议选择不同于服务端名称指示，已核验 2026-10-18。

HSTS 让浏览器记住 HTTPS

Thu, 08 Oct 2026 00:00:00 +0000

HTTP 严格传输安全 HSTS 告诉支持它的客户端：以后访问记住的主机名时使用 HTTPS。它可以消除重定向之前的那次明文 HTTP 请求，但前提是客户端已经通过此前可信响应或受支持的预加载机制知道策略。只在服务器添加一个 Header，不能追溯保护未知客户端第一次发出的 HTTP 请求。

客户端记住的是主机名

客户端通过没有安全错误的 HTTPS 收到有效 Strict-Transport-Security 后，才建立或刷新策略。max-age 是从接收时刻起计算的秒数。明文 HTTP 上的同名 Header 不能建立这种信任；后来某次响应没有 Header，也不会删除尚未过期的记录。状态由各个客户端分别维护，浏览器之间不存在自动共享的统一缓存。

策略范围是 DNS 主机名，不是包含协议和端口的 HTTP origin。includeSubDomains 向下覆盖子域名，不覆盖父域或同级名称。升级 URL 时，显式的 80 端口会改为 443，其他显式端口保持不变。因此，原本在另一个端口上提供的 HTTP-only 服务，也可能在客户端学习策略后变得不可用。

这条规则改变的是客户端处理 URL 的方式，不会自动把服务器的明文监听器变成 TLS 监听器；升级后的目标必须事先具备 HTTPS 服务。下面的实验故意在 HTTP 响应中发送 HSTS，只作为反向测试，并不是部署建议。两个测试服务都不返回重定向，因此从 HTTP URL 进入 TLS handler，证明的是客户端主动升级，而非成功跟随了一串服务端跳转。

HSTS 是升级规则，不是绕过证书验证的开关。支持它的浏览器仍须验证 HTTPS，而且面对 HSTS 主机的证书错误，不提供通常的点击继续入口。它不能修复过期证书、恢复不可用的 TLS 服务，也不能证明认证连接背后的应用内容一定可信。

坏掉的样子

较长的有效期或 includeSubDomains 可能影响被遗忘的服务、委托给其他团队的子域和内部名称。扩大范围前，应先清点这些依赖，从较短策略开始，检查真实入口，并确认续期链路可靠。扫描器建议增加某个字段，并不等于所有受影响主机都已经能够履行承诺。

恢复时也要分清机制。客户端收到可信的 max-age=0 响应后，会移除该主机的动态策略，但不会删除子域独立保存的策略，也不能立刻更新尚未再次连接的离线客户端。仅删除响应头不够；浏览器预加载名单的分发和移除，又是独立流程，不会随着服务端切换字段马上完成。

仅验证 Header 存在，不能证明客户端真的按它行动。测试应使用独立状态库，同时检查初始访问和后续 HTTP URL，避免污染个人浏览器配置。也不要为了看到一次“升级成功”，就关闭证书验证。客户端实现或预加载配置不同，需要分别验收，不能把一个工具的结果套到所有浏览器上。

主机策略改变下一次请求。依据原文与明确限制静态绘制；未为本图重跑原文夹具。

快速验证

保存为 hsts_probe.go，使用 Go 1.23 或更新版本，以及支持 --hsts 的 curl，运行 go run hsts_probe.go。程序建立两个回环服务并生成临时 P-256 CA，只把公开 CA 证书和 curl 缓存写进独立临时目录，退出时删除该目录。私钥始终留在内存中，不写入文件。

package main

import (
 "context"
 "crypto/ecdsa"
 "crypto/elliptic"
 "crypto/rand"
 "crypto/tls"
 "crypto/x509"
 "crypto/x509/pkix"
 "encoding/pem"
 "errors"
 "fmt"
 "io"
 "log"
 "math/big"
 "net/http"
 "net/http/httptest"
 "net/url"
 "os"
 "os/exec"
 "path/filepath"
 "runtime"
 "strings"
 "sync/atomic"
 "time"
)

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

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

func issue(template, parent *x509.Certificate, public any, signer *ecdsa.PrivateKey) *x509.Certificate {
 der, err := x509.CreateCertificate(rand.Reader, template, parent, public, signer)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return certificate
}

func main() {
 curl, err := exec.LookPath("curl")
 must(err)
 versionCommand := exec.Command(curl, "--disable", "--version")
 versionCommand.Env = append(os.Environ(), "SSLKEYLOGFILE=")
 version, err := versionCommand.Output()
 must(err)
 check(strings.Contains(string(version), "HSTS"), "curl must support HSTS")
 caKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 must(err)
 leafKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
 must(err)
 now := time.Now()
 template := &x509.Certificate{
 SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "HSTS fixture CA"},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 IsCA: true, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCertSign,
 }
 ca := issue(template, template, caKey.Public(), caKey)
 host, child := "hsts.example.test", "child.hsts.example.test"
 leaf := issue(&x509.Certificate{
 SerialNumber: big.NewInt(2), DNSNames: []string{host, child},
 NotBefore: now.Add(-time.Minute), NotAfter: now.Add(time.Hour),
 KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
 }, ca, leafKey.Public(), caKey)
 folder, err := os.MkdirTemp("", "hsts-probe-")
 must(err)
 defer func() { must(os.RemoveAll(folder)) }()
 caFile, cacheFile := filepath.Join(folder, "ca.pem"), filepath.Join(folder, "hsts.txt")
 must(os.WriteFile(caFile, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: ca.Raw}), 0600))

 var plainCount, secureCount atomic.Int64
 plain := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 plainCount.Add(1)
 if r.URL.Path == "/learn" {
 w.Header().Set("Strict-Transport-Security", "max-age=3600; includeSubDomains")
 }
 fmt.Fprint(w, "plain")
 }))
 defer plain.Close()
 secure := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 secureCount.Add(1)
 check(r.TLS != nil, "secure handler requires TLS")
 switch r.URL.Path {
 case "/learn":
 w.Header().Set("Strict-Transport-Security", "max-age=3600; includeSubDomains")
 case "/clear":
 w.Header().Set("Strict-Transport-Security", "max-age=0")
 }
 fmt.Fprint(w, "secure")
 }))
 secure.Config.ErrorLog = log.New(io.Discard, "", 0)
 secure.TLS = &tls.Config{
 MinVersion: tls.VersionTLS12,
 Certificates: []tls.Certificate{{Certificate: [][]byte{leaf.Raw}, PrivateKey: leafKey, Leaf: leaf}},
 }
 secure.StartTLS()
 defer secure.Close()
 plainURL, err := url.Parse(plain.URL)
 must(err)
 secureURL, err := url.Parse(secure.URL)
 must(err)
 check(plainURL.Hostname() == "127.0.0.1" && secureURL.Hostname() == "127.0.0.1", "IPv4 loopback fixtures required")
 request := func(scheme, name, port, route string, trust bool) (string, error) {
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 args := []string{
 "--disable", "--noproxy", "*", "--silent", "--show-error", "--fail",
 "--max-time", "3", "--hsts", cacheFile, "--resolve", name + ":" + port + ":127.0.0.1",
 }
 if trust {
 args = append(args, "--cacert", caFile)
 }
 args = append(args, scheme+"://"+name+":"+port+route)
 command := exec.CommandContext(ctx, curl, args...)
 command.Env = append(os.Environ(), "SSLKEYLOGFILE=")
 output, err := command.CombinedOutput()
 return string(output), err
 }
 _, err = request("https", host, secureURL.Port(), "/learn", false)
 var exit *exec.ExitError
 check(errors.As(err, &exit) && exit.ExitCode() == 60, "untrusted HTTPS must fail certificate verification")
 for _, test := range []struct {
 label, scheme, name, port, route, expected string
 }{
 {"HTTP cannot seed HSTS", "http", host, plainURL.Port(), "/learn", "plain"},
 {"still HTTP", "http", host, plainURL.Port(), "/probe", "plain"},
 {"trusted HTTPS seeds HSTS", "https", host, secureURL.Port(), "/learn", "secure"},
 {"HTTP URL upgrades", "http", host, secureURL.Port(), "/probe", "secure"},
 {"child inherits upgrade", "http", child, secureURL.Port(), "/probe", "secure"},
 {"authenticated removal", "https", host, secureURL.Port(), "/clear", "secure"},
 {"parent HTTP restored", "http", host, plainURL.Port(), "/probe", "plain"},
 {"child HTTP restored", "http", child, plainURL.Port(), "/probe", "plain"},
 } {
 output, err := request(test.scheme, test.name, test.port, test.route, true)
 check(err == nil, fmt.Sprintf("curl failed: %v: %s", err, output))
 check(output == test.expected, "wrong transport result")
 fmt.Println(test.label, "->", output)
 }
 check(plainCount.Load() == 4 && secureCount.Load() == 4, "expected four plaintext and four authenticated TLS requests")
 fmt.Println(strings.SplitN(string(version), "\n", 2)[0])
 fmt.Println(runtime.Version())
}

所有测试主机名都通过 --resolve 显式指向回环地址，不访问公共 DNS 或外部站点。--disable 放在 curl 参数最前面，避免加载个人配置；--noproxy 排除代理干扰。所有 curl 子进程都清空 SSLKEYLOGFILE，禁用从环境继承的 TLS 密钥日志。每次传输限时三秒，外层进程还有五秒截止时间。测试 CA 按请求传入，不安装到系统信任库。

第一次 HTTPS 请求没有携带测试 CA，必须以 curl 证书验证错误码 60 失败。随后即使明文 HTTP 响应发送了 HSTS，下一次访问仍然是明文。经过验证的 HTTPS 响应才会写入共享测试缓存；此后父域和子域的 HTTP URL 都进入 TLS handler。

可信的 max-age=0 响应移除父域记录后，父域和子域的 HTTP 请求又能进入明文 handler，因为本例从未给子域设置独立策略。最终两个 handler 各处理四次请求，证书验证失败的那次不进入任何应用 handler。升级过程中，URL 中显式给出的非标准 TLS 端口保持不变。

已核验的 macOS、Go 1.27.0、curl 8.7.1 运行通过全部断言。这验证的是 curl 真实的 HSTS 行为，不是浏览器策略验收。实验没有检查浏览器预加载名单、子域独立策略、等待到期、80 到 443 的端口映射、证书错误界面或生产发布。临时缓存随后被删除，不改变用户已有的持久 HSTS 状态。

来源

RFC 6797：HTTP 严格传输安全，经过认证的策略处理、主机范围和端口映射，已核验 2026-09-09。
MDN：Strict-Transport-Security，子域策略、移除和预加载边界，已核验 2026-09-09。
curl 手册，--hsts、显式名称解析、CA 选择与配置隔离，已核验 2026-09-09。

设定 TLS 版本下限并验证边界

Wed, 23 Sep 2026 00:00:00 +0000

TLS 版本策略决定一个端点愿意接受哪些握手。应明确最低版本，而不是假定库每次升级后的默认值都符合自己的要求。最高版本是另一项独立约束，没有必要地把它固定死，可能阻止以后采用库已经支持的新协议。无论设置了哪种上下限，都不能替代证书身份验证、合适的算法以及持续的安全更新。

最低版本与最高版本是两回事

RFC 8996 已废弃 TLS 1.0 和 1.1；RFC 9325 同时排除 SSLv2、SSLv3，建议支持 TLS 1.3 并在实现支持时优先协商它，也给出了继续使用 TLS 1.2 时应满足的安全要求。对于客户端群体明确的服务，可以评估兼容性后只允许 TLS 1.3；但不能因为存在更严格的配置，就把所有 TLS 1.2 连接一律说成不安全。

双方都支持 TLS 1.3 时，服务器同时允许 TLS 1.2，不等于攻击者可以随意强迫它们选择最弱的版本。TLS 有经过认证的协商过程，也有针对降级攻击的保护。不过，真实的旧版客户端仍然可能合法选择服务器允许的较旧版本，不安全的重试逻辑也可能削弱策略。最低版本应在每条新连接上执行，不能把“最后总算连上”当作唯一验收标准。

抓包里的版本数字还必须结合字段含义解读。TLS 1.3 为兼容性把 hello 中的旧版本字段设为 0x0303，实际版本则通过 supported_versions 协商。因此，单独看到这个旧字段，不能断定连接正在使用 TLS 1.2。有条件时应读取 TLS 库提供的最终协商状态，而不是从某一个兼容字段猜测协议。

坏掉的样子

浏览器访问成功，只能证明一条被允许的路径可用，不能证明 TLS 1.0 已经被拒绝，也不能证明业务必须支持的 TLS 1.2 客户端仍然可用。正向和反向边界需要分别测试，还要使用正确的目标名称与信任根，避免证书错误掩盖版本策略的效果。

负载均衡器可能在应用收到请求之前就终止了 TLS。客户端到边缘、边缘到源站，是两段不同的策略；不同端口、地址族或监听器也可能加载不同配置。验收时应探测真实用户访问的入口，不能只检查后端守护进程。配置重载成功说明预期配置被尝试应用，而实际握手结果才说明对端真正接受了什么。

Go 的 TLS Config 传给 TLS 函数后不得继续修改，因此本例在启动服务之前构造好各份配置。实际部署应采用服务支持的重载流程，再用新连接验证生效结果，不能在握手仍然使用同一个共享配置时原地改字段。配置对象的并发使用规则，也是调整安全策略时需要遵守的契约。

版本范围有交集也只是必要条件。签名算法、密钥交换组、证书名称或信任链不满足要求，仍然会造成失败。应保留原始错误，不能把所有握手失败都归因为版本不匹配，更不能遇到超时就悄悄降低最低版本。否则，一次临时网络问题可能触发持续存在的安全降级，排障时也很难还原最初的边界。

TLS 版本边界：机制与证据边界。

快速验证

把程序保存为 version_probe.go，使用 Go 1.23 或更新版本运行 go run version_probe.go。两个临时回环 HTTPS 服务使用相同测试逻辑，但具有不同的最低版本。测试证书只在本地测试客户端中受信任，不写入系统证书库；请求使用新的 transport，保持证书验证开启，并设置两秒期限。

服务端范围	客户端范围	预期结果
1.2–1.3	1.2–1.3	TLS 1.3
1.2–1.3	仅 1.2	TLS 1.2
1.2–1.3	仅 1.1	拒绝
仅 1.3	仅 1.2	拒绝
仅 1.3	1.2–1.3	TLS 1.3

package main

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

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

func probe(server *httptest.Server, minimum, maximum uint16) (uint16, error) {
 config := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 config.MinVersion, config.MaxVersion = minimum, maximum
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{TLSClientConfig: config, DisableKeepAlives: true}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 response, err := client.Get(server.URL)
 if err != nil {
 return 0, err
 }
 defer response.Body.Close()
 body, err := io.ReadAll(response.Body)
 if err != nil {
 return 0, err
 }
 check(response.StatusCode == 200 && string(body) == "ok\n", "unexpected HTTP reply")
 check(response.TLS.HandshakeComplete && len(response.TLS.VerifiedChains) > 0, "verified handshake required")
 return response.TLS.Version, nil
}

func main() {
 var handled atomic.Int64
 start := func(minimum uint16) *httptest.Server {
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 fmt.Fprintln(w, "ok")
 }))
 server.Config.ErrorLog = log.New(io.Discard, "", 0)
 server.TLS = &tls.Config{MinVersion: minimum, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 return server
 }
 compatible := start(tls.VersionTLS12)
 defer compatible.Close()
 strict := start(tls.VersionTLS13)
 defer strict.Close()

 version, err := probe(compatible, tls.VersionTLS12, tls.VersionTLS13)
 check(err == nil && version == tls.VersionTLS13, "modern peers must select TLS 1.3")
 fmt.Println("server 1.2-1.3, client 1.2-1.3:", tls.VersionName(version))

 version, err = probe(compatible, tls.VersionTLS12, tls.VersionTLS12)
 check(err == nil && version == tls.VersionTLS12, "TLS 1.2-only client must remain compatible")
 fmt.Println("server 1.2-1.3, client 1.2 only:", tls.VersionName(version))

 _, err = probe(compatible, tls.VersionTLS11, tls.VersionTLS11)
 check(err != nil, "client below TLS 1.2 floor must fail")
 _, err = probe(strict, tls.VersionTLS12, tls.VersionTLS12)
 check(err != nil, "client below TLS 1.3 floor must fail")
 check(handled.Load() == 2, "rejected handshakes must not reach HTTP")

 version, err = probe(strict, tls.VersionTLS12, tls.VersionTLS13)
 check(err == nil && version == tls.VersionTLS13, "strict server must still accept TLS 1.3")
 check(handled.Load() == 3, "exactly three HTTP requests must succeed")
 fmt.Println("both below-floor clients rejected; strict server still accepts TLS 1.3")
 fmt.Println(runtime.Version())
}

程序逐一断言表中的组合，并确认被拒绝的握手没有进入 HTTP handler。前两个正常请求之后，计数为二；两个反向测试之后仍然为二；最后，严格服务器接纳支持 TLS 1.3 的客户端，计数才变成三。这样同时检查拒绝边界和保留的正常能力，而不是把所有连接都拒绝后也算“加固成功”。

每个反向断言接受任何非空错误，并丢弃具体信息，因此不能独立证明拒绝原因就是版本不匹配。旧文的 macOS、Go 1.27.0 成功说法，在这里没有对应留存记录，本次审阅也未执行 TLS。固定最高版本让对照条件明确，不是生产建议；源码意在建立真实连接，但没有测试 SSLv2、SSLv3、TLS 1.0、主动降级攻击或生产代理发布。

提高线上最低版本之前，需要盘点仍应支持的客户端，在预发布环境测试实际监听器配置，并观察发布过程中的握手失败。兼容性不符合预期时，应重新评估原来的版本策略，而不是关闭身份验证来恢复表面上的成功。两个开关解决不同问题，不能用牺牲证书验证的方式弥补版本范围与真实用户能力之间的冲突。

来源

RFC 8996：废弃 TLS 1.0 和 TLS 1.1，拒绝已废弃协议版本，已核验 2026-09-09。
RFC 9325：安全使用 TLS 与 DTLS，版本策略、优先级与兼容性指导，已核验 2026-09-09。
RFC 8446：TLS 1.3，supported_versions 与降级保护，已核验 2026-09-09。
Go crypto/tls，MinVersion、MaxVersion 与协商状态，已核验 2026-09-09。
Go net/http/httptest，本地 TLS 测试服务与受信任测试客户端，已核验 2026-09-09。

TLS 1.3 握手基础

Thu, 06 Aug 2026 00:00:00 +0000

TLS 1.3 握手负责建立流量密钥，并按照应用指定的信任规则认证对端。普通 HTTPS 通常认证服务器，客户端证书需要另外配置，并不是连接一加密就自动双向认证。TCP 建连成功只说明传输连接建立了，既不证明证书身份正确，也不证明 HTTP 服务能够完成请求。

一次往返究竟计算什么

常见的证书认证握手由 ClientHello 开始，其中包含客户端支持的版本、算法和密钥份额。服务器通过 ServerHello 选择参数并提交自己的份额，随后发送加密扩展、证书、CertificateVerify 和 Finished。客户端验证证书与握手证明后，才发送自己的 Finished 和普通应用数据，而不是看到任意证书就立即信任对端。

没有 HelloRetryRequest 时，客户端可以在已建立的传输连接上经过一次 TLS 往返后发送这些数据。这一数字不包含 DNS 查询、TCP 建连，以及 HTTP 请求发出后的响应路程。如果客户端首次没有提供服务器需要的密钥份额，服务器可能要求 HelloRetryRequest，增加一次交换；如果根本没有共同参数，协商则可能直接失败。因此，一次 RTT 描述的是特定协议路径，不是整个网页加载时间的承诺。

TLS 1.3 的密码套件名称表示记录加密算法与哈希，并不会独自告诉你证书使用了什么签名算法，也不完整表示协商出的密钥交换组。看到套件里有 AES，不等于已经确认身份验证成功，更不能据此推断它使用了哪种临时交换。

身份认证与前向保密

在证书认证的临时 Diffie-Hellman 交换中，只要临时机密正确销毁、通信期间端点没有被攻破，攻击者日后仅取得证书私钥，不能据此还原此前记录的会话。这是有前提的前向保密，不是对任何形式的端点入侵都免疫。RSA 证书仍可以给临时交换做认证；证书是 RSA，不代表正在使用旧式 RSA 密钥传输。

但不能把这个结论扩展为“所有 TLS 1.3 模式都有同样的前向保密”。协议还定义了仅使用 PSK，以及 PSK 配合 DHE 的模式，前者没有后者的这项性质。可选 early data 的保证也更弱：它不具有前向保密，跨连接重放保护也不同于普通数据。服务器发过会话票据，不代表客户端自动启用 early data，更不代表以后的每次握手都变成零往返。

坏掉的样子

排障时要拆开版本协商、证书信任链、主机名验证和业务响应。两端版本范围没有交集，会在 HTTP 之前失败；未知签发者或错误的证书 SAN 也必须被拒绝，即使双方原本可以建立某种加密通信。证书过期和机器时钟异常需要分别核查，下方实验没有模拟这两种情况。

SNI 用于帮助服务器选择虚拟主机，主机名验证则检查返回的证书是否符合预期身份，两者不是同一个动作。工具打印了证书或密码套件，不意味着它已经执行并通过完整验证。应保留原始错误和预期访问名称，不能为了让检查通过就关闭验证、随意降低版本下限，或者不断重试掩盖确定性的配置错误。

下方把版本范围精确限定为 TLS 1.3，是为了观察清楚协商结果，不是未经评估就应采用的生产策略。版本上下限也不能修复证书信任问题。如果反向代理终止 TLS，必须分别检查客户端到代理、代理到上游的连接；它们是独立的握手，可能协商不同版本，也可能认证不同身份，不能用其中一段的成功代替另一段的证据。

快速验证

把下列代码保存为 handshake_probe.go，使用 Go 1.23 或更新版本执行 go run handshake_probe.go。程序只依赖标准库，在本机回环地址启动临时 HTTPS 服务。测试客户端仅信任该测试证书，不向系统证书库写入信任项；每个请求限制为两秒，并创建新的 HTTP transport，避免连接复用掩盖握手。

package main

import (
 "crypto/tls"
 "crypto/x509"
 "errors"
 "fmt"
 "io"
 "log"
 "net/http"
 "net/http/httptest"
 "runtime"
 "sync/atomic"
 "time"
)

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

func fetch(server *httptest.Server, config *tls.Config) (tls.ConnectionState, error) {
 transport := &http.Transport{
 TLSClientConfig: config,
 DisableKeepAlives: true,
 }
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}
 response, err := client.Get(server.URL)
 if err != nil {
 return tls.ConnectionState{}, err
 }
 defer response.Body.Close()
 body, err := io.ReadAll(response.Body)
 if err != nil {
 return tls.ConnectionState{}, err
 }
 check(response.StatusCode == 200 && string(body) == "ok\n", "unexpected HTTP reply")
 return *response.TLS, nil
}

func main() {
 var handled atomic.Int64
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 fmt.Fprintln(w, "ok")
 }))
 server.Config.ErrorLog = log.New(io.Discard, "", 0)
 server.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 server.StartTLS()
 defer server.Close()

 trusted := server.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 trusted.MinVersion, trusted.MaxVersion = tls.VersionTLS13, tls.VersionTLS13
 check(!trusted.InsecureSkipVerify, "certificate verification must stay enabled")
 state, err := fetch(server, trusted)
 check(err == nil, fmt.Sprint(err))
 check(state.HandshakeComplete && state.Version == tls.VersionTLS13, "TLS 1.3 required")
 check(!state.DidResume && len(state.VerifiedChains) > 0, "a verified full handshake is required")
 fmt.Println(tls.VersionName(state.Version), tls.CipherSuiteName(state.CipherSuite), "verified")

 wrongName := trusted.Clone()
 wrongName.ServerName = "wrong.invalid"
 _, err = fetch(server, wrongName)
 var nameError x509.HostnameError
 check(errors.As(err, &nameError), "wrong name must fail hostname verification")

 untrusted := trusted.Clone()
 untrusted.RootCAs = x509.NewCertPool()
 _, err = fetch(server, untrusted)
 var trustError x509.UnknownAuthorityError
 check(errors.As(err, &trustError), "empty roots must reject the test certificate")

 oldVersion := trusted.Clone()
 oldVersion.MinVersion, oldVersion.MaxVersion = tls.VersionTLS12, tls.VersionTLS12
 _, err = fetch(server, oldVersion)
 check(err != nil, "disjoint protocol versions must fail")
 check(handled.Load() == 1, "failed TLS attempts must not reach the HTTP handler")

 _, err = fetch(server, trusted)
 check(err == nil && handled.Load() == 2, "trusted TLS 1.3 must still work")
 fmt.Println("wrong name, untrusted certificate, and TLS 1.2-only client rejected before HTTP")
 fmt.Println(runtime.Version())
}

第一次请求输出 TLS 1.3 和协商得到的密码套件，具体套件可能随环境变化。错误名称和空信任根分别断言具体的 X.509 错误类型；随后只支持 TLS 1.2 的客户端无法连接只接受 TLS 1.3 的服务器。三个失败请求都没有进入 HTTP handler，计数始终为一；恢复正确配置后，请求再次成功，计数变成二。这说明拒绝发生在握手边界，而不是应用返回了一个错误页面。

图示为传输层已建立、没有 HelloRetryRequest 的常规证书认证 TLS 1.3 握手。文章的独立回环检查中，wrong.invalid、空信任根与不相交版本范围均在 HTTP 之前失败。本例不测量线上 RTT，也未验证 early data 或双向 TLS。

保留原文记述了 macOS、Go 1.27.0 上全部断言通过的结果；本轮没有重跑该 Go 夹具。源代码始终开启证书验证。该实验真实执行了 TLS 握手，但没有抓包测量 RTT，也没有验证双向 TLS、零往返数据、公共 DNS 或生产证书发布。调整线上协议范围之前，仍应单独测试实际客户端群体及其信任根；本地测试客户端信任测试证书，不能替代真实用户环境的兼容性检查。

来源

RFC 8446：TLS 1.3，第 1.2、2–2.3 节：完整握手、PSK 模式、重试交换与 early data 限制，已核验 2026-09-09。
Go crypto/tls，版本范围、证书验证与 ConnectionState，已核验 2026-09-09。
Go net/http/httptest，回环 TLS 测试服务与测试客户端信任配置，已核验 2026-09-09。

审计公共边缘的信任

Thu, 06 Aug 2026 00:00:00 +0000

Web 安全系列把设置当作带作用域与失败模式的契约。本教程检查你有权查询的主机。HTTP、TLS 与 DNS 请求是只读观察，但仍会产生日志和流量。SSH 检查读取你自己的信任记录；部署主机可能不同于网站主机。

用一次性本地工作目录保存输出。这里没有任何输出被当作刚测得的 www.xbcatm.com 生产状态；命令通过，只能证明它实际检查的性质。

每项观察只支持范围明确的论断。头部存在、证书日期与本地记录不能合成整站安全认证。

1. 从边缘声明的策略开始

抓取 GET 响应，不默默跟随重定向，再检查状态与头部：

host=www.xbcatm.com
url="https://$host/"
curl -sS --max-time 20 -D headers.txt -o body.html "$url"
cat headers.txt

仓库预期策略包含以下示意字段：

Content-Security-Policy: default-src 'self'; base-uri 'self'; form-action 'none'; frame-ancestors 'none'; object-src 'none'; script-src 'none'; style-src 'self'; img-src 'self' data:
Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-Frame-Options: DENY

script-src 'none' 是适合本站无脚本要求的严格选择，不是所有静态站的通用配方。CSP 由浏览器执行；报告模式不会阻止执行。应读完整策略，检查更具体的脚本指令，并比较普通页与错误路由。nosniff 限制 MIME 处理，尤其是脚本和样式表目标，但不证明正文的媒体类型正确。

HSTS 从有效 HTTPS 响应学习，作用于发送它的主机。www.example.com 的 includeSubDomains 覆盖该名称的后代，不覆盖兄弟 api.example.com 或父域 example.com。采用较长时长前先清点实际范围。代理增加或移除头部会改变浏览器契约，因此产物检查与边缘检查需要分开。

2. 读取证书日期前先验证 TLS 身份

SNI 选择目标虚拟主机，不验证证书名称。应让验证失败成为致命错误，并显式启用主机名验证。使用与受测客户端相适应、保持更新的信任库。

openssl s_client -connect "$host:443" -servername "$host" \
 -verify_hostname "$host" -verify_return_error -showcerts \
 </dev/null > tls.txt 2> tls.log
# Continue only if the command succeeded; preserve tls.log on failure.
openssl x509 -in tls.txt -noout -subject -issuer -dates -ext subjectAltName

分别检查每步结果，或在失败即停止的 shell 设置下运行。隐藏 stderr 或把结果管道给成功的 x509，可能掩盖握手失败。应检查 subjectAltName 的 DNS 名称；显示的 subject CN 不足以完成现代服务身份验证。某些库版本仍保留旧式 CN 回退，因此也要明确检查预期 SAN 存在。合法匹配的通配符可以有效，不相关的证书则不行。

notAfter 给出到期时刻，不证明信任链有效、主机名匹配，也不说明检查过吊销。记录日期与测量出的安全窗口，不要依赖记忆。OpenSSL 的结果描述其已配置的信任库与检查，不代表所有浏览器。

3. 读取呈现链，不虚构固定数量

-showcerts 输出的是服务器发送的证书，不是它们已经组成已验证链的声明。以下命令仅显示数量：

grep -c 'BEGIN CERTIFICATE' tls.txt

不存在“必须四张”的要求。服务器通常提供叶证书及必要的中间证书；根一般属于客户端信任库，不必发送。数量随 CA 与所选路径变化。只有一张时值得调查是否缺少中间证书，但数量本身既不代表成功，也不代表失败。

应使用第 2 步真实的验证结果，再调查签发者或 SAN 变化、中间证书缺失、到期及信任库差异。中间证书轮换可能只是正常 CA 维护；数量没变也可能出错。这个计数命令不会自动与任何预期值作比较。

4. 重新验证已抓取的表示

缓存是另一份契约，不是 TLS 身份证据。按照 HTTP 演练抓取当前 ETag，并对相同表示选择发出条件请求。匹配的条件 GET 可以返回 304；两次请求之间发生发布，则可能合法返回 200。旧的硬编码校验器不是变化站点的可复用测试夹具。

无脚本策略不等于 CSP 永远不变。安全头可以独立于 HTML 改变，正文 ETag 也不是所有响应头的指纹。发布后应再次记录真实策略。

5. 找到适用的 CAA 策略

CAA 约束合规证书机构的签发，不是证书固定，也不会追溯地使已签发证书失效。先检查查询名称及其祖先，保留响应状态，避免把 DNS 失败误当成空答案。

dig www.xbcatm.com CAA +noall +comments +answer
dig xbcatm.com CAA +noall +comments +answer

www 的空答案不代表签发无限制。RFC 8659 会向上寻找第一个适用的非空 CAA 集合，每次查找按 DNS 规则跟随别名；需要时继续检查祖先。检查 issue，涉及通配符签发时还要看 issuewild。只有 iodef 报告地址并不限制签发。若没有适用限制，CAA 不增加签发者限制，但常规域名验证与 CA 规则仍适用。

应将 CA 文档规定的 CAA 标识与适用策略比较，不是只看叶证书中供人阅读的 issuer CN。今天的 CAA 结果证明的是今天的 DNS 策略，不证明证书签发时存在什么策略。

6. 检查部署主机已记录的 SSH 身份

使用真实 SSH 目标；非默认端口需要方括号主机加端口形式。ssh-keygen -F 能找到直接 grep 主机名会遗漏的哈希 known-host 条目。

deploy_host=deploy.example.test
ssh-keygen -F "$deploy_host" -f "$HOME/.ssh/known_hosts" > host-record.txt
ssh-keygen -lf host-record.txt

把指纹与独立可信记录比较，例如提供商控制台或已验证的管理员渠道。这只读取本地记录，不证明远端现在呈现什么密钥。网络扫描到的密钥本身也不能完成身份认证。更新信任前先调查变化；重建只是可能原因，不是自动接受的许可。

检查已抓取响应中的所有 Set-Cookie，以及相关重定向或应用路由。一个页面没设置 Cookie，不证明整站从不设置。主机专用 Cookie 省略 Domain；添加父域 Domain 会扩大接收它的主机范围。Path 控制发送范围，但不是防御同源代码的安全边界。

Secure 限制传输，HttpOnly 阻止脚本访问 Cookie，SameSite 控制规定的跨站发送行为。它们针对不同风险，不能互相代替；现代浏览器中的 SameSite=None 需要 Secure。对本站无账户的内容模型，扩大作用域前应先问为什么需要 Cookie。共享审计记录时应隐藏 Cookie 值。

保留范围明确的审计记录

记录 UTC 时间、客户端版本、请求及最终 URL、状态、强制策略头、TLS 验证结果与日期、适用 CAA 查询及 SSH 记录来源。区分观察成功、意外结果与未执行检查。这几项观察不止“两条命令”，也不能证明整个服务安全。

证书、DNS、代理或部署变化后，重做相关检查。保留旧结果以发现漂移；论断依赖浏览器执行时，应另行测试真实浏览器行为。

来源

WHATWG Fetch Standard，nosniff 处理与请求目标，已核验 2026-10-15。
OpenSSL s_client，SNI、主机名验证、致命验证错误与呈现链，已核验 2026-10-15。
RFC 9525：Service Identity in TLS，基于 SAN 的服务身份与通配符匹配，已核验 2026-10-15。
RFC 8659：CAA，适用记录集搜索与签发策略，已核验 2026-10-15。
RFC 6797：HSTS，主机范围与策略处理，已核验 2026-10-15。
OpenSSH ssh-keygen，已知主机查找与指纹显示，已核验 2026-10-15。
W3C：CSP Level 3，强制与报告模式及脚本指令回退（工作草案），已核验 2026-10-15。
MDN：Set-Cookie，Cookie 属性与边界，已核验 2026-10-15。

HSTS 应带着恢复计划来灰度发布

Tue, 23 Jun 2026 00:00:00 +0000

HTTP Strict Transport Security 告诉支持的浏览器，在一个缓存周期内对该主机强制使用 HTTPS。这种持久性既是特性也是风险：移除响应头并不会立刻抹掉客户端已存储的策略。

观察后再增加 HSTS 时长，独立决定后代覆盖与预加载。恢复需要有效 HTTPS，也不能立刻抹除所有已存或预加载策略。

先验证 HTTPS 路径

在发送 HSTS 之前，确认规范主机名提供有效证书，并且 HTTP 在不依赖用户输入的情况下重定向到预期的 HTTPS URL：

curl -sS -D - -o /dev/null --max-redirs 0 http://www.example.test/
curl -sS -D - -o /dev/null https://www.example.test/

检查有代表性的深层路由与错误页。HSTS 无法修复证书错误，因为浏览器在接受该策略之前要求有效的 HTTPS 连接。

从一个短的 max-age 开始

分阶段发布能在配置还新的时候限制恢复窗口：

Strict-Transport-Security: max-age=300

观察站点与续期路径之后，再有意识地提高时长。记录日期、所选值与回滚条件。最终策略可能用一年，但这个数字是一种承诺，而不是扫描器分数。

把 includeSubDomains 当作独立的决定

includeSubDomains 把策略扩展到每个子域名。先盘点名称，包括旧服务、委派区，以及只在内部网络使用的主机名。即使只有一个仅 HTTP 的后代，也足以让该选项对收到父级策略的客户端产生破坏。

预加载不是普通的响应头配置

浏览器预加载程序可以在正常响应周期之外分发策略，其要求与移除延迟比设置一个响应头更严格。不要仅仅因为扫描器推荐就申请预加载；请先确认对域名及所有被覆盖名称的长期所有权。

验证公共响应

curl -sS -D - -o /dev/null https://www.example.test/ \
 | awk 'tolower($1) == "strict-transport-security:" { print }'

测试规范的公共边缘，而不只是某个源站端口。代理可能添加、移除或重复该响应头。

知道回滚能清除什么

通过有效 HTTPS 响应发送 max-age=0，只会让收到该响应的客户端清除该主机已学习的策略。移除响应头或通过 HTTP 发送它，都不能清除已缓存策略。子域无法退出父域仍有效的 includeSubDomains；清除父域策略，也不会删除客户端独立从子域学习到的策略。

作用域由发送响应头的主机决定：www.example.test 的策略覆盖自身，加上 includeSubDomains 后覆盖其后代，但不覆盖同级的 api.example.test 或父级 example.test。恢复期间必须保持 HTTPS 可用。移除预加载是独立的浏览器更新过程，不是响应头的即时回滚。

来源

RFC 6797 — HTTP Strict Transport Security，策略处理与作用域，已核验 2026-10-15。
MDN: Strict-Transport-Security，指令与部署注意事项，已核验 2026-10-15。
HSTS 预加载项目，提交要求与移除限制，已核验 2026-10-15。

TLS 证书过期是一个能读到的日期

Mon, 22 Jun 2026 00:00:00 +0000

证书过期是证书验证需要处理的截止时间，不是必然立刻关闭所有既有连接的定时器。检查时应读取目标主机名实际收到的证书，再把它的有效期与其他信任条件分开判断。即使 notAfter 还在未来，也不能仅凭这一个日期宣称整个 HTTPS 服务健康。

比较时刻，不比较日历标签

RFC 5280 把有效期定义为从 notBefore 到 notAfter，包含两个端点。验证时间落在区间之外时，证书不能通过有效期检查；恰好处于 notAfter 的那个时刻仍在区间内。但这不意味着可以等到最后一秒才处理续期，时钟误差、重试和分批部署都要求提前留出余量。

这些字段描述绝对时刻。日志统一使用 UTC 便于排查，但两个已经正确解析的时间，即使使用不同的时区表示，也可以指向同一个瞬间。应使用时间库计算差值，不要比较本地日期字符串，也不要只看向下取整后的“剩余几天”，否则可能掩盖尚未生效的证书，或者推迟已经紧急的告警。

检查公共入口时，需要带上正确的 SNI 和预期主机名，不能只检查源站磁盘上的证书文件。不同监听器、区域或负载均衡节点可能仍在提供不同证书。读取公开证书不需要私钥，但能够取到有效期，并不等于信任链、主机名、用途及适用的客户端策略都已经验证成功。

坏掉的样子

续签成功而部署失败是常见的两步错位：新证书已经落盘，运行中的进程却还在提供旧证书。重载之后，应从真实入口比较已提供证书的指纹和有效期，并覆盖相关边缘节点。也要检查实际选择的证书链，因为叶证书仍然有效时，中间证书过期一样可能导致验证失败。

时钟漂移会让刚签出的证书看起来尚未生效。监控若遇到连接超时、取不到证书或解析失败，不能把空的到期时间当作健康结果。应区分“没有取得可信证据”和“验证成功且剩余时间充足”，并为每个受监控入口安排明确的责任人和升级路径，避免告警存在却无人处理。

续期和预警阈值需要结合证书实际寿命及故障恢复时间，不能把三十天当成所有场景通用的常量。Let’s Encrypt 建议可用时采用 ACME Renewal Information，并分散续期工作。签发失败与正在提供的证书接近过期应分别监控；续期也不自动等于每次都轮换私钥，更不等于执行了吊销检查。

快速验证

保存为 expiry_probe.go，使用 Go 1.23 或更新版本运行 go run expiry_probe.go。程序只在内存中生成隔离的根证书、中间证书和叶证书，并明确设置测试信任库、主机名、服务端认证用途与验证时刻。合成时间从 2026-09-09 00:00:00 UTC 开始，不会修改机器的系统时钟。

package main

import (
 "crypto/ed25519"
 "crypto/rand"
 "crypto/x509"
 "crypto/x509/pkix"
 "errors"
 "fmt"
 "math/big"
 "runtime"
 "time"
)

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

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

func key() (ed25519.PublicKey, ed25519.PrivateKey) {
 public, private, err := ed25519.GenerateKey(rand.Reader)
 must(err)
 return public, private
}

func issue(serial int64, parent *x509.Certificate, public ed25519.PublicKey, signer ed25519.PrivateKey, start, end time.Time, ca bool) *x509.Certificate {
 template := &x509.Certificate{
 SerialNumber: big.NewInt(serial), Subject: pkix.Name{CommonName: fmt.Sprint("fixture-", serial)},
 NotBefore: start, NotAfter: end, IsCA: ca, BasicConstraintsValid: true,
 }
 if ca {
 template.KeyUsage = x509.KeyUsageCertSign
 } else {
 template.KeyUsage = x509.KeyUsageDigitalSignature
 template.ExtKeyUsage = []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}
 template.DNSNames = []string{"expiry.example.test"}
 }
 if parent == nil {
 parent = template
 }
 der, err := x509.CreateCertificate(rand.Reader, template, parent, public, signer)
 must(err)
 certificate, err := x509.ParseCertificate(der)
 must(err)
 return certificate
}

func main() {
 base := time.Date(2026, 9, 9, 0, 0, 0, 0, time.UTC)
 rootPublic, rootPrivate := key()
 issuerPublic, issuerPrivate := key()
 leafPublic, _ := key()
 root := issue(1, nil, rootPublic, rootPrivate, base.Add(-24*time.Hour), base.Add(24*time.Hour), true)
 issuer := issue(2, root, issuerPublic, rootPrivate, base.Add(-time.Hour), base.Add(3*time.Hour), true)
 leaf := issue(3, issuer, leafPublic, issuerPrivate, base, base.Add(2*time.Hour), false)
 roots, intermediates := x509.NewCertPool(), x509.NewCertPool()
 roots.AddCert(root)
 intermediates.AddCert(issuer)
 verify := func(certificate *x509.Certificate, instant time.Time, name string) error {
 _, err := certificate.Verify(x509.VerifyOptions{
 Roots: roots, Intermediates: intermediates, CurrentTime: instant, DNSName: name,
 KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
 })
 return err
 }
 expired := func(err error, certificate *x509.Certificate) {
 var invalid x509.CertificateInvalidError
 check(errors.As(err, &invalid) && invalid.Reason == x509.Expired &&
 invalid.Cert.SerialNumber.Cmp(certificate.SerialNumber) == 0, "wrong validity failure")
 }
 for _, test := range []struct {
 label string
 instant time.Time
 valid bool
 }{
 {"before", base.Add(-time.Second), false},
 {"notBefore", base, true},
 {"middle", base.Add(time.Hour), true},
 {"notAfter", base.Add(2 * time.Hour), true},
 {"after", base.Add(2*time.Hour + time.Second), false},
 } {
 err := verify(leaf, test.instant, "expiry.example.test")
 if test.valid {
 must(err)
 } else {
 expired(err, leaf)
 }
 fmt.Println(test.label, "valid:", err == nil)
 }
 longLeaf := issue(4, issuer, leafPublic, issuerPrivate, base, base.Add(6*time.Hour), false)
 expired(verify(longLeaf, base.Add(4*time.Hour), "expiry.example.test"), issuer)
 var hostname x509.HostnameError
 check(errors.As(verify(leaf, base.Add(time.Hour), "wrong.example.test"), &hostname), "wrong name must fail")
 sameInstant := base.In(time.FixedZone("fixture+08", 8*60*60))
 must(verify(leaf, sameInstant, "expiry.example.test"))
 check(leaf.NotAfter.Sub(sameInstant) == 2*time.Hour, "timezone must not change the instant")
 remaining := leaf.NotAfter.Sub(base.Add(90 * time.Minute))
 check(remaining == 30*time.Minute && remaining <= 45*time.Minute, "fixture alert must fire")
 fmt.Println("issuer expiry and wrong name rejected; timezone preserves instant; remaining=30m triggers 45m warning")
 fmt.Println(runtime.Version())
}

五个时间点应依次输出 false、true、true、true、false。普通叶证书有效两小时，中间证书有效到基准时刻之后三小时，根证书则到之后二十四小时。这样检查叶证书两个端点时，不会被其他签发者提前过期遮住真正要观察的行为。反向断言同时检查错误原因和出错证书的序列号。

第二张叶证书延长到六小时。把验证时刻移到第四小时，这张叶证书本身还在有效期内，但中间证书已经过期，验证应明确失败在签发者。另一个独立检查使用仍然有效的普通叶证书，却填写错误的 DNS 名称，此时得到 HostnameError，说明时间有效不代表名称也匹配。

合成基准为 2026-09-09 00:00:00 UTC。普通叶证书包含 0h 与 2h 两个端点。4h 时，另一张有效至 6h 的叶证书因签发者在 3h 到期而失败。剩余 30 分钟与 45 分钟预警均为实验参数，并非续期建议。本例在内存中验证 X.509，没有网络握手。

程序还把基准时刻改用固定 UTC+08 时区表示；表示方法变了，验证结果和剩余时长都不应改变。在第九十分钟，普通叶证书只剩三十分钟，因而触发本例四十五分钟的预警阈值。这些短时段专门用于实验，不是生产续期建议；运行结果只输出判断标签和 Go 版本，不打印任何私钥。

已核验的 macOS、Go 1.27.0 运行通过所有断言。实验执行的是 X.509 验证，并没有建立网络 TLS 握手，也没有实际部署自动续签。Go 的 Verify 不执行吊销检查；本例没有检查公共入口、浏览器专有策略、OCSP、CRL 或会话恢复行为。既有连接如何处理凭据变化，仍需单独制定并验证生命周期策略。

来源

RFC 5280：X.509 证书，包含端点的有效期与证书路径，已核验 2026-09-09。
Go crypto/x509，VerifyOptions、错误原因与吊销检查边界，已核验 2026-09-09。
Let’s Encrypt：集成指南，续期信息、调度与失败报告，已核验 2026-09-09。

CAA 记录应授权你实际使用的签发者

Wed, 17 Jun 2026 00:00:00 +0000

认证机构授权（CAA）记录让域名持有者声明，哪些证书颁发机构可以为该域名签发证书。只有当记录与真实续期路径一致、且操作者理解策略如何从父级名称继承时，它才有用。

CAA 在签发时授权签发者。查询遇到第一个相关非空记录集就停止，通配符标签进一步细化规则。已有证书与 HTTPS 信任属于不同边界，图中签发者仅为示例。

检视当前策略

查询确切主机名及其父名称：

for name in www.example.test example.test test; do
 printf '== %s\n' "$name"
 dig +noall +answer CAA "$name"
done

这里用占位域名通过已配置的解析器查询。叶子处空应答不一定代表没有适用策略：查询会跟随别名，并在逐级向上时遇到第一个相关的非空 CAA 记录集就停止，而不是合并所有父级限制。还要查看 DNS 状态与权威信息；只显示答案的空输出可能隐藏 NXDOMAIN 或 SERVFAIL。诊断变更时应比较权威应答与递归查询结果。

匹配 CA 的签发者标识

记录使用如 issue 或 issuewild 等标签与一个签发者域值：

example.test. 3600 IN CAA 0 issue "letsencrypt.org"

该值是授权标识，不是证书里的显示名。在证书颁发机构的当前文档中确认它。没有 issuewild 时，issue 也控制通配符签发；存在 issuewild 时，通配符请求优先适用它。同一标签的多条记录提供备选授权，并不是要求每一家 CA 同时参与。CAA 也不选择某张具体的中间证书。

在续期前编排 DNS 变更

在当前证书健康时添加或收紧 CAA。等待先前 TTL 对应的完整时间，查询权威与递归应答，并运行 ACME 客户端支持的暂存或续期测试。准备好回滚记录。

不要在过期事故期间添加限制性记录，除非签发者路径已验证。一条语法正确但错误的策略，会把自动续期变成硬失败。

观察签发失败

CAA 检查发生在签发时，而不是每次 HTTPS 请求。修改 CAA 不会吊销已有证书，也不能证明历史签发符合当时的策略。因此证书监控必须同时覆盖当前过期与续期尝试。把有效的 DNS 应答随 ACME 失败一起记录，而不是只记录一条笼统的授权错误。

来源

RFC 8659 — DNS Certification Authority Authorization，CAA 查询与属性语义，已核验 2026-10-15。
Let’s Encrypt: CAA，签发者标识与运维指引，已核验 2026-10-15。

证书过期是一个日期，而不是仪表盘上的颜色

Wed, 10 Jun 2026 00:00:00 +0000

HTTPS 进程可能是健康的，而公共证书却临近过期、为错误的名字签发，或在另一条边缘上被不同地提供。一条有用的检查，是向公共端点索取它会给真实客户端的那张证书。

先检视真实客户端看到的证书，再独立验证。到期告警应使用服务自己的响应阈值，配合握手检查、续期失败告警，以及相关边缘和地址族抽查。

包含主机名

TLS 虚拟主机依赖服务器名称。把主机名作为 SNI 传入，并检视对端证书：

host=www.example.test
openssl s_client -connect "$host:443" -servername "$host" </dev/null 2>/dev/null \
 | openssl x509 -noout -subject -issuer -dates -fingerprint -sha256

这条命令是只读的。它不会续签任何东西，也不能证明每个中间证书都被每个客户端接受。但它确实给出为该主机名呈现的证书的 not-before、not-after、subject、issuer 与指纹。

在阈值上告警

选择能留出续期失败、DNS 问题与人工响应时间的阈值。确切数字属于服务的恢复目标；并非普通的"30 天"规则就能替代这个决定。配套的TLS 过期检查会打印过期时间，并在剩余区间低于你传入的阈值时以非零退出。

尽可能从主机外部运行检查。本地进程看到的监听器、证书文件或代理路径，可能与公共网络上的访问者不同。

把观察与验证分开

SNI 用于选择虚拟主机，并不验证证书是否匹配该名称。即使 s_client 报告验证问题，这条管道也可能打印证书，而且它隐藏了标准错误。另做主机名与证书链验证，保留诊断信息并使用已知信任库。不要把这条检视管道最后一个命令的退出码当成 TLS 健康结论。

配套脚本以 OpenSSL -checkend 检查 notAfter，并不能证明主机名匹配、信任关系、吊销状态或 notBefore 已经到来。把到期告警与握手检查、续期失败告警配合使用。阈值应小于证书正常寿命，短期证书尤其如此；还应抽查相关边缘与地址族。

来源

Caddy Automatic HTTPS，自动 TLS 证书管理，已核验 2026-10-15。
OpenSSL s_client 文档，SNI 与证书检查选项，已核验 2026-10-15。
OpenSSL x509 文档，证书解析、日期与指纹，已核验 2026-10-15。

证书链是一条应当能打印出来的路径

Mon, 08 Jun 2026 00:00:00 +0000

TLS 客户端必须构建通向既有信任锚的有效证书路径，并验证请求的主机名。打印证书有助于诊断，但单靠打印不能证明这两点。

服务器提供证书，信任来自客户端的信任锚。验证路径、请求主机名与有效期；打印或统计证书数量不能证明这些结果。

叶证书不是全部

端点首先出示叶证书。其中包含公钥、有效期，以及用于主机名检查的主体备用名称。公共 CA 的部署通常还应发送构建路径所需的中间证书。缺少中间证书时，没有缓存它、也无法另行取得它的客户端可能失败。

通常不必发送自签名根证书：信任来自客户端配置的信任锚，而不是服务器把某张证书放进列表。主体名称包含“Root”的交叉签名证书，在所选路径中也可能充当中间证书。因此，证书数量本身不能判断完整性或信任。

阅读边缘实际发送的列表

OpenSSL 文档把 s_client -showcerts 定义为服务器发送的证书列表，而不是已经验证的链。本笔记先前版本记录过以下站点快照：

certificate 0: CN=www.xbcatm.com
 issuer : C=US, O=Let's Encrypt, CN=YE1
 notAfter : Nov 19 08:37:12 2026 GMT

certificate 1: CN=YE1 (intermediate)
 issuer : C=US, O=ISRG, CN=Root YE

certificate 2/3: Root YE / ISRG Root … (CA certificates)

原记录统计了四个证书块。这里没有保留原始握手日志，本轮审阅也未重现在线握手；这些值应视为历史报告，而不是当前边缘证据。Let’s Encrypt 的证书链文档确实列出 YE1 与 Root YE 的交叉签名路径，因此仅凭这些名称不能判定链无效。具体在哪张证书处终止信任，取决于客户端信任库与路径构建。

把签发授权单独看待

中间 CA 使根密钥可以保持离线，并将签发操作分离。吊销中间证书可能令依赖它的叶证书路径失效，甚至需要替换证书；并不会自动保全每张叶证书。

CAA 在签发时授权 CA 文档规定的签发者域标识。它不固定某张中间证书，不改变浏览器信任，也不能证明已有证书符合历史 CAA 策略。dns-caa-records 笔记讨论的是这项独立的策略检查。

数量用于盘点，验证用于信任

原记录使用的盘点命令如下：

$ echo | openssl s_client -connect www.xbcatm.com:443 -servername www.xbcatm.com -showcerts 2>/dev/null | grep 'BEGIN CERT' | wc -l
4

它产生只读网络流量，但隐藏诊断信息，且即使前面的命令失败，最后的计数仍可能成功。不要把 4 或其他固定数量设为健康阈值。只有叶证书时，应检查预期签发路径，而不是认定所有单证书链都无效。

实际验证时，应使用 OpenSSL 的 -verify_hostname 与 -verify_return_error 选项，要求检查主机名并在验证错误时失败，保留诊断信息，同时记录信任库与客户端版本。还要测试实际支持的客户端；一套 OpenSSL 信任库不能证明所有浏览器都兼容。

来源

RFC 8446 — TLS 1.3，第 4.4.2 节的证书列表顺序与可省略信任锚，已核验 2026-10-15。
RFC 5280 — X.509 PKI，第 6 节的信任锚输入与路径验证，已核验 2026-10-15。
Let’s Encrypt FAQ，证书兼容性概览，已核验 2026-10-15。
Let’s Encrypt: Chains of Trust，YE1 与 Root YE 的交叉签名路径，已核验 2026-10-15。
OpenSSL s_client，呈现列表与验证选项，已核验 2026-10-15。
RFC 8659 — CAA，签发授权与客户端信任的区别，已核验 2026-10-15。

TLS · XB 现场笔记

SNI 让一个 IP 承载多个 HTTPS 站点

名字最先报出

用 server_name 匹配

把缺省回退控制好

坏掉的样子

快速验证

延伸阅读

来源

OCSP 装订按客户端策略交付状态证据

传递证据并不转移信任责任

先核对支持范围，再决定启用

坏掉的样子

快速验证

来源

证书透明度让签发可被观察

承诺不等于包含证明

坏掉的样子

快速验证

延伸阅读

来源

TLS ECDHE 的前向保密边界

两类密钥承担不同职责

坏掉的样子

快速验证

延伸阅读

来源

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

坏掉的样子

快速验证

明确解析器与引导配置

延伸阅读

来源

客户端证书认证私钥控制能力

完成认证仍然需要授权

坏掉的样子

快速验证

延伸阅读

来源

TLS 1.3 会话恢复复用认证状态

新连接仍要派生新的流量密钥

坏掉的样子

快速验证

延伸阅读

来源

TLS 握手会拉长延迟，但可以缩小

消息会按批次传输

坏掉的样子

快速验证

延伸阅读

来源

Caddy 自动管理 HTTPS 证书的签发与续期

先让自动 HTTPS 知道服务名称

让挑战方式与真实路径匹配

坏掉的样子

快速验证

延伸阅读

来源

检查 HTTPS,而不只是那把锁

分别提出具体问题

坏掉的样子

快速验证

延伸阅读

来源

SNI 根据请求主机名选择 TLS 证书

同一个地址上的不同决策

坏掉的样子

快速验证

延伸阅读

来源

HSTS 让浏览器记住 HTTPS

客户端记住的是主机名

坏掉的样子

快速验证

延伸阅读

来源

设定 TLS 版本下限并验证边界

最低版本与最高版本是两回事

坏掉的样子

快速验证