完善证书申请续期与安装初始化流程
This commit is contained in:
1 parent
fd8d8608f5
commit
07636abe44
66 files changed
+9470
-165
No files matched your search
@@ -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())
|
||||
}
|
||||
}
|
||||
@@ -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) {
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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"
|
||||
}`
|
||||
}
|
||||
Reference in new issue
Block a user