"公钥加密"解决的是怎么加密的问题, 但留下一个更难的问题: 这把公钥真的是 api.example.com 的吗? PKI(公钥基础设施)就是为了回答这个问题—— 引入一个被多方信任的第三方 (CA), 由它用数字签名给"公钥 + 主体"绑死, 签出来的东西就叫证书。

证书链与信任锚

X.509 v3 关键字段

PEM 与 DER 编码

# 看一张正式证书 (用 https://www.google.com 演示)
$ echo | openssl s_client -connect www.google.com:443 -servername www.google.com 2>/dev/null \
    | openssl x509 -noout -issuer -subject -dates -ext subjectAltName

issuer=C=US, O=Google Trust Services, CN=WR2
subject=CN=www.google.com
notBefore=Apr 15 ... 2026 GMT
notAfter=Jul  8 ... 2026 GMT
X509v3 Subject Alternative Name:
    DNS:www.google.com

# DER ↔ PEM 互转
$ openssl x509 -in cert.pem -outform DER -out cert.der
$ openssl x509 -in cert.der -inform DER -out cert.pem

# 把证书链拼起来 (服务端要发送 leaf + intermediate, root 在客户端本地)
$ cat leaf.pem intermediate.pem > fullchain.pem

吊销机制: CRL / OCSP / Stapling

TLS 1.3 (RFC 8446, 2018) 是 TLS 协议历史上最大的一次重构—— 砍掉了 90% 的密码套件, 把握手从 2-RTT 压到 1-RTT, 默认强制前向保密。 理解 1.3 握手, 你就能在排查 TLS 问题时, 用 Wireshark 的输出直接对上协议字段。

TLS 1.2 vs TLS 1.3 握手对比

TLS 1.3 的五个关键改动

1. 密码套件大瘦身。 TLS 1.2 有 300+ 套件, TLS 1.3 只保留 5 个 AEAD 套件(AES-GCM / ChaCha20-Poly1305 系列)。历史性弱算法(RC4 / MD5 / SHA1 / CBC) 全部砍掉。
2. 1-RTT 默认。 Client 在 ClientHello 就发 KeyShare(基于 ECDHE 的临时公钥), Server 一次回应就能算出共享密钥, 不再需要"先协商再交换"。
3. 强制前向保密(Forward Secrecy)。 密钥协商必须用 (EC)DHE, 静态 RSA 密钥交换被废弃——意味着就算服务端私钥日后泄露, 历史流量也解不开。
4. 更早加密。 ServerHello 之后所有消息(包括证书)都用握手密钥加密——证书不再明文暴露在网络上。
5. 0-RTT 可选。 客户端如果之前连过同一服务器, 可以在 ClientHello 里"附带"应用数据(early_data), 0 个 RTT 就送出去。代价: early_data 可被重放, 只能用于幂等操作。

密钥派生与 HKDF

TLS 1.3 用 HKDF (RFC 5869) 从一个共享秘密派生出多个用途的密钥—— 不同方向(C→S / S→C)、不同阶段(握手 / 应用 / 重启)都有独立密钥。 这就是"前向保密"的工程实现: 每次会话密钥独立, 一个泄露不影响其他。

# 用 Wireshark 看 TLS 1.3 握手
# 1) 在 curl 之前设置 SSLKEYLOGFILE 让 TLS 库导出会话密钥
$ export SSLKEYLOGFILE=/tmp/tls.keys
$ curl -v https://www.google.com

# 2) Wireshark → Preferences → Protocols → TLS → (Pre)-Master-Secret log filename
#    指向 /tmp/tls.keys, 然后捕获包就能看到解密后的握手细节

# curl 直接观察协商出的版本和套件
$ curl -v https://example.com 2>&1 | grep "SSL connection"
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / RSASSA-PSS

TLS 自身定义了"怎么协商加密通道", 但现代 Web 需要在握手阶段就回答两个问题—— "我要的是哪个网站?"(IPv4 短缺导致一 IP 多域) 和 "我要走的是哪个上层协议?"(HTTP/1.1 / HTTP/2 / HTTP/3)。 SNI 解决前者, ALPN 解决后者, ECH 解决 SNI 暴露域名的隐私问题。

配套基础设施

标准 TLS 只验证"服务端是不是真的", 客户端可以匿名; mTLS(mutual TLS)要求双向: 客户端也要拿出一张被服务端信任的 CA 签的证书。 这是开放平台服务间通信的标准方案—— 内部 Service A 调 Service B, 不靠 Token, 靠证书证明"我是 A"。 Istio / Linkerd 这类 Service Mesh 给每个 Pod 自动签发证书, 默认就是 mTLS。

mTLS 双向握手

Lab · 用 openssl 建本地 CA + 签证书

# 1) 建 CA — 一次性, 私钥严格保管
$ openssl genrsa -out ca.key 4096
$ openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 \
    -out ca.crt \
    -subj "/CN=My Local CA/O=Demo"

# 2) 签服务端证书 (注意 SAN 必须写)
$ openssl genrsa -out server.key 2048
$ openssl req -new -key server.key -out server.csr \
    -subj "/CN=localhost" \
    -addext "subjectAltName = DNS:localhost,IP:127.0.0.1"
$ openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
    -out server.crt -days 365 -sha256 \
    -extfile <(echo "subjectAltName=DNS:localhost,IP:127.0.0.1")

# 3) 签客户端证书 (mTLS 才需要)
$ openssl genrsa -out client.key 2048
$ openssl req -new -key client.key -out client.csr \
    -subj "/CN=service-a"
$ openssl x509 -req -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
    -out client.crt -days 365 -sha256

Lab · Go HTTPS 服务端

// https_server.go · 起一个 HTTPS 服务
package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "hello, TLS %x\n", r.TLS.Version)
    })

    // ListenAndServeTLS 自动选 TLS 1.3 + 强密码套件
    err := http.ListenAndServeTLS(":8443", "server.crt", "server.key", nil)
    if err != nil {
        fmt.Println(err)
    }
}

# 启动 + 用 curl 测试 (--cacert 告诉 curl 信任我们的本地 CA)
$ go run https_server.go &
$ curl --cacert ca.crt https://localhost:8443/
hello, TLS 304   # 0x0304 = TLS 1.3

# 不指定 --cacert 会报 self-signed certificate
$ curl https://localhost:8443/
curl: (60) SSL certificate problem: unable to get local issuer certificate

Lab · Go mTLS 服务端 + 客户端

// mtls_server.go · 要求客户端必须出示证书
package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "net/http"
    "os"
)

func main() {
    // 1) 把 CA 加进信任池, 用来验证客户端证书
    caPEM, _ := os.ReadFile("ca.crt")
    pool := x509.NewCertPool()
    pool.AppendCertsFromPEM(caPEM)

    cfg := &tls.Config{
        ClientCAs:  pool,
        ClientAuth: tls.RequireAndVerifyClientCert,  // 关键: 强制双向
        MinVersion: tls.VersionTLS13,
    }

    srv := &http.Server{
        Addr:      ":8443",
        TLSConfig: cfg,
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // 从客户端证书提取身份
            cn := r.TLS.PeerCertificates[0].Subject.CommonName
            fmt.Fprintf(w, "hi, %s\n", cn)
        }),
    }
    _ = srv.ListenAndServeTLS("server.crt", "server.key")
}

// mtls_client.go · 带客户端证书
package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    cert, _ := tls.LoadX509KeyPair("client.crt", "client.key")

    caPEM, _ := os.ReadFile("ca.crt")
    pool := x509.NewCertPool()
    pool.AppendCertsFromPEM(caPEM)

    cli := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: &tls.Config{
                Certificates: []tls.Certificate{cert},  // 提供自己的证书
                RootCAs:      pool,                  // 信任本地 CA
                MinVersion:   tls.VersionTLS13,
            },
        },
    }

    resp, _ := cli.Get("https://localhost:8443/")
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))  // → hi, service-a
}

1. 用 30 秒讲清"信任锚 → 中间 CA → 叶子证书"三层链的验证流程。客户端验到哪一步会停下?
2. TLS 1.3 为什么能 1-RTT, 而 TLS 1.2 必须 2-RTT? 关键的协议改动是什么?
3. 0-RTT 的 early_data 有什么安全风险? 为什么 POST 请求不能走 0-RTT?
4. SNI 解决了什么问题? 没有它的话, 一台服务器最多能配多少个 HTTPS 网站?
5. 写一段 Go 代码: 让 http.Client 信任一个自签 CA, 调用 https://internal.api——不要 InsecureSkipVerify。