补充真实ACME协议回归并登记系统设置隔离任务
This commit is contained in:
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
|
||||
}
|
||||
Reference in new issue
Block a user