完成初始化证书事务和远程部署互斥并纳入发布构建脚本

This commit is contained in:
xuans committed 2026-09-15 20:17:34 +08:00
1 parent 05e05a1a23
commit a4dffb04d4
27 files changed
+1294 -25

No files matched your search

+118
View File
@@ -0,0 +1,118 @@
package cli
import (
"context"
"errors"
"fmt"
"io"
"os"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/dnsprovider"
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/setup"
)
type initCertificateIssuer func(context.Context, config.Config) (certificate.SavedResource, error)
type initCertificateRollback func(context.Context, certificate.SavedResource) error
func issueInitCertificate(ctx context.Context, cfg config.Config) (certificate.SavedResource, error) {
store, err := secretstore.Open(cfg.Paths.Config)
if err != nil {
return certificate.SavedResource{}, fmt.Errorf("打开初始化凭据存储失败:%w", err)
}
service := certificate.NewService(cfg, nil, store, dnsprovider.NewLegoFactory(), certificate.NewAccountRepository(store))
service.SetDNSAuthorizationChecker(dnsprovider.NewAliyunAuthorizationChecker())
return service.IssueForSetup(ctx, certificate.SetupCertificateRequest{
Domains: []string{cfg.Web.Hostname}, CertificateType: "single",
ProviderID: cfg.DNS.Provider, CredentialRef: cfg.DNS.CredentialRef,
AccountEmail: cfg.Admin.Email, Environment: cfg.ACME.Environment,
CertificateRoot: cfg.Paths.Certificate, BackupRoot: cfg.Paths.Backup,
})
}
// completeInit 在证书校验及配置保存均成功后才发布就绪状态;失败时独立回滚证书。
func completeInit(ctx context.Context, cfg *config.Config, path string, manager firewall.Manager, issue initCertificateIssuer, rollback initCertificateRollback) (result firewall.Result, err error) {
if cfg == nil || issue == nil || rollback == nil {
return result, errors.New("初始化证书事务未配置")
}
cfg.SetupReady, cfg.Web.InitReady = false, false
if cfg.Web.PublicIP != "" || strings.TrimSpace(cfg.Web.Hostname) == "" {
return result, errors.New("DNS-01 初始化必须配置管理后台域名,不支持直接签发公网 IP 证书")
}
if err := cfg.Validate(); err != nil {
return result, err
}
issueCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
saved, err := issue(issueCtx, *cfg)
cancel()
if err != nil {
return result, fmt.Errorf("申请管理后台证书失败,初始化尚未完成:%w", err)
}
defer func() {
if err == nil {
return
}
rollbackCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if rollbackErr := rollback(rollbackCtx, saved); rollbackErr != nil {
err = errors.Join(err, fmt.Errorf("管理后台证书回滚失败,请手动检查证书目录:%w", rollbackErr))
}
}()
for _, filename := range []string{saved.CertificatePath, saved.FullChainPath, saved.PrivateKeyPath} {
info, statErr := os.Lstat(filename)
if statErr != nil || !info.Mode().IsRegular() {
return result, fmt.Errorf("初始化证书必须是可读取的普通文件:%s", filename)
}
}
if _, err = (certificate.LocalValidator{}).ValidateFiles(ctx, saved.CertificatePath, saved.FullChainPath, saved.PrivateKeyPath, []string{cfg.Web.Hostname}); err != nil {
return result, fmt.Errorf("初始化证书文件校验失败:%w", err)
}
// 签发服务已按 ACME 环境验证信任链,这里再次校验实际落盘内容与私钥。
updated := *cfg
updated.Server.TLSCert, updated.Server.TLSKey = saved.FullChainPath, saved.PrivateKeyPath
updated.SetupReady, updated.Web.InitReady = true, true
if err = updated.Validate(); err != nil {
return result, err
}
if err = ctx.Err(); err != nil {
return result, err
}
result, err = saveSetupWithFirewall(ctx, updated, path, manager)
if err == nil {
*cfg = updated
}
return result, err
}
func verifyExistingDNSCredentials(ctx context.Context, cfg config.Config, input *setup.Input, output io.Writer, checker certificate.DNSAuthorizationChecker) (func(), error) {
input.DNSVerified = false
if !strings.EqualFold(input.DNSProvider, dnsprovider.Aliyun) || checker == nil {
return func() {}, errors.New("已有凭据引用必须通过阿里云在线权限校验,不能通过参数声明已验证")
}
target := strings.TrimSpace(input.WebHostname)
if target == "" {
return func() {}, errors.New("校验已有 DNS 凭据前必须填写管理后台域名")
}
store, err := secretstore.Open(cfg.Paths.Config)
if err != nil {
return func() {}, err
}
credentials, err := store.Get(ctx, input.DNSCredentialRef)
if err != nil {
return func() {}, fmt.Errorf("读取已有 DNS 凭据失败:%w", err)
}
verifyCtx, cancel := context.WithTimeout(ctx, dnsVerificationTimeout(cfg))
defer cancel()
if err := checker.VerifyDomain(verifyCtx, input.DNSProvider, target, credentials); err != nil {
return func() {}, fmt.Errorf("已有 DNS 凭据在线权限校验失败:%w", err)
}
input.DNSVerified = true
fmt.Fprintln(output, "已有 DNS 凭据已重新通过管理后台域名的在线权限校验。")
// 用户原有凭据不属于本次事务,即使后续失败也不得删除。
return func() {}, nil
}
@@ -0,0 +1,184 @@
package cli
import (
"context"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"encoding/pem"
"errors"
"io"
"math/big"
"os"
"path/filepath"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/setup"
)
func initTestConfig(t *testing.T) config.Config {
t.Helper()
root := t.TempDir()
cfg := config.Default(root)
cfg.Paths.Config = filepath.Join(root, "conf")
cfg.Paths.Certificate = filepath.Join(root, "certificates")
cfg.Paths.Backup = filepath.Join(root, "backups")
cfg.Admin.Username, cfg.Admin.Email, cfg.Admin.PasswordHash = "admin", "admin@example.com", "test-only-hash"
cfg.Web.Hostname, cfg.Web.PublicIP = "panel.example.com", ""
cfg.DNS.Provider, cfg.DNS.CredentialRef, cfg.DNS.VerificationState = "aliyun", "secret://dns/aliyun/init-test", "verified"
return cfg
}
func initTestResource(t *testing.T) certificate.Resource {
t.Helper()
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatal(err)
}
template := &x509.Certificate{
SerialNumber: big.NewInt(time.Now().UnixNano()), DNSNames: []string{"panel.example.com"},
NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageDigitalSignature, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
}
der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
if err != nil {
t.Fatal(err)
}
private, err := x509.MarshalECPrivateKey(key)
if err != nil {
t.Fatal(err)
}
return certificate.Resource{
Domains: []string{"panel.example.com"}, Certificate: pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}),
PrivateKey: pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: private}),
}
}
func TestCompleteInitCommitsOnlyAfterCertificateAndRollsBackFailures(t *testing.T) {
for _, scenario := range []string{"success", "issue_failure", "invalid_files", "firewall_failure", "save_failure", "cancelled", "rollback_failure"} {
t.Run(scenario, func(t *testing.T) {
cfg := initTestConfig(t)
path := filepath.Join(cfg.Paths.Config, "scert.json")
manager := &cliFakeFirewallManager{result: firewall.Result{Created: true}}
if scenario == "firewall_failure" {
manager.openErr = errors.New("测试防火墙拒绝")
}
if scenario == "save_failure" {
blocked := filepath.Join(t.TempDir(), "blocked")
if err := os.WriteFile(blocked, []byte("blocked"), 0o600); err != nil {
t.Fatal(err)
}
path = filepath.Join(blocked, "scert.json")
}
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
var saved certificate.SavedResource
issue := func(ctx context.Context, candidate config.Config) (certificate.SavedResource, error) {
if candidate.SetupReady || candidate.Web.InitReady {
t.Fatal("签发开始前不得标记就绪")
}
if scenario == "issue_failure" {
return saved, errors.New("测试签发失败")
}
store := certificate.FileStore{Root: cfg.Paths.Certificate, BackupRoot: cfg.Paths.Backup}
var err error
saved, err = store.SaveForType(ctx, cfg.Web.Hostname, "single", initTestResource(t))
if err != nil {
t.Fatal(err)
}
if scenario == "invalid_files" || scenario == "rollback_failure" {
if err := os.WriteFile(saved.PrivateKeyPath, []byte("invalid-test-key"), 0o600); err != nil {
t.Fatal(err)
}
}
if scenario == "cancelled" {
cancel()
}
return saved, nil
}
rolledBack := false
rollback := func(ctx context.Context, saved certificate.SavedResource) error {
rolledBack = true
if ctx.Err() != nil {
t.Fatal("回滚必须使用独立的有效上下文")
}
if err := certificate.RollbackSavedResource(ctx, saved); err != nil {
return err
}
if scenario == "rollback_failure" {
return errors.New("测试回滚报告失败")
}
return nil
}
_, err := completeInit(ctx, &cfg, path, manager, issue, rollback)
if scenario == "success" {
if err != nil || rolledBack || !cfg.SetupReady || !cfg.Web.InitReady {
t.Fatalf("正常初始化未提交就绪状态:%v", err)
}
stored, err := config.Load(path)
if err != nil || !stored.SetupReady || stored.Server.TLSCert != saved.FullChainPath || stored.Server.TLSKey != saved.PrivateKeyPath {
t.Fatalf("证书配置未正确保存:%v", err)
}
return
}
if err == nil || cfg.SetupReady || cfg.Web.InitReady {
t.Fatalf("失败时不得发布就绪状态:%v", err)
}
if _, err := os.Stat(path); err == nil {
t.Fatal("失败时不得留下已完成的配置")
}
if scenario != "issue_failure" && !rolledBack {
t.Fatal("后续阶段失败必须回滚证书")
}
if scenario == "save_failure" && !manager.rollbackCall {
t.Fatal("保存失败必须回滚新建防火墙规则")
}
if scenario == "rollback_failure" && !strings.Contains(err.Error(), "手动检查") {
t.Fatal("必须明确报告回滚失败")
}
})
}
}
type initAuthorizationChecker struct {
err error
calls int
}
func (c *initAuthorizationChecker) VerifyDomain(context.Context, string, string, map[string]string) error {
c.calls++
return c.err
}
func TestExistingDNSReferenceCannotBypassVerification(t *testing.T) {
cfg := initTestConfig(t)
store, err := secretstore.Open(cfg.Paths.Config)
if err != nil {
t.Fatal(err)
}
if err := store.Put(t.Context(), cfg.DNS.CredentialRef, map[string]string{"access_key_id": "test-id", "access_key_secret": "test-secret"}); err != nil {
t.Fatal(err)
}
for _, denied := range []bool{false, true} {
input := &setup.Input{DNSProvider: "aliyun", DNSCredentialRef: cfg.DNS.CredentialRef, DNSVerified: true, WebHostname: cfg.Web.Hostname}
checker := &initAuthorizationChecker{}
if denied {
checker.err = errors.New("测试撤权")
}
cleanup, err := verifyExistingDNSCredentials(t.Context(), cfg, input, io.Discard, checker)
cleanup()
if checker.calls != 1 || (err != nil) != denied || input.DNSVerified == denied {
t.Fatal("已有引用或已验证参数不得绕过当前权限检查")
}
if exists, err := store.Has(t.Context(), cfg.DNS.CredentialRef); err != nil || !exists {
t.Fatal("失败清理不得删除用户原有凭据")
}
}
}
+25 -5
View File
@@ -116,13 +116,17 @@ func newInitCommand() *cobra.Command {
}
func newInitCommandWithFirewall(firewallManager firewall.Manager) *cobra.Command {
return newInitCommandWithDependencies(firewallManager, issueInitCertificate)
}
func newInitCommandWithDependencies(firewallManager firewall.Manager, issue initCertificateIssuer) *cobra.Command {
var (
adminUsername, adminEmail, adminPassword, emailProvider, emailEndpoint string
emailHTTPPath, emailHTTPLoginPath, emailHTTPAuthMode, emailHTTPCredentialRef, emailHTTPHeaders string
emailSMTPHost, emailSMTPUsername, emailSMTPPassword, emailSMTPMode string
emailEventMode, emailSenderName, emailSenderEmail, emailRetryIntervals string
recipients, dnsProvider, dnsCredentialRef, certificateRoot string
webHostname, webPublicIP, httpsMode string
webHostname, webPublicIP, httpsMode, acmeEnvironment string
serverPort, emailTimeoutSecs, emailRetryCount, emailSMTPPort int
emailHTTPEnabled, emailSMTPEnabled, emailSMTPAllowPlaintextAuth, emailIncludeDeploymentDetails bool
emailIncludeCertificateSerial, emailIncludeManagementURL bool
@@ -136,6 +140,18 @@ func newInitCommandWithFirewall(firewallManager firewall.Manager) *cobra.Command
return err
}
cfg := config.Default(baseDir)
cfg.ACME.Environment = acmeEnvironment
lock, err := acquireProcessLock(cfg, "初始化、服务或备份恢复任务正在执行,请稍后重试")
if err != nil {
return err
}
defer lock.Close()
// 等待进程锁期间另一个初始化可能已完成,必须在取得锁后再次检查。
if _, err := os.Lstat(path); err == nil {
return fmt.Errorf("配置文件已存在:%s", path)
} else if !errors.Is(err, os.ErrNotExist) {
return err
}
emailHeaders, err := parseStringMap(emailHTTPHeaders)
if err != nil {
return fmt.Errorf("HTTP 自定义请求头格式无效:%w", err)
@@ -184,13 +200,16 @@ func newInitCommandWithFirewall(firewallManager firewall.Manager) *cobra.Command
cleanupSecret()
return err
}
firewallResult, err := saveSetupWithFirewall(cmd.Context(), cfg, path, firewallManager)
firewallResult, err := completeInit(cmd.Context(), &cfg, path, firewallManager, issue, certificate.RollbackSavedResource)
if err != nil {
cleanupSecret()
return err
}
fmt.Fprintf(cmd.OutOrStdout(), "初始化配置已保存:%s\n", path)
fmt.Fprintf(cmd.OutOrStdout(), "DNS API 已完成在线验证,凭据已加密保存;真实 Web 证书申请将在后续任务接入。\n")
fmt.Fprintln(cmd.OutOrStdout(), "管理后台证书已申请并校验,DNS 凭据已加密保存。")
if cfg.ACME.Environment == "staging" {
fmt.Fprintln(cmd.OutOrStdout(), "当前使用 ACME 测试环境,证书不受浏览器信任,不能作为正式生产证书。")
}
fmt.Fprintf(cmd.OutOrStdout(), "本机防火墙:%s\n", firewallResult.Message)
fmt.Fprintf(cmd.OutOrStdout(), "请确认云安全组已放行主服务端口 %d。Scert-admin 默认关闭;需要重置密码时启动后访问:%s\n", cfg.Server.Port, cfg.ResetURL())
return nil
@@ -226,7 +245,8 @@ func newInitCommandWithFirewall(firewallManager firewall.Manager) *cobra.Command
command.Flags().StringVar(&emailRetryIntervals, "email-retry-intervals", "30,120,600", "通知重试间隔(秒,逗号分隔)")
command.Flags().StringVar(&dnsProvider, "dns-provider", "", "DNS API 服务商标识")
command.Flags().StringVar(&dnsCredentialRef, "dns-credential-ref", "", "DNS 凭据引用")
command.Flags().BoolVar(&dnsVerified, "dns-verified", false, "DNS API 是否已通过验证测试")
command.Flags().BoolVar(&dnsVerified, "dns-verified", false, "兼容参数,不会跳过在线权限和证书校验")
command.Flags().StringVar(&acmeEnvironment, "acme-environment", "staging", "ACME 环境:staging 为测试,production 为正式签发")
command.Flags().StringVar(&certificateRoot, "certificate-root", "", "证书部署根目录,默认使用系统目录")
command.Flags().StringVar(&webHostname, "web-hostname", "", "管理页面域名")
command.Flags().StringVar(&webPublicIP, "web-public-ip", "", "没有域名时使用的公网 IP")
@@ -442,7 +462,7 @@ func prepareDNSCredentials(ctx context.Context, cfg config.Config, input *setup.
return func() {}, errors.New("初始化输入不能为空")
}
if strings.TrimSpace(input.DNSCredentialRef) != "" {
return func() {}, nil
return verifyExistingDNSCredentials(ctx, cfg, input, output, dnsprovider.NewAliyunAuthorizationChecker())
}
if len(input.DNSCredentials) == 0 {
return func() {}, errors.New("DNS 凭据不能为空")