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

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

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

完成认证仍然需要授权

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 运行通过全部断言。这验证了真实双向 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。

MTLS · XB 现场笔记

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

完成认证仍然需要授权

坏掉的样子

快速验证

延伸阅读

来源