完善证书申请续期与安装初始化流程

This commit is contained in:
xuans committed 2026-08-27 00:31:40 +08:00
1 parent fd8d8608f5
commit 07636abe44
66 files changed
+9470 -165

No files matched your search

+65 -1
View File
@@ -9,6 +9,7 @@ import (
"net/http/httptest"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
"git.pcux.cn/xuans/Scert/backend/internal/config"
@@ -18,9 +19,18 @@ import (
type stubDomainRepository struct {
items []domain.Domain
created domain.Domain
loaded domain.Domain
updated domain.Domain
listErr error
createErr error
getErr error
updateErr error
deleteErr error
stateErr error
}
func (r *stubDomainRepository) UpdateCertificateState(_ context.Context, id, status string, expiresAt *time.Time) error {
return r.stateErr
}
func (r *stubDomainRepository) Create(_ context.Context, item domain.Domain) error {
@@ -29,7 +39,13 @@ func (r *stubDomainRepository) Create(_ context.Context, item domain.Domain) err
}
func (r *stubDomainRepository) GetByID(_ context.Context, _ string) (domain.Domain, error) {
return domain.Domain{}, sql.ErrNoRows
if r.getErr != nil {
return domain.Domain{}, r.getErr
}
if r.loaded.ID == "" {
return domain.Domain{}, sql.ErrNoRows
}
return r.loaded, nil
}
func (r *stubDomainRepository) List(_ context.Context) ([]domain.Domain, error) {
@@ -40,6 +56,11 @@ func (r *stubDomainRepository) Delete(_ context.Context, _ string) error {
return r.deleteErr
}
func (r *stubDomainRepository) Update(_ context.Context, item domain.Domain) error {
r.updated = item
return r.updateErr
}
func TestStatusReturnsApplicationAndConfigVersions(t *testing.T) {
cfg := config.Default(t.TempDir())
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
@@ -102,3 +123,46 @@ func TestDeleteMissingDomainReturnsNotFound(t *testing.T) {
t.Fatalf("删除不存在域名响应不正确:%d %s", response.Code, response.Body.String())
}
}
func TestUpdateDomainAPI(t *testing.T) {
cfg := config.Default(t.TempDir())
loaded := domain.Domain{ID: "domain-1", Name: "example.com", CertificateType: domain.CertificateSingle, SANs: []string{"example.com"}, Status: "active"}
repo := &stubDomainRepository{loaded: loaded}
server := New(Dependencies{Config: cfg, Repository: repo})
request := httptest.NewRequest(http.MethodPut, "/api/v1/domains/domain-1", strings.NewReader(`{"name":"example.com","certificate_type":"san","sans":["www.example.com"],"auto_renew":false,"acme_environment":"production","dns_provider":"cloudflare"}`))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("更新域名响应错误:%d %s", response.Code, response.Body.String())
}
if repo.updated.ID != loaded.ID || repo.updated.Status != "pending" || repo.updated.AutoRenew || repo.updated.ACMEEnvironment != domain.ACMEEnvironmentProduction || len(repo.updated.SANs) != 2 {
t.Fatalf("更新域名参数不正确:%+v", repo.updated)
}
}
func TestCreateDomainConflictReturnsConflict(t *testing.T) {
cfg := config.Default(t.TempDir())
repo := &stubDomainRepository{createErr: errors.New("UNIQUE constraint failed: domains.name")}
server := New(Dependencies{Config: cfg, Repository: repo})
request := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"single"}`))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusConflict {
t.Fatalf("重复域名响应错误:%d %s", response.Code, response.Body.String())
}
}
func TestUpdateDomainRejectsInvalidEnvironment(t *testing.T) {
cfg := config.Default(t.TempDir())
loaded := domain.Domain{ID: "domain-1", Name: "example.com"}
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{loaded: loaded}})
request := httptest.NewRequest(http.MethodPut, "/api/v1/domains/domain-1", strings.NewReader(`{"name":"example.com","certificate_type":"single","acme_environment":"invalid"}`))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest {
t.Fatalf("非法 ACME 环境响应错误:%d %s", response.Code, response.Body.String())
}
}
+89 -10
View File
@@ -6,6 +6,7 @@ import (
"net"
"net/http"
"strconv"
"sync"
"time"
"github.com/gin-gonic/gin"
@@ -13,20 +14,28 @@ import (
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
"git.pcux.cn/xuans/Scert/backend/internal/logging"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
type Dependencies struct {
Config config.Config
ConfigPath string
Logger *logging.Logger
Repository repository.DomainRepository
SetupDNS setupDNSVerifier
Firewall firewall.Manager
}
type Server struct {
configMu sync.RWMutex
config config.Config
configPath string
logger *logging.Logger
repository repository.DomainRepository
setupDNS setupDNSVerifier
firewall firewall.Manager
httpServer *http.Server
router *gin.Engine
}
@@ -35,16 +44,22 @@ func New(deps Dependencies) *Server {
gin.SetMode(gin.ReleaseMode)
router := gin.New()
router.Use(gin.Recovery())
server := &Server{config: deps.Config, logger: deps.Logger, repository: deps.Repository, router: router}
server := &Server{
config: deps.Config, configPath: deps.ConfigPath, logger: deps.Logger,
repository: deps.Repository, setupDNS: deps.SetupDNS, firewall: deps.Firewall, router: router,
}
server.registerRoutes()
server.registerSetupRoutes()
return server
}
func (s *Server) registerRoutes() {
// 主路由保持独立,初始化路由由专用模块注册。
s.router.GET("/healthz", s.health)
s.router.GET("/api/v1/status", s.status)
s.router.GET("/api/v1/domains", s.listDomains)
s.router.POST("/api/v1/domains", s.createDomain)
s.router.PUT("/api/v1/domains/:id", s.updateDomain)
s.router.DELETE("/api/v1/domains/:id", s.deleteDomain)
}
@@ -53,8 +68,11 @@ func (s *Server) Handler() http.Handler {
}
func (s *Server) ListenAndServe() error {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
s.httpServer = &http.Server{
Addr: net.JoinHostPort(s.config.Server.Host, strconv.Itoa(s.config.Server.Port)),
Addr: net.JoinHostPort(cfg.Server.Host, strconv.Itoa(cfg.Server.Port)),
Handler: s.router,
ReadHeaderTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Second,
@@ -62,7 +80,7 @@ func (s *Server) ListenAndServe() error {
IdleTimeout: 60 * time.Second,
}
if s.logger != nil {
s.logger.Info("HTTP 服务启动", "address", s.httpServer.Addr, "https_mode", s.config.Server.HTTPSMode)
s.logger.Info("HTTP 服务启动", "address", s.httpServer.Addr, "https_mode", cfg.Server.HTTPSMode)
}
return s.httpServer.ListenAndServe()
}
@@ -78,10 +96,13 @@ func (s *Server) Shutdown(ctx context.Context) error {
return err
}
type createDomainRequest struct {
type domainRequest struct {
Name string `json:"name" binding:"required"`
CertificateType string `json:"certificate_type" binding:"required"`
SANs []string `json:"sans"`
AutoRenew *bool `json:"auto_renew"`
ACMEEnvironment string `json:"acme_environment"`
DNSProvider string `json:"dns_provider"`
}
func (s *Server) health(c *gin.Context) {
@@ -89,13 +110,16 @@ func (s *Server) health(c *gin.Context) {
}
func (s *Server) status(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
c.JSON(http.StatusOK, gin.H{
"service": "scert",
"version": buildinfo.Version,
"config_version": s.config.Version,
"setup_ready": s.config.SetupReady,
"https_mode": s.config.Server.HTTPSMode,
"database_driver": s.config.Database.Driver,
"config_version": cfg.Version,
"setup_ready": cfg.SetupReady,
"https_mode": cfg.Server.HTTPSMode,
"database_driver": cfg.Database.Driver,
})
}
@@ -109,23 +133,78 @@ func (s *Server) listDomains(c *gin.Context) {
}
func (s *Server) createDomain(c *gin.Context) {
var request createDomainRequest
var request domainRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
item, err := domain.NewDomain(request.Name, domain.CertificateType(request.CertificateType), request.SANs)
item, err := newDomainFromRequest(request)
if err != nil {
s.writeError(c, http.StatusBadRequest, "域名配置无效", err)
return
}
if err := s.repository.Create(c.Request.Context(), item); err != nil {
if repository.IsConflict(err) {
s.writeError(c, http.StatusConflict, "域名已经存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "保存域名失败", err)
return
}
c.JSON(http.StatusCreated, item)
}
func (s *Server) updateDomain(c *gin.Context) {
var request domainRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
existing, err := s.repository.GetByID(c.Request.Context(), c.Param("id"))
if err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "域名不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取域名失败", err)
return
}
item, err := newDomainFromRequest(request)
if err != nil {
s.writeError(c, http.StatusBadRequest, "域名配置无效", err)
return
}
item.ID = existing.ID
item.CreatedAt = existing.CreatedAt
item.Status = "pending"
item.ExpiresAt = nil
if err := s.repository.Update(c.Request.Context(), item); err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "域名不存在", err)
return
}
if repository.IsConflict(err) {
s.writeError(c, http.StatusConflict, "域名已经存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "更新域名失败", err)
return
}
c.JSON(http.StatusOK, item)
}
func newDomainFromRequest(request domainRequest) (domain.Domain, error) {
autoRenew := true
if request.AutoRenew != nil {
autoRenew = *request.AutoRenew
}
acmeEnvironment := request.ACMEEnvironment
if acmeEnvironment == "" {
acmeEnvironment = domain.ACMEEnvironmentStaging
}
return domain.NewDomainWithOptions(request.Name, domain.CertificateType(request.CertificateType), request.SANs, autoRenew, acmeEnvironment, request.DNSProvider)
}
func (s *Server) deleteDomain(c *gin.Context) {
if err := s.repository.Delete(c.Request.Context(), c.Param("id")); err != nil {
if repository.IsNotFound(err) {
+272
View File
@@ -0,0 +1,272 @@
package httpapi
import (
"context"
"errors"
"fmt"
"net"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/dnsprovider"
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
"git.pcux.cn/xuans/Scert/backend/internal/setup"
)
const setupRequestLimit = 64 * 1024
type setupDNSVerifier interface {
Verify(ctx context.Context, input setup.DNSVerificationInput) (setup.DNSVerificationResult, error)
Check(token, providerID, credentialRef, testDomain string) error
Consume(token, providerID, credentialRef, testDomain string) error
}
type setupRequest struct {
AdminUsername string `json:"admin_username"`
AdminPassword string `json:"admin_password"`
ServerPort int `json:"server_port"`
ResetServicePort int `json:"reset_service_port"`
EmailProvider string `json:"email_provider"`
EmailEndpoint string `json:"email_endpoint"`
Recipients []string `json:"recipients"`
DNSProvider string `json:"dns_provider"`
DNSCredentialRef string `json:"dns_credential_ref"`
DNSVerificationToken string `json:"dns_verification_token"`
DNSTestDomain string `json:"dns_test_domain"`
CertificateRoot string `json:"certificate_root"`
WebHostname string `json:"web_hostname"`
WebPublicIP string `json:"web_public_ip"`
WebEnabled *bool `json:"web_enabled"`
HTTPSMode string `json:"https_mode"`
}
type dnsTestRequest struct {
ProviderID string `json:"provider"`
TestDomain string `json:"test_domain"`
Credentials map[string]string `json:"credentials"`
}
func (s *Server) registerSetupRoutes() {
s.router.GET("/api/v1/setup/status", s.setupStatus)
s.router.GET("/api/v1/setup/dns/providers", s.setupDNSProviders)
s.router.POST("/api/v1/setup/dns/test", s.testSetupDNS)
s.router.POST("/api/v1/setup", s.applySetup)
}
func (s *Server) setupStatus(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if !cfg.SetupReady && !isLoopbackRequest(c.Request) {
s.writeError(c, http.StatusForbidden, "首次初始化接口仅允许从本机访问", nil)
return
}
phase := "ready"
blockers := []string{}
if !cfg.SetupReady {
phase = "configuration_required"
blockers = append(blockers, "需要完成首次初始化")
if cfg.DNS.VerificationState != "verified" {
blockers = append(blockers, "DNS API 尚未验证")
}
}
c.JSON(http.StatusOK, gin.H{
"initialized": cfg.SetupReady,
"phase": phase,
"blockers": blockers,
"server_port": cfg.Server.Port,
"reset_service_port": cfg.Admin.ResetServicePort,
"https_mode": cfg.Server.HTTPSMode,
"web_enabled": cfg.Web.Enabled,
"web_hostname": cfg.Web.Hostname,
"web_public_ip": cfg.Web.PublicIP,
"certificate_root": cfg.Paths.Certificate,
"dns_provider": cfg.DNS.Provider,
"dns_verification_state": cfg.DNS.VerificationState,
"dns_test_available": s.setupDNS != nil,
})
}
func (s *Server) setupDNSProviders(c *gin.Context) {
if !s.allowSetupRequest(c) {
return
}
c.JSON(http.StatusOK, gin.H{"items": dnsprovider.Descriptors()})
}
func (s *Server) testSetupDNS(c *gin.Context) {
if !s.allowSetupRequest(c) {
return
}
if s.setupDNS == nil {
s.writeError(c, http.StatusServiceUnavailable, "DNS 在线验证服务尚未初始化", nil)
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, setupRequestLimit)
var request dnsTestRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "DNS 测试请求参数无效", err)
return
}
ctx, cancel := context.WithTimeout(c.Request.Context(), 45*time.Second)
defer cancel()
result, err := s.setupDNS.Verify(ctx, setup.DNSVerificationInput{
ProviderID: request.ProviderID, TestDomain: request.TestDomain, Credentials: request.Credentials,
})
if err != nil {
if errors.Is(err, dnsprovider.ErrProviderUnavailable) {
s.writeError(c, http.StatusNotImplemented, "该 DNS 服务商在线验证适配器尚未开放", nil)
return
}
if s.logger != nil {
s.logger.Error("DNS API 在线验证失败", "provider", request.ProviderID, "test_domain", request.TestDomain)
}
c.JSON(http.StatusUnprocessableEntity, gin.H{"error": "DNS API 在线验证失败,请检查凭据、测试域名和 DNS 权限"})
return
}
c.JSON(http.StatusOK, gin.H{
"verified": true,
"credential_ref": result.CredentialRef,
"verification_token": result.VerificationToken,
"expires_at": result.ExpiresAt,
"message": "DNS API 在线验证通过,凭据已加密保存。",
})
}
func (s *Server) applySetup(c *gin.Context) {
s.configMu.Lock()
defer s.configMu.Unlock()
if !isLoopbackRequest(c.Request) {
s.writeError(c, http.StatusForbidden, "首次初始化接口仅允许从本机访问", nil)
return
}
if s.config.SetupReady {
s.writeError(c, http.StatusConflict, "初始化已经完成,不能重复提交", nil)
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, setupRequestLimit)
var request setupRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "初始化请求参数无效", err)
return
}
if s.setupDNS == nil {
s.writeError(c, http.StatusServiceUnavailable, "DNS 在线验证服务尚未初始化", nil)
return
}
testDomain := strings.TrimSpace(request.DNSTestDomain)
if testDomain == "" {
testDomain = strings.TrimSpace(request.WebHostname)
}
if err := s.setupDNS.Check(request.DNSVerificationToken, request.DNSProvider, request.DNSCredentialRef, testDomain); err != nil {
s.writeError(c, http.StatusBadRequest, err.Error(), nil)
return
}
webEnabled := true
if request.WebEnabled != nil {
webEnabled = *request.WebEnabled
}
updated := s.config
err := setup.Apply(&updated, setup.Input{
AdminUsername: request.AdminUsername,
AdminPassword: request.AdminPassword,
ServerPort: request.ServerPort,
ResetServicePort: request.ResetServicePort,
EmailProvider: request.EmailProvider,
EmailEndpoint: request.EmailEndpoint,
EmailRecipients: request.Recipients,
DNSProvider: request.DNSProvider,
DNSCredentialRef: request.DNSCredentialRef,
DNSVerified: true,
CertificateRoot: request.CertificateRoot,
WebHostname: request.WebHostname,
WebPublicIP: request.WebPublicIP,
WebEnabled: webEnabled,
HTTPSMode: request.HTTPSMode,
})
if err != nil {
s.writeError(c, http.StatusBadRequest, err.Error(), err)
return
}
if strings.TrimSpace(s.configPath) == "" {
s.writeError(c, http.StatusInternalServerError, "服务未配置配置文件路径,无法保存初始化结果", nil)
return
}
firewallResult := firewall.Result{
Backend: firewall.BackendNone, Port: updated.Server.Port,
Message: "未配置防火墙管理器,已跳过本机规则创建",
}
if s.firewall != nil {
firewallContext, cancel := context.WithTimeout(c.Request.Context(), 30*time.Second)
firewallResult, err = s.firewall.OpenTCP(firewallContext, updated.Server.Port)
cancel()
if err != nil {
s.writeError(c, http.StatusInternalServerError, "自动配置本机防火墙失败,请使用管理员权限重新运行初始化程序", err)
return
}
}
if err := updated.Save(s.configPath); err != nil {
if firewallResult.Created && s.firewall != nil {
rollbackContext, cancel := context.WithTimeout(context.Background(), 30*time.Second)
rollbackErr := s.firewall.Rollback(rollbackContext, firewallResult)
cancel()
if rollbackErr != nil {
if s.logger != nil {
s.logger.Error("保存初始化配置失败,且回滚本机防火墙规则失败", "error", rollbackErr, "rule", firewallResult.RuleName)
}
s.writeError(c, http.StatusInternalServerError, "保存初始化配置失败,且自动创建的防火墙规则回滚失败,请手动检查本机防火墙", err)
return
}
}
s.writeError(c, http.StatusInternalServerError, "保存初始化配置失败", err)
return
}
if err := s.setupDNS.Consume(request.DNSVerificationToken, request.DNSProvider, request.DNSCredentialRef, testDomain); err != nil && s.logger != nil {
s.logger.Warn("初始化配置已保存,但清理 DNS 验证令牌失败", "error", err)
}
s.config = updated
c.JSON(http.StatusOK, gin.H{
"initialized": true,
"message": fmt.Sprintf(
"初始化配置已保存,DNS API 已完成在线验证且凭据已加密保存。%s。请确认云安全组已放行主服务端口 %d;Scert-admin 仅允许本机访问。证书申请和 HTTPS 切换将在后续任务中完成。",
firewallResult.Message, updated.Server.Port,
),
"status": gin.H{
"server_port": updated.Server.Port,
"reset_service_port": updated.Admin.ResetServicePort,
"web_enabled": updated.Web.Enabled,
"https_mode": updated.Server.HTTPSMode,
"firewall": firewallResult,
},
})
}
func (s *Server) allowSetupRequest(c *gin.Context) bool {
s.configMu.RLock()
initialized := s.config.SetupReady
s.configMu.RUnlock()
if initialized {
s.writeError(c, http.StatusConflict, "初始化已经完成,不能重复执行初始化 DNS 测试", nil)
return false
}
if !isLoopbackRequest(c.Request) {
s.writeError(c, http.StatusForbidden, "首次初始化接口仅允许从本机访问", nil)
return false
}
return true
}
func isLoopbackRequest(request *http.Request) bool {
if request == nil {
return false
}
host, _, err := net.SplitHostPort(request.RemoteAddr)
if err != nil {
host = request.RemoteAddr
}
ip := net.ParseIP(strings.TrimSpace(host))
return ip != nil && ip.IsLoopback()
}
+400
View File
@@ -0,0 +1,400 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"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/setup"
)
type fakeSetupDNSVerifier struct {
verifyResult setup.DNSVerificationResult
verifyErr error
checkErr error
consumeErr error
checked bool
consumed bool
}
type fakeFirewallManager struct {
result firewall.Result
openErr error
rollbackErr error
openedPort int
rollbackCall bool
}
func (f *fakeFirewallManager) OpenTCP(_ context.Context, port int) (firewall.Result, error) {
f.openedPort = port
if f.result.Port == 0 {
f.result.Port = port
}
return f.result, f.openErr
}
func (f *fakeFirewallManager) Rollback(_ context.Context, result firewall.Result) error {
f.rollbackCall = true
if !result.Created {
return errors.New("不应回滚未创建的防火墙规则")
}
return f.rollbackErr
}
func (f *fakeSetupDNSVerifier) Verify(context.Context, setup.DNSVerificationInput) (setup.DNSVerificationResult, error) {
if f.verifyResult.CredentialRef == "" {
f.verifyResult = setup.DNSVerificationResult{
CredentialRef: "secret://dns/cloudflare/test",
VerificationToken: "verified-token",
ExpiresAt: time.Now().UTC().Add(15 * time.Minute),
}
}
return f.verifyResult, f.verifyErr
}
func (f *fakeSetupDNSVerifier) Check(token, providerID, credentialRef, testDomain string) error {
if f.checkErr != nil {
return f.checkErr
}
if token == "" || providerID == "" || credentialRef == "" || testDomain == "" {
return errors.New("DNS 验证参数不完整")
}
f.checked = true
return nil
}
func (f *fakeSetupDNSVerifier) Consume(token, providerID, credentialRef, testDomain string) error {
if f.consumeErr != nil {
return f.consumeErr
}
if err := f.Check(token, providerID, credentialRef, testDomain); err != nil {
return err
}
f.consumed = true
return nil
}
func TestSetupStatusOnlyAllowsLocalAccessBeforeInitialization(t *testing.T) {
cfg := config.Default(t.TempDir())
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, SetupDNS: &fakeSetupDNSVerifier{}})
local := httptest.NewRequest(http.MethodGet, "/api/v1/setup/status", nil)
local.RemoteAddr = "127.0.0.1:53000"
localResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(localResponse, local)
if localResponse.Code != http.StatusOK {
t.Fatalf("本机读取初始化状态失败:%d %s", localResponse.Code, localResponse.Body.String())
}
if !strings.Contains(localResponse.Body.String(), `"dns_test_available":true`) {
t.Fatalf("初始化状态应显示 DNS 在线测试可用:%s", localResponse.Body.String())
}
remote := httptest.NewRequest(http.MethodGet, "/api/v1/setup/status", nil)
remote.RemoteAddr = "203.0.113.8:53000"
remoteResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(remoteResponse, remote)
if remoteResponse.Code != http.StatusForbidden {
t.Fatalf("远程访问初始化状态应被拒绝:%d", remoteResponse.Code)
}
}
func TestSetupDNSProviderCatalogAndOnlineTest(t *testing.T) {
cfg := config.Default(t.TempDir())
verifier := &fakeSetupDNSVerifier{}
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, SetupDNS: verifier})
catalogRequest := httptest.NewRequest(http.MethodGet, "/api/v1/setup/dns/providers", nil)
catalogRequest.RemoteAddr = "127.0.0.1:53000"
catalogResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(catalogResponse, catalogRequest)
if catalogResponse.Code != http.StatusOK || !strings.Contains(catalogResponse.Body.String(), "cloudflare") {
t.Fatalf("读取 DNS 服务商目录失败:%d %s", catalogResponse.Code, catalogResponse.Body.String())
}
payload := `{"provider":"cloudflare","test_domain":"example.com","credentials":{"api_token":"secret-token"}}`
testRequest := httptest.NewRequest(http.MethodPost, "/api/v1/setup/dns/test", strings.NewReader(payload))
testRequest.RemoteAddr = "127.0.0.1:53000"
testRequest.Header.Set("Content-Type", "application/json")
testResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(testResponse, testRequest)
if testResponse.Code != http.StatusOK {
t.Fatalf("DNS 在线测试失败:%d %s", testResponse.Code, testResponse.Body.String())
}
if strings.Contains(testResponse.Body.String(), "secret-token") {
t.Fatal("DNS 在线测试响应不应返回明文凭据")
}
}
func TestSetupApplyPersistsConfigurationWithoutPlainPassword(t *testing.T) {
baseDir := t.TempDir()
cfg := config.Default(baseDir)
configPath := filepath.Join(baseDir, "config", "scert.json")
verifier := &fakeSetupDNSVerifier{}
firewallManager := &fakeFirewallManager{result: firewall.Result{
Backend: "windows", RuleName: "Scert Web TCP 8443", Port: 8443, Created: true, Message: "已创建测试规则",
}}
server := New(Dependencies{
Config: cfg, ConfigPath: configPath, Repository: &stubDomainRepository{},
SetupDNS: verifier, Firewall: firewallManager,
})
payload := `{
"admin_username":"root-admin",
"admin_password":"secure-pass-123",
"server_port":8443,
"reset_service_port":8091,
"email_provider":"mail-api",
"email_endpoint":"https://mail.example.test/send",
"recipients":["ops@example.test","ops@example.test"],
"dns_provider":"cloudflare",
"dns_credential_ref":"secret://dns/cloudflare/default",
"dns_verification_token":"verified-token",
"dns_test_domain":"scert.example.test",
"certificate_root":"` + filepath.ToSlash(filepath.Join(baseDir, "ssl")) + `",
"web_hostname":"scert.example.test",
"web_enabled":true,
"https_mode":"direct"
}`
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(payload))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("提交初始化配置失败:%d %s", response.Code, response.Body.String())
}
if !verifier.consumed {
t.Fatal("初始化提交前应消费 DNS 在线验证令牌")
}
if firewallManager.openedPort != 8443 || firewallManager.rollbackCall {
t.Fatalf("应只开放主服务端口且成功时不回滚:port=%d rollback=%t", firewallManager.openedPort, firewallManager.rollbackCall)
}
if !strings.Contains(response.Body.String(), `"firewall"`) || !strings.Contains(response.Body.String(), `"created":true`) {
t.Fatalf("初始化响应应返回本机防火墙结果:%s", response.Body.String())
}
data, err := os.ReadFile(configPath)
if err != nil {
t.Fatalf("读取保存后的配置失败:%v", err)
}
if strings.Contains(string(data), "secure-pass-123") {
t.Fatal("配置文件不应保存管理员明文密码")
}
var saved config.Config
if err := json.Unmarshal(data, &saved); err != nil {
t.Fatalf("解析保存后的配置失败:%v", err)
}
if !saved.SetupReady || saved.Admin.Username != "root-admin" || saved.Server.Port != 8443 {
t.Fatalf("保存后的初始化配置不正确:%+v", saved)
}
if len(saved.Notification.Recipients) != 1 {
t.Fatalf("通知收件人未去重:%v", saved.Notification.Recipients)
}
repeat := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(payload))
repeat.RemoteAddr = "127.0.0.1:53001"
repeat.Header.Set("Content-Type", "application/json")
repeatResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(repeatResponse, repeat)
if repeatResponse.Code != http.StatusConflict {
t.Fatalf("重复初始化应返回冲突:%d", repeatResponse.Code)
}
}
func TestSetupApplyRejectsUnverifiedDNSConfiguration(t *testing.T) {
cfg := config.Default(t.TempDir())
verifier := &fakeSetupDNSVerifier{checkErr: errors.New("DNS 验证令牌无效或已经过期,请重新测试")}
server := New(Dependencies{Config: cfg, ConfigPath: filepath.Join(t.TempDir(), "scert.json"), Repository: &stubDomainRepository{}, SetupDNS: verifier})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(`{"dns_provider":"cloudflare"}`))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest || !strings.Contains(response.Body.String(), "DNS 验证令牌") {
t.Fatalf("未验证 DNS 配置应被拒绝:%d %s", response.Code, response.Body.String())
}
}
func TestSetupApplyRejectsOversizedRequest(t *testing.T) {
cfg := config.Default(t.TempDir())
server := New(Dependencies{
Config: cfg, ConfigPath: filepath.Join(t.TempDir(), "scert.json"),
Repository: &stubDomainRepository{}, SetupDNS: &fakeSetupDNSVerifier{},
})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(`{"padding":"`+strings.Repeat("x", setupRequestLimit)+`"}`))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest {
t.Fatalf("超大初始化请求应被拒绝:%d", response.Code)
}
}
func TestSetupDNSTestRejectsRemoteAndOversizedRequests(t *testing.T) {
cfg := config.Default(t.TempDir())
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, SetupDNS: &fakeSetupDNSVerifier{}})
remoteRequest := httptest.NewRequest(http.MethodPost, "/api/v1/setup/dns/test", strings.NewReader(`{"provider":"cloudflare"}`))
remoteRequest.RemoteAddr = "203.0.113.8:53000"
remoteRequest.Header.Set("Content-Type", "application/json")
remoteResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(remoteResponse, remoteRequest)
if remoteResponse.Code != http.StatusForbidden {
t.Fatalf("远程 DNS 测试请求应被拒绝:%d %s", remoteResponse.Code, remoteResponse.Body.String())
}
oversizedRequest := httptest.NewRequest(http.MethodPost, "/api/v1/setup/dns/test", strings.NewReader(`{"provider":"cloudflare","padding":"`+strings.Repeat("x", setupRequestLimit)+`"}`))
oversizedRequest.RemoteAddr = "127.0.0.1:53000"
oversizedRequest.Header.Set("Content-Type", "application/json")
oversizedResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(oversizedResponse, oversizedRequest)
if oversizedResponse.Code != http.StatusBadRequest {
t.Fatalf("超大 DNS 测试请求应被拒绝:%d %s", oversizedResponse.Code, oversizedResponse.Body.String())
}
}
func TestSetupDNSTestReturnsNotImplementedForUnavailableProvider(t *testing.T) {
cfg := config.Default(t.TempDir())
verifier := &fakeSetupDNSVerifier{verifyErr: dnsprovider.ErrProviderUnavailable}
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, SetupDNS: verifier})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup/dns/test", strings.NewReader(`{"provider":"aliyun","test_domain":"example.com","credentials":{"access_key_id":"id","access_key_secret":"secret"}}`))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusNotImplemented || !strings.Contains(response.Body.String(), "适配器尚未开放") {
t.Fatalf("未开放 DNS Provider 应返回 501:%d %s", response.Code, response.Body.String())
}
if strings.Contains(response.Body.String(), "access_key_secret") || strings.Contains(response.Body.String(), "secret") {
t.Fatal("未开放 Provider 响应不应包含提交的凭据")
}
}
func TestSetupValidationFailureDoesNotConsumeDNSToken(t *testing.T) {
baseDir := t.TempDir()
verifier := &fakeSetupDNSVerifier{}
server := New(Dependencies{
Config: config.Default(baseDir), ConfigPath: filepath.Join(baseDir, "config", "scert.json"),
Repository: &stubDomainRepository{}, SetupDNS: verifier,
})
payload := setupPayload(baseDir, "short")
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(payload))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest {
t.Fatalf("无效初始化配置应被拒绝:%d %s", response.Code, response.Body.String())
}
if !verifier.checked || verifier.consumed {
t.Fatalf("配置校验失败时应检查但不消费 DNS 令牌:checked=%t consumed=%t", verifier.checked, verifier.consumed)
}
}
func TestSetupSaveFailureDoesNotConsumeDNSToken(t *testing.T) {
baseDir := t.TempDir()
blockedParent := filepath.Join(baseDir, "blocked")
if err := os.WriteFile(blockedParent, []byte("占位"), 0o600); err != nil {
t.Fatalf("创建阻塞路径失败:%v", err)
}
verifier := &fakeSetupDNSVerifier{}
firewallManager := &fakeFirewallManager{result: firewall.Result{
Backend: "ufw", RuleName: "Scert Web TCP 8443", Port: 8443, Created: true,
}}
server := New(Dependencies{
Config: config.Default(baseDir), ConfigPath: filepath.Join(blockedParent, "scert.json"),
Repository: &stubDomainRepository{}, SetupDNS: verifier, Firewall: firewallManager,
})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(setupPayload(baseDir, "secure-pass-123")))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusInternalServerError {
t.Fatalf("配置保存失败应返回服务器错误:%d %s", response.Code, response.Body.String())
}
if !verifier.checked || verifier.consumed {
t.Fatalf("配置保存失败时应检查但不消费 DNS 令牌:checked=%t consumed=%t", verifier.checked, verifier.consumed)
}
if !firewallManager.rollbackCall {
t.Fatal("配置保存失败时应回滚本次新建的防火墙规则")
}
}
func TestSetupSaveFailureKeepsExistingFirewallRule(t *testing.T) {
baseDir := t.TempDir()
blockedParent := filepath.Join(baseDir, "blocked")
if err := os.WriteFile(blockedParent, []byte("占位"), 0o600); err != nil {
t.Fatalf("创建阻塞路径失败:%v", err)
}
firewallManager := &fakeFirewallManager{result: firewall.Result{
Backend: "ufw", RuleName: "Scert Web TCP 8443", Port: 8443, Created: false,
}}
server := New(Dependencies{
Config: config.Default(baseDir), ConfigPath: filepath.Join(blockedParent, "scert.json"),
Repository: &stubDomainRepository{}, SetupDNS: &fakeSetupDNSVerifier{}, Firewall: firewallManager,
})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(setupPayload(baseDir, "secure-pass-123")))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusInternalServerError {
t.Fatalf("配置保存失败应返回服务器错误:%d %s", response.Code, response.Body.String())
}
if firewallManager.rollbackCall {
t.Fatal("配置保存失败时不得删除初始化前已经存在的防火墙规则")
}
}
func TestSetupFirewallFailureDoesNotSaveOrConsumeToken(t *testing.T) {
baseDir := t.TempDir()
configPath := filepath.Join(baseDir, "config", "scert.json")
verifier := &fakeSetupDNSVerifier{}
firewallManager := &fakeFirewallManager{openErr: errors.New("access denied")}
server := New(Dependencies{
Config: config.Default(baseDir), ConfigPath: configPath,
Repository: &stubDomainRepository{}, SetupDNS: verifier, Firewall: firewallManager,
})
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(setupPayload(baseDir, "secure-pass-123")))
request.RemoteAddr = "127.0.0.1:53000"
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusInternalServerError || !strings.Contains(response.Body.String(), "管理员权限") {
t.Fatalf("防火墙配置失败应返回明确错误:%d %s", response.Code, response.Body.String())
}
if verifier.consumed {
t.Fatal("防火墙配置失败时不得消费 DNS 验证令牌")
}
if _, err := os.Stat(configPath); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("防火墙配置失败时不得保存初始化配置:%v", err)
}
}
func setupPayload(baseDir, password string) string {
return `{
"admin_username":"root-admin",
"admin_password":"` + password + `",
"server_port":8443,
"reset_service_port":8091,
"dns_provider":"cloudflare",
"dns_credential_ref":"secret://dns/cloudflare/test",
"dns_verification_token":"verified-token",
"dns_test_domain":"scert.example.test",
"certificate_root":"` + filepath.ToSlash(filepath.Join(baseDir, "ssl")) + `",
"web_hostname":"scert.example.test",
"web_enabled":true,
"https_mode":"direct"
}`
}