完善证书申请续期与安装初始化流程
This commit is contained in:
1 parent
fd8d8608f5
commit
07636abe44
66 files changed
+9470
-165
No files matched your search
@@ -0,0 +1,110 @@
|
||||
package admin
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLinuxInstallerPolicy(t *testing.T) {
|
||||
_, sourceFile, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("无法定位测试源文件")
|
||||
}
|
||||
installerPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "install-linux.sh")
|
||||
data, err := os.ReadFile(installerPath)
|
||||
if err != nil {
|
||||
t.Fatalf("读取 Linux 安装器失败:%v", err)
|
||||
}
|
||||
content := string(data)
|
||||
|
||||
required := []string{
|
||||
`readonly INSTALL_DIR="/scert"`,
|
||||
`readonly DEFAULT_CERTIFICATE_DIR="/ssl"`,
|
||||
`readonly SERVICE_USER="Scert"`,
|
||||
`readonly INSTALL_METADATA_FILE="$INSTALL_DIR/conf/installation.json"`,
|
||||
`useradd --system`,
|
||||
`--badname`,
|
||||
`--shell "$nologin_shell"`,
|
||||
`systemctl daemon-reload`,
|
||||
`--certificate-dir`,
|
||||
`readlink -m -- "$certificate_dir"`,
|
||||
`reject_symlink_path "$certificate_dir" "证书目录"`,
|
||||
`/etc|/etc/*`,
|
||||
`/scert|/scert/*`,
|
||||
`chown -R -h "$SERVICE_USER:$SERVICE_GROUP"`,
|
||||
`write_install_metadata`,
|
||||
`10-certificate-path.conf`,
|
||||
`"$INSTALL_DIR/conf"`,
|
||||
`"$INSTALL_DIR/data"`,
|
||||
`"$INSTALL_DIR/log"`,
|
||||
`"$INSTALL_DIR/backups"`,
|
||||
`"$certificate_dir"`,
|
||||
}
|
||||
for _, item := range required {
|
||||
if !strings.Contains(content, item) {
|
||||
t.Errorf("Linux 安装器缺少必要策略:%s", item)
|
||||
}
|
||||
}
|
||||
|
||||
forbiddenCommands := []string{
|
||||
"systemctl enable Scert-admin",
|
||||
"systemctl start Scert-admin",
|
||||
"systemctl restart Scert-admin",
|
||||
"systemctl enable --now Scert-admin",
|
||||
}
|
||||
for _, command := range forbiddenCommands {
|
||||
if containsExecutableLine(content, command) || containsSystemctlAction(content, strings.Fields(command)[1], "Scert-admin") {
|
||||
t.Errorf("Linux 安装器不得执行命令:%s", command)
|
||||
}
|
||||
}
|
||||
for _, command := range []string{"ufw ", "firewall-cmd ", "New-NetFirewallRule"} {
|
||||
if strings.Contains(content, command) {
|
||||
t.Errorf("Linux 文件安装器不得直接配置防火墙:%s", command)
|
||||
}
|
||||
}
|
||||
|
||||
if countExecutableLine(content, "systemctl daemon-reload") != 1 {
|
||||
t.Errorf("Linux 安装器必须且只能执行一次 systemctl daemon-reload")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSystemctlPolicyMatcherCoversWrappedCommands(t *testing.T) {
|
||||
for _, content := range []string{
|
||||
"systemctl --no-block start Scert-admin",
|
||||
`command systemctl restart "Scert-admin"`,
|
||||
"sudo systemctl reload Scert-admin",
|
||||
} {
|
||||
if !containsSystemctlAction(content, strings.Fields(content)[2], "Scert-admin") {
|
||||
t.Fatalf("未识别受禁止的 systemctl 调用:%s", content)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func containsExecutableLine(content, command string) bool {
|
||||
return countExecutableLine(content, command) > 0
|
||||
}
|
||||
|
||||
func containsSystemctlAction(content, action, unit string) bool {
|
||||
pattern := `(?m)^\s*(?:command\s+|sudo\s+)?systemctl\b[^\n]*\b` + regexp.QuoteMeta(action) + `\b[^\n]*\b` + regexp.QuoteMeta(unit) + `\b`
|
||||
return regexp.MustCompile(pattern).MatchString(content)
|
||||
}
|
||||
|
||||
func countExecutableLine(content, command string) int {
|
||||
count := 0
|
||||
scanner := bufio.NewScanner(strings.NewReader(content))
|
||||
for scanner.Scan() {
|
||||
line := strings.TrimSpace(scanner.Text())
|
||||
if line == "" || strings.HasPrefix(line, "#") {
|
||||
continue
|
||||
}
|
||||
if line == command {
|
||||
count++
|
||||
}
|
||||
}
|
||||
return count
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package admin
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
config config.Config
|
||||
http *http.Server
|
||||
}
|
||||
|
||||
func New(cfg config.Config) *Server {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/healthz", health)
|
||||
mux.HandleFunc("/api/v1/admin/status", func(writer http.ResponseWriter, request *http.Request) {
|
||||
if request.Method != http.MethodGet {
|
||||
writer.WriteHeader(http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
_ = json.NewEncoder(writer).Encode(map[string]any{
|
||||
"service": "scert-admin",
|
||||
"reset_enabled": false,
|
||||
"listen_scope": "local_only",
|
||||
"message": "密码重置协议尚未启用,当前仅提供受保护服务入口",
|
||||
})
|
||||
})
|
||||
return &Server{config: cfg, http: &http.Server{
|
||||
Addr: net.JoinHostPort(cfg.Admin.ResetServiceHost, strconv.Itoa(cfg.Admin.ResetServicePort)),
|
||||
Handler: mux,
|
||||
ReadHeaderTimeout: 10 * time.Second,
|
||||
ReadTimeout: 30 * time.Second,
|
||||
WriteTimeout: 30 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}}
|
||||
}
|
||||
|
||||
func (s *Server) ListenAndServe() error {
|
||||
if s.config.Admin.ResetServiceHost != "127.0.0.1" && s.config.Admin.ResetServiceHost != "::1" {
|
||||
return fmt.Errorf("Scert-admin 仅允许监听本机回环地址")
|
||||
}
|
||||
return s.http.ListenAndServe()
|
||||
}
|
||||
|
||||
func (s *Server) Shutdown(ctx context.Context) error {
|
||||
if s == nil || s.http == nil {
|
||||
return nil
|
||||
}
|
||||
return s.http.Shutdown(ctx)
|
||||
}
|
||||
|
||||
func health(writer http.ResponseWriter, request *http.Request) {
|
||||
if request.Method != http.MethodGet {
|
||||
writer.WriteHeader(http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
_ = json.NewEncoder(writer).Encode(map[string]string{"status": "ok", "service": "scert-admin"})
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package admin
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
func TestScertAdminSystemdUnitKeepsManualOnlyPolicy(t *testing.T) {
|
||||
_, sourceFile, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("无法定位测试源文件")
|
||||
}
|
||||
unitPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "systemd", "Scert-admin.service")
|
||||
data, err := os.ReadFile(unitPath)
|
||||
if err != nil {
|
||||
t.Fatalf("读取 Scert-admin systemd unit 失败:%v", err)
|
||||
}
|
||||
unit := activeUnitText(string(data))
|
||||
|
||||
for _, required := range []string{
|
||||
"Documentation=file:///scert/docs/Scert-admin服务管理说明.md",
|
||||
"User=Scert",
|
||||
"Group=Scert",
|
||||
"ExecStart=/scert/scert-admin --config /scert/conf/scert.json",
|
||||
"Restart=no",
|
||||
"UMask=0077",
|
||||
"ProtectHome=yes",
|
||||
"NoNewPrivileges=yes",
|
||||
} {
|
||||
if !strings.Contains(unit, required) {
|
||||
t.Errorf("Scert-admin systemd unit 缺少必要策略:%s", required)
|
||||
}
|
||||
}
|
||||
for _, forbidden := range []string{
|
||||
"[Install]",
|
||||
"WantedBy=",
|
||||
"Restart=always",
|
||||
"Restart=on-failure",
|
||||
"ExecReload=",
|
||||
} {
|
||||
if strings.Contains(unit, forbidden) {
|
||||
t.Errorf("Scert-admin systemd unit 不得包含:%s", forbidden)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestListenAndServeRejectsNonLoopbackHost(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
cfg.Admin.ResetServiceHost = "0.0.0.0"
|
||||
server := New(cfg)
|
||||
if err := server.ListenAndServe(); err == nil {
|
||||
t.Fatal("Scert-admin 必须拒绝非回环监听地址")
|
||||
}
|
||||
}
|
||||
|
||||
func TestConfigRejectsLocalhostAlias(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
cfg.Admin.ResetServiceHost = "localhost"
|
||||
if err := cfg.Validate(); err == nil {
|
||||
t.Fatal("Scert-admin 不得依赖 localhost 名称解析")
|
||||
}
|
||||
}
|
||||
|
||||
func activeUnitText(unit string) string {
|
||||
lines := strings.Split(unit, "\n")
|
||||
active := make([]string, 0, len(lines))
|
||||
for _, line := range lines {
|
||||
trimmed := strings.TrimSpace(line)
|
||||
if trimmed == "" || strings.HasPrefix(trimmed, "#") {
|
||||
continue
|
||||
}
|
||||
active = append(active, trimmed)
|
||||
}
|
||||
return strings.Join(active, "\n")
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package admin
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestScertSystemdUnitPolicy(t *testing.T) {
|
||||
_, sourceFile, _, ok := runtime.Caller(0)
|
||||
if !ok {
|
||||
t.Fatal("无法定位测试源文件")
|
||||
}
|
||||
unitPath := filepath.Join(filepath.Dir(sourceFile), "..", "..", "..", "deploy", "systemd", "Scert.service")
|
||||
data, err := os.ReadFile(unitPath)
|
||||
if err != nil {
|
||||
t.Fatalf("读取 Scert systemd unit 失败:%v", err)
|
||||
}
|
||||
unit := activeUnitText(string(data))
|
||||
for _, required := range []string{
|
||||
"Documentation=file:///scert/docs/Scert服务管理说明.md",
|
||||
"User=Scert",
|
||||
"Group=Scert",
|
||||
"ExecStart=/scert/scert --config /scert/conf/scert.json serve",
|
||||
"Restart=on-failure",
|
||||
"UMask=0077",
|
||||
"ReadWritePaths=/ssl /scert/conf /scert/data /scert/log /scert/backups",
|
||||
"[Install]",
|
||||
"WantedBy=multi-user.target",
|
||||
} {
|
||||
if !strings.Contains(unit, required) {
|
||||
t.Errorf("Scert systemd unit 缺少必要策略:%s", required)
|
||||
}
|
||||
}
|
||||
for _, forbidden := range []string{"ExecReload=", "Restart=always"} {
|
||||
if strings.Contains(unit, forbidden) {
|
||||
t.Errorf("Scert systemd unit 不得包含:%s", forbidden)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,24 +4,38 @@ import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"path/filepath"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/dnsprovider"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/httpapi"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/logging"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/setup"
|
||||
)
|
||||
|
||||
type App struct {
|
||||
Config config.Config
|
||||
Logger *logging.Logger
|
||||
Database *database.Database
|
||||
Repository *repository.SQLDomainRepository
|
||||
HTTP *httpapi.Server
|
||||
Config config.Config
|
||||
Logger *logging.Logger
|
||||
Database *database.Database
|
||||
Repository *repository.SQLDomainRepository
|
||||
SecretStore *secretstore.Store
|
||||
DNSVerification *setup.DNSVerificationManager
|
||||
Certificates *certificate.Service
|
||||
Renewal *certificate.RenewalScheduler
|
||||
HTTP *httpapi.Server
|
||||
}
|
||||
|
||||
func New(ctx context.Context, cfg config.Config) (*App, error) {
|
||||
return NewWithConfigPath(ctx, cfg, filepath.Join(cfg.Paths.Config, "scert.json"))
|
||||
}
|
||||
|
||||
func NewWithConfigPath(ctx context.Context, cfg config.Config, configPath string) (*App, error) {
|
||||
if err := cfg.Validate(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -44,9 +58,28 @@ func New(ctx context.Context, cfg config.Config) (*App, error) {
|
||||
_ = logger.Close()
|
||||
return nil, err
|
||||
}
|
||||
secretStore, err := secretstore.Open(cfg.Paths.Config)
|
||||
if err != nil {
|
||||
_ = db.Close()
|
||||
_ = logger.Close()
|
||||
return nil, fmt.Errorf("初始化敏感信息存储失败:%w", err)
|
||||
}
|
||||
dnsTester := dnsprovider.NewTester(dnsprovider.NewLegoFactory())
|
||||
dnsVerification := setup.NewDNSVerificationManager(dnsTester, secretStore)
|
||||
repo := repository.NewSQLDomainRepository(db.DB)
|
||||
server := httpapi.New(httpapi.Dependencies{Config: cfg, Logger: logger, Repository: repo})
|
||||
return &App{Config: cfg, Logger: logger, Database: db, Repository: repo, HTTP: server}, nil
|
||||
accounts := certificate.NewAccountRepository(secretStore)
|
||||
certificates := certificate.NewService(cfg, repo, secretStore, dnsprovider.NewLegoFactory(), accounts)
|
||||
renewal := certificate.NewRenewalScheduler(repo, certificates, cfg.ACME.RenewalThresholdDays)
|
||||
server := httpapi.New(httpapi.Dependencies{
|
||||
Config: cfg, ConfigPath: configPath, Logger: logger, Repository: repo,
|
||||
SetupDNS: dnsVerification, Firewall: firewall.NewManager(),
|
||||
})
|
||||
return &App{
|
||||
Config: cfg, Logger: logger, Database: db, Repository: repo,
|
||||
SecretStore: secretStore, DNSVerification: dnsVerification, HTTP: server,
|
||||
Certificates: certificates,
|
||||
Renewal: renewal,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (a *App) Close() error {
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/go-acme/lego/v5/acme"
|
||||
"github.com/go-acme/lego/v5/certcrypto"
|
||||
)
|
||||
|
||||
type AccountSecretStore interface {
|
||||
Put(ctx context.Context, reference string, value map[string]string) error
|
||||
Get(ctx context.Context, reference string) (map[string]string, error)
|
||||
Has(ctx context.Context, reference string) (bool, error)
|
||||
}
|
||||
|
||||
type AccountRepository struct {
|
||||
store AccountSecretStore
|
||||
}
|
||||
|
||||
func NewAccountRepository(store AccountSecretStore) *AccountRepository {
|
||||
return &AccountRepository{store: store}
|
||||
}
|
||||
|
||||
func (r *AccountRepository) LoadOrCreate(ctx context.Context, environment, email string) (*AccountUser, error) {
|
||||
if r == nil || r.store == nil {
|
||||
return nil, errors.New("ACME 账户存储未初始化")
|
||||
}
|
||||
reference, err := accountReference(environment)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
exists, err := r.store.Has(ctx, reference)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("检查 ACME 账户失败:%w", err)
|
||||
}
|
||||
if !exists {
|
||||
key, err := certcrypto.GeneratePrivateKey(certcrypto.EC256)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("生成 ACME 账户私钥失败:%w", err)
|
||||
}
|
||||
user := &AccountUser{Email: strings.TrimSpace(email), PrivateKey: key}
|
||||
if err := r.Save(ctx, environment, user); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
payload, err := r.store.Get(ctx, reference)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("读取 ACME 账户失败:%w", err)
|
||||
}
|
||||
key, err := certcrypto.ParsePEMPrivateKey([]byte(payload["private_key"]))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("解析 ACME 账户私钥失败:%w", err)
|
||||
}
|
||||
storedEmail := strings.TrimSpace(payload["email"])
|
||||
if strings.TrimSpace(email) != "" {
|
||||
storedEmail = strings.TrimSpace(email)
|
||||
}
|
||||
user := &AccountUser{Email: storedEmail, PrivateKey: key}
|
||||
if value := strings.TrimSpace(payload["registration"]); value != "" {
|
||||
var registration acme.ExtendedAccount
|
||||
if err := json.Unmarshal([]byte(value), ®istration); err != nil {
|
||||
return nil, fmt.Errorf("解析 ACME 注册状态失败:%w", err)
|
||||
}
|
||||
user.Registration = ®istration
|
||||
}
|
||||
return user, nil
|
||||
}
|
||||
|
||||
func (r *AccountRepository) Save(ctx context.Context, environment string, user *AccountUser) error {
|
||||
if r == nil || r.store == nil {
|
||||
return errors.New("ACME 账户存储未初始化")
|
||||
}
|
||||
if user == nil || user.PrivateKey == nil {
|
||||
return errors.New("ACME 账户私钥未配置")
|
||||
}
|
||||
reference, err := accountReference(environment)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
payload := map[string]string{
|
||||
"email": strings.TrimSpace(user.Email),
|
||||
"private_key": string(certcrypto.PEMEncode(user.PrivateKey)),
|
||||
}
|
||||
if user.Registration != nil {
|
||||
value, err := json.Marshal(user.Registration)
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码 ACME 注册状态失败:%w", err)
|
||||
}
|
||||
payload["registration"] = string(value)
|
||||
}
|
||||
if err := r.store.Put(ctx, reference, payload); err != nil {
|
||||
return fmt.Errorf("保存 ACME 账户失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func accountReference(environment string) (string, error) {
|
||||
environment = strings.ToLower(strings.TrimSpace(environment))
|
||||
if environment != "staging" && environment != "production" {
|
||||
return "", fmt.Errorf("ACME 环境无效:%s", environment)
|
||||
}
|
||||
return "secret://acme/letsencrypt/" + environment, nil
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/go-acme/lego/v5/acme"
|
||||
)
|
||||
|
||||
type memoryAccountStore struct {
|
||||
items map[string]map[string]string
|
||||
}
|
||||
|
||||
func (s *memoryAccountStore) Put(_ context.Context, reference string, value map[string]string) error {
|
||||
if s.items == nil {
|
||||
s.items = map[string]map[string]string{}
|
||||
}
|
||||
copyValue := make(map[string]string, len(value))
|
||||
for key, item := range value {
|
||||
copyValue[key] = item
|
||||
}
|
||||
s.items[reference] = copyValue
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *memoryAccountStore) Get(_ context.Context, reference string) (map[string]string, error) {
|
||||
return s.items[reference], nil
|
||||
}
|
||||
|
||||
func (s *memoryAccountStore) Has(_ context.Context, reference string) (bool, error) {
|
||||
_, ok := s.items[reference]
|
||||
return ok, nil
|
||||
}
|
||||
|
||||
func TestAccountRepositoryPersistsKeyAndRegistration(t *testing.T) {
|
||||
store := &memoryAccountStore{}
|
||||
repository := NewAccountRepository(store)
|
||||
user, err := repository.LoadOrCreate(context.Background(), "staging", "admin@example.com")
|
||||
if err != nil {
|
||||
t.Fatalf("创建 ACME 账户失败:%v", err)
|
||||
}
|
||||
if user.PrivateKey == nil {
|
||||
t.Fatal("ACME 账户私钥未生成")
|
||||
}
|
||||
user.Registration = &acme.ExtendedAccount{
|
||||
Account: acme.Account{Status: acme.StatusValid, TermsOfServiceAgreed: true},
|
||||
Location: "https://acme.example.test/account/1",
|
||||
}
|
||||
if err := repository.Save(context.Background(), "staging", user); err != nil {
|
||||
t.Fatalf("保存 ACME 账户失败:%v", err)
|
||||
}
|
||||
loaded, err := repository.LoadOrCreate(context.Background(), "staging", "")
|
||||
if err != nil {
|
||||
t.Fatalf("重新读取 ACME 账户失败:%v", err)
|
||||
}
|
||||
if loaded.Email != "admin@example.com" {
|
||||
t.Fatalf("ACME 账户邮箱错误:%s", loaded.Email)
|
||||
}
|
||||
if loaded.Registration == nil || loaded.Registration.Location != user.Registration.Location {
|
||||
t.Fatalf("ACME 注册状态未持久化:%+v", loaded.Registration)
|
||||
}
|
||||
if loaded.PrivateKey == nil {
|
||||
t.Fatal("ACME 账户私钥未恢复")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAccountRepositorySeparatesEnvironments(t *testing.T) {
|
||||
store := &memoryAccountStore{}
|
||||
repository := NewAccountRepository(store)
|
||||
if _, err := repository.LoadOrCreate(context.Background(), "staging", ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := repository.LoadOrCreate(context.Background(), "production", ""); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(store.items) != 2 {
|
||||
t.Fatalf("测试环境与生产环境应使用独立账户:%d", len(store.items))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
acme "github.com/go-acme/lego/v5/acme"
|
||||
"github.com/go-acme/lego/v5/certcrypto"
|
||||
legoCertificate "github.com/go-acme/lego/v5/certificate"
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
lego "github.com/go-acme/lego/v5/lego"
|
||||
"github.com/go-acme/lego/v5/registration"
|
||||
)
|
||||
|
||||
type AccountUser struct {
|
||||
Email string
|
||||
PrivateKey crypto.Signer
|
||||
Registration *acme.ExtendedAccount
|
||||
}
|
||||
|
||||
func (u *AccountUser) GetEmail() string { return u.Email }
|
||||
func (u *AccountUser) GetRegistration() *acme.ExtendedAccount { return u.Registration }
|
||||
func (u *AccountUser) GetPrivateKey() crypto.Signer { return u.PrivateKey }
|
||||
|
||||
type LegoIssuer struct {
|
||||
User *AccountUser
|
||||
Provider challenge.Provider
|
||||
Environment string
|
||||
HTTPClient *http.Client
|
||||
Now func() time.Time
|
||||
}
|
||||
|
||||
func (i *LegoIssuer) Obtain(ctx context.Context, request ObtainRequest) (Resource, error) {
|
||||
if i == nil || i.User == nil || i.User.PrivateKey == nil {
|
||||
return Resource{}, errors.New("ACME 账户未配置")
|
||||
}
|
||||
if i.Provider == nil {
|
||||
return Resource{}, errors.New("DNS 验证服务商未配置")
|
||||
}
|
||||
domains, err := NormalizeDomains(request.Domains)
|
||||
if err != nil {
|
||||
return Resource{}, err
|
||||
}
|
||||
environment := strings.ToLower(strings.TrimSpace(request.Environment))
|
||||
if environment == "" {
|
||||
environment = "production"
|
||||
}
|
||||
caURL := lego.DirectoryURLLetsEncrypt
|
||||
if environment == "staging" {
|
||||
caURL = lego.DirectoryURLLetsEncryptStaging
|
||||
} else if environment != "production" {
|
||||
return Resource{}, fmt.Errorf("ACME 环境无效:%s", environment)
|
||||
}
|
||||
clientConfig := lego.NewConfig(i.User)
|
||||
clientConfig.CADirURL = caURL
|
||||
clientConfig.UserAgent = "Scert/0.1"
|
||||
if i.HTTPClient != nil {
|
||||
clientConfig.HTTPClient = i.HTTPClient
|
||||
}
|
||||
client, err := lego.NewClient(clientConfig)
|
||||
if err != nil {
|
||||
return Resource{}, fmt.Errorf("创建 ACME 客户端失败:%w", err)
|
||||
}
|
||||
if err := client.Challenge.SetDNS01Provider(i.Provider); err != nil {
|
||||
return Resource{}, fmt.Errorf("配置 DNS-01 验证失败:%w", err)
|
||||
}
|
||||
if i.User.Registration == nil {
|
||||
account, err := client.Registration.Register(ctx, registration.RegisterOptions{TermsOfServiceAgreed: true})
|
||||
if err != nil {
|
||||
return Resource{}, fmt.Errorf("注册 ACME 账户失败:%w", err)
|
||||
}
|
||||
i.User.Registration = account
|
||||
}
|
||||
issued, err := client.Certificate.Obtain(ctx, legoCertificate.ObtainRequest{
|
||||
Domains: domains, EmailAddresses: nonEmptyEmail(request.AccountEmail, i.User.Email),
|
||||
KeyType: certcrypto.RSA2048, Bundle: true,
|
||||
PreferredChain: request.PreferredChain,
|
||||
})
|
||||
if err != nil {
|
||||
return Resource{}, fmt.Errorf("申请证书失败:%w", err)
|
||||
}
|
||||
resource := Resource{
|
||||
Domains: issued.Domains, Certificate: issued.Certificate,
|
||||
IssuerCertificate: issued.IssuerCertificate, PrivateKey: issued.PrivateKey,
|
||||
}
|
||||
if i.Now != nil {
|
||||
_ = i.Now()
|
||||
}
|
||||
return ValidateResource(resource)
|
||||
}
|
||||
|
||||
func nonEmptyEmail(values ...string) []string {
|
||||
for _, value := range values {
|
||||
if strings.TrimSpace(value) != "" {
|
||||
return []string{strings.TrimSpace(value)}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,330 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"crypto/x509"
|
||||
"encoding/json"
|
||||
"encoding/pem"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Issuer interface {
|
||||
Obtain(ctx context.Context, request ObtainRequest) (Resource, error)
|
||||
}
|
||||
|
||||
type ObtainRequest struct {
|
||||
Domains []string
|
||||
AccountEmail string
|
||||
Environment string
|
||||
PreferredChain string
|
||||
}
|
||||
|
||||
type Resource struct {
|
||||
Domains []string
|
||||
Certificate []byte
|
||||
IssuerCertificate []byte
|
||||
PrivateKey []byte
|
||||
NotBefore time.Time
|
||||
NotAfter time.Time
|
||||
}
|
||||
|
||||
type SavedResource struct {
|
||||
Domain string `json:"domain"`
|
||||
Directory string `json:"directory"`
|
||||
CertificatePath string `json:"certificate_path"`
|
||||
FullChainPath string `json:"fullchain_path"`
|
||||
PrivateKeyPath string `json:"private_key_path"`
|
||||
NotBefore time.Time `json:"not_before"`
|
||||
NotAfter time.Time `json:"not_after"`
|
||||
BackupDirectory string `json:"backup_directory,omitempty"`
|
||||
}
|
||||
|
||||
type FileStore struct {
|
||||
Root string
|
||||
BackupRoot string
|
||||
Now func() time.Time
|
||||
}
|
||||
|
||||
func NormalizeDomains(domains []string) ([]string, error) {
|
||||
seen := make(map[string]struct{}, len(domains))
|
||||
result := make([]string, 0, len(domains))
|
||||
for _, value := range domains {
|
||||
value = strings.ToLower(strings.TrimSuffix(strings.TrimSpace(value), "."))
|
||||
if value == "" {
|
||||
continue
|
||||
}
|
||||
if strings.HasPrefix(value, "*.") {
|
||||
value = "*." + strings.TrimPrefix(value, "*.")
|
||||
}
|
||||
if !validDomain(value) {
|
||||
return nil, fmt.Errorf("证书域名无效:%s", value)
|
||||
}
|
||||
if _, exists := seen[value]; exists {
|
||||
continue
|
||||
}
|
||||
seen[value] = struct{}{}
|
||||
result = append(result, value)
|
||||
}
|
||||
if len(result) == 0 {
|
||||
return nil, errors.New("证书域名不能为空")
|
||||
}
|
||||
sort.Strings(result)
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func ValidateResource(resource Resource) (Resource, error) {
|
||||
if len(resource.Certificate) == 0 || len(resource.PrivateKey) == 0 {
|
||||
return Resource{}, errors.New("证书和私钥不能为空")
|
||||
}
|
||||
certificate, err := parseLeafCertificate(resource.Certificate)
|
||||
if err != nil {
|
||||
return Resource{}, fmt.Errorf("解析证书失败:%w", err)
|
||||
}
|
||||
if _, err := tls.X509KeyPair(resource.Certificate, resource.PrivateKey); err != nil {
|
||||
return Resource{}, fmt.Errorf("证书与私钥不匹配:%w", err)
|
||||
}
|
||||
domains, err := NormalizeDomains(resource.Domains)
|
||||
if err != nil {
|
||||
return Resource{}, err
|
||||
}
|
||||
if resource.NotBefore.IsZero() {
|
||||
resource.NotBefore = certificate.NotBefore
|
||||
}
|
||||
if resource.NotAfter.IsZero() {
|
||||
resource.NotAfter = certificate.NotAfter
|
||||
}
|
||||
if !resource.NotAfter.After(resource.NotBefore) {
|
||||
return Resource{}, errors.New("证书有效期无效")
|
||||
}
|
||||
resource.Domains = domains
|
||||
if len(resource.IssuerCertificate) > 0 {
|
||||
if _, err := parseLeafCertificate(resource.IssuerCertificate); err != nil {
|
||||
return Resource{}, fmt.Errorf("解析签发者证书失败:%w", err)
|
||||
}
|
||||
}
|
||||
return resource, nil
|
||||
}
|
||||
|
||||
// ValidateResourceForDomains 校验证书内容,并确认叶子证书覆盖全部申请域名。
|
||||
func ValidateResourceForDomains(resource Resource, expected []string) (Resource, error) {
|
||||
resource, err := ValidateResource(resource)
|
||||
if err != nil {
|
||||
return Resource{}, err
|
||||
}
|
||||
wanted, err := NormalizeDomains(expected)
|
||||
if err != nil {
|
||||
return Resource{}, err
|
||||
}
|
||||
leaf, err := parseLeafCertificate(resource.Certificate)
|
||||
if err != nil {
|
||||
return Resource{}, fmt.Errorf("解析证书失败:%w", err)
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
if now.Before(leaf.NotBefore) {
|
||||
return Resource{}, fmt.Errorf("证书尚未生效:%s", leaf.NotBefore.UTC().Format(time.RFC3339))
|
||||
}
|
||||
if !now.Before(leaf.NotAfter) {
|
||||
return Resource{}, fmt.Errorf("证书已经过期:%s", leaf.NotAfter.UTC().Format(time.RFC3339))
|
||||
}
|
||||
for _, name := range wanted {
|
||||
probe := name
|
||||
if strings.HasPrefix(probe, "*.") {
|
||||
probe = "scert-wildcard-probe." + strings.TrimPrefix(probe, "*.")
|
||||
}
|
||||
if err := leaf.VerifyHostname(probe); err != nil {
|
||||
return Resource{}, fmt.Errorf("证书不覆盖域名 %s:%w", name, err)
|
||||
}
|
||||
}
|
||||
return resource, nil
|
||||
}
|
||||
|
||||
func (s FileStore) Save(ctx context.Context, domain string, resource Resource) (SavedResource, error) {
|
||||
if err := ctx.Err(); err != nil {
|
||||
return SavedResource{}, err
|
||||
}
|
||||
resource, err := ValidateResource(resource)
|
||||
if err != nil {
|
||||
return SavedResource{}, err
|
||||
}
|
||||
primary := strings.TrimSpace(domain)
|
||||
if primary == "" {
|
||||
primary = resource.Domains[0]
|
||||
}
|
||||
if _, err := NormalizeDomains([]string{primary}); err != nil {
|
||||
return SavedResource{}, err
|
||||
}
|
||||
root := filepath.Clean(strings.TrimSpace(s.Root))
|
||||
if root == "." || root == "" {
|
||||
return SavedResource{}, errors.New("证书存储根目录不能为空")
|
||||
}
|
||||
directory := filepath.Join(root, directoryName(primary))
|
||||
if err := os.MkdirAll(directory, 0o700); err != nil {
|
||||
return SavedResource{}, fmt.Errorf("创建证书目录失败:%w", err)
|
||||
}
|
||||
backupDirectory, err := s.backupExisting(directory, primary)
|
||||
if err != nil {
|
||||
return SavedResource{}, err
|
||||
}
|
||||
certificatePath := filepath.Join(directory, "cert.pem")
|
||||
fullChainPath := filepath.Join(directory, "fullchain.pem")
|
||||
privateKeyPath := filepath.Join(directory, "key.pem")
|
||||
fullChain := resource.Certificate
|
||||
if len(resource.IssuerCertificate) > 0 && !bytes.Contains(resource.Certificate, resource.IssuerCertificate) {
|
||||
fullChain = append(append([]byte(nil), resource.Certificate...), resource.IssuerCertificate...)
|
||||
}
|
||||
if err := atomicWrite(certificatePath, resource.Certificate, 0o644); err != nil {
|
||||
return SavedResource{}, fmt.Errorf("保存证书失败:%w", err)
|
||||
}
|
||||
if err := atomicWrite(fullChainPath, fullChain, 0o644); err != nil {
|
||||
return SavedResource{}, fmt.Errorf("保存完整证书链失败:%w", err)
|
||||
}
|
||||
if err := atomicWrite(privateKeyPath, resource.PrivateKey, 0o600); err != nil {
|
||||
return SavedResource{}, fmt.Errorf("保存私钥失败:%w", err)
|
||||
}
|
||||
result := SavedResource{
|
||||
Domain: primary, Directory: directory, CertificatePath: certificatePath,
|
||||
FullChainPath: fullChainPath, PrivateKeyPath: privateKeyPath,
|
||||
NotBefore: resource.NotBefore, NotAfter: resource.NotAfter,
|
||||
BackupDirectory: backupDirectory,
|
||||
}
|
||||
metadata, err := json.MarshalIndent(result, "", " ")
|
||||
if err != nil {
|
||||
return SavedResource{}, fmt.Errorf("生成证书元数据失败:%w", err)
|
||||
}
|
||||
if err := atomicWrite(filepath.Join(directory, "metadata.json"), metadata, 0o600); err != nil {
|
||||
return SavedResource{}, fmt.Errorf("保存证书元数据失败:%w", err)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (s FileStore) backupExisting(directory, domain string) (string, error) {
|
||||
entries, err := os.ReadDir(directory)
|
||||
if err != nil {
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return "", nil
|
||||
}
|
||||
return "", fmt.Errorf("读取原证书目录失败:%w", err)
|
||||
}
|
||||
if len(entries) == 0 {
|
||||
return "", nil
|
||||
}
|
||||
backupRoot := filepath.Clean(strings.TrimSpace(s.BackupRoot))
|
||||
if backupRoot == "." || backupRoot == "" {
|
||||
return "", errors.New("证书备份根目录不能为空")
|
||||
}
|
||||
now := time.Now
|
||||
if s.Now != nil {
|
||||
now = s.Now
|
||||
}
|
||||
backupDirectory := filepath.Join(backupRoot, directoryName(domain), now().UTC().Format("20060102-150405.000000000"))
|
||||
if err := os.MkdirAll(filepath.Dir(backupDirectory), 0o700); err != nil {
|
||||
return "", fmt.Errorf("创建证书备份目录失败:%w", err)
|
||||
}
|
||||
if err := copyDirectory(directory, backupDirectory); err != nil {
|
||||
return "", fmt.Errorf("备份原证书失败:%w", err)
|
||||
}
|
||||
return backupDirectory, nil
|
||||
}
|
||||
|
||||
func atomicWrite(path string, data []byte, mode os.FileMode) error {
|
||||
temporary, err := os.CreateTemp(filepath.Dir(path), ".scert-*")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
temporaryName := temporary.Name()
|
||||
defer os.Remove(temporaryName)
|
||||
if err := temporary.Chmod(mode); err != nil {
|
||||
_ = temporary.Close()
|
||||
return err
|
||||
}
|
||||
if _, err := temporary.Write(data); err != nil {
|
||||
_ = temporary.Close()
|
||||
return err
|
||||
}
|
||||
if err := temporary.Sync(); err != nil {
|
||||
_ = temporary.Close()
|
||||
return err
|
||||
}
|
||||
if err := temporary.Close(); err != nil {
|
||||
return err
|
||||
}
|
||||
if runtime.GOOS == "windows" {
|
||||
if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return os.Rename(temporaryName, path)
|
||||
}
|
||||
|
||||
func copyDirectory(source, target string) error {
|
||||
entries, err := os.ReadDir(source)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.MkdirAll(target, 0o700); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() {
|
||||
continue
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(source, entry.Name()))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := atomicWrite(filepath.Join(target, entry.Name()), data, 0o600); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func parseLeafCertificate(data []byte) (*x509.Certificate, error) {
|
||||
remaining := data
|
||||
for len(remaining) > 0 {
|
||||
block, rest := pem.Decode(remaining)
|
||||
if block == nil {
|
||||
break
|
||||
}
|
||||
remaining = rest
|
||||
if block.Type != "CERTIFICATE" {
|
||||
continue
|
||||
}
|
||||
return x509.ParseCertificate(block.Bytes)
|
||||
}
|
||||
return nil, errors.New("未找到 PEM 证书")
|
||||
}
|
||||
|
||||
func directoryName(domain string) string {
|
||||
name := strings.ToLower(strings.TrimSpace(domain))
|
||||
name = strings.ReplaceAll(name, "*.", "_wildcard.")
|
||||
name = strings.ReplaceAll(name, string(filepath.Separator), "_")
|
||||
return name
|
||||
}
|
||||
|
||||
func validDomain(value string) bool {
|
||||
value = strings.TrimPrefix(value, "*.")
|
||||
if len(value) < 3 || len(value) > 253 || !strings.Contains(value, ".") {
|
||||
return false
|
||||
}
|
||||
for _, label := range strings.Split(value, ".") {
|
||||
if label == "" || len(label) > 63 || label[0] == '-' || label[len(label)-1] == '-' {
|
||||
return false
|
||||
}
|
||||
for _, r := range label {
|
||||
if !(r == '-' || r >= 'a' && r <= 'z' || r >= '0' && r <= '9') {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
"crypto/x509"
|
||||
"crypto/x509/pkix"
|
||||
"encoding/pem"
|
||||
"math/big"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestNormalizeDomainsSupportsSANAndWildcard(t *testing.T) {
|
||||
got, err := NormalizeDomains([]string{"Example.COM.", "*.example.com", "example.com"})
|
||||
if err != nil {
|
||||
t.Fatalf("规范化域名失败:%v", err)
|
||||
}
|
||||
if len(got) != 2 || got[0] != "*.example.com" || got[1] != "example.com" {
|
||||
t.Fatalf("规范化结果错误:%v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFileStoreSaveBacksUpAndKeepsKeyRestricted(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
store := FileStore{Root: filepath.Join(root, "ssl"), BackupRoot: filepath.Join(root, "backups"), Now: func() time.Time { return time.Date(2026, 8, 26, 10, 0, 0, 0, time.UTC) }}
|
||||
resource := testResource(t, "example.com")
|
||||
first, err := store.Save(context.Background(), "example.com", resource)
|
||||
if err != nil {
|
||||
t.Fatalf("第一次保存失败:%v", err)
|
||||
}
|
||||
if first.BackupDirectory != "" {
|
||||
t.Fatal("第一次保存不应生成备份")
|
||||
}
|
||||
resource.Certificate = append([]byte(nil), resource.Certificate...)
|
||||
second, err := store.Save(context.Background(), "example.com", resource)
|
||||
if err != nil {
|
||||
t.Fatalf("第二次保存失败:%v", err)
|
||||
}
|
||||
if second.BackupDirectory == "" {
|
||||
t.Fatal("替换已有证书时应生成备份")
|
||||
}
|
||||
if _, err := os.Stat(second.FullChainPath); err != nil {
|
||||
t.Fatalf("完整证书链不存在:%v", err)
|
||||
}
|
||||
if info, err := os.Stat(second.PrivateKeyPath); err != nil {
|
||||
t.Fatalf("私钥不存在:%v", err)
|
||||
} else if runtime.GOOS != "windows" && info.Mode().Perm() != 0o600 {
|
||||
t.Fatalf("私钥权限错误:%o", info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateResourceRejectsMismatchedKey(t *testing.T) {
|
||||
resource := testResource(t, "example.com")
|
||||
key, err := rsa.GenerateKey(rand.Reader, 2048)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resource.PrivateKey = pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})
|
||||
if _, err := ValidateResource(resource); err == nil {
|
||||
t.Fatal("证书与私钥不匹配时应失败")
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateResourceForDomainsSupportsWildcard(t *testing.T) {
|
||||
resource := testResourceForWildcard(t, "*.example.com")
|
||||
if _, err := ValidateResourceForDomains(resource, []string{"*.example.com"}); err != nil {
|
||||
t.Fatalf("泛域名证书覆盖校验失败:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func testResource(t *testing.T, name string) Resource {
|
||||
key, err := rsa.GenerateKey(rand.Reader, 2048)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
template := &x509.Certificate{SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: name}, DNSNames: []string{name}, NotBefore: now.Add(-time.Minute), NotAfter: now.Add(90 * 24 * 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)
|
||||
}
|
||||
return Resource{Domains: []string{name}, Certificate: pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}), PrivateKey: pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})}
|
||||
}
|
||||
|
||||
func testResourceForWildcard(t *testing.T, name string) Resource {
|
||||
t.Helper()
|
||||
key, err := rsa.GenerateKey(rand.Reader, 2048)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
template := &x509.Certificate{SerialNumber: big.NewInt(3), Subject: pkix.Name{CommonName: name}, DNSNames: []string{name}, NotBefore: now.Add(-time.Minute), NotAfter: now.Add(90 * 24 * 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)
|
||||
}
|
||||
return Resource{Domains: []string{name}, Certificate: pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}), PrivateKey: pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)})}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type DomainLister interface {
|
||||
List(ctx context.Context) ([]domain.Domain, error)
|
||||
}
|
||||
|
||||
type CertificateIssuer interface {
|
||||
Issue(ctx context.Context, domainID string) (IssueResult, error)
|
||||
}
|
||||
|
||||
type RenewalScheduler struct {
|
||||
lister DomainLister
|
||||
issuer CertificateIssuer
|
||||
threshold time.Duration
|
||||
now func() time.Time
|
||||
interval time.Duration
|
||||
mu sync.Mutex
|
||||
runMu sync.Mutex
|
||||
running bool
|
||||
}
|
||||
|
||||
type RenewalReport struct {
|
||||
Checked int `json:"checked"`
|
||||
Selected int `json:"selected"`
|
||||
Succeeded int `json:"succeeded"`
|
||||
Failed int `json:"failed"`
|
||||
Errors []string `json:"errors,omitempty"`
|
||||
}
|
||||
|
||||
func NewRenewalScheduler(lister DomainLister, issuer CertificateIssuer, thresholdDays int) *RenewalScheduler {
|
||||
if thresholdDays < 1 {
|
||||
thresholdDays = 6
|
||||
}
|
||||
return &RenewalScheduler{
|
||||
lister: lister, issuer: issuer, threshold: time.Duration(thresholdDays) * 24 * time.Hour,
|
||||
now: time.Now, interval: 24 * time.Hour,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *RenewalScheduler) RunOnce(ctx context.Context) (RenewalReport, error) {
|
||||
if s == nil || s.lister == nil || s.issuer == nil {
|
||||
return RenewalReport{}, errors.New("自动续期服务未初始化")
|
||||
}
|
||||
if !s.runMu.TryLock() {
|
||||
return RenewalReport{}, errors.New("自动续期任务正在执行")
|
||||
}
|
||||
defer s.runMu.Unlock()
|
||||
items, err := s.lister.List(ctx)
|
||||
if err != nil {
|
||||
return RenewalReport{}, fmt.Errorf("查询续期域名失败:%w", err)
|
||||
}
|
||||
report := RenewalReport{Checked: len(items)}
|
||||
now := s.now().UTC()
|
||||
for _, item := range items {
|
||||
if !item.AutoRenew || item.Status == "issuing" {
|
||||
continue
|
||||
}
|
||||
if item.ExpiresAt != nil && item.ExpiresAt.Sub(now) > s.threshold {
|
||||
continue
|
||||
}
|
||||
report.Selected++
|
||||
if _, err := s.issuer.Issue(ctx, item.ID); err != nil {
|
||||
report.Failed++
|
||||
report.Errors = append(report.Errors, fmt.Sprintf("%s:%v", item.Name, err))
|
||||
continue
|
||||
}
|
||||
report.Succeeded++
|
||||
}
|
||||
return report, nil
|
||||
}
|
||||
|
||||
func (s *RenewalScheduler) Start(ctx context.Context) {
|
||||
if s == nil {
|
||||
return
|
||||
}
|
||||
s.mu.Lock()
|
||||
if s.running {
|
||||
s.mu.Unlock()
|
||||
return
|
||||
}
|
||||
s.running = true
|
||||
s.mu.Unlock()
|
||||
go func() {
|
||||
defer func() {
|
||||
s.mu.Lock()
|
||||
s.running = false
|
||||
s.mu.Unlock()
|
||||
}()
|
||||
_, _ = s.RunOnce(ctx)
|
||||
ticker := time.NewTicker(s.interval)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
_, _ = s.RunOnce(ctx)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type renewalLister struct {
|
||||
items []domain.Domain
|
||||
err error
|
||||
}
|
||||
|
||||
func (r renewalLister) List(context.Context) ([]domain.Domain, error) { return r.items, r.err }
|
||||
|
||||
type renewalService struct {
|
||||
ids []string
|
||||
err error
|
||||
}
|
||||
|
||||
func (s *renewalService) Issue(_ context.Context, id string) (IssueResult, error) {
|
||||
s.ids = append(s.ids, id)
|
||||
return IssueResult{}, s.err
|
||||
}
|
||||
|
||||
func TestRenewalSchedulerSelectsOnlyExpiringAutoRenewDomains(t *testing.T) {
|
||||
now := time.Date(2026, 8, 26, 0, 0, 0, 0, time.UTC)
|
||||
soon := now.Add(2 * 24 * time.Hour)
|
||||
later := now.Add(20 * 24 * time.Hour)
|
||||
items := []domain.Domain{
|
||||
{ID: "soon", Name: "soon.example.com", AutoRenew: true, ExpiresAt: &soon},
|
||||
{ID: "later", Name: "later.example.com", AutoRenew: true, ExpiresAt: &later},
|
||||
{ID: "disabled", Name: "disabled.example.com", AutoRenew: false, ExpiresAt: &soon},
|
||||
{ID: "missing", Name: "missing.example.com", AutoRenew: true},
|
||||
}
|
||||
service := &renewalService{}
|
||||
scheduler := NewRenewalScheduler(renewalLister{items: items}, service, 6)
|
||||
scheduler.now = func() time.Time { return now }
|
||||
report, err := scheduler.RunOnce(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if report.Checked != 4 || report.Selected != 2 || report.Succeeded != 2 || report.Failed != 0 {
|
||||
t.Fatalf("续期筛选结果错误:%+v", report)
|
||||
}
|
||||
if len(service.ids) != 2 || service.ids[0] != "soon" || service.ids[1] != "missing" {
|
||||
t.Fatalf("续期执行域名错误:%v", service.ids)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRenewalSchedulerReportsFailures(t *testing.T) {
|
||||
now := time.Now().UTC()
|
||||
expires := now.Add(time.Hour)
|
||||
item := domain.Domain{ID: "one", Name: "one.example.com", AutoRenew: true, ExpiresAt: &expires}
|
||||
scheduler := NewRenewalScheduler(renewalLister{items: []domain.Domain{item}}, &renewalService{err: errors.New("模拟续期失败")}, 6)
|
||||
report, err := scheduler.RunOnce(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if report.Failed != 1 || len(report.Errors) != 1 {
|
||||
t.Fatalf("续期失败结果错误:%+v", report)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type DomainStateRepository interface {
|
||||
GetByID(ctx context.Context, id string) (domain.Domain, error)
|
||||
UpdateCertificateState(ctx context.Context, id, status string, expiresAt *time.Time) error
|
||||
}
|
||||
|
||||
type CredentialReader interface {
|
||||
Get(ctx context.Context, reference string) (map[string]string, error)
|
||||
}
|
||||
|
||||
type ProviderFactory interface {
|
||||
Create(providerID string, credentials map[string]string) (challenge.Provider, error)
|
||||
}
|
||||
|
||||
type AccountManager interface {
|
||||
LoadOrCreate(ctx context.Context, environment, email string) (*AccountUser, error)
|
||||
Save(ctx context.Context, environment string, user *AccountUser) error
|
||||
}
|
||||
|
||||
type IssuerFactory func(user *AccountUser, provider challenge.Provider, environment string) Issuer
|
||||
|
||||
type Service struct {
|
||||
config config.Config
|
||||
repository DomainStateRepository
|
||||
credentials CredentialReader
|
||||
providers ProviderFactory
|
||||
accounts AccountManager
|
||||
store FileStore
|
||||
newIssuer IssuerFactory
|
||||
preferredChain string
|
||||
}
|
||||
|
||||
type IssueResult struct {
|
||||
DomainID string `json:"domain_id"`
|
||||
Domains []string `json:"domains"`
|
||||
Saved SavedResource `json:"saved"`
|
||||
}
|
||||
|
||||
type ImportRequest struct {
|
||||
DomainID string
|
||||
Certificate string
|
||||
PrivateKey string
|
||||
IssuerBundle string
|
||||
}
|
||||
|
||||
func NewService(cfg config.Config, repository DomainStateRepository, credentials CredentialReader, providers ProviderFactory, accounts AccountManager) *Service {
|
||||
return &Service{
|
||||
config: cfg, repository: repository, credentials: credentials, providers: providers, accounts: accounts,
|
||||
store: FileStore{Root: cfg.Paths.Certificate, BackupRoot: cfg.Paths.Backup},
|
||||
newIssuer: func(user *AccountUser, provider challenge.Provider, environment string) Issuer {
|
||||
return &LegoIssuer{User: user, Provider: provider, Environment: environment}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) Issue(ctx context.Context, domainID string) (IssueResult, error) {
|
||||
if s == nil || s.repository == nil || s.credentials == nil || s.providers == nil || s.accounts == nil || s.newIssuer == nil {
|
||||
return IssueResult{}, errors.New("证书申请服务未初始化")
|
||||
}
|
||||
domainID = strings.TrimSpace(domainID)
|
||||
if domainID == "" {
|
||||
return IssueResult{}, errors.New("域名 ID 不能为空")
|
||||
}
|
||||
item, err := s.repository.GetByID(ctx, domainID)
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("读取域名配置失败:%w", err)
|
||||
}
|
||||
domains, err := requestedDomains(item)
|
||||
if err != nil {
|
||||
return IssueResult{}, err
|
||||
}
|
||||
providerID := strings.ToLower(strings.TrimSpace(item.DNSProvider))
|
||||
if providerID == "" {
|
||||
providerID = strings.ToLower(strings.TrimSpace(s.config.DNS.Provider))
|
||||
}
|
||||
if providerID == "" || strings.TrimSpace(s.config.DNS.CredentialRef) == "" {
|
||||
return IssueResult{}, errors.New("DNS Provider 或凭据引用未配置")
|
||||
}
|
||||
if configured := strings.ToLower(strings.TrimSpace(s.config.DNS.Provider)); configured != "" && providerID != configured {
|
||||
return IssueResult{}, fmt.Errorf("域名配置的 DNS Provider %s 尚未绑定独立凭据,当前初始化凭据属于 %s", providerID, configured)
|
||||
}
|
||||
if s.config.DNS.VerificationState != "verified" {
|
||||
return IssueResult{}, errors.New("DNS API 尚未通过验证")
|
||||
}
|
||||
if err := s.repository.UpdateCertificateState(ctx, item.ID, "issuing", item.ExpiresAt); err != nil {
|
||||
return IssueResult{}, fmt.Errorf("更新证书申请状态失败:%w", err)
|
||||
}
|
||||
fail := func(cause error) (IssueResult, error) {
|
||||
if stateErr := s.repository.UpdateCertificateState(context.Background(), item.ID, "failed", item.ExpiresAt); stateErr != nil {
|
||||
return IssueResult{}, fmt.Errorf("%v;更新失败状态时发生错误:%w", cause, stateErr)
|
||||
}
|
||||
return IssueResult{}, cause
|
||||
}
|
||||
|
||||
credentials, err := s.credentials.Get(ctx, s.config.DNS.CredentialRef)
|
||||
if err != nil {
|
||||
return fail(fmt.Errorf("读取 DNS 凭据失败:%w", err))
|
||||
}
|
||||
provider, err := s.providers.Create(providerID, credentials)
|
||||
if err != nil {
|
||||
return fail(fmt.Errorf("创建 DNS Provider 失败:%w", err))
|
||||
}
|
||||
email := strings.TrimSpace(s.config.ACME.AccountEmail)
|
||||
if email == "" && len(s.config.Notification.Recipients) > 0 {
|
||||
email = strings.TrimSpace(s.config.Notification.Recipients[0])
|
||||
}
|
||||
user, err := s.accounts.LoadOrCreate(ctx, item.ACMEEnvironment, email)
|
||||
if err != nil {
|
||||
return fail(err)
|
||||
}
|
||||
issuer := s.newIssuer(user, provider, item.ACMEEnvironment)
|
||||
resource, issueErr := issuer.Obtain(ctx, ObtainRequest{
|
||||
Domains: domains, AccountEmail: email, Environment: item.ACMEEnvironment, PreferredChain: s.preferredChain,
|
||||
})
|
||||
if saveErr := s.accounts.Save(ctx, item.ACMEEnvironment, user); saveErr != nil {
|
||||
if issueErr != nil {
|
||||
return fail(fmt.Errorf("%v;保存 ACME 账户状态失败:%w", issueErr, saveErr))
|
||||
}
|
||||
return fail(saveErr)
|
||||
}
|
||||
if issueErr != nil {
|
||||
return fail(issueErr)
|
||||
}
|
||||
resource, err = ValidateResourceForDomains(resource, domains)
|
||||
if err != nil {
|
||||
return fail(err)
|
||||
}
|
||||
saved, err := s.store.Save(ctx, item.Name, resource)
|
||||
if err != nil {
|
||||
return fail(fmt.Errorf("保存证书文件失败:%w", err))
|
||||
}
|
||||
if err := s.repository.UpdateCertificateState(ctx, item.ID, "valid", &saved.NotAfter); err != nil {
|
||||
return IssueResult{}, fmt.Errorf("证书已保存,但更新域名状态失败:%w", err)
|
||||
}
|
||||
return IssueResult{DomainID: item.ID, Domains: domains, Saved: saved}, nil
|
||||
}
|
||||
|
||||
func (s *Service) Import(ctx context.Context, request ImportRequest) (IssueResult, error) {
|
||||
if s == nil || s.repository == nil {
|
||||
return IssueResult{}, errors.New("证书导入服务未初始化")
|
||||
}
|
||||
item, err := s.repository.GetByID(ctx, strings.TrimSpace(request.DomainID))
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("读取域名配置失败:%w", err)
|
||||
}
|
||||
certificatePath, err := cleanInputPath(request.Certificate, "证书文件")
|
||||
if err != nil {
|
||||
return IssueResult{}, err
|
||||
}
|
||||
privateKeyPath, err := cleanInputPath(request.PrivateKey, "私钥文件")
|
||||
if err != nil {
|
||||
return IssueResult{}, err
|
||||
}
|
||||
certificateData, err := os.ReadFile(certificatePath)
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("读取证书文件失败:%w", err)
|
||||
}
|
||||
privateKeyData, err := os.ReadFile(privateKeyPath)
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("读取私钥文件失败:%w", err)
|
||||
}
|
||||
var issuerData []byte
|
||||
if strings.TrimSpace(request.IssuerBundle) != "" {
|
||||
issuerPath, err := cleanInputPath(request.IssuerBundle, "签发者证书文件")
|
||||
if err != nil {
|
||||
return IssueResult{}, err
|
||||
}
|
||||
issuerData, err = os.ReadFile(issuerPath)
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("读取签发者证书文件失败:%w", err)
|
||||
}
|
||||
}
|
||||
domains := requestedDomainsForImport(item)
|
||||
resource, err := ValidateResourceForDomains(Resource{
|
||||
Domains: domains, Certificate: certificateData, IssuerCertificate: issuerData, PrivateKey: privateKeyData,
|
||||
}, domains)
|
||||
if err != nil {
|
||||
return IssueResult{}, err
|
||||
}
|
||||
saved, err := s.store.Save(ctx, item.Name, resource)
|
||||
if err != nil {
|
||||
return IssueResult{}, fmt.Errorf("保存导入证书失败:%w", err)
|
||||
}
|
||||
if err := s.repository.UpdateCertificateState(ctx, item.ID, "valid", &saved.NotAfter); err != nil {
|
||||
return IssueResult{}, fmt.Errorf("证书已保存,但更新域名状态失败:%w", err)
|
||||
}
|
||||
return IssueResult{DomainID: item.ID, Domains: resource.Domains, Saved: saved}, nil
|
||||
}
|
||||
|
||||
func cleanInputPath(value, label string) (string, error) {
|
||||
value = strings.TrimSpace(value)
|
||||
if value == "" {
|
||||
return "", fmt.Errorf("%s不能为空", label)
|
||||
}
|
||||
path := filepath.Clean(value)
|
||||
if path == "." {
|
||||
return "", fmt.Errorf("%s路径无效", label)
|
||||
}
|
||||
return path, nil
|
||||
}
|
||||
|
||||
func requestedDomainsForImport(item domain.Domain) []string {
|
||||
if item.CertificateType == domain.CertificateSAN && len(item.SANs) > 0 {
|
||||
return item.SANs
|
||||
}
|
||||
return []string{item.Name}
|
||||
}
|
||||
|
||||
func requestedDomains(item domain.Domain) ([]string, error) {
|
||||
values := item.SANs
|
||||
if item.CertificateType != domain.CertificateSAN {
|
||||
values = []string{item.Name}
|
||||
}
|
||||
return NormalizeDomains(values)
|
||||
}
|
||||
@@ -0,0 +1,234 @@
|
||||
package certificate
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/rsa"
|
||||
"crypto/x509"
|
||||
"crypto/x509/pkix"
|
||||
"encoding/pem"
|
||||
"errors"
|
||||
"math/big"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type serviceRepository struct {
|
||||
item domain.Domain
|
||||
states []string
|
||||
}
|
||||
|
||||
func (r *serviceRepository) GetByID(_ context.Context, _ string) (domain.Domain, error) {
|
||||
return r.item, nil
|
||||
}
|
||||
|
||||
func (r *serviceRepository) UpdateCertificateState(_ context.Context, _ string, status string, expiresAt *time.Time) error {
|
||||
r.states = append(r.states, status)
|
||||
r.item.Status = status
|
||||
r.item.ExpiresAt = expiresAt
|
||||
return nil
|
||||
}
|
||||
|
||||
type serviceCredentials struct{}
|
||||
|
||||
func (serviceCredentials) Get(context.Context, string) (map[string]string, error) {
|
||||
return map[string]string{"api_token": "test-token"}, nil
|
||||
}
|
||||
|
||||
type serviceProvider struct{}
|
||||
|
||||
func (serviceProvider) Present(context.Context, string, string, string) error { return nil }
|
||||
func (serviceProvider) CleanUp(context.Context, string, string, string) error { return nil }
|
||||
|
||||
type serviceProviderFactory struct{}
|
||||
|
||||
func (serviceProviderFactory) Create(string, map[string]string) (challenge.Provider, error) {
|
||||
return serviceProvider{}, nil
|
||||
}
|
||||
|
||||
type serviceAccounts struct{}
|
||||
|
||||
func (serviceAccounts) LoadOrCreate(context.Context, string, string) (*AccountUser, error) {
|
||||
return &AccountUser{}, nil
|
||||
}
|
||||
|
||||
func (serviceAccounts) Save(context.Context, string, *AccountUser) error { return nil }
|
||||
|
||||
type serviceIssuer struct {
|
||||
request ObtainRequest
|
||||
resource Resource
|
||||
err error
|
||||
}
|
||||
|
||||
func (i *serviceIssuer) Obtain(_ context.Context, request ObtainRequest) (Resource, error) {
|
||||
i.request = request
|
||||
return i.resource, i.err
|
||||
}
|
||||
|
||||
func TestServiceIssuesSANCertificateAndUpdatesState(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
cfg := certificateTestConfig(root)
|
||||
item, err := domain.NewDomainWithOptions("example.com", domain.CertificateSAN, []string{"example.com", "www.example.com"}, true, domain.ACMEEnvironmentStaging, "cloudflare")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
repository := &serviceRepository{item: item}
|
||||
issuer := &serviceIssuer{resource: testResourceForDomains(t, []string{"example.com", "www.example.com"})}
|
||||
service := NewService(cfg, repository, serviceCredentials{}, serviceProviderFactory{}, serviceAccounts{})
|
||||
service.newIssuer = func(*AccountUser, challenge.Provider, string) Issuer { return issuer }
|
||||
|
||||
result, err := service.Issue(context.Background(), item.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("申请 SAN 证书失败:%v", err)
|
||||
}
|
||||
if len(issuer.request.Domains) != 2 {
|
||||
t.Fatalf("SAN 申请域名错误:%v", issuer.request.Domains)
|
||||
}
|
||||
if len(repository.states) != 2 || repository.states[0] != "issuing" || repository.states[1] != "valid" {
|
||||
t.Fatalf("证书状态流转错误:%v", repository.states)
|
||||
}
|
||||
if _, err := os.Stat(result.Saved.PrivateKeyPath); err != nil {
|
||||
t.Fatalf("证书私钥未保存:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceFailureKeepsExistingCertificate(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
cfg := certificateTestConfig(root)
|
||||
item, err := domain.NewDomainWithOptions("example.com", domain.CertificateSingle, nil, true, domain.ACMEEnvironmentStaging, "cloudflare")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
oldExpiry := time.Now().UTC().Add(10 * 24 * time.Hour)
|
||||
item.ExpiresAt = &oldExpiry
|
||||
store := FileStore{Root: cfg.Paths.Certificate, BackupRoot: cfg.Paths.Backup}
|
||||
oldResource := testResource(t, "example.com")
|
||||
saved, err := store.Save(context.Background(), item.Name, oldResource)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before, err := os.ReadFile(saved.CertificatePath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
repository := &serviceRepository{item: item}
|
||||
issuer := &serviceIssuer{err: errors.New("模拟 ACME 申请失败")}
|
||||
service := NewService(cfg, repository, serviceCredentials{}, serviceProviderFactory{}, serviceAccounts{})
|
||||
service.newIssuer = func(*AccountUser, challenge.Provider, string) Issuer { return issuer }
|
||||
|
||||
if _, err := service.Issue(context.Background(), item.ID); err == nil {
|
||||
t.Fatal("ACME 申请失败时应返回错误")
|
||||
}
|
||||
after, err := os.ReadFile(saved.CertificatePath)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(after) != string(before) {
|
||||
t.Fatal("申请失败时不应覆盖现有证书")
|
||||
}
|
||||
if len(repository.states) != 2 || repository.states[1] != "failed" {
|
||||
t.Fatalf("失败状态未正确记录:%v", repository.states)
|
||||
}
|
||||
if repository.item.ExpiresAt == nil || !repository.item.ExpiresAt.Equal(oldExpiry) {
|
||||
t.Fatal("申请失败时应保留原证书到期时间")
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceImportsOwnedCertificate(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
cfg := certificateTestConfig(root)
|
||||
item, err := domain.NewDomainWithOptions("example.com", domain.CertificateSAN, []string{"example.com", "api.example.com"}, true, domain.ACMEEnvironmentStaging, "cloudflare")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resource := testResourceForDomains(t, []string{"example.com", "api.example.com"})
|
||||
certificatePath := filepath.Join(root, "owned-cert.pem")
|
||||
privateKeyPath := filepath.Join(root, "owned-key.pem")
|
||||
if err := os.WriteFile(certificatePath, resource.Certificate, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(privateKeyPath, resource.PrivateKey, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
repository := &serviceRepository{item: item}
|
||||
service := NewService(cfg, repository, nil, nil, nil)
|
||||
result, err := service.Import(context.Background(), ImportRequest{
|
||||
DomainID: item.ID, Certificate: certificatePath, PrivateKey: privateKeyPath,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("导入自有证书失败:%v", err)
|
||||
}
|
||||
if len(result.Domains) != 2 || repository.item.Status != "valid" {
|
||||
t.Fatalf("导入结果错误:%+v,状态:%s", result, repository.item.Status)
|
||||
}
|
||||
if _, err := os.Stat(result.Saved.FullChainPath); err != nil {
|
||||
t.Fatalf("导入证书未保存:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceRejectsOwnedCertificateForWrongDomain(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
cfg := certificateTestConfig(root)
|
||||
item, err := domain.NewDomainWithOptions("example.com", domain.CertificateSingle, nil, true, domain.ACMEEnvironmentStaging, "cloudflare")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
resource := testResource(t, "other.example.com")
|
||||
certificatePath := filepath.Join(root, "wrong-cert.pem")
|
||||
privateKeyPath := filepath.Join(root, "wrong-key.pem")
|
||||
if err := os.WriteFile(certificatePath, resource.Certificate, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(privateKeyPath, resource.PrivateKey, 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
service := NewService(cfg, &serviceRepository{item: item}, nil, nil, nil)
|
||||
if _, err := service.Import(context.Background(), ImportRequest{
|
||||
DomainID: item.ID, Certificate: certificatePath, PrivateKey: privateKeyPath,
|
||||
}); err == nil {
|
||||
t.Fatal("证书不覆盖托管域名时应拒绝导入")
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(cfg.Paths.Certificate, "example.com", "cert.pem")); !errors.Is(err, os.ErrNotExist) {
|
||||
t.Fatalf("导入失败时不应写入证书:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func certificateTestConfig(root string) config.Config {
|
||||
cfg := config.Default(root)
|
||||
cfg.Paths.Certificate = filepath.Join(root, "ssl")
|
||||
cfg.Paths.Backup = filepath.Join(root, "backups")
|
||||
cfg.DNS.Provider = "cloudflare"
|
||||
cfg.DNS.CredentialRef = "secret://dns/cloudflare/test"
|
||||
cfg.DNS.VerificationState = "verified"
|
||||
cfg.Notification.Recipients = []string{"admin@example.com"}
|
||||
return cfg
|
||||
}
|
||||
|
||||
func testResourceForDomains(t *testing.T, names []string) Resource {
|
||||
t.Helper()
|
||||
key, err := rsa.GenerateKey(rand.Reader, 2048)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
template := &x509.Certificate{
|
||||
SerialNumber: big.NewInt(2), Subject: pkix.Name{CommonName: names[0]}, DNSNames: names,
|
||||
NotBefore: now.Add(-time.Minute), NotAfter: now.Add(90 * 24 * 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)
|
||||
}
|
||||
return Resource{
|
||||
Domains: names, Certificate: pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}),
|
||||
PrivateKey: pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)}),
|
||||
}
|
||||
}
|
||||
+351
-13
@@ -1,22 +1,30 @@
|
||||
package cli
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/app"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
|
||||
"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/setup"
|
||||
)
|
||||
|
||||
const version = buildinfo.Version
|
||||
@@ -98,7 +106,18 @@ func localizeHelpFlags(command *cobra.Command) {
|
||||
}
|
||||
|
||||
func newInitCommand() *cobra.Command {
|
||||
return &cobra.Command{Use: "init", Short: "生成初始配置", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
return newInitCommandWithFirewall(firewall.NewManager())
|
||||
}
|
||||
|
||||
func newInitCommandWithFirewall(firewallManager firewall.Manager) *cobra.Command {
|
||||
var (
|
||||
adminUsername, adminPassword, emailProvider, emailEndpoint string
|
||||
recipients, dnsProvider, dnsCredentialRef, certificateRoot string
|
||||
webHostname, webPublicIP, httpsMode string
|
||||
serverPort, resetServicePort int
|
||||
dnsVerified, webEnabled bool
|
||||
)
|
||||
command := &cobra.Command{Use: "init", Short: "交互式初始化配置", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
path := resolveConfigPath()
|
||||
if _, err := os.Stat(path); err == nil {
|
||||
return fmt.Errorf("配置文件已存在:%s", path)
|
||||
@@ -106,13 +125,195 @@ func newInitCommand() *cobra.Command {
|
||||
return err
|
||||
}
|
||||
cfg := config.Default(baseDir)
|
||||
if err := cfg.Save(path); err != nil {
|
||||
input := setup.Input{
|
||||
AdminUsername: adminUsername, AdminPassword: adminPassword, ServerPort: serverPort,
|
||||
ResetServicePort: resetServicePort, EmailProvider: emailProvider, EmailEndpoint: emailEndpoint,
|
||||
EmailRecipients: splitValues(recipients), DNSProvider: dnsProvider, DNSCredentialRef: dnsCredentialRef,
|
||||
DNSVerified: dnsVerified, CertificateRoot: certificateRoot, WebHostname: webHostname,
|
||||
WebPublicIP: webPublicIP, WebEnabled: webEnabled, HTTPSMode: httpsMode,
|
||||
}
|
||||
if !cmd.Flags().Changed("admin-username") {
|
||||
if err := readInteractiveInit(cmd.InOrStdin(), cmd.OutOrStdout(), &input, cfg); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if err := setup.Apply(&cfg, input); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("初始配置已生成:%s\n", path)
|
||||
fmt.Println("当前默认使用 ACME Staging 环境,完成 DNS 配置后再切换 Production。")
|
||||
firewallResult, err := saveSetupWithFirewall(cmd.Context(), cfg, path, firewallManager)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "初始化配置已保存:%s\n", path)
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "DNS API 已标记为验证通过;真实 provider 连通性测试和 Web 证书申请将在后续任务接入。\n")
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "本机防火墙:%s\n", firewallResult.Message)
|
||||
fmt.Fprintf(cmd.OutOrStdout(), "请确认云安全组已放行主服务端口 %d;密码重置服务仅监听本机 %s:%d,不创建对外入站规则。\n", cfg.Server.Port, cfg.Admin.ResetServiceHost, cfg.Admin.ResetServicePort)
|
||||
return nil
|
||||
}}
|
||||
command.Flags().StringVar(&adminUsername, "admin-username", "", "超级管理员用户名")
|
||||
command.Flags().StringVar(&adminPassword, "admin-password", "", "超级管理员密码(仅建议临时使用参数,优先交互输入)")
|
||||
command.Flags().IntVar(&serverPort, "server-port", 8080, "Scert 主服务端口")
|
||||
command.Flags().IntVar(&resetServicePort, "reset-service-port", 8091, "Scert-admin 密码重置端口")
|
||||
command.Flags().StringVar(&emailProvider, "email-provider", "", "第三方邮箱服务标识")
|
||||
command.Flags().StringVar(&emailEndpoint, "email-endpoint", "", "第三方邮箱 API 地址")
|
||||
command.Flags().StringVar(&recipients, "recipients", "", "通知收件人,多个地址用逗号分隔")
|
||||
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().StringVar(&certificateRoot, "certificate-root", "", "证书部署根目录,默认使用系统目录")
|
||||
command.Flags().StringVar(&webHostname, "web-hostname", "", "Web 管理页面域名")
|
||||
command.Flags().StringVar(&webPublicIP, "web-public-ip", "", "没有域名时使用的公网 IP")
|
||||
command.Flags().BoolVar(&webEnabled, "web-enabled", true, "是否开启 Web 管理页面")
|
||||
command.Flags().StringVar(&httpsMode, "https-mode", "direct", "HTTPS 模式:direct、proxy")
|
||||
return command
|
||||
}
|
||||
|
||||
func saveSetupWithFirewall(ctx context.Context, cfg config.Config, path string, firewallManager firewall.Manager) (firewall.Result, error) {
|
||||
result := firewall.Result{
|
||||
Backend: firewall.BackendNone, Port: cfg.Server.Port,
|
||||
Message: "未配置防火墙管理器,已跳过本机规则创建",
|
||||
}
|
||||
if firewallManager != nil {
|
||||
firewallContext, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
var err error
|
||||
result, err = firewallManager.OpenTCP(firewallContext, cfg.Server.Port)
|
||||
cancel()
|
||||
if err != nil {
|
||||
return firewall.Result{}, fmt.Errorf("自动配置本机防火墙失败,请使用管理员权限重新运行初始化程序:%w", err)
|
||||
}
|
||||
}
|
||||
if err := cfg.Save(path); err != nil {
|
||||
if result.Created && firewallManager != nil {
|
||||
rollbackContext, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
rollbackErr := firewallManager.Rollback(rollbackContext, result)
|
||||
cancel()
|
||||
if rollbackErr != nil {
|
||||
return firewall.Result{}, fmt.Errorf("保存初始化配置失败,且自动创建的防火墙规则回滚失败,请手动检查本机防火墙:保存错误:%v;回滚错误:%w", err, rollbackErr)
|
||||
}
|
||||
}
|
||||
return firewall.Result{}, err
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func readInteractiveInit(input io.Reader, output io.Writer, value *setup.Input, cfg config.Config) error {
|
||||
reader := bufio.NewReader(input)
|
||||
fmt.Fprintln(output, "开始初始化 Scert。带 * 的项目为必填项。")
|
||||
var err error
|
||||
value.AdminUsername, err = ask(reader, output, "超级管理员用户名 *", "admin")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.AdminPassword, err = ask(reader, output, "超级管理员密码 *", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
port, err := askInt(reader, output, "Scert 主服务端口 *", cfg.Server.Port)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.ServerPort = port
|
||||
port, err = askInt(reader, output, "Scert-admin 密码重置端口 *", cfg.Admin.ResetServicePort)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.ResetServicePort = port
|
||||
value.EmailProvider, err = ask(reader, output, "第三方邮箱服务标识", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.EmailEndpoint, err = ask(reader, output, "第三方邮箱 API 地址", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
receiver, err := ask(reader, output, "通知收件人(逗号分隔)", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.EmailRecipients = splitValues(receiver)
|
||||
value.DNSProvider, err = ask(reader, output, "DNS API 服务商 *", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.DNSCredentialRef, err = ask(reader, output, "DNS 凭据引用 *(不要输入明文密钥)", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.DNSVerified, err = askYesNo(reader, output, "DNS API 是否已经完成验证测试?", false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.CertificateRoot, err = ask(reader, output, "证书部署根目录", cfg.Paths.Certificate)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
value.WebHostname, err = ask(reader, output, "Web 管理页面域名(无域名可留空)", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if value.WebHostname == "" {
|
||||
value.WebPublicIP, err = ask(reader, output, "Web 管理页面公网 IP", "")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
value.WebEnabled, err = askYesNo(reader, output, "是否开启 Web 管理页面?", true)
|
||||
return err
|
||||
}
|
||||
|
||||
func ask(reader *bufio.Reader, output io.Writer, label, defaultValue string) (string, error) {
|
||||
if defaultValue != "" {
|
||||
fmt.Fprintf(output, "%s [%s]:", label, defaultValue)
|
||||
} else {
|
||||
fmt.Fprintf(output, "%s:", label)
|
||||
}
|
||||
line, err := reader.ReadString('\n')
|
||||
if err != nil && !errors.Is(err, io.EOF) {
|
||||
return "", err
|
||||
}
|
||||
line = strings.TrimSpace(line)
|
||||
if line == "" {
|
||||
line = defaultValue
|
||||
}
|
||||
return line, nil
|
||||
}
|
||||
|
||||
func askInt(reader *bufio.Reader, output io.Writer, label string, defaultValue int) (int, error) {
|
||||
value, err := ask(reader, output, label, strconv.Itoa(defaultValue))
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
parsed, err := strconv.Atoi(value)
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("%s 必须是数字", label)
|
||||
}
|
||||
return parsed, nil
|
||||
}
|
||||
|
||||
func askYesNo(reader *bufio.Reader, output io.Writer, label string, defaultValue bool) (bool, error) {
|
||||
defaultText := "否"
|
||||
if defaultValue {
|
||||
defaultText = "是"
|
||||
}
|
||||
value, err := ask(reader, output, label+"(是/否)", defaultText)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
switch strings.ToLower(value) {
|
||||
case "是", "y", "yes":
|
||||
return true, nil
|
||||
case "否", "n", "no":
|
||||
return false, nil
|
||||
default:
|
||||
return false, fmt.Errorf("%s 请输入是或否", label)
|
||||
}
|
||||
}
|
||||
|
||||
func splitValues(value string) []string {
|
||||
if strings.TrimSpace(value) == "" {
|
||||
return nil
|
||||
}
|
||||
return strings.Split(value, ",")
|
||||
}
|
||||
|
||||
func newStatusCommand() *cobra.Command {
|
||||
@@ -126,7 +327,7 @@ func newStatusCommand() *cobra.Command {
|
||||
}
|
||||
|
||||
func commandStatus(cfg config.Config) map[string]any {
|
||||
return map[string]any{"service": "scert", "version": buildinfo.Version, "config_version": cfg.Version, "setup_ready": cfg.SetupReady, "https_mode": cfg.Server.HTTPSMode, "database_driver": cfg.Database.Driver}
|
||||
return map[string]any{"service": "scert", "version": buildinfo.Version, "config_version": cfg.Version, "setup_ready": cfg.SetupReady, "https_mode": cfg.Server.HTTPSMode, "database_driver": cfg.Database.Driver, "server_port": cfg.Server.Port, "reset_service_port": cfg.Admin.ResetServicePort, "web_enabled": cfg.Web.Enabled, "web_hostname": cfg.Web.Hostname, "web_public_ip": cfg.Web.PublicIP, "dns_verification_state": cfg.DNS.VerificationState}
|
||||
}
|
||||
|
||||
func newServeCommand() *cobra.Command {
|
||||
@@ -135,13 +336,23 @@ func newServeCommand() *cobra.Command {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if !cfg.SetupReady {
|
||||
cfg.Server.Host = "127.0.0.1"
|
||||
fmt.Fprintln(cmd.OutOrStdout(), "系统尚未初始化,临时服务仅监听本机;请完成初始化后重启服务。")
|
||||
}
|
||||
if cfg.SetupReady && !cfg.Web.Enabled {
|
||||
return fmt.Errorf("Web 管理页面已关闭")
|
||||
}
|
||||
service, err := app.NewWithConfigPath(cmd.Context(), cfg, resolveConfigPath())
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
ctx, stop := signal.NotifyContext(cmd.Context(), os.Interrupt, syscall.SIGTERM)
|
||||
defer stop()
|
||||
if service.Renewal != nil && cfg.SetupReady {
|
||||
service.Renewal.Start(ctx)
|
||||
}
|
||||
errCh := make(chan error, 1)
|
||||
go func() { errCh <- service.HTTP.ListenAndServe() }()
|
||||
select {
|
||||
@@ -158,7 +369,66 @@ func newServeCommand() *cobra.Command {
|
||||
|
||||
func newDomainCommand() *cobra.Command {
|
||||
command := &cobra.Command{Use: "domain", Short: "管理托管域名"}
|
||||
command.AddCommand(newDomainListCommand(), newDomainAddCommand())
|
||||
command.AddCommand(newDomainListCommand(), newDomainAddCommand(), newDomainEditCommand(), newDomainDeleteCommand(), newDomainIssueCommand(), newDomainImportCommand())
|
||||
return command
|
||||
}
|
||||
|
||||
func newDomainIssueCommand() *cobra.Command {
|
||||
var id string
|
||||
command := &cobra.Command{Use: "issue", Short: "申请或续期域名证书", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
if service.Certificates == nil {
|
||||
return fmt.Errorf("证书申请服务未初始化")
|
||||
}
|
||||
result, err := service.Certificates.Issue(cmd.Context(), id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return printJSON(cmd, result)
|
||||
}}
|
||||
command.Flags().StringVar(&id, "id", "", "域名 ID")
|
||||
_ = command.MarkFlagRequired("id")
|
||||
return command
|
||||
}
|
||||
|
||||
func newDomainImportCommand() *cobra.Command {
|
||||
var id, certificatePath, privateKeyPath, issuerPath string
|
||||
command := &cobra.Command{Use: "import", Short: "导入自有证书", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
if service.Certificates == nil {
|
||||
return fmt.Errorf("证书导入服务未初始化")
|
||||
}
|
||||
result, err := service.Certificates.Import(cmd.Context(), certificate.ImportRequest{
|
||||
DomainID: id, Certificate: certificatePath, PrivateKey: privateKeyPath, IssuerBundle: issuerPath,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return printJSON(cmd, result)
|
||||
}}
|
||||
command.Flags().StringVar(&id, "id", "", "域名 ID")
|
||||
command.Flags().StringVar(&certificatePath, "certificate", "", "证书 PEM 文件路径")
|
||||
command.Flags().StringVar(&privateKeyPath, "private-key", "", "私钥 PEM 文件路径")
|
||||
command.Flags().StringVar(&issuerPath, "issuer", "", "签发者证书 PEM 文件路径,可选")
|
||||
_ = command.MarkFlagRequired("id")
|
||||
_ = command.MarkFlagRequired("certificate")
|
||||
_ = command.MarkFlagRequired("private-key")
|
||||
return command
|
||||
}
|
||||
|
||||
@@ -182,8 +452,9 @@ func newDomainListCommand() *cobra.Command {
|
||||
}
|
||||
|
||||
func newDomainAddCommand() *cobra.Command {
|
||||
var name, certificateType string
|
||||
var name, certificateType, acmeEnvironment, dnsProvider string
|
||||
var sans []string
|
||||
var autoRenew bool
|
||||
command := &cobra.Command{Use: "add", Short: "添加托管域名", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
@@ -194,7 +465,7 @@ func newDomainAddCommand() *cobra.Command {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
item, err := domain.NewDomain(name, domain.CertificateType(certificateType), sans)
|
||||
item, err := domain.NewDomainWithOptions(name, domain.CertificateType(certificateType), sans, autoRenew, acmeEnvironment, dnsProvider)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -207,10 +478,80 @@ func newDomainAddCommand() *cobra.Command {
|
||||
command.Flags().StringVar(&name, "name", "", "域名")
|
||||
command.Flags().StringVar(&certificateType, "type", string(domain.CertificateSingle), "证书类型:single、wildcard、san")
|
||||
command.Flags().StringSliceVar(&sans, "sans", nil, "SAN 域名列表")
|
||||
command.Flags().BoolVar(&autoRenew, "auto-renew", true, "是否启用自动续期")
|
||||
command.Flags().StringVar(&acmeEnvironment, "acme-environment", domain.ACMEEnvironmentStaging, "ACME 环境:staging、production")
|
||||
command.Flags().StringVar(&dnsProvider, "dns-provider", "", "DNS 验证服务商标识")
|
||||
_ = command.MarkFlagRequired("name")
|
||||
return command
|
||||
}
|
||||
|
||||
func newDomainEditCommand() *cobra.Command {
|
||||
var id, name, certificateType, acmeEnvironment, dnsProvider string
|
||||
var sans []string
|
||||
var autoRenew bool
|
||||
command := &cobra.Command{Use: "edit", Short: "编辑托管域名", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
existing, err := service.Repository.GetByID(cmd.Context(), id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
item, err := domain.NewDomainWithOptions(name, domain.CertificateType(certificateType), sans, autoRenew, acmeEnvironment, dnsProvider)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
item.ID = existing.ID
|
||||
item.CreatedAt = existing.CreatedAt
|
||||
item.Status = "pending"
|
||||
item.ExpiresAt = nil
|
||||
if err := service.Repository.Update(cmd.Context(), item); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("域名已更新:%s\n", item.Name)
|
||||
return nil
|
||||
}}
|
||||
command.Flags().StringVar(&id, "id", "", "域名 ID")
|
||||
command.Flags().StringVar(&name, "name", "", "域名")
|
||||
command.Flags().StringVar(&certificateType, "type", string(domain.CertificateSingle), "证书类型:single、wildcard、san")
|
||||
command.Flags().StringSliceVar(&sans, "sans", nil, "SAN 域名列表")
|
||||
command.Flags().BoolVar(&autoRenew, "auto-renew", true, "是否启用自动续期")
|
||||
command.Flags().StringVar(&acmeEnvironment, "acme-environment", domain.ACMEEnvironmentStaging, "ACME 环境:staging、production")
|
||||
command.Flags().StringVar(&dnsProvider, "dns-provider", "", "DNS 验证服务商标识")
|
||||
_ = command.MarkFlagRequired("id")
|
||||
_ = command.MarkFlagRequired("name")
|
||||
return command
|
||||
}
|
||||
|
||||
func newDomainDeleteCommand() *cobra.Command {
|
||||
var id string
|
||||
command := &cobra.Command{Use: "delete", Short: "删除托管域名", RunE: func(cmd *cobra.Command, args []string) error {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
service, err := app.New(cmd.Context(), cfg)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer service.Close()
|
||||
if err := service.Repository.Delete(cmd.Context(), id); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("域名已删除:%s\n", id)
|
||||
return nil
|
||||
}}
|
||||
command.Flags().StringVar(&id, "id", "", "域名 ID")
|
||||
_ = command.MarkFlagRequired("id")
|
||||
return command
|
||||
}
|
||||
|
||||
func printJSON(cmd *cobra.Command, value any) error {
|
||||
data, err := json.MarshalIndent(value, "", " ")
|
||||
if err != nil {
|
||||
@@ -220,10 +561,7 @@ func printJSON(cmd *cobra.Command, value any) error {
|
||||
return err
|
||||
}
|
||||
|
||||
func loadConfig() (config.Config, error) {
|
||||
path := resolveConfigPath()
|
||||
return config.Load(path)
|
||||
}
|
||||
func loadConfig() (config.Config, error) { return config.Load(resolveConfigPath()) }
|
||||
|
||||
func resolveConfigPath() string {
|
||||
if configPath != "" {
|
||||
|
||||
@@ -2,13 +2,39 @@ package cli
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
|
||||
)
|
||||
|
||||
type cliFakeFirewallManager struct {
|
||||
result firewall.Result
|
||||
openErr error
|
||||
rollbackErr error
|
||||
openedPort int
|
||||
rollbackCall bool
|
||||
}
|
||||
|
||||
func (f *cliFakeFirewallManager) 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 *cliFakeFirewallManager) Rollback(_ context.Context, _ firewall.Result) error {
|
||||
f.rollbackCall = true
|
||||
return f.rollbackErr
|
||||
}
|
||||
|
||||
func TestHelpIsLocalizedAndHasNoDuplicateCommands(t *testing.T) {
|
||||
configPath = ""
|
||||
baseDir = ""
|
||||
@@ -58,3 +84,57 @@ func TestCommandStatusUsesApplicationVersion(t *testing.T) {
|
||||
t.Fatalf("状态版本字段不正确:%+v", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveSetupWithFirewallOpensOnlyMainPort(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
cfg.Server.Port = 8443
|
||||
cfg.Admin.ResetServicePort = 8091
|
||||
manager := &cliFakeFirewallManager{result: firewall.Result{
|
||||
Backend: "windows", RuleName: "Scert Web TCP 8443", Created: true, Message: "已创建测试规则",
|
||||
}}
|
||||
path := filepath.Join(t.TempDir(), "config", "scert.json")
|
||||
result, err := saveSetupWithFirewall(context.Background(), cfg, path, manager)
|
||||
if err != nil {
|
||||
t.Fatalf("保存初始化配置失败:%v", err)
|
||||
}
|
||||
if manager.openedPort != 8443 || manager.rollbackCall || !result.Created {
|
||||
t.Fatalf("CLI 防火墙事务不正确:port=%d rollback=%t result=%+v", manager.openedPort, manager.rollbackCall, result)
|
||||
}
|
||||
if _, err := os.Stat(path); err != nil {
|
||||
t.Fatalf("初始化配置未保存:%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveSetupWithFirewallRollsBackNewRuleOnSaveFailure(t *testing.T) {
|
||||
baseDir := t.TempDir()
|
||||
blockedParent := filepath.Join(baseDir, "blocked")
|
||||
if err := os.WriteFile(blockedParent, []byte("占位"), 0o600); err != nil {
|
||||
t.Fatalf("创建阻塞路径失败:%v", err)
|
||||
}
|
||||
manager := &cliFakeFirewallManager{result: firewall.Result{
|
||||
Backend: "ufw", RuleName: "Scert Web TCP 8080", Port: 8080, Created: true,
|
||||
}}
|
||||
_, err := saveSetupWithFirewall(context.Background(), config.Default(baseDir), filepath.Join(blockedParent, "scert.json"), manager)
|
||||
if err == nil {
|
||||
t.Fatal("配置保存失败应返回错误")
|
||||
}
|
||||
if !manager.rollbackCall {
|
||||
t.Fatal("配置保存失败时应回滚本次新建的防火墙规则")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveSetupWithFirewallReportsRollbackFailure(t *testing.T) {
|
||||
baseDir := t.TempDir()
|
||||
blockedParent := filepath.Join(baseDir, "blocked")
|
||||
if err := os.WriteFile(blockedParent, []byte("占位"), 0o600); err != nil {
|
||||
t.Fatalf("创建阻塞路径失败:%v", err)
|
||||
}
|
||||
manager := &cliFakeFirewallManager{
|
||||
result: firewall.Result{Backend: "ufw", RuleName: "Scert Web TCP 8080", Port: 8080, Created: true},
|
||||
rollbackErr: errors.New("rollback denied"),
|
||||
}
|
||||
_, err := saveSetupWithFirewall(context.Background(), config.Default(baseDir), filepath.Join(blockedParent, "scert.json"), manager)
|
||||
if err == nil || !strings.Contains(err.Error(), "手动检查本机防火墙") {
|
||||
t.Fatalf("防火墙回滚失败应返回明确错误:%v", err)
|
||||
}
|
||||
}
|
||||
@@ -11,21 +11,45 @@ import (
|
||||
|
||||
const CurrentVersion = 1
|
||||
const ConfigFormat = "json"
|
||||
const LinuxInstallationMetadataPath = "/scert/conf/installation.json"
|
||||
|
||||
type installationMetadata struct {
|
||||
CertificateRoot string `json:"certificate_root"`
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
Version int `json:"version"`
|
||||
SetupReady bool `json:"setup_ready"`
|
||||
Admin AdminConfig `json:"admin"`
|
||||
Server ServerConfig `json:"server"`
|
||||
Web WebConfig `json:"web"`
|
||||
Database DatabaseConfig `json:"database"`
|
||||
Paths PathsConfig `json:"paths"`
|
||||
ACME ACMEConfig `json:"acme"`
|
||||
DNS DNSConfig `json:"dns"`
|
||||
Notification NotificationConfig `json:"notification"`
|
||||
}
|
||||
|
||||
type AdminConfig struct {
|
||||
Username string `json:"username"`
|
||||
PasswordHash string `json:"password_hash"`
|
||||
ResetServiceHost string `json:"reset_service_host"`
|
||||
ResetServicePort int `json:"reset_service_port"`
|
||||
}
|
||||
|
||||
type ServerConfig struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
HTTPSMode string `json:"https_mode"`
|
||||
TLSCert string `json:"tls_cert"`
|
||||
TLSKey string `json:"tls_key"`
|
||||
}
|
||||
|
||||
type WebConfig struct {
|
||||
Enabled bool `json:"enabled"`
|
||||
Hostname string `json:"hostname"`
|
||||
PublicIP string `json:"public_ip"`
|
||||
InitReady bool `json:"init_ready"`
|
||||
}
|
||||
|
||||
type DatabaseConfig struct {
|
||||
@@ -52,11 +76,20 @@ type ACMEConfig struct {
|
||||
RenewalThresholdDays int `json:"renewal_threshold_days"`
|
||||
}
|
||||
|
||||
type DNSConfig struct {
|
||||
Provider string `json:"provider"`
|
||||
CredentialRef string `json:"credential_ref"`
|
||||
VerificationState string `json:"verification_state"`
|
||||
}
|
||||
|
||||
type NotificationConfig struct {
|
||||
HTTPEnabled bool `json:"http_enabled"`
|
||||
SMTPEnabled bool `json:"smtp_enabled"`
|
||||
TimeoutSecs int `json:"timeout_secs"`
|
||||
RetryCount int `json:"retry_count"`
|
||||
HTTPEnabled bool `json:"http_enabled"`
|
||||
SMTPEnabled bool `json:"smtp_enabled"`
|
||||
Provider string `json:"provider"`
|
||||
Endpoint string `json:"endpoint"`
|
||||
Recipients []string `json:"recipients"`
|
||||
TimeoutSecs int `json:"timeout_secs"`
|
||||
RetryCount int `json:"retry_count"`
|
||||
}
|
||||
|
||||
func Default(baseDir string) Config {
|
||||
@@ -64,21 +97,30 @@ func Default(baseDir string) Config {
|
||||
return Config{
|
||||
Version: CurrentVersion,
|
||||
SetupReady: false,
|
||||
Server: ServerConfig{Host: "127.0.0.1", Port: 8080, HTTPSMode: "direct"},
|
||||
Admin: AdminConfig{ResetServiceHost: "127.0.0.1", ResetServicePort: 8091},
|
||||
Server: ServerConfig{Host: "0.0.0.0", Port: 8080, HTTPSMode: "direct"},
|
||||
Web: WebConfig{Enabled: true},
|
||||
Database: DatabaseConfig{
|
||||
Driver: "sqlite", DSN: filepath.Join(paths.Data, "scert.db"),
|
||||
MaxOpenConns: 4, MaxIdleConns: 2, ConnMaxLifetimeMins: 30,
|
||||
},
|
||||
Paths: paths,
|
||||
ACME: ACMEConfig{CA: "letsencrypt", Environment: "staging", RenewalThresholdDays: 6},
|
||||
DNS: DNSConfig{VerificationState: "not_configured"},
|
||||
Notification: NotificationConfig{TimeoutSecs: 10, RetryCount: 3},
|
||||
}
|
||||
}
|
||||
|
||||
func DefaultPaths(baseDir string) PathsConfig {
|
||||
if runtime.GOOS == "linux" {
|
||||
certificateRoot := "/ssl"
|
||||
if strings.TrimSpace(baseDir) == "" {
|
||||
if installedRoot, err := readInstalledCertificateRoot(LinuxInstallationMetadataPath); err == nil {
|
||||
certificateRoot = installedRoot
|
||||
}
|
||||
}
|
||||
return PathsConfig{
|
||||
Install: "/scert", Certificate: "/ssl", Config: "/scert/conf",
|
||||
Install: "/scert", Certificate: certificateRoot, Config: "/scert/conf",
|
||||
Data: "/scert/data", Log: "/scert/log", Backup: "/scert/backups",
|
||||
}
|
||||
}
|
||||
@@ -93,6 +135,22 @@ func DefaultPaths(baseDir string) PathsConfig {
|
||||
}
|
||||
}
|
||||
|
||||
func readInstalledCertificateRoot(path string) (string, error) {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
var metadata installationMetadata
|
||||
if err := json.Unmarshal(data, &metadata); err != nil {
|
||||
return "", fmt.Errorf("解析安装路径记录失败:%w", err)
|
||||
}
|
||||
root := filepath.Clean(strings.TrimSpace(metadata.CertificateRoot))
|
||||
if !filepath.IsAbs(root) || root == string(filepath.Separator) {
|
||||
return "", fmt.Errorf("安装路径记录中的证书目录无效")
|
||||
}
|
||||
return root, nil
|
||||
}
|
||||
|
||||
func Load(path string) (Config, error) {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
@@ -102,12 +160,36 @@ func Load(path string) (Config, error) {
|
||||
if err := json.Unmarshal(data, &cfg); err != nil {
|
||||
return Config{}, fmt.Errorf("解析配置文件失败:%w", err)
|
||||
}
|
||||
cfg.Normalize()
|
||||
if err := cfg.Validate(); err != nil {
|
||||
return Config{}, err
|
||||
}
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
func (c *Config) Normalize() {
|
||||
if c == nil {
|
||||
return
|
||||
}
|
||||
if c.Admin.ResetServiceHost == "" {
|
||||
c.Admin.ResetServiceHost = "127.0.0.1"
|
||||
}
|
||||
if c.Admin.ResetServicePort == 0 {
|
||||
c.Admin.ResetServicePort = 8091
|
||||
}
|
||||
if c.Server.Host == "" {
|
||||
c.Server.Host = "0.0.0.0"
|
||||
}
|
||||
if c.Server.HTTPSMode == "" {
|
||||
c.Server.HTTPSMode = "direct"
|
||||
}
|
||||
if c.Web.Hostname == "" && c.Web.PublicIP == "" && !c.SetupReady {
|
||||
c.Web.Enabled = true
|
||||
}
|
||||
if c.DNS.VerificationState == "" {
|
||||
c.DNS.VerificationState = "not_configured"
|
||||
}
|
||||
}
|
||||
func (c Config) Save(path string) error {
|
||||
if err := c.Validate(); err != nil {
|
||||
return err
|
||||
@@ -144,6 +226,18 @@ func (c Config) Validate() error {
|
||||
if c.Server.Port < 1 || c.Server.Port > 65535 {
|
||||
return fmt.Errorf("服务监听端口无效:%d", c.Server.Port)
|
||||
}
|
||||
if strings.TrimSpace(c.Admin.ResetServiceHost) == "" {
|
||||
return fmt.Errorf("密码重置服务监听地址不能为空")
|
||||
}
|
||||
if c.Admin.ResetServiceHost != "127.0.0.1" && c.Admin.ResetServiceHost != "::1" {
|
||||
return fmt.Errorf("密码重置服务仅允许使用 127.0.0.1 或 ::1")
|
||||
}
|
||||
if c.Admin.ResetServicePort < 1 || c.Admin.ResetServicePort > 65535 {
|
||||
return fmt.Errorf("密码重置服务监听端口无效:%d", c.Admin.ResetServicePort)
|
||||
}
|
||||
if c.Server.Port == c.Admin.ResetServicePort && c.Server.Host == c.Admin.ResetServiceHost {
|
||||
return fmt.Errorf("主服务和密码重置服务不能使用相同监听地址和端口")
|
||||
}
|
||||
if c.Server.HTTPSMode != "direct" && c.Server.HTTPSMode != "proxy" {
|
||||
return fmt.Errorf("HTTPS 模式无效:%s", c.Server.HTTPSMode)
|
||||
}
|
||||
@@ -176,6 +270,20 @@ func (c Config) Validate() error {
|
||||
if c.ACME.RenewalThresholdDays < 1 {
|
||||
return fmt.Errorf("续期阈值必须大于 0")
|
||||
}
|
||||
if c.DNS.VerificationState != "not_configured" && c.DNS.VerificationState != "pending" && c.DNS.VerificationState != "verified" && c.DNS.VerificationState != "failed" {
|
||||
return fmt.Errorf("DNS 验证状态无效:%s", c.DNS.VerificationState)
|
||||
}
|
||||
if c.SetupReady {
|
||||
if strings.TrimSpace(c.Admin.Username) == "" || strings.TrimSpace(c.Admin.PasswordHash) == "" {
|
||||
return fmt.Errorf("初始化完成时必须配置超级管理员账号")
|
||||
}
|
||||
if c.DNS.VerificationState != "verified" {
|
||||
return fmt.Errorf("初始化完成时必须先通过 DNS API 验证")
|
||||
}
|
||||
if strings.TrimSpace(c.Web.Hostname) == "" && strings.TrimSpace(c.Web.PublicIP) == "" {
|
||||
return fmt.Errorf("初始化完成时必须配置 Web 域名或公网 IP")
|
||||
}
|
||||
}
|
||||
if c.Notification.TimeoutSecs < 1 || c.Notification.RetryCount < 0 {
|
||||
return fmt.Errorf("通知配置无效")
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"testing"
|
||||
@@ -19,6 +20,39 @@ func TestDefaultPaths(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadInstalledCertificateRoot(t *testing.T) {
|
||||
if runtime.GOOS != "linux" {
|
||||
t.Skip("安装路径记录仅用于 Linux")
|
||||
}
|
||||
path := filepath.Join(t.TempDir(), "installation.json")
|
||||
if err := os.WriteFile(path, []byte(`{
|
||||
"certificate_root": "/data/scert/ssl"
|
||||
}
|
||||
`), 0o600); err != nil {
|
||||
t.Fatalf("写入安装路径记录失败:%v", err)
|
||||
}
|
||||
root, err := readInstalledCertificateRoot(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取安装路径记录失败:%v", err)
|
||||
}
|
||||
if root != filepath.Clean("/data/scert/ssl") {
|
||||
t.Fatalf("证书目录读取结果不正确:%s", root)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadInstalledCertificateRootRejectsUnsafeValue(t *testing.T) {
|
||||
if runtime.GOOS != "linux" {
|
||||
t.Skip("安装路径记录仅用于 Linux")
|
||||
}
|
||||
path := filepath.Join(t.TempDir(), "installation.json")
|
||||
if err := os.WriteFile(path, []byte(`{"certificate_root":"/"}`), 0o600); err != nil {
|
||||
t.Fatalf("写入安装路径记录失败:%v", err)
|
||||
}
|
||||
if _, err := readInstalledCertificateRoot(path); err == nil {
|
||||
t.Fatal("根目录不得作为安装记录中的证书目录")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAndLoad(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := Default(dir)
|
||||
|
||||
@@ -2,6 +2,7 @@ package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
@@ -24,7 +25,11 @@ func TestOpenAndMigrateSQLite(t *testing.T) {
|
||||
if err := db.DB.QueryRow("SELECT COUNT(*) FROM schema_migrations").Scan(&count); err != nil {
|
||||
t.Fatalf("读取迁移版本失败:%v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
if count != 2 {
|
||||
t.Fatalf("迁移版本数量错误:%d", count)
|
||||
}
|
||||
var autoRenew bool
|
||||
if err := db.DB.QueryRow("SELECT auto_renew FROM domains LIMIT 1").Scan(&autoRenew); err != nil && err != sql.ErrNoRows {
|
||||
t.Fatalf("检查域名选项字段失败:%v", err)
|
||||
}
|
||||
}
|
||||
@@ -8,7 +8,7 @@ import (
|
||||
"strings"
|
||||
)
|
||||
|
||||
//go:embed migrations/sqlite/0001_initial.sql migrations/mysql/0001_initial.sql
|
||||
//go:embed migrations/sqlite/0001_initial.sql migrations/sqlite/0002_domain_options.sql migrations/mysql/0001_initial.sql migrations/mysql/0002_domain_options.sql
|
||||
var migrationFiles embed.FS
|
||||
|
||||
func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
@@ -29,13 +29,18 @@ func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
if err == sql.ErrNoRows {
|
||||
version = 0
|
||||
}
|
||||
if version >= 1 {
|
||||
return nil
|
||||
}
|
||||
path := "migrations/sqlite/0001_initial.sql"
|
||||
if driver == "mysql" {
|
||||
path = "migrations/mysql/0001_initial.sql"
|
||||
for nextVersion := version + 1; nextVersion <= latestMigrationVersion; nextVersion++ {
|
||||
if err := applyMigration(ctx, db, driver, nextVersion); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const latestMigrationVersion = 2
|
||||
|
||||
func applyMigration(ctx context.Context, db *sql.DB, driver string, version int) error {
|
||||
path := fmt.Sprintf("migrations/%s/%04d_%s.sql", driver, version, migrationName(version))
|
||||
content, err := migrationFiles.ReadFile(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取迁移文件失败:%w", err)
|
||||
@@ -47,7 +52,7 @@ func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
return fmt.Errorf("执行数据库迁移失败:%w", err)
|
||||
}
|
||||
}
|
||||
if _, err := db.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (1)"); err != nil {
|
||||
if _, err := db.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (?)", version); err != nil {
|
||||
return fmt.Errorf("记录迁移版本失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
@@ -62,7 +67,7 @@ func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
return fmt.Errorf("执行数据库迁移失败:%w", err)
|
||||
}
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (1)"); err != nil {
|
||||
if _, err := tx.ExecContext(ctx, "INSERT INTO schema_migrations (version) VALUES (?)", version); err != nil {
|
||||
_ = tx.Rollback()
|
||||
return fmt.Errorf("记录迁移版本失败:%w", err)
|
||||
}
|
||||
@@ -72,6 +77,17 @@ func Migrate(ctx context.Context, db *sql.DB, driver string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func migrationName(version int) string {
|
||||
switch version {
|
||||
case 1:
|
||||
return "initial"
|
||||
case 2:
|
||||
return "domain_options"
|
||||
default:
|
||||
return "unknown"
|
||||
}
|
||||
}
|
||||
|
||||
func migrationStatements(content []byte) []string {
|
||||
statements := make([]string, 0)
|
||||
for _, statement := range strings.Split(string(content), ";") {
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
ALTER TABLE domains ADD COLUMN auto_renew BOOLEAN NOT NULL DEFAULT TRUE;
|
||||
ALTER TABLE domains ADD COLUMN acme_environment VARCHAR(32) NOT NULL DEFAULT 'staging';
|
||||
ALTER TABLE domains ADD COLUMN dns_provider VARCHAR(64) NOT NULL DEFAULT '';
|
||||
@@ -0,0 +1,3 @@
|
||||
ALTER TABLE domains ADD COLUMN auto_renew BOOLEAN NOT NULL DEFAULT 1;
|
||||
ALTER TABLE domains ADD COLUMN acme_environment TEXT NOT NULL DEFAULT 'staging';
|
||||
ALTER TABLE domains ADD COLUMN dns_provider TEXT NOT NULL DEFAULT '';
|
||||
@@ -52,7 +52,7 @@ func TestSQLiteMigrationIsIdempotentAndCreatesBaseTables(t *testing.T) {
|
||||
if err := db.DB.QueryRow("SELECT COUNT(*) FROM schema_migrations").Scan(&versions); err != nil {
|
||||
t.Fatalf("读取迁移版本失败:%v", err)
|
||||
}
|
||||
if versions != 1 {
|
||||
if versions != 2 {
|
||||
t.Fatalf("重复迁移写入了多条版本记录:%d", versions)
|
||||
}
|
||||
var tables int
|
||||
|
||||
@@ -0,0 +1,170 @@
|
||||
package dnsprovider
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
Cloudflare = "cloudflare"
|
||||
Aliyun = "aliyun"
|
||||
DNSPod = "dnspod"
|
||||
CNAME = "cname"
|
||||
HuaweiCloud = "huaweicloud"
|
||||
TencentCloud = "tencentcloud"
|
||||
Route53 = "route53"
|
||||
GoogleCloud = "googlecloud"
|
||||
Other = "other"
|
||||
)
|
||||
|
||||
var ErrProviderUnavailable = errors.New("DNS 服务商适配器尚未开放")
|
||||
|
||||
type CredentialField struct {
|
||||
Name string `json:"name"`
|
||||
Label string `json:"label"`
|
||||
Secret bool `json:"secret"`
|
||||
Required bool `json:"required"`
|
||||
Placeholder string `json:"placeholder,omitempty"`
|
||||
}
|
||||
|
||||
type Descriptor struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Available bool `json:"available"`
|
||||
CredentialFields []CredentialField `json:"credential_fields"`
|
||||
Description string `json:"description"`
|
||||
}
|
||||
|
||||
var descriptors = map[string]Descriptor{
|
||||
Cloudflare: {
|
||||
ID: Cloudflare, Name: "Cloudflare", Available: true,
|
||||
Description: "使用 API Token 创建并清理 DNS-01 测试记录。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "api_token", Label: "DNS API Token", Secret: true, Required: true, Placeholder: "需要 Zone:Read 与 DNS:Edit 权限"},
|
||||
{Name: "zone_token", Label: "Zone API Token", Secret: true, Placeholder: "可选;用于拆分 Zone 读取权限"},
|
||||
},
|
||||
},
|
||||
Aliyun: {
|
||||
ID: Aliyun, Name: "阿里云 DNS", Description: "适配器字段已定义,在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "access_key_id", Label: "AccessKey ID", Required: true},
|
||||
{Name: "access_key_secret", Label: "AccessKey Secret", Secret: true, Required: true},
|
||||
{Name: "security_token", Label: "Security Token", Secret: true},
|
||||
},
|
||||
},
|
||||
DNSPod: {
|
||||
ID: DNSPod, Name: "DNSPod", Description: "使用腾讯云 DNSPod API 凭据;在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "secret_id", Label: "SecretId", Required: true},
|
||||
{Name: "secret_key", Label: "SecretKey", Secret: true, Required: true},
|
||||
{Name: "session_token", Label: "Session Token", Secret: true},
|
||||
},
|
||||
},
|
||||
CNAME: {
|
||||
ID: CNAME, Name: "CNAME 委派", Description: "需要先配置委派目标和目标 DNS 服务商,后续任务接入自动验证。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "delegated_domain", Label: "专用验证域", Required: true, Placeholder: "例如 acme.example.com"},
|
||||
{Name: "delegated_provider", Label: "委派目标 DNS 服务商", Required: true},
|
||||
},
|
||||
},
|
||||
HuaweiCloud: {
|
||||
ID: HuaweiCloud, Name: "华为云", Description: "适配器字段已定义,在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "access_key_id", Label: "Access Key ID", Required: true},
|
||||
{Name: "secret_access_key", Label: "Secret Access Key", Secret: true, Required: true},
|
||||
{Name: "region", Label: "区域", Required: true, Placeholder: "例如 cn-north-4"},
|
||||
},
|
||||
},
|
||||
TencentCloud: {
|
||||
ID: TencentCloud, Name: "腾讯云", Description: "使用腾讯云 DNSPod API;在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "secret_id", Label: "SecretId", Required: true},
|
||||
{Name: "secret_key", Label: "SecretKey", Secret: true, Required: true},
|
||||
{Name: "region", Label: "区域", Placeholder: "可选"},
|
||||
{Name: "session_token", Label: "Session Token", Secret: true},
|
||||
},
|
||||
},
|
||||
Route53: {
|
||||
ID: Route53, Name: "AWS Route 53", Description: "适配器字段已定义,在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "access_key_id", Label: "Access Key ID", Required: true},
|
||||
{Name: "secret_access_key", Label: "Secret Access Key", Secret: true, Required: true},
|
||||
{Name: "region", Label: "区域", Required: true, Placeholder: "例如 us-east-1"},
|
||||
{Name: "session_token", Label: "Session Token", Secret: true},
|
||||
{Name: "hosted_zone_id", Label: "Hosted Zone ID"},
|
||||
},
|
||||
},
|
||||
GoogleCloud: {
|
||||
ID: GoogleCloud, Name: "Google Cloud DNS", Description: "适配器字段已定义,在线验证将在后续任务接入。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "service_account_json", Label: "服务账号 JSON", Secret: true, Required: true},
|
||||
{Name: "project", Label: "项目 ID", Required: true},
|
||||
{Name: "zone_id", Label: "托管区域 ID"},
|
||||
},
|
||||
},
|
||||
Other: {
|
||||
ID: Other, Name: "其他服务商", Description: "扩展占位;需要实现专用 Provider 适配器后才能在线验证。",
|
||||
CredentialFields: []CredentialField{
|
||||
{Name: "provider_name", Label: "服务商标识", Required: true},
|
||||
{Name: "config_json", Label: "Provider 配置 JSON", Secret: true, Required: true},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func Descriptors() []Descriptor {
|
||||
order := []string{Cloudflare, Aliyun, DNSPod, CNAME, HuaweiCloud, TencentCloud, Route53, GoogleCloud, Other}
|
||||
result := make([]Descriptor, 0, len(order))
|
||||
for _, id := range order {
|
||||
result = append(result, descriptors[id])
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func GetDescriptor(providerID string) (Descriptor, error) {
|
||||
providerID = strings.ToLower(strings.TrimSpace(providerID))
|
||||
descriptor, ok := descriptors[providerID]
|
||||
if !ok {
|
||||
return Descriptor{}, fmt.Errorf("未知 DNS 服务商:%s", providerID)
|
||||
}
|
||||
return descriptor, nil
|
||||
}
|
||||
|
||||
func ValidateCredentials(providerID string, credentials map[string]string) (map[string]string, error) {
|
||||
descriptor, err := GetDescriptor(providerID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
cleaned := make(map[string]string, len(descriptor.CredentialFields))
|
||||
allowed := make(map[string]struct{}, len(descriptor.CredentialFields))
|
||||
for _, field := range descriptor.CredentialFields {
|
||||
allowed[field.Name] = struct{}{}
|
||||
value := strings.TrimSpace(credentials[field.Name])
|
||||
if field.Required && value == "" {
|
||||
return nil, fmt.Errorf("%s不能为空", field.Label)
|
||||
}
|
||||
if value != "" {
|
||||
cleaned[field.Name] = value
|
||||
}
|
||||
}
|
||||
for name := range credentials {
|
||||
if _, ok := allowed[name]; !ok {
|
||||
return nil, fmt.Errorf("DNS 凭据字段无效:%s", name)
|
||||
}
|
||||
}
|
||||
return cleaned, nil
|
||||
}
|
||||
|
||||
func CredentialNames(providerID string) []string {
|
||||
descriptor, err := GetDescriptor(providerID)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
result := make([]string, 0, len(descriptor.CredentialFields))
|
||||
for _, field := range descriptor.CredentialFields {
|
||||
result = append(result, field.Name)
|
||||
}
|
||||
sort.Strings(result)
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
package dnsprovider
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
"github.com/go-acme/lego/v5/providers/dns/cloudflare"
|
||||
)
|
||||
|
||||
type LegoFactory struct{}
|
||||
|
||||
func NewLegoFactory() LegoFactory {
|
||||
return LegoFactory{}
|
||||
}
|
||||
|
||||
func (LegoFactory) Create(providerID string, credentials map[string]string) (challenge.Provider, error) {
|
||||
providerID = strings.ToLower(strings.TrimSpace(providerID))
|
||||
descriptor, err := GetDescriptor(providerID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !descriptor.Available {
|
||||
return nil, fmt.Errorf("%w:%s", ErrProviderUnavailable, descriptor.Name)
|
||||
}
|
||||
switch providerID {
|
||||
case Cloudflare:
|
||||
cfg := cloudflare.NewDefaultConfig()
|
||||
cfg.AuthToken = credentials["api_token"]
|
||||
cfg.ZoneToken = credentials["zone_token"]
|
||||
if cfg.ZoneToken == "" {
|
||||
cfg.ZoneToken = cfg.AuthToken
|
||||
}
|
||||
provider, err := cloudflare.NewDNSProviderConfig(cfg)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("创建 Cloudflare DNS Provider 失败:%w", err)
|
||||
}
|
||||
return provider, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("%w:%s", ErrProviderUnavailable, descriptor.Name)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package dnsprovider
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type Factory interface {
|
||||
Create(providerID string, credentials map[string]string) (challenge.Provider, error)
|
||||
}
|
||||
|
||||
type Tester struct {
|
||||
factory Factory
|
||||
}
|
||||
|
||||
func NewTester(factory Factory) *Tester {
|
||||
return &Tester{factory: factory}
|
||||
}
|
||||
|
||||
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 验证服务未初始化")
|
||||
}
|
||||
testDomain = strings.ToLower(strings.TrimSuffix(strings.TrimSpace(testDomain), "."))
|
||||
if !domain.IsValidName(testDomain) {
|
||||
return fmt.Errorf("DNS 测试域名格式无效:%s", testDomain)
|
||||
}
|
||||
cleaned, err := ValidateCredentials(providerID, credentials)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
provider, err := t.factory.Create(providerID, cleaned)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
token, err := randomValue(24)
|
||||
if err != nil {
|
||||
return fmt.Errorf("生成 DNS 测试标识失败:%w", err)
|
||||
}
|
||||
keyAuth, err := randomValue(48)
|
||||
if err != nil {
|
||||
return fmt.Errorf("生成 DNS 测试授权值失败:%w", err)
|
||||
}
|
||||
if err := provider.Present(ctx, testDomain, token, keyAuth); err != nil {
|
||||
return fmt.Errorf("创建 DNS 测试记录失败:%w", err)
|
||||
}
|
||||
if err := provider.CleanUp(ctx, testDomain, token, keyAuth); err != nil {
|
||||
return fmt.Errorf("DNS 测试记录已创建,但自动清理失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func randomValue(size int) (string, error) {
|
||||
data := make([]byte, size)
|
||||
if _, err := rand.Read(data); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return base64.RawURLEncoding.EncodeToString(data), nil
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package dnsprovider
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/go-acme/lego/v5/challenge"
|
||||
)
|
||||
|
||||
type fakeFactory struct {
|
||||
provider challenge.Provider
|
||||
err error
|
||||
}
|
||||
|
||||
func (f fakeFactory) Create(string, map[string]string) (challenge.Provider, error) {
|
||||
return f.provider, f.err
|
||||
}
|
||||
|
||||
type fakeProvider struct {
|
||||
presented bool
|
||||
cleaned bool
|
||||
presentErr error
|
||||
cleanupErr error
|
||||
}
|
||||
|
||||
func (p *fakeProvider) Present(context.Context, string, string, string) error {
|
||||
p.presented = true
|
||||
return p.presentErr
|
||||
}
|
||||
|
||||
func (p *fakeProvider) CleanUp(context.Context, string, string, string) error {
|
||||
p.cleaned = true
|
||||
return p.cleanupErr
|
||||
}
|
||||
|
||||
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"})
|
||||
if err != nil {
|
||||
t.Fatalf("DNS 测试失败:%v", err)
|
||||
}
|
||||
if !provider.presented || !provider.cleaned {
|
||||
t.Fatalf("DNS 测试未完整执行:presented=%v cleaned=%v", provider.presented, provider.cleaned)
|
||||
}
|
||||
}
|
||||
|
||||
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"})
|
||||
if err == nil {
|
||||
t.Fatal("创建测试记录失败时应返回错误")
|
||||
}
|
||||
if provider.cleaned {
|
||||
t.Fatal("创建测试记录失败时不应执行清理")
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateCredentialsRejectsUnknownField(t *testing.T) {
|
||||
_, err := ValidateCredentials(Cloudflare, map[string]string{"api_token": "token", "unexpected": "value"})
|
||||
if err == nil {
|
||||
t.Fatal("未知凭据字段应被拒绝")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnavailableProviderReturnsTypedError(t *testing.T) {
|
||||
_, err := NewLegoFactory().Create(Aliyun, map[string]string{"access_key_id": "id", "access_key_secret": "secret"})
|
||||
if !errors.Is(err, ErrProviderUnavailable) {
|
||||
t.Fatalf("未开放适配器应返回指定错误:%v", err)
|
||||
}
|
||||
}
|
||||
@@ -18,11 +18,19 @@ const (
|
||||
CertificateSAN CertificateType = "san"
|
||||
)
|
||||
|
||||
const (
|
||||
ACMEEnvironmentStaging = "staging"
|
||||
ACMEEnvironmentProduction = "production"
|
||||
)
|
||||
|
||||
type Domain struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
CertificateType CertificateType `json:"certificate_type"`
|
||||
SANs []string `json:"sans"`
|
||||
AutoRenew bool `json:"auto_renew"`
|
||||
ACMEEnvironment string `json:"acme_environment"`
|
||||
DNSProvider string `json:"dns_provider,omitempty"`
|
||||
Status string `json:"status"`
|
||||
ExpiresAt *time.Time `json:"expires_at,omitempty"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
@@ -30,6 +38,10 @@ type Domain struct {
|
||||
}
|
||||
|
||||
func NewDomain(name string, certificateType CertificateType, sans []string) (Domain, error) {
|
||||
return NewDomainWithOptions(name, certificateType, sans, true, ACMEEnvironmentStaging, "")
|
||||
}
|
||||
|
||||
func NewDomainWithOptions(name string, certificateType CertificateType, sans []string, autoRenew bool, acmeEnvironment string, dnsProvider string) (Domain, error) {
|
||||
name = strings.ToLower(strings.TrimSpace(name))
|
||||
if !IsValidName(name) {
|
||||
return Domain{}, fmt.Errorf("域名格式无效:%s", name)
|
||||
@@ -37,6 +49,11 @@ func NewDomain(name string, certificateType CertificateType, sans []string) (Dom
|
||||
if certificateType != CertificateSingle && certificateType != CertificateWildcard && certificateType != CertificateSAN {
|
||||
return Domain{}, fmt.Errorf("证书类型无效:%s", certificateType)
|
||||
}
|
||||
acmeEnvironment = strings.ToLower(strings.TrimSpace(acmeEnvironment))
|
||||
if !IsValidACMEEnvironment(acmeEnvironment) {
|
||||
return Domain{}, fmt.Errorf("ACME 环境无效:%s", acmeEnvironment)
|
||||
}
|
||||
dnsProvider = strings.ToLower(strings.TrimSpace(dnsProvider))
|
||||
cleanSANs := normalizeSANs(sans)
|
||||
if certificateType == CertificateSAN {
|
||||
cleanSANs = normalizeSANs(append([]string{name}, cleanSANs...))
|
||||
@@ -60,7 +77,22 @@ func NewDomain(name string, certificateType CertificateType, sans []string) (Dom
|
||||
return Domain{}, fmt.Errorf("只有泛域名证书类型允许使用 *. 域名")
|
||||
}
|
||||
now := time.Now().UTC()
|
||||
return Domain{ID: NewID(), Name: name, CertificateType: certificateType, SANs: cleanSANs, Status: "pending", CreatedAt: now, UpdatedAt: now}, nil
|
||||
return Domain{
|
||||
ID: NewID(),
|
||||
Name: name,
|
||||
CertificateType: certificateType,
|
||||
SANs: cleanSANs,
|
||||
AutoRenew: autoRenew,
|
||||
ACMEEnvironment: acmeEnvironment,
|
||||
DNSProvider: dnsProvider,
|
||||
Status: "pending",
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func IsValidACMEEnvironment(value string) bool {
|
||||
return value == ACMEEnvironmentStaging || value == ACMEEnvironmentProduction
|
||||
}
|
||||
|
||||
func IsValidName(name string) bool {
|
||||
|
||||
@@ -30,6 +30,9 @@ func TestNewDomainTypes(t *testing.T) {
|
||||
if result.Name == "" || len(result.SANs) != 1 || result.SANs[0] != result.Name {
|
||||
t.Fatalf("域名规范化结果不正确:%+v", result)
|
||||
}
|
||||
if !result.AutoRenew || result.ACMEEnvironment != ACMEEnvironmentStaging {
|
||||
t.Fatalf("默认域名选项不正确:%+v", result)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -55,3 +58,16 @@ func TestNewDomainSANValidation(t *testing.T) {
|
||||
t.Fatal("非法 SAN 域名未被拒绝")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewDomainOptionsValidation(t *testing.T) {
|
||||
item, err := NewDomainWithOptions("example.com", CertificateSingle, nil, false, ACMEEnvironmentProduction, "cloudflare")
|
||||
if err != nil {
|
||||
t.Fatalf("带选项创建域名失败:%v", err)
|
||||
}
|
||||
if item.AutoRenew || item.ACMEEnvironment != ACMEEnvironmentProduction || item.DNSProvider != "cloudflare" {
|
||||
t.Fatalf("域名选项保存不正确:%+v", item)
|
||||
}
|
||||
if _, err := NewDomainWithOptions("example.com", CertificateSingle, nil, true, "invalid", ""); err == nil {
|
||||
t.Fatal("非法 ACME 环境未被拒绝")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package firewall
|
||||
|
||||
import "context"
|
||||
|
||||
const BackendNone = "none"
|
||||
|
||||
type Result struct {
|
||||
Backend string `json:"backend"`
|
||||
RuleName string `json:"rule_name,omitempty"`
|
||||
Port int `json:"port"`
|
||||
Created bool `json:"created"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
type Manager interface {
|
||||
OpenTCP(ctx context.Context, port int) (Result, error)
|
||||
Rollback(ctx context.Context, result Result) error
|
||||
}
|
||||
|
||||
type CommandResult struct {
|
||||
Output []byte
|
||||
ExitCode int
|
||||
}
|
||||
|
||||
type Runner interface {
|
||||
LookPath(name string) (string, error)
|
||||
Run(ctx context.Context, name string, args ...string) (CommandResult, error)
|
||||
}
|
||||
@@ -0,0 +1,143 @@
|
||||
package firewall
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func (m *manager) openLinux(ctx context.Context, port int) (Result, error) {
|
||||
ufw, ufwErr := m.runner.LookPath("ufw")
|
||||
if ufwErr == nil {
|
||||
status, err := m.runner.Run(ctx, ufw, "status")
|
||||
if err != nil || status.ExitCode != 0 {
|
||||
return Result{}, commandError("检查 UFW 状态", ufw, status, err)
|
||||
}
|
||||
if ufwIsActive(status.Output) {
|
||||
return m.openUFW(ctx, ufw, port, status.Output)
|
||||
}
|
||||
}
|
||||
|
||||
firewallCMD, firewalldErr := m.runner.LookPath("firewall-cmd")
|
||||
if firewalldErr == nil {
|
||||
state, err := m.runner.Run(ctx, firewallCMD, "--state")
|
||||
if err != nil {
|
||||
return Result{}, commandError("检查 firewalld 状态", firewallCMD, state, err)
|
||||
}
|
||||
if state.ExitCode == 0 && strings.TrimSpace(strings.ToLower(string(state.Output))) == "running" {
|
||||
return m.openFirewalld(ctx, firewallCMD, port)
|
||||
}
|
||||
if state.ExitCode != 0 && state.ExitCode != 252 && !strings.Contains(strings.ToLower(string(state.Output)), "not running") {
|
||||
return Result{}, commandError("检查 firewalld 状态", firewallCMD, state, nil)
|
||||
}
|
||||
}
|
||||
|
||||
return Result{
|
||||
Backend: BackendNone, Port: port,
|
||||
Message: "未检测到已启用的 UFW 或 firewalld,无需创建主服务端口入站规则",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *manager) openUFW(ctx context.Context, executable string, port int, statusOutput []byte) (Result, error) {
|
||||
name := ruleName(port)
|
||||
if ufwHasRule(statusOutput, port) {
|
||||
return Result{
|
||||
Backend: backendUFW, RuleName: name, Port: port,
|
||||
Message: fmt.Sprintf("UFW 已放行主服务 TCP 端口 %d", port),
|
||||
}, nil
|
||||
}
|
||||
rule := strconv.Itoa(port) + "/tcp"
|
||||
added, err := m.runner.Run(ctx, executable, "allow", rule, "comment", name)
|
||||
if err != nil || added.ExitCode != 0 {
|
||||
return Result{}, commandError("创建 UFW 入站规则", executable, added, err)
|
||||
}
|
||||
return Result{
|
||||
Backend: backendUFW, RuleName: name, Port: port, Created: true,
|
||||
Message: fmt.Sprintf("已通过 UFW 放行主服务 TCP 端口 %d", port),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *manager) rollbackUFW(ctx context.Context, result Result) error {
|
||||
executable, err := m.runner.LookPath("ufw")
|
||||
if err != nil {
|
||||
return fmt.Errorf("未找到 UFW,无法回滚防火墙规则:%w", err)
|
||||
}
|
||||
rule := strconv.Itoa(result.Port) + "/tcp"
|
||||
removed, err := m.runner.Run(ctx, executable, "--force", "delete", "allow", rule)
|
||||
if err != nil || removed.ExitCode != 0 {
|
||||
return commandError("回滚 UFW 入站规则", executable, removed, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *manager) openFirewalld(ctx context.Context, executable string, port int) (Result, error) {
|
||||
name := ruleName(port)
|
||||
rule := strconv.Itoa(port) + "/tcp"
|
||||
query, err := m.runner.Run(ctx, executable, "--permanent", "--query-port="+rule)
|
||||
if err != nil {
|
||||
return Result{}, commandError("检查 firewalld 规则", executable, query, err)
|
||||
}
|
||||
if query.ExitCode == 0 {
|
||||
return Result{
|
||||
Backend: backendFirewalld, RuleName: name, Port: port,
|
||||
Message: fmt.Sprintf("firewalld 已放行主服务 TCP 端口 %d", port),
|
||||
}, nil
|
||||
}
|
||||
if query.ExitCode != 1 {
|
||||
return Result{}, commandError("检查 firewalld 规则", executable, query, nil)
|
||||
}
|
||||
added, err := m.runner.Run(ctx, executable, "--permanent", "--add-port="+rule)
|
||||
if err != nil || added.ExitCode != 0 {
|
||||
return Result{}, commandError("创建 firewalld 永久规则", executable, added, err)
|
||||
}
|
||||
reloaded, err := m.runner.Run(ctx, executable, "--reload")
|
||||
if err != nil || reloaded.ExitCode != 0 {
|
||||
rollback, rollbackErr := m.runner.Run(ctx, executable, "--permanent", "--remove-port="+rule)
|
||||
if rollbackErr == nil && rollback.ExitCode == 0 {
|
||||
_, _ = m.runner.Run(ctx, executable, "--reload")
|
||||
}
|
||||
return Result{}, commandError("重新加载 firewalld", executable, reloaded, err)
|
||||
}
|
||||
return Result{
|
||||
Backend: backendFirewalld, RuleName: name, Port: port, Created: true,
|
||||
Message: fmt.Sprintf("已通过 firewalld 放行主服务 TCP 端口 %d", port),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *manager) rollbackFirewalld(ctx context.Context, result Result) error {
|
||||
executable, err := m.runner.LookPath("firewall-cmd")
|
||||
if err != nil {
|
||||
return fmt.Errorf("未找到 firewalld,无法回滚防火墙规则:%w", err)
|
||||
}
|
||||
rule := strconv.Itoa(result.Port) + "/tcp"
|
||||
removed, err := m.runner.Run(ctx, executable, "--permanent", "--remove-port="+rule)
|
||||
if err != nil || removed.ExitCode != 0 {
|
||||
return commandError("回滚 firewalld 永久规则", executable, removed, err)
|
||||
}
|
||||
reloaded, err := m.runner.Run(ctx, executable, "--reload")
|
||||
if err != nil || reloaded.ExitCode != 0 {
|
||||
return commandError("重新加载 firewalld", executable, reloaded, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ufwIsActive(output []byte) bool {
|
||||
for _, line := range strings.Split(strings.ToLower(string(output)), "\n") {
|
||||
if strings.TrimSpace(line) == "status: active" {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func ufwHasRule(output []byte, port int) bool {
|
||||
prefix := strconv.Itoa(port) + "/tcp"
|
||||
for _, line := range strings.Split(strings.ToLower(string(output)), "\n") {
|
||||
line = strings.TrimSpace(line)
|
||||
if strings.HasPrefix(line, prefix) && strings.Contains(line, "allow") {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package firewall
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
backendWindows = "windows"
|
||||
backendUFW = "ufw"
|
||||
backendFirewalld = "firewalld"
|
||||
)
|
||||
|
||||
type manager struct {
|
||||
goos string
|
||||
runner Runner
|
||||
}
|
||||
|
||||
type execRunner struct{}
|
||||
|
||||
func NewManager() Manager {
|
||||
return NewManagerForOS(runtime.GOOS, execRunner{})
|
||||
}
|
||||
|
||||
func NewManagerForOS(goos string, runner Runner) Manager {
|
||||
if runner == nil {
|
||||
runner = execRunner{}
|
||||
}
|
||||
return &manager{goos: strings.ToLower(strings.TrimSpace(goos)), runner: runner}
|
||||
}
|
||||
|
||||
func (execRunner) LookPath(name string) (string, error) {
|
||||
return exec.LookPath(name)
|
||||
}
|
||||
|
||||
func (execRunner) Run(ctx context.Context, name string, args ...string) (CommandResult, error) {
|
||||
command := exec.CommandContext(ctx, name, args...)
|
||||
command.Env = append(os.Environ(), "LC_ALL=C", "LANG=C")
|
||||
output, err := command.CombinedOutput()
|
||||
if err == nil {
|
||||
return CommandResult{Output: output, ExitCode: 0}, nil
|
||||
}
|
||||
var exitErr *exec.ExitError
|
||||
if errors.As(err, &exitErr) {
|
||||
return CommandResult{Output: output, ExitCode: exitErr.ExitCode()}, nil
|
||||
}
|
||||
return CommandResult{Output: output, ExitCode: -1}, err
|
||||
}
|
||||
|
||||
func (m *manager) OpenTCP(ctx context.Context, port int) (Result, error) {
|
||||
if err := validatePort(port); err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
switch m.goos {
|
||||
case "windows":
|
||||
return m.openWindows(ctx, port)
|
||||
case "linux":
|
||||
return m.openLinux(ctx, port)
|
||||
default:
|
||||
return Result{
|
||||
Backend: BackendNone, Port: port,
|
||||
Message: fmt.Sprintf("当前操作系统 %s 不在自动防火墙配置范围内,已跳过本机规则创建", m.goos),
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
|
||||
func (m *manager) Rollback(ctx context.Context, result Result) error {
|
||||
if !result.Created {
|
||||
return nil
|
||||
}
|
||||
if err := validatePort(result.Port); err != nil {
|
||||
return err
|
||||
}
|
||||
switch result.Backend {
|
||||
case backendWindows:
|
||||
return m.rollbackWindows(ctx, result)
|
||||
case backendUFW:
|
||||
return m.rollbackUFW(ctx, result)
|
||||
case backendFirewalld:
|
||||
return m.rollbackFirewalld(ctx, result)
|
||||
default:
|
||||
return fmt.Errorf("无法回滚未知防火墙后端:%s", result.Backend)
|
||||
}
|
||||
}
|
||||
|
||||
func validatePort(port int) error {
|
||||
if port < 1 || port > 65535 {
|
||||
return fmt.Errorf("防火墙端口无效:%d", port)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ruleName(port int) string {
|
||||
return "Scert Web TCP " + strconv.Itoa(port)
|
||||
}
|
||||
|
||||
func commandError(action, name string, result CommandResult, err error) error {
|
||||
if err != nil {
|
||||
return fmt.Errorf("%s失败,无法执行 %s:%w", action, name, err)
|
||||
}
|
||||
message := strings.TrimSpace(string(result.Output))
|
||||
if message == "" {
|
||||
message = fmt.Sprintf("退出码 %d", result.ExitCode)
|
||||
}
|
||||
return fmt.Errorf("%s失败:%s", action, message)
|
||||
}
|
||||
@@ -0,0 +1,205 @@
|
||||
package firewall
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type runnerCall struct {
|
||||
name string
|
||||
args []string
|
||||
}
|
||||
|
||||
type runnerResponse struct {
|
||||
result CommandResult
|
||||
err error
|
||||
}
|
||||
|
||||
type fakeRunner struct {
|
||||
paths map[string]string
|
||||
responses []runnerResponse
|
||||
calls []runnerCall
|
||||
}
|
||||
|
||||
func (f *fakeRunner) LookPath(name string) (string, error) {
|
||||
path, ok := f.paths[name]
|
||||
if !ok {
|
||||
return "", errors.New("not found")
|
||||
}
|
||||
return path, nil
|
||||
}
|
||||
|
||||
func (f *fakeRunner) Run(_ context.Context, name string, args ...string) (CommandResult, error) {
|
||||
f.calls = append(f.calls, runnerCall{name: name, args: append([]string(nil), args...)})
|
||||
if len(f.responses) == 0 {
|
||||
return CommandResult{}, errors.New("unexpected command")
|
||||
}
|
||||
response := f.responses[0]
|
||||
f.responses = f.responses[1:]
|
||||
return response.result, response.err
|
||||
}
|
||||
|
||||
func TestOpenTCPRejectsInvalidPortBeforeRunningCommand(t *testing.T) {
|
||||
runner := &fakeRunner{}
|
||||
manager := NewManagerForOS("windows", runner)
|
||||
if _, err := manager.OpenTCP(context.Background(), 0); err == nil {
|
||||
t.Fatal("无效端口应被拒绝")
|
||||
}
|
||||
if len(runner.calls) != 0 {
|
||||
t.Fatalf("无效端口不应执行系统命令:%+v", runner.calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWindowsCreatesIdempotentRuleAndRollsBackOwnChange(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"powershell.exe": `C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`},
|
||||
responses: []runnerResponse{
|
||||
{result: CommandResult{Output: []byte("enabled\n")}},
|
||||
{result: CommandResult{ExitCode: 3}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
},
|
||||
}
|
||||
manager := NewManagerForOS("windows", runner)
|
||||
result, err := manager.OpenTCP(context.Background(), 8443)
|
||||
if err != nil {
|
||||
t.Fatalf("创建 Windows 防火墙规则失败:%v", err)
|
||||
}
|
||||
if !result.Created || result.Backend != backendWindows || result.RuleName != "Scert Web TCP 8443" {
|
||||
t.Fatalf("Windows 防火墙结果不正确:%+v", result)
|
||||
}
|
||||
addArgs := runner.calls[2].args
|
||||
if got := addArgs[len(addArgs)-2:]; !reflect.DeepEqual(got, []string{"Scert Web TCP 8443", "8443"}) {
|
||||
t.Fatalf("端口和规则名称必须通过独立参数传递:%v", addArgs)
|
||||
}
|
||||
if err := manager.Rollback(context.Background(), result); err != nil {
|
||||
t.Fatalf("回滚 Windows 防火墙规则失败:%v", err)
|
||||
}
|
||||
removeArgs := runner.calls[3].args
|
||||
if removeArgs[len(removeArgs)-1] != result.RuleName {
|
||||
t.Fatalf("回滚规则名称不正确:%v", removeArgs)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWindowsSkipsRuleWhenFirewallIsDisabled(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"powershell.exe": "powershell.exe"},
|
||||
responses: []runnerResponse{{result: CommandResult{Output: []byte("disabled\n")}}},
|
||||
}
|
||||
result, err := NewManagerForOS("windows", runner).OpenTCP(context.Background(), 443)
|
||||
if err != nil {
|
||||
t.Fatalf("检查 Windows 防火墙失败:%v", err)
|
||||
}
|
||||
if result.Created || result.Backend != BackendNone || len(runner.calls) != 1 {
|
||||
t.Fatalf("Windows 防火墙未启用时不应创建规则:%+v calls=%+v", result, runner.calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUFWCreatesRuleAndRollbackUsesExactPortArgument(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"ufw": "/usr/sbin/ufw"},
|
||||
responses: []runnerResponse{
|
||||
{result: CommandResult{Output: []byte("Status: active\n")}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
},
|
||||
}
|
||||
manager := NewManagerForOS("linux", runner)
|
||||
result, err := manager.OpenTCP(context.Background(), 8443)
|
||||
if err != nil {
|
||||
t.Fatalf("创建 UFW 规则失败:%v", err)
|
||||
}
|
||||
if !result.Created || result.Backend != backendUFW {
|
||||
t.Fatalf("UFW 结果不正确:%+v", result)
|
||||
}
|
||||
if got := runner.calls[1].args; !reflect.DeepEqual(got, []string{"allow", "8443/tcp", "comment", "Scert Web TCP 8443"}) {
|
||||
t.Fatalf("UFW 创建参数不正确:%v", got)
|
||||
}
|
||||
if err := manager.Rollback(context.Background(), result); err != nil {
|
||||
t.Fatalf("回滚 UFW 规则失败:%v", err)
|
||||
}
|
||||
if got := runner.calls[2].args; !reflect.DeepEqual(got, []string{"--force", "delete", "allow", "8443/tcp"}) {
|
||||
t.Fatalf("UFW 回滚参数不正确:%v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUFWKeepsExistingRule(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"ufw": "/usr/sbin/ufw"},
|
||||
responses: []runnerResponse{{result: CommandResult{Output: []byte("Status: active\n8443/tcp ALLOW Anywhere\n")}}},
|
||||
}
|
||||
result, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 8443)
|
||||
if err != nil {
|
||||
t.Fatalf("检查 UFW 规则失败:%v", err)
|
||||
}
|
||||
if result.Created || result.Backend != backendUFW || len(runner.calls) != 1 {
|
||||
t.Fatalf("已有 UFW 规则不应重复创建:%+v calls=%+v", result, runner.calls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFirewalldCreatesPermanentRuleAndReloads(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
|
||||
responses: []runnerResponse{
|
||||
{result: CommandResult{Output: []byte("running\n")}},
|
||||
{result: CommandResult{ExitCode: 1}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
},
|
||||
}
|
||||
manager := NewManagerForOS("linux", runner)
|
||||
result, err := manager.OpenTCP(context.Background(), 9443)
|
||||
if err != nil {
|
||||
t.Fatalf("创建 firewalld 规则失败:%v", err)
|
||||
}
|
||||
if !result.Created || result.Backend != backendFirewalld {
|
||||
t.Fatalf("firewalld 结果不正确:%+v", result)
|
||||
}
|
||||
if got := runner.calls[2].args; !reflect.DeepEqual(got, []string{"--permanent", "--add-port=9443/tcp"}) {
|
||||
t.Fatalf("firewalld 创建参数不正确:%v", got)
|
||||
}
|
||||
if err := manager.Rollback(context.Background(), result); err != nil {
|
||||
t.Fatalf("回滚 firewalld 规则失败:%v", err)
|
||||
}
|
||||
if got := runner.calls[4].args; !reflect.DeepEqual(got, []string{"--permanent", "--remove-port=9443/tcp"}) {
|
||||
t.Fatalf("firewalld 回滚参数不正确:%v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFirewalldReloadFailureRemovesNewPermanentRule(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
|
||||
responses: []runnerResponse{
|
||||
{result: CommandResult{Output: []byte("running\n")}},
|
||||
{result: CommandResult{ExitCode: 1}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{Output: []byte("reload failed"), ExitCode: 2}},
|
||||
{result: CommandResult{}},
|
||||
{result: CommandResult{}},
|
||||
},
|
||||
}
|
||||
_, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 9443)
|
||||
if err == nil {
|
||||
t.Fatal("firewalld 重新加载失败时初始化应失败")
|
||||
}
|
||||
if got := runner.calls[4].args; !reflect.DeepEqual(got, []string{"--permanent", "--remove-port=9443/tcp"}) {
|
||||
t.Fatalf("重新加载失败时应移除本次新增规则:%v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFirewalldStatePermissionFailureIsNotReportedAsDisabled(t *testing.T) {
|
||||
runner := &fakeRunner{
|
||||
paths: map[string]string{"firewall-cmd": "/usr/bin/firewall-cmd"},
|
||||
responses: []runnerResponse{{result: CommandResult{
|
||||
Output: []byte("Authorization failed"), ExitCode: 2,
|
||||
}}},
|
||||
}
|
||||
result, err := NewManagerForOS("linux", runner).OpenTCP(context.Background(), 8443)
|
||||
if err == nil {
|
||||
t.Fatalf("firewalld 权限错误不得被报告为未启用:%+v", result)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package firewall
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
windowsStatusScript = `$ErrorActionPreference='Stop'; if ((Get-NetFirewallProfile | Where-Object { $_.Enabled }).Count -gt 0) { Write-Output 'enabled' } else { Write-Output 'disabled' }`
|
||||
windowsQueryScript = `$ErrorActionPreference='Stop'; $rule=Get-NetFirewallRule -DisplayName $args[0] -ErrorAction SilentlyContinue; if ($null -eq $rule) { exit 3 }; exit 0`
|
||||
windowsAddScript = `$ErrorActionPreference='Stop'; New-NetFirewallRule -DisplayName $args[0] -Direction Inbound -Action Allow -Enabled True -Profile Any -Protocol TCP -LocalPort ([int]$args[1]) | Out-Null`
|
||||
windowsRemoveScript = `$ErrorActionPreference='Stop'; Remove-NetFirewallRule -DisplayName $args[0]`
|
||||
)
|
||||
|
||||
func (m *manager) openWindows(ctx context.Context, port int) (Result, error) {
|
||||
powershell, err := m.runner.LookPath("powershell.exe")
|
||||
if err != nil {
|
||||
return Result{}, fmt.Errorf("未找到 Windows PowerShell,无法配置本机防火墙:%w", err)
|
||||
}
|
||||
status, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsStatusScript)
|
||||
if err != nil || status.ExitCode != 0 {
|
||||
return Result{}, commandError("检查 Windows 防火墙状态", powershell, status, err)
|
||||
}
|
||||
if !strings.Contains(strings.ToLower(string(status.Output)), "enabled") {
|
||||
return Result{
|
||||
Backend: BackendNone, Port: port,
|
||||
Message: "Windows 防火墙当前未启用,无需创建主服务端口入站规则",
|
||||
}, nil
|
||||
}
|
||||
|
||||
name := ruleName(port)
|
||||
query, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsQueryScript, name)
|
||||
if err != nil {
|
||||
return Result{}, commandError("检查 Windows 防火墙规则", powershell, query, err)
|
||||
}
|
||||
if query.ExitCode == 0 {
|
||||
return Result{
|
||||
Backend: backendWindows, RuleName: name, Port: port,
|
||||
Message: fmt.Sprintf("Windows 防火墙规则已存在:%s", name),
|
||||
}, nil
|
||||
}
|
||||
if query.ExitCode != 3 {
|
||||
return Result{}, commandError("检查 Windows 防火墙规则", powershell, query, nil)
|
||||
}
|
||||
|
||||
added, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsAddScript, name, strconv.Itoa(port))
|
||||
if err != nil || added.ExitCode != 0 {
|
||||
return Result{}, commandError("创建 Windows 防火墙入站规则", powershell, added, err)
|
||||
}
|
||||
return Result{
|
||||
Backend: backendWindows, RuleName: name, Port: port, Created: true,
|
||||
Message: fmt.Sprintf("已创建 Windows 防火墙规则:%s", name),
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *manager) rollbackWindows(ctx context.Context, result Result) error {
|
||||
powershell, err := m.runner.LookPath("powershell.exe")
|
||||
if err != nil {
|
||||
return fmt.Errorf("未找到 Windows PowerShell,无法回滚防火墙规则:%w", err)
|
||||
}
|
||||
removed, err := m.runner.Run(ctx, powershell, "-NoProfile", "-NonInteractive", "-Command", windowsRemoveScript, result.RuleName)
|
||||
if err != nil || removed.ExitCode != 0 {
|
||||
return commandError("回滚 Windows 防火墙规则", powershell, removed, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -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"
|
||||
}`
|
||||
}
|
||||
@@ -2,13 +2,16 @@ package repository
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
type DomainRepository interface {
|
||||
Create(ctx context.Context, item domain.Domain) error
|
||||
Update(ctx context.Context, item domain.Domain) error
|
||||
GetByID(ctx context.Context, id string) (domain.Domain, error)
|
||||
List(ctx context.Context) ([]domain.Domain, error)
|
||||
Delete(ctx context.Context, id string) error
|
||||
UpdateCertificateState(ctx context.Context, id, status string, expiresAt *time.Time) error
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
@@ -28,20 +29,45 @@ func (r *SQLDomainRepository) Create(ctx context.Context, item domain.Domain) er
|
||||
return fmt.Errorf("编码 SAN 域名失败:%w", err)
|
||||
}
|
||||
_, err = r.db.ExecContext(ctx, `INSERT INTO domains
|
||||
(id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.Name, item.CertificateType, string(payload), item.Status,
|
||||
nullableTime(item.ExpiresAt), item.CreatedAt, item.UpdatedAt)
|
||||
(id, name, certificate_type, sans_json, auto_renew, acme_environment, dns_provider, status, expires_at, created_at, updated_at)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, item.ID, item.Name, item.CertificateType, string(payload), item.AutoRenew,
|
||||
item.ACMEEnvironment, item.DNSProvider, item.Status, nullableTime(item.ExpiresAt), item.CreatedAt, item.UpdatedAt)
|
||||
if err != nil {
|
||||
return fmt.Errorf("保存域名失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) Update(ctx context.Context, item domain.Domain) error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("数据库连接不能为空")
|
||||
}
|
||||
payload, err := json.Marshal(item.SANs)
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码 SAN 域名失败:%w", err)
|
||||
}
|
||||
result, err := r.db.ExecContext(ctx, `UPDATE domains SET
|
||||
name = ?, certificate_type = ?, sans_json = ?, auto_renew = ?, acme_environment = ?, dns_provider = ?, updated_at = ?
|
||||
WHERE id = ?`, item.Name, item.CertificateType, string(payload), item.AutoRenew, item.ACMEEnvironment,
|
||||
item.DNSProvider, item.UpdatedAt, item.ID)
|
||||
if err != nil {
|
||||
return fmt.Errorf("更新域名失败:%w", err)
|
||||
}
|
||||
count, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取更新结果失败:%w", err)
|
||||
}
|
||||
if count == 0 {
|
||||
return sql.ErrNoRows
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) GetByID(ctx context.Context, id string) (domain.Domain, error) {
|
||||
if r == nil || r.db == nil {
|
||||
return domain.Domain{}, errors.New("数据库连接不能为空")
|
||||
}
|
||||
row := r.db.QueryRowContext(ctx, `SELECT id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at
|
||||
row := r.db.QueryRowContext(ctx, `SELECT id, name, certificate_type, sans_json, auto_renew, acme_environment, dns_provider, status, expires_at, created_at, updated_at
|
||||
FROM domains WHERE id = ?`, id)
|
||||
return scanDomain(row)
|
||||
}
|
||||
@@ -50,7 +76,7 @@ func (r *SQLDomainRepository) List(ctx context.Context) ([]domain.Domain, error)
|
||||
if r == nil || r.db == nil {
|
||||
return nil, errors.New("数据库连接不能为空")
|
||||
}
|
||||
rows, err := r.db.QueryContext(ctx, `SELECT id, name, certificate_type, sans_json, status, expires_at, created_at, updated_at
|
||||
rows, err := r.db.QueryContext(ctx, `SELECT id, name, certificate_type, sans_json, auto_renew, acme_environment, dns_provider, status, expires_at, created_at, updated_at
|
||||
FROM domains ORDER BY name`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("查询域名失败:%w", err)
|
||||
@@ -88,6 +114,29 @@ func (r *SQLDomainRepository) Delete(ctx context.Context, id string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *SQLDomainRepository) UpdateCertificateState(ctx context.Context, id, status string, expiresAt *time.Time) error {
|
||||
if r == nil || r.db == nil {
|
||||
return errors.New("数据库连接不能为空")
|
||||
}
|
||||
status = strings.TrimSpace(status)
|
||||
if status == "" {
|
||||
return errors.New("证书状态不能为空")
|
||||
}
|
||||
result, err := r.db.ExecContext(ctx, `UPDATE domains SET status = ?, expires_at = ?, updated_at = ? WHERE id = ?`,
|
||||
status, nullableTime(expiresAt), time.Now().UTC(), id)
|
||||
if err != nil {
|
||||
return fmt.Errorf("更新证书状态失败:%w", err)
|
||||
}
|
||||
count, err := result.RowsAffected()
|
||||
if err != nil {
|
||||
return fmt.Errorf("读取证书状态更新结果失败:%w", err)
|
||||
}
|
||||
if count == 0 {
|
||||
return sql.ErrNoRows
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type scanner interface {
|
||||
Scan(dest ...any) error
|
||||
}
|
||||
@@ -96,8 +145,11 @@ func scanDomain(row scanner) (domain.Domain, error) {
|
||||
var item domain.Domain
|
||||
var certificateType string
|
||||
var sansJSON string
|
||||
var autoRenew bool
|
||||
var acmeEnvironment string
|
||||
var dnsProvider string
|
||||
var expiresAt sql.NullTime
|
||||
if err := row.Scan(&item.ID, &item.Name, &certificateType, &sansJSON, &item.Status, &expiresAt, &item.CreatedAt, &item.UpdatedAt); err != nil {
|
||||
if err := row.Scan(&item.ID, &item.Name, &certificateType, &sansJSON, &autoRenew, &acmeEnvironment, &dnsProvider, &item.Status, &expiresAt, &item.CreatedAt, &item.UpdatedAt); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return domain.Domain{}, sql.ErrNoRows
|
||||
}
|
||||
@@ -107,6 +159,9 @@ func scanDomain(row scanner) (domain.Domain, error) {
|
||||
return domain.Domain{}, fmt.Errorf("解析 SAN 域名失败:%w", err)
|
||||
}
|
||||
item.CertificateType = domain.CertificateType(certificateType)
|
||||
item.AutoRenew = autoRenew
|
||||
item.ACMEEnvironment = acmeEnvironment
|
||||
item.DNSProvider = dnsProvider
|
||||
if expiresAt.Valid {
|
||||
value := expiresAt.Time
|
||||
item.ExpiresAt = &value
|
||||
@@ -124,3 +179,13 @@ func nullableTime(value *time.Time) any {
|
||||
func IsNotFound(err error) bool {
|
||||
return err != nil && errors.Is(err, sql.ErrNoRows)
|
||||
}
|
||||
|
||||
func IsConflict(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
message := strings.ToLower(err.Error())
|
||||
return strings.Contains(message, "duplicate") ||
|
||||
strings.Contains(message, "unique constraint") ||
|
||||
strings.Contains(message, "constraint failed")
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import (
|
||||
"database/sql"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
@@ -65,6 +66,20 @@ func TestRepositoryCRUD(t *testing.T) {
|
||||
if loaded.Name != item.Name || len(loaded.SANs) != 2 {
|
||||
t.Fatalf("读取域名内容不正确:%+v", loaded)
|
||||
}
|
||||
item.Name = "www.example.com"
|
||||
item.CertificateType = domain.CertificateSingle
|
||||
item.SANs = []string{"www.example.com"}
|
||||
item.AutoRenew = false
|
||||
item.ACMEEnvironment = domain.ACMEEnvironmentProduction
|
||||
item.DNSProvider = "cloudflare"
|
||||
item.UpdatedAt = item.UpdatedAt.Add(time.Minute)
|
||||
if err := repo.Update(context.Background(), item); err != nil {
|
||||
t.Fatalf("更新域名失败:%v", err)
|
||||
}
|
||||
loaded, err = repo.GetByID(context.Background(), item.ID)
|
||||
if err != nil || loaded.Name != item.Name || loaded.AutoRenew || loaded.ACMEEnvironment != domain.ACMEEnvironmentProduction || loaded.DNSProvider != "cloudflare" {
|
||||
t.Fatalf("更新后的域名内容不正确:%v,%+v", err, loaded)
|
||||
}
|
||||
items, err := repo.List(context.Background())
|
||||
if err != nil || len(items) != 1 {
|
||||
t.Fatalf("域名列表不正确:%v,%+v", err, items)
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
package secretstore
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const storeVersion = 1
|
||||
|
||||
type encryptedItem struct {
|
||||
Nonce string `json:"nonce"`
|
||||
Ciphertext string `json:"ciphertext"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
}
|
||||
|
||||
type fileData struct {
|
||||
Version int `json:"version"`
|
||||
Items map[string]encryptedItem `json:"items"`
|
||||
}
|
||||
|
||||
type Store struct {
|
||||
mu sync.Mutex
|
||||
key []byte
|
||||
filePath string
|
||||
}
|
||||
|
||||
func Open(configDir string) (*Store, error) {
|
||||
if configDir == "" {
|
||||
return nil, errors.New("敏感信息目录不能为空")
|
||||
}
|
||||
if err := os.MkdirAll(configDir, 0o700); err != nil {
|
||||
return nil, fmt.Errorf("创建敏感信息目录失败:%w", err)
|
||||
}
|
||||
key, err := loadOrCreateKey(filepath.Join(configDir, "master.key"))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Store{key: key, filePath: filepath.Join(configDir, "secrets.json")}, nil
|
||||
}
|
||||
|
||||
func (s *Store) Put(ctx context.Context, reference string, value map[string]string) error {
|
||||
if s == nil {
|
||||
return errors.New("敏感信息存储未初始化")
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return err
|
||||
}
|
||||
if reference == "" {
|
||||
return errors.New("敏感信息引用不能为空")
|
||||
}
|
||||
plaintext, err := json.Marshal(value)
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码敏感信息失败:%w", err)
|
||||
}
|
||||
block, err := aes.NewCipher(s.key)
|
||||
if err != nil {
|
||||
return fmt.Errorf("初始化敏感信息加密器失败:%w", err)
|
||||
}
|
||||
gcm, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return fmt.Errorf("初始化敏感信息加密模式失败:%w", err)
|
||||
}
|
||||
nonce := make([]byte, gcm.NonceSize())
|
||||
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
|
||||
return fmt.Errorf("生成敏感信息随机数失败:%w", err)
|
||||
}
|
||||
ciphertext := gcm.Seal(nil, nonce, plaintext, []byte(reference))
|
||||
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
data, err := s.readLocked()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
data.Items[reference] = encryptedItem{
|
||||
Nonce: base64.RawStdEncoding.EncodeToString(nonce),
|
||||
Ciphertext: base64.RawStdEncoding.EncodeToString(ciphertext),
|
||||
UpdatedAt: time.Now().UTC(),
|
||||
}
|
||||
return s.writeLocked(data)
|
||||
}
|
||||
|
||||
func (s *Store) Get(ctx context.Context, reference string) (map[string]string, error) {
|
||||
if s == nil {
|
||||
return nil, errors.New("敏感信息存储未初始化")
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
data, err := s.readLocked()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
item, ok := data.Items[reference]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("敏感信息引用不存在:%s", reference)
|
||||
}
|
||||
nonce, err := base64.RawStdEncoding.DecodeString(item.Nonce)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("解析敏感信息随机数失败:%w", err)
|
||||
}
|
||||
ciphertext, err := base64.RawStdEncoding.DecodeString(item.Ciphertext)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("解析敏感信息密文失败:%w", err)
|
||||
}
|
||||
block, err := aes.NewCipher(s.key)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("初始化敏感信息解密器失败:%w", err)
|
||||
}
|
||||
gcm, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("初始化敏感信息解密模式失败:%w", err)
|
||||
}
|
||||
plaintext, err := gcm.Open(nil, nonce, ciphertext, []byte(reference))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("解密敏感信息失败:%w", err)
|
||||
}
|
||||
var result map[string]string
|
||||
if err := json.Unmarshal(plaintext, &result); err != nil {
|
||||
return nil, fmt.Errorf("解析敏感信息失败:%w", err)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// Has 检查敏感信息引用是否存在,但不解密内容。
|
||||
func (s *Store) Has(ctx context.Context, reference string) (bool, error) {
|
||||
if s == nil {
|
||||
return false, errors.New("敏感信息存储未初始化")
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if reference == "" {
|
||||
return false, errors.New("敏感信息引用不能为空")
|
||||
}
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
data, err := s.readLocked()
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
_, ok := data.Items[reference]
|
||||
return ok, nil
|
||||
}
|
||||
|
||||
func (s *Store) readLocked() (fileData, error) {
|
||||
data := fileData{Version: storeVersion, Items: map[string]encryptedItem{}}
|
||||
content, err := os.ReadFile(s.filePath)
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
return data, nil
|
||||
}
|
||||
if err != nil {
|
||||
return fileData{}, fmt.Errorf("读取敏感信息文件失败:%w", err)
|
||||
}
|
||||
if err := json.Unmarshal(content, &data); err != nil {
|
||||
return fileData{}, fmt.Errorf("解析敏感信息文件失败:%w", err)
|
||||
}
|
||||
if data.Version != storeVersion {
|
||||
return fileData{}, fmt.Errorf("敏感信息文件版本不兼容:%d", data.Version)
|
||||
}
|
||||
if data.Items == nil {
|
||||
data.Items = map[string]encryptedItem{}
|
||||
}
|
||||
return data, nil
|
||||
}
|
||||
|
||||
func (s *Store) writeLocked(data fileData) error {
|
||||
content, err := json.MarshalIndent(data, "", " ")
|
||||
if err != nil {
|
||||
return fmt.Errorf("编码敏感信息文件失败:%w", err)
|
||||
}
|
||||
content = append(content, '\n')
|
||||
if err := writeAtomicFile(s.filePath, content, 0o600, os.Rename); err != nil {
|
||||
return fmt.Errorf("写入敏感信息文件失败:%w", err)
|
||||
}
|
||||
if err := os.Chmod(s.filePath, 0o600); err != nil {
|
||||
return fmt.Errorf("设置敏感信息文件权限失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func writeAtomicFile(path string, content []byte, mode fs.FileMode, renameFile func(string, string) error) error {
|
||||
if renameFile == nil {
|
||||
renameFile = os.Rename
|
||||
}
|
||||
directory := filepath.Dir(path)
|
||||
temporary, err := os.CreateTemp(directory, "."+filepath.Base(path)+".tmp-*")
|
||||
if err != nil {
|
||||
return fmt.Errorf("创建敏感信息临时文件失败:%w", err)
|
||||
}
|
||||
temporaryPath := temporary.Name()
|
||||
closed := false
|
||||
committed := false
|
||||
defer func() {
|
||||
if !closed {
|
||||
_ = temporary.Close()
|
||||
}
|
||||
if !committed {
|
||||
_ = os.Remove(temporaryPath)
|
||||
}
|
||||
}()
|
||||
if err := temporary.Chmod(mode); err != nil {
|
||||
return fmt.Errorf("设置敏感信息临时文件权限失败:%w", err)
|
||||
}
|
||||
if _, err := temporary.Write(content); err != nil {
|
||||
return fmt.Errorf("写入敏感信息临时文件失败:%w", err)
|
||||
}
|
||||
if err := temporary.Sync(); err != nil {
|
||||
return fmt.Errorf("同步敏感信息临时文件失败:%w", err)
|
||||
}
|
||||
if err := temporary.Close(); err != nil {
|
||||
closed = true
|
||||
return fmt.Errorf("关闭敏感信息临时文件失败:%w", err)
|
||||
}
|
||||
closed = true
|
||||
if err := renameFile(temporaryPath, path); err != nil {
|
||||
return fmt.Errorf("原子替换敏感信息文件失败:%w", err)
|
||||
}
|
||||
committed = true
|
||||
if err := syncDirectory(directory); err != nil {
|
||||
return fmt.Errorf("同步敏感信息目录失败:%w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func syncDirectory(path string) error {
|
||||
if runtime.GOOS == "windows" {
|
||||
return nil
|
||||
}
|
||||
directory, err := os.Open(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer directory.Close()
|
||||
return directory.Sync()
|
||||
}
|
||||
func loadOrCreateKey(path string) ([]byte, error) {
|
||||
content, err := os.ReadFile(path)
|
||||
if err == nil {
|
||||
key, decodeErr := base64.RawStdEncoding.DecodeString(string(content))
|
||||
if decodeErr != nil || len(key) != 32 {
|
||||
return nil, errors.New("配置主密钥格式无效")
|
||||
}
|
||||
if chmodErr := os.Chmod(path, 0o600); chmodErr != nil {
|
||||
return nil, fmt.Errorf("收紧配置主密钥权限失败:%w", chmodErr)
|
||||
}
|
||||
return key, nil
|
||||
}
|
||||
if !errors.Is(err, os.ErrNotExist) {
|
||||
return nil, fmt.Errorf("读取配置主密钥失败:%w", err)
|
||||
}
|
||||
key := make([]byte, 32)
|
||||
if _, err := io.ReadFull(rand.Reader, key); err != nil {
|
||||
return nil, fmt.Errorf("生成配置主密钥失败:%w", err)
|
||||
}
|
||||
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("创建配置主密钥失败:%w", err)
|
||||
}
|
||||
encoded := base64.RawStdEncoding.EncodeToString(key)
|
||||
if _, err := file.WriteString(encoded); err != nil {
|
||||
_ = file.Close()
|
||||
return nil, fmt.Errorf("写入配置主密钥失败:%w", err)
|
||||
}
|
||||
if err := file.Close(); err != nil {
|
||||
return nil, fmt.Errorf("关闭配置主密钥文件失败:%w", err)
|
||||
}
|
||||
return key, nil
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
package secretstore
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestStoreEncryptsAndRestoresValues(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
store, err := Open(directory)
|
||||
if err != nil {
|
||||
t.Fatalf("打开敏感信息存储失败:%v", err)
|
||||
}
|
||||
reference := "secret://dns/cloudflare/test"
|
||||
secret := "plain-api-token"
|
||||
if err := store.Put(t.Context(), reference, map[string]string{"api_token": secret}); err != nil {
|
||||
t.Fatalf("保存敏感信息失败:%v", err)
|
||||
}
|
||||
content, err := os.ReadFile(filepath.Join(directory, "secrets.json"))
|
||||
if err != nil {
|
||||
t.Fatalf("读取敏感信息文件失败:%v", err)
|
||||
}
|
||||
if strings.Contains(string(content), secret) {
|
||||
t.Fatal("敏感信息文件中不应出现明文凭据")
|
||||
}
|
||||
value, err := store.Get(t.Context(), reference)
|
||||
if err != nil {
|
||||
t.Fatalf("读取敏感信息失败:%v", err)
|
||||
}
|
||||
if value["api_token"] != secret {
|
||||
t.Fatalf("敏感信息解密结果不正确:%v", value)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStoreSupportsMultipleUpdates(t *testing.T) {
|
||||
store, err := Open(t.TempDir())
|
||||
if err != nil {
|
||||
t.Fatalf("打开敏感信息存储失败:%v", err)
|
||||
}
|
||||
if err := store.Put(t.Context(), "secret://dns/cloudflare/one", map[string]string{"api_token": "first"}); err != nil {
|
||||
t.Fatalf("第一次保存失败:%v", err)
|
||||
}
|
||||
if err := store.Put(t.Context(), "secret://dns/cloudflare/two", map[string]string{"api_token": "second"}); err != nil {
|
||||
t.Fatalf("第二次保存失败:%v", err)
|
||||
}
|
||||
value, err := store.Get(t.Context(), "secret://dns/cloudflare/one")
|
||||
if err != nil || value["api_token"] != "first" {
|
||||
t.Fatalf("多次保存后读取失败:value=%v err=%v", value, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteAtomicFileReplacesExistingFile(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
path := filepath.Join(directory, "secrets.json")
|
||||
if err := os.WriteFile(path, []byte("old"), 0o600); err != nil {
|
||||
t.Fatalf("写入旧敏感信息文件失败:%v", err)
|
||||
}
|
||||
if err := writeAtomicFile(path, []byte("new"), 0o600, os.Rename); err != nil {
|
||||
t.Fatalf("原子替换敏感信息文件失败:%v", err)
|
||||
}
|
||||
content, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取替换后的敏感信息文件失败:%v", err)
|
||||
}
|
||||
if string(content) != "new" {
|
||||
t.Fatalf("敏感信息文件内容未更新:%q", content)
|
||||
}
|
||||
assertNoSecretTempFiles(t, directory)
|
||||
}
|
||||
|
||||
func TestWriteAtomicFileKeepsOldFileWhenRenameFails(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
path := filepath.Join(directory, "secrets.json")
|
||||
if err := os.WriteFile(path, []byte("old"), 0o600); err != nil {
|
||||
t.Fatalf("写入旧敏感信息文件失败:%v", err)
|
||||
}
|
||||
err := writeAtomicFile(path, []byte("new"), 0o600, func(string, string) error {
|
||||
return errors.New("模拟替换失败")
|
||||
})
|
||||
if err == nil || !strings.Contains(err.Error(), "原子替换敏感信息文件失败") {
|
||||
t.Fatalf("应返回原子替换错误:%v", err)
|
||||
}
|
||||
content, readErr := os.ReadFile(path)
|
||||
if readErr != nil {
|
||||
t.Fatalf("读取旧敏感信息文件失败:%v", readErr)
|
||||
}
|
||||
if string(content) != "old" {
|
||||
t.Fatalf("替换失败后旧文件不应被破坏:%q", content)
|
||||
}
|
||||
assertNoSecretTempFiles(t, directory)
|
||||
}
|
||||
|
||||
func TestStoreSecretFileUsesRestrictedPermissions(t *testing.T) {
|
||||
if os.PathSeparator == '\\' {
|
||||
t.Skip("Windows 文件权限由 ACL 控制")
|
||||
}
|
||||
directory := t.TempDir()
|
||||
store, err := Open(directory)
|
||||
if err != nil {
|
||||
t.Fatalf("打开敏感信息存储失败:%v", err)
|
||||
}
|
||||
if err := store.Put(t.Context(), "secret://dns/cloudflare/mode", map[string]string{"api_token": "token"}); err != nil {
|
||||
t.Fatalf("保存敏感信息失败:%v", err)
|
||||
}
|
||||
info, err := os.Stat(filepath.Join(directory, "secrets.json"))
|
||||
if err != nil {
|
||||
t.Fatalf("读取敏感信息文件权限失败:%v", err)
|
||||
}
|
||||
if info.Mode().Perm() != 0o600 {
|
||||
t.Fatalf("敏感信息文件权限应为 0600,实际为 %o", info.Mode().Perm())
|
||||
}
|
||||
}
|
||||
|
||||
func assertNoSecretTempFiles(t *testing.T, directory string) {
|
||||
t.Helper()
|
||||
matches, err := filepath.Glob(filepath.Join(directory, ".secrets.json.tmp-*"))
|
||||
if err != nil {
|
||||
t.Fatalf("检查敏感信息临时文件失败:%v", err)
|
||||
}
|
||||
if len(matches) != 0 {
|
||||
t.Fatalf("不应残留敏感信息临时文件:%v", matches)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
package setup
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
)
|
||||
|
||||
const dnsVerificationLifetime = 15 * time.Minute
|
||||
|
||||
type DNSCredentialTester interface {
|
||||
Verify(ctx context.Context, providerID, testDomain string, credentials map[string]string) error
|
||||
}
|
||||
|
||||
type SecretWriter interface {
|
||||
Put(ctx context.Context, reference string, value map[string]string) error
|
||||
}
|
||||
|
||||
type DNSVerificationInput struct {
|
||||
ProviderID string
|
||||
TestDomain string
|
||||
Credentials map[string]string
|
||||
}
|
||||
|
||||
type DNSVerificationResult struct {
|
||||
CredentialRef string
|
||||
VerificationToken string
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
type dnsVerificationSession struct {
|
||||
ProviderID string
|
||||
TestDomain string
|
||||
CredentialRef string
|
||||
ExpiresAt time.Time
|
||||
}
|
||||
|
||||
type DNSVerificationManager struct {
|
||||
mu sync.Mutex
|
||||
tester DNSCredentialTester
|
||||
store SecretWriter
|
||||
now func() time.Time
|
||||
sessions map[string]dnsVerificationSession
|
||||
}
|
||||
|
||||
func NewDNSVerificationManager(tester DNSCredentialTester, store SecretWriter) *DNSVerificationManager {
|
||||
return &DNSVerificationManager{
|
||||
tester: tester, store: store, now: time.Now,
|
||||
sessions: make(map[string]dnsVerificationSession),
|
||||
}
|
||||
}
|
||||
|
||||
func (m *DNSVerificationManager) Verify(ctx context.Context, input DNSVerificationInput) (DNSVerificationResult, error) {
|
||||
if m == nil || m.tester == nil || m.store == nil {
|
||||
return DNSVerificationResult{}, errors.New("DNS 在线验证服务未初始化")
|
||||
}
|
||||
providerID := strings.ToLower(strings.TrimSpace(input.ProviderID))
|
||||
testDomain := normalizeTestDomain(input.TestDomain)
|
||||
if providerID == "" {
|
||||
return DNSVerificationResult{}, errors.New("DNS 服务商不能为空")
|
||||
}
|
||||
if !domain.IsValidName(testDomain) {
|
||||
return DNSVerificationResult{}, fmt.Errorf("DNS 测试域名格式无效:%s", testDomain)
|
||||
}
|
||||
if err := m.tester.Verify(ctx, providerID, testDomain, input.Credentials); err != nil {
|
||||
return DNSVerificationResult{}, err
|
||||
}
|
||||
credentialID, err := secureToken(18)
|
||||
if err != nil {
|
||||
return DNSVerificationResult{}, fmt.Errorf("生成 DNS 凭据引用失败:%w", err)
|
||||
}
|
||||
credentialRef := fmt.Sprintf("secret://dns/%s/%s", providerID, credentialID)
|
||||
if err := m.store.Put(ctx, credentialRef, input.Credentials); err != nil {
|
||||
return DNSVerificationResult{}, fmt.Errorf("加密保存 DNS 凭据失败:%w", err)
|
||||
}
|
||||
verificationToken, err := secureToken(32)
|
||||
if err != nil {
|
||||
return DNSVerificationResult{}, fmt.Errorf("生成 DNS 验证令牌失败:%w", err)
|
||||
}
|
||||
expiresAt := m.now().UTC().Add(dnsVerificationLifetime)
|
||||
m.mu.Lock()
|
||||
m.clearExpiredLocked(m.now().UTC())
|
||||
m.sessions[verificationToken] = dnsVerificationSession{
|
||||
ProviderID: providerID, TestDomain: testDomain,
|
||||
CredentialRef: credentialRef, ExpiresAt: expiresAt,
|
||||
}
|
||||
m.mu.Unlock()
|
||||
return DNSVerificationResult{
|
||||
CredentialRef: credentialRef, VerificationToken: verificationToken, ExpiresAt: expiresAt,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (m *DNSVerificationManager) Check(token, providerID, credentialRef, testDomain string) error {
|
||||
return m.validateSession(token, providerID, credentialRef, testDomain, false)
|
||||
}
|
||||
|
||||
func (m *DNSVerificationManager) Consume(token, providerID, credentialRef, testDomain string) error {
|
||||
return m.validateSession(token, providerID, credentialRef, testDomain, true)
|
||||
}
|
||||
|
||||
func (m *DNSVerificationManager) validateSession(token, providerID, credentialRef, testDomain string, consume bool) error {
|
||||
if m == nil {
|
||||
return errors.New("DNS 在线验证服务未初始化")
|
||||
}
|
||||
token = strings.TrimSpace(token)
|
||||
if token == "" {
|
||||
return errors.New("必须先完成 DNS API 在线验证")
|
||||
}
|
||||
now := m.now().UTC()
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.clearExpiredLocked(now)
|
||||
session, ok := m.sessions[token]
|
||||
if !ok {
|
||||
return errors.New("DNS 验证令牌无效或已经过期,请重新测试")
|
||||
}
|
||||
if session.ProviderID != strings.ToLower(strings.TrimSpace(providerID)) ||
|
||||
session.CredentialRef != strings.TrimSpace(credentialRef) ||
|
||||
session.TestDomain != normalizeTestDomain(testDomain) {
|
||||
return errors.New("DNS 验证结果与当前配置不匹配,请重新测试")
|
||||
}
|
||||
if consume {
|
||||
delete(m.sessions, token)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *DNSVerificationManager) clearExpiredLocked(now time.Time) {
|
||||
for token, session := range m.sessions {
|
||||
if !session.ExpiresAt.After(now) {
|
||||
delete(m.sessions, token)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func normalizeTestDomain(value string) string {
|
||||
return strings.ToLower(strings.TrimSuffix(strings.TrimSpace(value), "."))
|
||||
}
|
||||
|
||||
func secureToken(size int) (string, error) {
|
||||
value := make([]byte, size)
|
||||
if _, err := rand.Read(value); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return base64.RawURLEncoding.EncodeToString(value), nil
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package setup
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
type fakeDNSTester struct {
|
||||
err error
|
||||
}
|
||||
|
||||
func (f fakeDNSTester) Verify(context.Context, string, string, map[string]string) error {
|
||||
return f.err
|
||||
}
|
||||
|
||||
type memorySecretWriter struct {
|
||||
values map[string]map[string]string
|
||||
}
|
||||
|
||||
func (m *memorySecretWriter) Put(_ context.Context, reference string, value map[string]string) error {
|
||||
if m.values == nil {
|
||||
m.values = map[string]map[string]string{}
|
||||
}
|
||||
m.values[reference] = value
|
||||
return nil
|
||||
}
|
||||
|
||||
func TestDNSVerificationManagerIssuesOneTimeToken(t *testing.T) {
|
||||
store := &memorySecretWriter{}
|
||||
manager := NewDNSVerificationManager(fakeDNSTester{}, store)
|
||||
result, err := manager.Verify(t.Context(), DNSVerificationInput{
|
||||
ProviderID: "cloudflare", TestDomain: "example.com",
|
||||
Credentials: map[string]string{"api_token": "secret"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("DNS 在线验证失败:%v", err)
|
||||
}
|
||||
if result.CredentialRef == "" || result.VerificationToken == "" {
|
||||
t.Fatalf("DNS 验证结果不完整:%+v", result)
|
||||
}
|
||||
if len(store.values) != 1 {
|
||||
t.Fatalf("DNS 凭据没有写入敏感信息存储:%v", store.values)
|
||||
}
|
||||
if err := manager.Check(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err != nil {
|
||||
t.Fatalf("检查 DNS 验证令牌失败:%v", err)
|
||||
}
|
||||
if err := manager.Check(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err != nil {
|
||||
t.Fatalf("检查 DNS 验证令牌不应消费令牌:%v", err)
|
||||
}
|
||||
if err := manager.Consume(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err != nil {
|
||||
t.Fatalf("消费 DNS 验证令牌失败:%v", err)
|
||||
}
|
||||
if err := manager.Check(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err == nil {
|
||||
t.Fatal("已消费的 DNS 验证令牌不应继续通过检查")
|
||||
}
|
||||
if err := manager.Consume(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err == nil {
|
||||
t.Fatal("DNS 验证令牌只能使用一次")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDNSVerificationManagerRejectsMismatchedConfiguration(t *testing.T) {
|
||||
manager := NewDNSVerificationManager(fakeDNSTester{}, &memorySecretWriter{})
|
||||
result, err := manager.Verify(t.Context(), DNSVerificationInput{
|
||||
ProviderID: "cloudflare", TestDomain: "example.com",
|
||||
Credentials: map[string]string{"api_token": "secret"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("DNS 在线验证失败:%v", err)
|
||||
}
|
||||
if err := manager.Consume(result.VerificationToken, "cloudflare", result.CredentialRef, "other.example.com"); err == nil {
|
||||
t.Fatal("DNS 验证结果不应允许绑定到其他域名")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDNSVerificationManagerRejectsExpiredToken(t *testing.T) {
|
||||
manager := NewDNSVerificationManager(fakeDNSTester{}, &memorySecretWriter{})
|
||||
now := time.Date(2026, 8, 26, 8, 0, 0, 0, time.UTC)
|
||||
manager.now = func() time.Time { return now }
|
||||
result, err := manager.Verify(t.Context(), DNSVerificationInput{
|
||||
ProviderID: "cloudflare", TestDomain: "example.com",
|
||||
Credentials: map[string]string{"api_token": "secret"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("DNS 在线验证失败:%v", err)
|
||||
}
|
||||
now = now.Add(dnsVerificationLifetime + time.Second)
|
||||
if err := manager.Consume(result.VerificationToken, "cloudflare", result.CredentialRef, "example.com"); err == nil {
|
||||
t.Fatal("过期 DNS 验证令牌应被拒绝")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDNSVerificationManagerDoesNotStoreFailedCredential(t *testing.T) {
|
||||
store := &memorySecretWriter{}
|
||||
manager := NewDNSVerificationManager(fakeDNSTester{err: errors.New("权限不足")}, store)
|
||||
_, err := manager.Verify(t.Context(), DNSVerificationInput{
|
||||
ProviderID: "cloudflare", TestDomain: "example.com",
|
||||
Credentials: map[string]string{"api_token": "secret"},
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("DNS 测试失败时应返回错误")
|
||||
}
|
||||
if len(store.values) != 0 {
|
||||
t.Fatal("DNS 测试失败时不应保存凭据")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
package setup
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
type Input struct {
|
||||
AdminUsername string
|
||||
AdminPassword string
|
||||
ServerPort int
|
||||
ResetServicePort int
|
||||
EmailProvider string
|
||||
EmailEndpoint string
|
||||
EmailRecipients []string
|
||||
DNSProvider string
|
||||
DNSCredentialRef string
|
||||
DNSVerified bool
|
||||
CertificateRoot string
|
||||
WebHostname string
|
||||
WebPublicIP string
|
||||
WebEnabled bool
|
||||
HTTPSMode string
|
||||
}
|
||||
|
||||
func Apply(cfg *config.Config, input Input) error {
|
||||
if cfg == nil {
|
||||
return fmt.Errorf("配置不能为空")
|
||||
}
|
||||
if strings.TrimSpace(input.AdminUsername) == "" {
|
||||
return fmt.Errorf("超级管理员用户名不能为空")
|
||||
}
|
||||
if len(input.AdminPassword) < 8 {
|
||||
return fmt.Errorf("超级管理员密码至少需要 8 个字符")
|
||||
}
|
||||
if input.ServerPort < 1 || input.ServerPort > 65535 {
|
||||
return fmt.Errorf("主服务端口无效:%d", input.ServerPort)
|
||||
}
|
||||
if input.ResetServicePort < 1 || input.ResetServicePort > 65535 {
|
||||
return fmt.Errorf("密码重置服务端口无效:%d", input.ResetServicePort)
|
||||
}
|
||||
if input.ServerPort == input.ResetServicePort {
|
||||
return fmt.Errorf("主服务和密码重置服务不能使用相同端口")
|
||||
}
|
||||
if strings.TrimSpace(input.DNSProvider) == "" {
|
||||
return fmt.Errorf("DNS 服务商不能为空")
|
||||
}
|
||||
if strings.TrimSpace(input.DNSCredentialRef) == "" {
|
||||
return fmt.Errorf("DNS 凭据引用不能为空;明文密钥不会直接写入配置文件")
|
||||
}
|
||||
if !input.DNSVerified {
|
||||
return fmt.Errorf("DNS API 尚未通过验证测试")
|
||||
}
|
||||
if strings.TrimSpace(input.WebHostname) == "" && strings.TrimSpace(input.WebPublicIP) == "" {
|
||||
return fmt.Errorf("Web 页面必须配置域名或公网 IP")
|
||||
}
|
||||
if input.WebHostname != "" && input.WebPublicIP != "" {
|
||||
return fmt.Errorf("Web 页面不能同时配置域名和公网 IP")
|
||||
}
|
||||
if input.WebPublicIP != "" && net.ParseIP(input.WebPublicIP) == nil {
|
||||
return fmt.Errorf("Web 公网 IP 格式无效")
|
||||
}
|
||||
if input.HTTPSMode == "" {
|
||||
input.HTTPSMode = "direct"
|
||||
}
|
||||
if input.HTTPSMode != "direct" && input.HTTPSMode != "proxy" {
|
||||
return fmt.Errorf("HTTPS 模式无效:%s", input.HTTPSMode)
|
||||
}
|
||||
if strings.TrimSpace(input.CertificateRoot) == "" {
|
||||
input.CertificateRoot = cfg.Paths.Certificate
|
||||
}
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte(input.AdminPassword), bcrypt.DefaultCost)
|
||||
if err != nil {
|
||||
return fmt.Errorf("生成管理员密码摘要失败:%w", err)
|
||||
}
|
||||
cfg.Admin.Username = strings.TrimSpace(input.AdminUsername)
|
||||
cfg.Admin.PasswordHash = string(hash)
|
||||
cfg.Admin.ResetServicePort = input.ResetServicePort
|
||||
cfg.Server.Port = input.ServerPort
|
||||
cfg.Server.HTTPSMode = input.HTTPSMode
|
||||
cfg.Web.Enabled = input.WebEnabled
|
||||
cfg.Web.Hostname = strings.TrimSpace(input.WebHostname)
|
||||
cfg.Web.PublicIP = strings.TrimSpace(input.WebPublicIP)
|
||||
cfg.Web.InitReady = true
|
||||
cfg.Paths.Certificate = strings.TrimSpace(input.CertificateRoot)
|
||||
cfg.DNS.Provider = strings.TrimSpace(input.DNSProvider)
|
||||
cfg.DNS.CredentialRef = strings.TrimSpace(input.DNSCredentialRef)
|
||||
cfg.DNS.VerificationState = "verified"
|
||||
cfg.Notification.Provider = strings.TrimSpace(input.EmailProvider)
|
||||
cfg.Notification.Endpoint = strings.TrimSpace(input.EmailEndpoint)
|
||||
cfg.Notification.Recipients = cleanRecipients(input.EmailRecipients)
|
||||
cfg.SetupReady = true
|
||||
return cfg.Validate()
|
||||
}
|
||||
|
||||
func cleanRecipients(values []string) []string {
|
||||
items := make([]string, 0, len(values))
|
||||
seen := make(map[string]struct{}, len(values))
|
||||
for _, value := range values {
|
||||
for _, part := range strings.Split(value, ",") {
|
||||
part = strings.TrimSpace(part)
|
||||
if part == "" {
|
||||
continue
|
||||
}
|
||||
if _, ok := seen[part]; ok {
|
||||
continue
|
||||
}
|
||||
seen[part] = struct{}{}
|
||||
items = append(items, part)
|
||||
}
|
||||
}
|
||||
return items
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package setup
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
)
|
||||
|
||||
func TestApplyRequiresVerifiedDNS(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
err := Apply(&cfg, Input{
|
||||
AdminUsername: "admin", AdminPassword: "password123", ServerPort: 8080, ResetServicePort: 8091,
|
||||
DNSProvider: "cloudflare", DNSCredentialRef: "credential-1", CertificateRoot: cfg.Paths.Certificate,
|
||||
WebHostname: "panel.example.com", WebEnabled: true,
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("未通过 DNS 验证时不应完成初始化")
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyBuildsReadyConfig(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
err := Apply(&cfg, Input{
|
||||
AdminUsername: "admin", AdminPassword: "password123", ServerPort: 8080, ResetServicePort: 8091,
|
||||
EmailProvider: "mail-api", EmailEndpoint: "https://mail.example.test/send", EmailRecipients: []string{"a@example.test,b@example.test", "a@example.test"},
|
||||
DNSProvider: "cloudflare", DNSCredentialRef: "credential-1", DNSVerified: true, CertificateRoot: cfg.Paths.Certificate,
|
||||
WebHostname: "panel.example.com", WebEnabled: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("初始化配置失败:%v", err)
|
||||
}
|
||||
if !cfg.SetupReady || cfg.DNS.VerificationState != "verified" || cfg.Admin.Username != "admin" {
|
||||
t.Fatalf("初始化状态不正确:%+v", cfg)
|
||||
}
|
||||
if len(cfg.Notification.Recipients) != 2 {
|
||||
t.Fatalf("收件人去重失败:%v", cfg.Notification.Recipients)
|
||||
}
|
||||
if cfg.Admin.PasswordHash == "password123" || cfg.Admin.PasswordHash == "" {
|
||||
t.Fatal("管理员密码不应明文保存")
|
||||
}
|
||||
}
|
||||
|
||||
func TestApplyRejectsWebIPAsHostnamePair(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
err := Apply(&cfg, Input{
|
||||
AdminUsername: "admin", AdminPassword: "password123", ServerPort: 8080, ResetServicePort: 8091,
|
||||
DNSProvider: "cloudflare", DNSCredentialRef: "credential-1", DNSVerified: true,
|
||||
WebHostname: "panel.example.com", WebPublicIP: "203.0.113.10", WebEnabled: true,
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("域名和公网 IP 同时配置时应被拒绝")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user