完善 Scert 前后端与部署支持

This commit is contained in:
xuans committed 2026-08-30 17:44:54 +08:00
1 parent afdb947bea
commit 7f0af703ed
85 files changed
+7530 -800

No files matched your search

+3 -1
View File
@@ -65,10 +65,12 @@ var descriptors = map[string]Descriptor{
},
},
CNAME: {
ID: CNAME, Name: "CNAME 委派", Description: "需要先配置委派目标和目标 DNS 服务商,后续任务接入自动验证。",
ID: CNAME, Name: "CNAME 委派", Description: "使用已配置的 CNAME 将 DNS-01 挑战转发到专用验证域,并由目标 DNS 服务商创建和清理 TXT 记录。",
Available: true,
CredentialFields: []CredentialField{
{Name: "delegated_domain", Label: "专用验证域", Required: true, Placeholder: "例如 acme.example.com"},
{Name: "delegated_provider", Label: "委派目标 DNS 服务商", Required: true},
{Name: "delegated_credentials_json", Label: "委派凭据 JSON", Secret: true, Required: true, Placeholder: "例如 {\"api_token\":\"...\"}"},
},
},
HuaweiCloud: {
@@ -0,0 +1,38 @@
package dnsprovider
import (
"context"
"strings"
"github.com/go-acme/lego/v5/challenge"
)
// cnameDelegationProvider 将原始域名的 DNS-01 挑战转发到专用验证域。
// 委派域上的 TXT 记录由目标 Provider 管理,原始域名上的 CNAME 记录由用户提前配置。
type cnameDelegationProvider struct {
delegatedDomain string
target challenge.Provider
}
func newCNAMEDelegationProvider(delegatedDomain string, target challenge.Provider) (challenge.Provider, error) {
delegatedDomain = normalizeProviderDomain(delegatedDomain)
if delegatedDomain == "" {
return nil, ErrInvalidDelegatedDomain
}
if target == nil {
return nil, ErrDelegatedProviderUnavailable
}
return &cnameDelegationProvider{delegatedDomain: delegatedDomain, target: target}, nil
}
func (p *cnameDelegationProvider) Present(ctx context.Context, _ string, token, keyAuth string) error {
return p.target.Present(ctx, p.delegatedDomain, token, keyAuth)
}
func (p *cnameDelegationProvider) CleanUp(ctx context.Context, _ string, token, keyAuth string) error {
return p.target.CleanUp(ctx, p.delegatedDomain, token, keyAuth)
}
func normalizeProviderDomain(value string) string {
return strings.ToLower(strings.TrimSuffix(strings.TrimSpace(value), "."))
}
@@ -0,0 +1,105 @@
package dnsprovider
import (
"context"
"errors"
"testing"
"github.com/go-acme/lego/v5/challenge"
)
type delegationRecordingProvider struct {
presentDomain string
cleanupDomain string
presentToken string
cleanupToken string
presentErr error
cleanupErr error
}
func (p *delegationRecordingProvider) Present(_ context.Context, domain, token, _ string) error {
p.presentDomain = domain
p.presentToken = token
return p.presentErr
}
func (p *delegationRecordingProvider) CleanUp(_ context.Context, domain, token, _ string) error {
p.cleanupDomain = domain
p.cleanupToken = token
return p.cleanupErr
}
var _ challenge.Provider = (*delegationRecordingProvider)(nil)
func TestCNAMEDelegationProviderForwardsChallengeDomain(t *testing.T) {
target := &delegationRecordingProvider{}
provider, err := newCNAMEDelegationProvider(" ACME.Example.com. ", target)
if err != nil {
t.Fatalf("创建 CNAME 委派 Provider 失败:%v", err)
}
ctx := context.Background()
if err := provider.Present(ctx, "www.example.net", "token", "key-auth"); err != nil {
t.Fatalf("转发创建 TXT 记录失败:%v", err)
}
if target.presentDomain != "acme.example.com" || target.presentToken != "token" {
t.Fatalf("创建记录未转发到规范化委派域:domain=%q token=%q", target.presentDomain, target.presentToken)
}
if err := provider.CleanUp(ctx, "www.example.net", "token", "key-auth"); err != nil {
t.Fatalf("转发清理 TXT 记录失败:%v", err)
}
if target.cleanupDomain != "acme.example.com" || target.cleanupToken != "token" {
t.Fatalf("清理记录未转发到规范化委派域:domain=%q token=%q", target.cleanupDomain, target.cleanupToken)
}
}
func TestCNAMEDelegationProviderPropagatesTargetErrors(t *testing.T) {
presentErr := errors.New("创建失败")
cleanupErr := errors.New("清理失败")
target := &delegationRecordingProvider{presentErr: presentErr, cleanupErr: cleanupErr}
provider, err := newCNAMEDelegationProvider("acme.example.com", target)
if err != nil {
t.Fatalf("创建 CNAME 委派 Provider 失败:%v", err)
}
if err := provider.Present(context.Background(), "example.com", "token", "key-auth"); !errors.Is(err, presentErr) {
t.Fatalf("创建错误未透传:%v", err)
}
if err := provider.CleanUp(context.Background(), "example.com", "token", "key-auth"); !errors.Is(err, cleanupErr) {
t.Fatalf("清理错误未透传:%v", err)
}
}
func TestLegoFactoryCreatesCNAMEDelegationProvider(t *testing.T) {
provider, err := NewLegoFactory().Create(CNAME, map[string]string{
"delegated_domain": "acme.example.com",
"delegated_provider": Cloudflare,
"delegated_credentials_json": `{"api_token":"test-token"}`,
})
if err != nil {
t.Fatalf("创建 CNAME 委派 Provider 失败:%v", err)
}
if provider == nil {
t.Fatal("CNAME 委派 Provider 不应为空")
}
}
func TestLegoFactoryRejectsRecursiveCNAMEDelegation(t *testing.T) {
_, err := NewLegoFactory().Create(CNAME, map[string]string{
"delegated_domain": "acme.example.com",
"delegated_provider": CNAME,
"delegated_credentials_json": `{}`,
})
if !errors.Is(err, ErrDelegatedProviderUnavailable) {
t.Fatalf("递归 CNAME 委派应被拒绝:%v", err)
}
}
func TestLegoFactoryRejectsInvalidCNAMEDelegationCredentials(t *testing.T) {
_, err := NewLegoFactory().Create(CNAME, map[string]string{
"delegated_domain": "acme.example.com",
"delegated_provider": Cloudflare,
"delegated_credentials_json": `[]`,
})
if !errors.Is(err, ErrInvalidDelegatedCredentials) {
t.Fatalf("非对象 CNAME 凭据应被拒绝:%v", err)
}
}
+9
View File
@@ -0,0 +1,9 @@
package dnsprovider
import "errors"
var (
ErrInvalidDelegatedDomain = errors.New("CNAME 委派域名无效")
ErrInvalidDelegatedCredentials = errors.New("CNAME 委派凭据无效")
ErrDelegatedProviderUnavailable = errors.New("CNAME 委派目标 Provider 不可用")
)
@@ -15,6 +15,8 @@ import (
"github.com/go-acme/lego/v5/providers/dns/tencentcloud"
"golang.org/x/oauth2/google"
gdns "google.golang.org/api/dns/v1"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
type LegoFactory struct{}
@@ -37,6 +39,27 @@ func (LegoFactory) Create(providerID string, credentials map[string]string) (cha
return nil, err
}
switch providerID {
case CNAME:
delegatedDomain := normalizeProviderDomain(cleaned["delegated_domain"])
if delegatedDomain == "" || strings.HasPrefix(delegatedDomain, "*.") || !domain.IsValidName(delegatedDomain) {
return nil, ErrInvalidDelegatedDomain
}
delegatedProvider := strings.ToLower(strings.TrimSpace(cleaned["delegated_provider"]))
if delegatedProvider == CNAME || delegatedProvider == Other || delegatedProvider == "" {
return nil, fmt.Errorf("%w: %s", ErrDelegatedProviderUnavailable, delegatedProvider)
}
var delegatedCredentials map[string]string
if err := json.Unmarshal([]byte(cleaned["delegated_credentials_json"]), &delegatedCredentials); err != nil {
return nil, fmt.Errorf("%w: %v", ErrInvalidDelegatedCredentials, err)
}
if delegatedCredentials == nil {
return nil, ErrInvalidDelegatedCredentials
}
target, err := (LegoFactory{}).Create(delegatedProvider, delegatedCredentials)
if err != nil {
return nil, fmt.Errorf("%w: %v", ErrDelegatedProviderUnavailable, err)
}
return newCNAMEDelegationProvider(delegatedDomain, target)
case Cloudflare:
cfg := cloudflare.NewDefaultConfig()
cfg.AuthToken = cleaned["api_token"]
+150 -15
View File
@@ -7,55 +7,190 @@ import (
"errors"
"fmt"
"strings"
"time"
"github.com/go-acme/lego/v5/challenge"
"github.com/go-acme/lego/v5/challenge/dns01"
"github.com/go-acme/lego/v5/challenge/dnspersist01"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/setup"
)
type Factory interface {
Create(providerID string, credentials map[string]string) (challenge.Provider, error)
}
type Tester struct {
factory Factory
type TXTResolver interface {
LookupTXT(ctx context.Context, fqdn string) ([]string, error)
}
type Tester struct {
factory Factory
resolver TXTResolver
}
const dnsCleanupTimeout = 30 * time.Second
func NewTester(factory Factory) *Tester {
return &Tester{factory: factory}
return NewTesterWithResolver(factory, legoTXTResolver{})
}
func (t *Tester) Verify(ctx context.Context, providerID, testDomain string, credentials map[string]string) error {
if t == nil || t.factory == nil {
return errors.New("DNS 验证服务未初始化")
func NewTesterWithResolver(factory Factory, resolver TXTResolver) *Tester {
return &Tester{factory: factory, resolver: resolver}
}
type VerificationError struct {
Report setup.DNSVerificationReport
Err error
}
func (e *VerificationError) Error() string {
if e == nil || e.Err == nil {
return "DNS API 在线验证失败"
}
return e.Err.Error()
}
func (e *VerificationError) Unwrap() error {
if e == nil {
return nil
}
return e.Err
}
func (t *Tester) Verify(ctx context.Context, providerID, testDomain string, credentials map[string]string) (setup.DNSVerificationReport, error) {
return t.VerifyWithReport(ctx, providerID, testDomain, credentials)
}
func (t *Tester) VerifyWithReport(ctx context.Context, providerID, testDomain string, credentials map[string]string) (setup.DNSVerificationReport, error) {
report := setup.DNSVerificationReport{}
if t == nil || t.factory == nil || t.resolver == nil {
return report, errors.New("DNS 验证服务未初始化")
}
testDomain = strings.ToLower(strings.TrimSuffix(strings.TrimSpace(testDomain), "."))
if !domain.IsValidName(testDomain) {
return fmt.Errorf("DNS 测试域名格式无效:%s", testDomain)
return report, fmt.Errorf("DNS 测试域名格式无效:%s", testDomain)
}
cleaned, err := ValidateCredentials(providerID, credentials)
if err != nil {
return err
return report, err
}
provider, err := t.factory.Create(providerID, cleaned)
if err != nil {
return err
return report, err
}
token, err := randomValue(24)
if err != nil {
return fmt.Errorf("生成 DNS 测试标识失败:%w", err)
return report, fmt.Errorf("生成 DNS 测试标识失败:%w", err)
}
keyAuth, err := randomValue(48)
if err != nil {
return fmt.Errorf("生成 DNS 测试授权值失败:%w", err)
return report, fmt.Errorf("生成 DNS 测试授权值失败:%w", err)
}
challengeInfo := dns01.GetChallengeInfo(ctx, testDomain, keyAuth)
report.RecordName = challengeInfo.EffectiveFQDN
if err := provider.Present(ctx, testDomain, token, keyAuth); err != nil {
return fmt.Errorf("创建 DNS 测试记录失败:%w", err)
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "创建记录", Status: "failed", Message: "调用 DNS API 创建临时 TXT 记录失败。",
})
return report, &VerificationError{Report: report, Err: fmt.Errorf("创建 DNS 测试记录失败:%w", err)}
}
if err := provider.CleanUp(ctx, testDomain, token, keyAuth); err != nil {
return fmt.Errorf("DNS 测试记录已创建,但自动清理失败:%w", err)
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "创建记录", Status: "completed", Message: "已调用 DNS API 创建临时 TXT 记录。",
})
if err := waitForTXT(ctx, t.resolver, report.RecordName, challengeInfo.Value); err != nil {
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "查询记录", Status: "failed", Message: "公网 DNS 查询未确认 TXT 记录已生效。",
})
cleanupErr := cleanupChallenge(ctx, provider, testDomain, token, keyAuth)
if cleanupErr != nil {
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "清理记录", Status: "failed", Message: "测试记录清理失败,请检查 DNS API 权限。",
})
return report, &VerificationError{Report: report, Err: fmt.Errorf("DNS 测试记录未通过公网查询,且自动清理失败:%w", cleanupErr)}
}
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "清理记录", Status: "completed", Message: "已清理未通过查询确认的临时 TXT 记录。",
})
return report, &VerificationError{Report: report, Err: fmt.Errorf("DNS 测试记录未通过公网查询:%w", err)}
}
return nil
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "查询记录", Status: "completed", Message: "公网 DNS 查询已确认 TXT 记录生效。",
})
if err := cleanupChallenge(ctx, provider, testDomain, token, keyAuth); err != nil {
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "清理记录", Status: "failed", Message: "测试记录已创建并确认生效,但自动清理失败。",
})
return report, &VerificationError{Report: report, Err: fmt.Errorf("DNS 测试记录已创建并确认生效,但自动清理失败:%w", err)}
}
report.Stages = append(report.Stages, setup.DNSVerificationStage{
Name: "清理记录", Status: "completed", Message: "已调用 DNS API 清理临时 TXT 记录。",
})
if values, err := t.resolver.LookupTXT(ctx, report.RecordName); err == nil && containsTXT(values, challengeInfo.Value) {
report.Stages[len(report.Stages)-1] = setup.DNSVerificationStage{
Name: "清理记录", Status: "warning", Message: "清理请求已成功,但公网 DNS 仍能查询到旧记录,可能正在等待缓存刷新。",
}
}
return report, nil
}
func cleanupChallenge(ctx context.Context, provider challenge.Provider, testDomain, token, keyAuth string) error {
cleanupBase := context.WithoutCancel(ctx)
cleanupCtx, cancel := context.WithTimeout(cleanupBase, dnsCleanupTimeout)
defer cancel()
return provider.CleanUp(cleanupCtx, testDomain, token, keyAuth)
}
type legoTXTResolver struct{}
func (legoTXTResolver) LookupTXT(ctx context.Context, fqdn string) ([]string, error) {
result, err := dnspersist01.DefaultClient().LookupTXT(ctx, fqdn)
if err != nil {
return nil, err
}
values := make([]string, 0, len(result.Records))
for _, record := range result.Records {
values = append(values, record.Value)
}
return values, nil
}
func waitForTXT(ctx context.Context, resolver TXTResolver, fqdn, expected string) error {
if resolver == nil {
return errors.New("TXT 查询服务未初始化")
}
deadline := time.NewTimer(30 * time.Second)
defer deadline.Stop()
ticker := time.NewTicker(2 * time.Second)
defer ticker.Stop()
for {
values, err := resolver.LookupTXT(ctx, fqdn)
if err == nil && containsTXT(values, expected) {
return nil
}
select {
case <-ctx.Done():
return ctx.Err()
case <-deadline.C:
if err != nil {
return fmt.Errorf("查询 TXT 记录失败:%w", err)
}
return errors.New("查询结果中未找到测试 TXT 值")
case <-ticker.C:
}
}
}
func containsTXT(values []string, expected string) bool {
for _, value := range values {
if strings.TrimSpace(value) == expected {
return true
}
}
return false
}
func randomValue(size int) (string, error) {
+84 -15
View File
@@ -3,9 +3,11 @@ package dnsprovider
import (
"context"
"errors"
"strings"
"testing"
"github.com/go-acme/lego/v5/challenge"
"github.com/go-acme/lego/v5/challenge/dns01"
)
type fakeFactory struct {
@@ -18,38 +20,69 @@ func (f fakeFactory) Create(string, map[string]string) (challenge.Provider, erro
}
type fakeProvider struct {
presented bool
cleaned bool
presentErr error
cleanupErr error
presented bool
cleaned bool
cleanupSawCanceled bool
presentErr error
cleanupErr error
domain string
keyAuth string
}
func (p *fakeProvider) Present(context.Context, string, string, string) error {
type fakeTXTResolver struct {
provider *fakeProvider
}
func (r fakeTXTResolver) LookupTXT(ctx context.Context, _ string) ([]string, error) {
if r.provider == nil || r.provider.domain == "" || r.provider.keyAuth == "" {
return nil, errors.New("测试 DNS 记录尚未创建")
}
return []string{dns01.GetChallengeInfo(ctx, r.provider.domain, r.provider.keyAuth).Value}, nil
}
func (p *fakeProvider) Present(_ context.Context, domain, _, keyAuth string) error {
p.presented = true
p.domain = domain
p.keyAuth = keyAuth
return p.presentErr
}
func (p *fakeProvider) CleanUp(context.Context, string, string, string) error {
func (p *fakeProvider) CleanUp(ctx context.Context, _ string, _ string, _ string) error {
p.cleaned = true
p.cleanupSawCanceled = ctx.Err() != nil
return p.cleanupErr
}
type missingTXTResolver struct{}
func (missingTXTResolver) LookupTXT(context.Context, string) ([]string, error) {
return nil, nil
}
func TestTesterCreatesAndCleansChallengeRecord(t *testing.T) {
provider := &fakeProvider{}
tester := NewTester(fakeFactory{provider: provider})
err := tester.Verify(t.Context(), Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
tester := NewTesterWithResolver(fakeFactory{provider: provider}, fakeTXTResolver{provider: provider})
report, err := tester.Verify(t.Context(), Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
if err != nil {
t.Fatalf("DNS 测试失败:%v", err)
}
if !provider.presented || !provider.cleaned {
t.Fatalf("DNS 测试未完整执行:presented=%v cleaned=%v", provider.presented, provider.cleaned)
}
if report.RecordName == "" || len(report.Stages) != 3 {
t.Fatalf("DNS 测试阶段报告不完整:%+v", report)
}
for index, stage := range report.Stages {
if stage.Status != "completed" && !(index == 2 && stage.Status == "warning") {
t.Fatalf("DNS 测试阶段状态异常:%+v", report.Stages)
}
}
}
func TestTesterDoesNotCleanupWhenPresentFails(t *testing.T) {
provider := &fakeProvider{presentErr: errors.New("拒绝访问")}
tester := NewTester(fakeFactory{provider: provider})
err := tester.Verify(t.Context(), Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
_, err := tester.Verify(t.Context(), Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
if err == nil {
t.Fatal("创建测试记录失败时应返回错误")
}
@@ -58,6 +91,39 @@ func TestTesterDoesNotCleanupWhenPresentFails(t *testing.T) {
}
}
func TestTesterCleansUpWithIndependentContextAfterQueryCancellation(t *testing.T) {
provider := &fakeProvider{}
tester := NewTesterWithResolver(fakeFactory{provider: provider}, missingTXTResolver{})
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := tester.Verify(ctx, Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
if err == nil {
t.Fatal("公网查询被取消时应返回错误")
}
if !provider.cleaned {
t.Fatal("公网查询被取消时仍应尝试清理测试记录")
}
if provider.cleanupSawCanceled {
t.Fatal("清理测试记录不应继承已取消的请求上下文")
}
}
func TestTesterReportsCleanupFailureAfterQueryFailure(t *testing.T) {
provider := &fakeProvider{cleanupErr: errors.New("权限不足")}
tester := NewTesterWithResolver(fakeFactory{provider: provider}, missingTXTResolver{})
ctx, cancel := context.WithCancel(context.Background())
cancel()
report, err := tester.Verify(ctx, Cloudflare, "example.com", map[string]string{"api_token": "secret-token"})
if err == nil || !strings.Contains(err.Error(), "自动清理失败") {
t.Fatalf("查询失败且清理失败时应返回组合诊断:%v", err)
}
if len(report.Stages) != 3 || report.Stages[1].Status != "failed" || report.Stages[2].Status != "failed" {
t.Fatalf("查询和清理失败阶段报告不完整:%+v", report.Stages)
}
}
func TestValidateCredentialsRejectsUnknownField(t *testing.T) {
_, err := ValidateCredentials(Cloudflare, map[string]string{"api_token": "token", "unexpected": "value"})
if err == nil {
@@ -65,10 +131,13 @@ func TestValidateCredentialsRejectsUnknownField(t *testing.T) {
}
}
func TestUnavailableProviderReturnsTypedError(t *testing.T) {
_, err := NewLegoFactory().Create(CNAME, map[string]string{"delegated_domain": "acme.example.com", "delegated_provider": "cloudflare"})
if !errors.Is(err, ErrProviderUnavailable) {
t.Fatalf("未开放适配器应返回指定错误:%v", err)
func TestCNAMEProviderIsAvailable(t *testing.T) {
descriptor, err := GetDescriptor(CNAME)
if err != nil {
t.Fatalf("failed to read CNAME descriptor: %v", err)
}
if !descriptor.Available {
t.Fatal("CNAME delegation adapter should be available")
}
}
@@ -95,7 +164,7 @@ func TestLegoFactoryCreatesConfiguredProviders(t *testing.T) {
},
},
{
name: "华为云无效区域校验",
name: "DNSPod",
providerID: HuaweiCloud,
credentials: map[string]string{
"access_key_id": "id",
@@ -104,7 +173,7 @@ func TestLegoFactoryCreatesConfiguredProviders(t *testing.T) {
},
},
{
name: "腾讯云",
name: "华为云无效区域校验",
providerID: TencentCloud,
credentials: map[string]string{
"secret_id": "id",