补充真实ACME协议回归并登记系统设置隔离任务

This commit is contained in:
xuans committed 2026-10-04 03:27:33 +08:00
1 parent f3272980c0
commit 6d425259f6
8 files changed
+487 -5

No files matched your search

@@ -0,0 +1,87 @@
package certificate
import (
"context"
"crypto/x509"
"net/http"
"slices"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/httpchallenge"
)
// 使用真实 lego 客户端、签名请求、挑战服务和动态 CSR 证书,不替换签发器。
// 隔离 CA 只验证本产品用到的协议流程,不代表公共 CA 或公网签发验收。
func TestLegoHTTP01Protocol(t *testing.T) {
for _, item := range []struct {
name string
domains []string
environment string
reject bool
cancel bool
}{
{name: "single", domains: []string{"example.com"}, environment: "production"},
{name: "san", domains: []string{"example.com", "www.example.com"}, environment: "staging"},
{name: "rejected", domains: []string{"example.com", "www.example.com"}, reject: true},
{name: "canceled", domains: []string{"example.com"}, cancel: true},
} {
t.Run(item.name, func(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
store := httpchallenge.NewStore()
lease, err := store.NewLease(ctx, item.domains)
if err != nil {
t.Fatal(err)
}
defer lease.Close()
ca := newProtocolCA(t, store, item.domains)
ca.reject = item.reject
if item.cancel {
ca.cancel = cancel
}
issuer := &LegoIssuer{User: ca.user, Provider: lease, HTTPClient: ca.client}
resource, err := issuer.Obtain(ctx, ObtainRequest{
Domains: item.domains, ChallengeType: domain.ChallengeHTTP01, Environment: item.environment,
})
if item.reject || item.cancel {
if err == nil || len(resource.Certificate) != 0 || len(resource.PrivateKey) != 0 {
t.Fatal("失败或取消的 ACME 订单返回了成功证书")
}
} else {
if err != nil {
t.Fatal(err)
}
if _, err := ValidateResourceForDomains(resource, item.domains); err != nil {
t.Fatal("实际 CSR 证书或密钥不匹配:", err)
}
roots := x509.NewCertPool()
roots.AddCert(ca.root)
validator := LocalValidator{Roots: roots, VerifyChain: true}
if _, err := validator.ValidatePEM(ctx, resource.Certificate, item.domains); err != nil {
t.Fatal("隔离 CA 返回的证书链校验失败:", err)
}
}
ca.mu.Lock()
defer ca.mu.Unlock()
if !ca.registered || ca.proofs == 0 || len(ca.failures) != 0 {
t.Fatalf("协议没有按预期完成:注册=%t,挑战=%d,异常=%v", ca.registered, ca.proofs, ca.failures)
}
if item.reject || item.cancel {
if ca.finalized || ca.downloads != 0 {
t.Fatal("失败订单不应提交 CSR 或下载证书")
}
} else if !ca.finalized || ca.downloads != 1 || ca.proofs != len(item.domains) || !slices.Equal(ca.csrNames, item.domains) {
t.Fatal("成功订单缺少逐域名授权、CSR 或证书下载")
}
// 在调用 Lease.Close 之前核对,避免测试清理掩盖 lego 未回收挑战。
for i, name := range item.domains {
code, _, err := ca.readProof(context.Background(), name, protocolToken(i))
if err != nil || code != http.StatusNotFound {
t.Fatalf("订单结束后挑战仍可读:域名=%s,状态=%d,错误=%v", name, code, err)
}
}
})
}
}
@@ -0,0 +1,375 @@
package certificate
import (
"context"
"crypto"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"crypto/x509/pkix"
"encoding/base64"
"encoding/json"
"encoding/pem"
"fmt"
"io"
"math/big"
"net/http"
"net/http/httptest"
"net/url"
"slices"
"strconv"
"strings"
"sync"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/httpchallenge"
"github.com/go-jose/go-jose/v4"
)
type protocolTransport struct {
base http.RoundTripper
target *url.URL
}
func (p protocolTransport) RoundTrip(r *http.Request) (*http.Response, error) {
if r.URL.Scheme == "https" && r.URL.Path == "/directory" &&
(r.URL.Host == "acme-v02.api.letsencrypt.org" || r.URL.Host == "acme-staging-v02.api.letsencrypt.org") {
r = r.Clone(r.Context())
target := *p.target
target.Path = "/directory"
r.URL = &target
r.Host = target.Host
}
if r.URL.Scheme != p.target.Scheme || r.URL.Host != p.target.Host {
return nil, fmt.Errorf("隔离协议测试禁止访问外部地址")
}
return p.base.RoundTrip(r)
}
type protocolCA struct {
mu sync.Mutex
server *httptest.Server
challenge *httptest.Server
client *http.Client
user *AccountUser
root *x509.Certificate
key *ecdsa.PrivateKey
names []string
statuses []string
nonces map[string]bool
sequence int
registered bool
finalized bool
downloads int
proofs int
csrNames []string
chain []byte
reject bool
cancel context.CancelFunc
failures []string
}
func newProtocolCA(t *testing.T, store *httpchallenge.Store, names []string) *protocolCA {
t.Helper()
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatal(err)
}
accountKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatal(err)
}
template := &x509.Certificate{
SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "Scert protocol test CA"},
NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour),
IsCA: true, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageCertSign,
}
der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
if err != nil {
t.Fatal(err)
}
root, err := x509.ParseCertificate(der)
if err != nil {
t.Fatal(err)
}
c := &protocolCA{
key: key, root: root, names: slices.Clone(names), nonces: make(map[string]bool),
user: &AccountUser{Email: "acme@example.com", PrivateKey: accountKey},
statuses: make([]string, len(names)),
}
for i := range c.statuses {
c.statuses[i] = "pending"
}
c.challenge = httptest.NewServer(store)
t.Cleanup(c.challenge.Close)
c.server = httptest.NewTLSServer(http.HandlerFunc(c.serveHTTP))
t.Cleanup(c.server.Close)
target, err := url.Parse(c.server.URL)
if err != nil {
t.Fatal(err)
}
// 仅注入测试 CA 信任,不跳过 TLS;真实签发器的生产/测试目录选择不变。
c.client = c.server.Client()
c.client.Timeout = 5 * time.Second
c.client.Transport = protocolTransport{base: c.client.Transport, target: target}
return c
}
func protocolToken(index int) string {
return base64.RawURLEncoding.EncodeToString([]byte(fmt.Sprintf("scert-isolated-acme-token-%d", index)))
}
func (c *protocolCA) fail(w http.ResponseWriter, err error) {
c.failures = append(c.failures, err.Error())
http.Error(w, "隔离 CA 协议断言失败", http.StatusBadRequest)
}
func (c *protocolCA) signedPayload(r *http.Request) ([]byte, error) {
if r.Method != http.MethodPost || r.Header.Get("Content-Type") != "application/jose+json" {
return nil, fmt.Errorf("请求方法或签名媒体类型不正确")
}
data, err := io.ReadAll(io.LimitReader(r.Body, 64*1024))
if err != nil {
return nil, err
}
jws, err := jose.ParseSigned(string(data), []jose.SignatureAlgorithm{jose.ES256})
if err != nil || len(jws.Signatures) != 1 {
return nil, fmt.Errorf("请求缺少唯一有效签名")
}
header := jws.Signatures[0].Protected
if !c.nonces[header.Nonce] || header.ExtraHeaders[jose.HeaderKey("url")] != c.server.URL+r.URL.Path {
return nil, fmt.Errorf("签名地址或一次性随机数无效")
}
delete(c.nonces, header.Nonce)
if r.URL.Path == "/account" {
if header.JSONWebKey == nil || header.KeyID != "" {
return nil, fmt.Errorf("注册请求缺少账户公钥")
}
} else if !c.registered || header.KeyID != c.server.URL+"/account/1" || header.JSONWebKey != nil {
return nil, fmt.Errorf("请求未引用已注册账户")
}
return jws.Verify(c.user.PrivateKey.Public())
}
func (c *protocolCA) order() map[string]any {
status := "ready"
ids := make([]map[string]string, len(c.names))
auths := make([]string, len(c.names))
for i, name := range c.names {
ids[i] = map[string]string{"type": "dns", "value": name}
auths[i] = fmt.Sprintf("%s/auth/%d", c.server.URL, i)
if c.statuses[i] != "valid" {
status = "pending"
}
}
if c.finalized {
status = "valid"
}
return map[string]any{"status": status, "identifiers": ids, "authorizations": auths,
"finalize": c.server.URL + "/finalize", "certificate": c.server.URL + "/certificate"}
}
func (c *protocolCA) authorization(index int) map[string]any {
challenge := map[string]any{
"type": "http-01", "url": fmt.Sprintf("%s/challenge/%d", c.server.URL, index),
"status": c.statuses[index], "token": protocolToken(index),
}
if c.statuses[index] == "invalid" {
challenge["error"] = map[string]any{"type": "urn:ietf:params:acme:error:unauthorized", "detail": "隔离 CA 拒绝授权", "status": 403}
}
return map[string]any{
"status": c.statuses[index], "identifier": map[string]string{"type": "dns", "value": c.names[index]},
"challenges": []any{map[string]string{"type": "dns-01", "url": c.server.URL + "/forbidden-dns", "status": "pending", "token": protocolToken(index)}, challenge},
}
}
func (c *protocolCA) readProof(ctx context.Context, name, token string) (int, string, error) {
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.challenge.URL+httpchallenge.PathPrefix+token, nil)
if err != nil {
return 0, "", err
}
req.Host = name
resp, err := c.challenge.Client().Do(req)
if err != nil {
return 0, "", err
}
defer resp.Body.Close()
data, err := io.ReadAll(io.LimitReader(resp.Body, 4096))
return resp.StatusCode, string(data), err
}
func (c *protocolCA) serveHTTP(w http.ResponseWriter, r *http.Request) {
c.mu.Lock()
defer c.mu.Unlock()
c.sequence++
nonce := base64.RawURLEncoding.EncodeToString([]byte(fmt.Sprintf("scert-isolated-nonce-%d", c.sequence)))
c.nonces[nonce] = true
w.Header().Set("Replay-Nonce", nonce)
w.Header().Set("Content-Type", "application/json")
write := func(value any) { _ = json.NewEncoder(w).Encode(value) }
if r.URL.Path == "/directory" && r.Method == http.MethodGet {
write(map[string]any{"newNonce": c.server.URL + "/nonce", "newAccount": c.server.URL + "/account", "newOrder": c.server.URL + "/order", "revokeCert": c.server.URL + "/revoke", "keyChange": c.server.URL + "/key-change"})
return
}
if r.URL.Path == "/nonce" && r.Method == http.MethodHead {
w.WriteHeader(http.StatusNoContent)
return
}
payload, err := c.signedPayload(r)
if err != nil {
c.fail(w, err)
return
}
switch r.URL.Path {
case "/account":
var account struct {
Terms bool `json:"termsOfServiceAgreed"`
Contact []string `json:"contact"`
}
if json.Unmarshal(payload, &account) != nil || !account.Terms || !slices.Equal(account.Contact, []string{"mailto:" + c.user.Email}) {
c.fail(w, fmt.Errorf("注册未确认条款或账户邮箱不符"))
return
}
c.registered = true
w.Header().Set("Location", c.server.URL+"/account/1")
w.WriteHeader(http.StatusCreated)
write(map[string]any{"status": "valid", "contact": account.Contact, "orders": c.server.URL + "/orders"})
case "/order":
var order struct {
Identifiers []struct {
Type string `json:"type"`
Value string `json:"value"`
} `json:"identifiers"`
}
if json.Unmarshal(payload, &order) != nil || len(order.Identifiers) != len(c.names) {
c.fail(w, fmt.Errorf("订单域名数量不符"))
return
}
for i, id := range order.Identifiers {
if id.Type != "dns" || id.Value != c.names[i] {
c.fail(w, fmt.Errorf("订单域名被修改"))
return
}
}
w.Header().Set("Location", c.server.URL+"/order/1")
w.WriteHeader(http.StatusCreated)
write(c.order())
case "/order/1":
if len(payload) != 0 {
c.fail(w, fmt.Errorf("订单查询不是签名空载荷"))
return
}
write(c.order())
case "/finalize":
if err := c.finalize(payload); err != nil {
c.fail(w, err)
return
}
write(c.order())
case "/certificate":
if !c.finalized || len(payload) != 0 {
c.fail(w, fmt.Errorf("证书下载早于订单完成或载荷非空"))
return
}
c.downloads++
w.Header().Set("Content-Type", "application/pem-certificate-chain")
_, _ = w.Write(c.chain)
default:
parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/"), "/")
if len(parts) != 2 || (parts[0] != "auth" && parts[0] != "challenge") {
c.fail(w, fmt.Errorf("客户端访问了未授权协议路径:%s", r.URL.Path))
return
}
index, err := strconv.Atoi(parts[1])
if err != nil || index < 0 || index >= len(c.names) {
c.fail(w, fmt.Errorf("授权索引无效"))
return
}
if parts[0] == "auth" {
if len(payload) != 0 {
var state struct {
Status string `json:"status"`
}
if json.Unmarshal(payload, &state) != nil || state.Status != "deactivated" {
c.fail(w, fmt.Errorf("授权更新不是合法停用"))
return
}
c.statuses[index] = "deactivated"
}
write(c.authorization(index))
return
}
if err := c.verifyChallenge(r.Context(), index); err != nil {
c.fail(w, err)
return
}
write(c.authorization(index)["challenges"].([]any)[1])
}
}
func (c *protocolCA) verifyChallenge(ctx context.Context, index int) error {
key := jose.JSONWebKey{Key: c.user.PrivateKey.Public()}
thumbprint, err := key.Thumbprint(crypto.SHA256)
if err != nil {
return err
}
code, value, err := c.readProof(ctx, c.names[index], protocolToken(index))
if err != nil || code != http.StatusOK || value != protocolToken(index)+"."+base64.RawURLEncoding.EncodeToString(thumbprint) {
return fmt.Errorf("真实 HTTP 挑战未返回账户公钥绑定证明:状态=%d", code)
}
c.proofs++
c.statuses[index] = "valid"
if c.reject {
c.statuses[index] = "invalid"
}
if c.cancel != nil {
c.cancel()
}
return nil
}
func (c *protocolCA) finalize(payload []byte) error {
for _, status := range c.statuses {
if status != "valid" {
return fmt.Errorf("未完成全部授权就提交 CSR")
}
}
var request struct {
CSR string `json:"csr"`
}
if err := json.Unmarshal(payload, &request); err != nil {
return err
}
der, err := base64.RawURLEncoding.DecodeString(request.CSR)
if err != nil {
return err
}
csr, err := x509.ParseCertificateRequest(der)
if err != nil {
return err
}
if err := csr.CheckSignature(); err != nil {
return err
}
if !slices.Equal(csr.DNSNames, c.names) {
return fmt.Errorf("CSR 的 SAN 与原订单不符")
}
c.csrNames = slices.Clone(csr.DNSNames)
leaf := &x509.Certificate{
SerialNumber: big.NewInt(2), Subject: csr.Subject, DNSNames: csr.DNSNames,
NotBefore: time.Now().Add(-time.Minute), NotAfter: time.Now().Add(30 * time.Minute),
KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
}
der, err = x509.CreateCertificate(rand.Reader, leaf, c.root, csr.PublicKey, c.key)
if err != nil {
return err
}
c.chain = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
c.chain = append(c.chain, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: c.root.Raw})...)
c.finalized = true
return nil
}