生产部署整改阶段检查点

This commit is contained in:
xuans committed 2026-08-31 23:33:56 +08:00
1 parent f3348cf95d
commit 92d4b3d398
56 files changed
+4178 -240

No files matched your search

+675
View File
@@ -0,0 +1,675 @@
package cli
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path/filepath"
"runtime"
"sort"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
)
const backupManifestVersion = 1
type backupManifest struct {
Version int `json:"version"`
CreatedAt time.Time `json:"created_at"`
Files []backupManifestFile `json:"files"`
}
type backupManifestFile struct {
Path string `json:"path"`
Mode uint32 `json:"mode"`
Size int64 `json:"size"`
SHA256 string `json:"sha256"`
}
func createBackup(ctx context.Context, cfg config.Config, configPath, output string) error {
output = filepath.Clean(output)
if err := ensureBackupDestination(output); err != nil {
return err
}
parent := filepath.Dir(output)
if err := os.MkdirAll(parent, 0o700); err != nil {
return fmt.Errorf("创建备份父目录失败:%w", err)
}
parentInfo, err := os.Lstat(parent)
if err != nil {
return fmt.Errorf("检查备份父目录失败:%w", err)
}
if parentInfo.Mode()&os.ModeSymlink != 0 || !parentInfo.IsDir() {
return errors.New("备份父路径必须是普通目录")
}
staging, err := os.MkdirTemp(parent, ".scert-backup-")
if err != nil {
return fmt.Errorf("创建备份暂存目录失败:%w", err)
}
completed := false
defer func() {
if !completed {
_ = os.RemoveAll(staging)
}
}()
if err := os.Chmod(staging, 0o700); err != nil {
return fmt.Errorf("设置备份暂存目录权限失败:%w", err)
}
if err := copyFileExclusive(configPath, filepath.Join(staging, "scert.json"), 0o600); err != nil {
return err
}
if err := validateBackupSecretStore(ctx, cfg.Paths.Config, cfg); err != nil {
return err
}
for _, name := range []string{"master.key", "secrets.json"} {
source := filepath.Join(cfg.Paths.Config, name)
info, statErr := os.Lstat(source)
if statErr == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
return fmt.Errorf("敏感配置文件不是普通文件:%s", name)
}
if err := copyFileExclusive(source, filepath.Join(staging, name), 0o600); err != nil {
return err
}
continue
}
if !errors.Is(statErr, os.ErrNotExist) {
return fmt.Errorf("检查敏感配置文件失败:%w", statErr)
}
if cfg.SetupReady {
return fmt.Errorf("已初始化配置缺少敏感配置文件:%s", name)
}
}
if cfg.Database.Driver == "sqlite" {
_, memory, err := sqliteDatabasePath(cfg.Database.DSN)
if err != nil {
return err
}
if !memory {
if err := backupSQLiteDatabase(ctx, cfg, filepath.Join(staging, "scert.db")); err != nil {
return err
}
}
}
if cfg.Database.Driver == "mysql" {
if err := backupMySQL(ctx, cfg, filepath.Join(staging, "scert.sql")); err != nil {
return err
}
}
if info, err := os.Lstat(cfg.Paths.Certificate); err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return errors.New("证书根目录必须是普通目录,不能使用符号链接")
}
if pathsOverlap(cfg.Paths.Certificate, output) {
return errors.New("备份目录不能位于证书根目录内,也不能包含证书根目录")
}
if err := copyDirectoryExclusive(cfg.Paths.Certificate, filepath.Join(staging, "certificates")); err != nil {
return fmt.Errorf("备份证书目录失败:%w", err)
}
} else if !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("检查证书根目录失败:%w", err)
}
if err := writeBackupManifest(staging); err != nil {
return err
}
if err := syncDirectory(staging); err != nil {
return fmt.Errorf("同步备份暂存目录失败:%w", err)
}
if err := os.Rename(staging, output); err != nil {
return fmt.Errorf("发布备份目录失败:%w", err)
}
if err := syncDirectory(parent); err != nil {
return fmt.Errorf("同步备份父目录失败:%w", err)
}
completed = true
return nil
}
func backupSQLiteDatabase(ctx context.Context, cfg config.Config, output string) error {
if _, memory, err := sqliteDatabasePath(cfg.Database.DSN); err != nil {
return err
} else if memory {
return errors.New("内存 SQLite 数据库不能创建文件备份")
}
db, err := database.Open(ctx, cfg.Database)
if err != nil {
return fmt.Errorf("打开 SQLite 数据库失败:%w", err)
}
defer db.Close()
absOutput, err := filepath.Abs(output)
if err != nil {
return fmt.Errorf("解析 SQLite 备份路径失败:%w", err)
}
if _, err := os.Lstat(absOutput); err == nil {
return errors.New("SQLite 备份文件已存在")
} else if !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("检查 SQLite 备份文件失败:%w", err)
}
statement := "VACUUM INTO '" + strings.ReplaceAll(filepath.ToSlash(absOutput), "'", "''") + "'"
if _, err := db.DB.ExecContext(ctx, statement); err != nil {
return fmt.Errorf("创建 SQLite 一致性快照失败:%w", err)
}
if err := os.Chmod(absOutput, 0o600); err != nil {
return fmt.Errorf("设置 SQLite 备份权限失败:%w", err)
}
if err := validateSQLiteDatabase(ctx, absOutput); err != nil {
return err
}
return nil
}
func validateSQLiteDatabase(ctx context.Context, path string) error {
if !isRegularFile(path) {
return errors.New("SQLite 备份不是普通文件")
}
db, err := sql.Open("sqlite", path)
if err != nil {
return fmt.Errorf("打开 SQLite 备份失败:%w", err)
}
defer db.Close()
var result string
if err := db.QueryRowContext(ctx, "PRAGMA quick_check").Scan(&result); err != nil {
return fmt.Errorf("检查 SQLite 备份完整性失败:%w", err)
}
if !strings.EqualFold(strings.TrimSpace(result), "ok") {
return fmt.Errorf("SQLite 备份完整性检查失败:%s", result)
}
return nil
}
func sqliteDatabasePath(dsn string) (string, bool, error) {
dsn = strings.TrimSpace(dsn)
if dsn == ":memory:" || strings.HasPrefix(dsn, "file::memory:") {
return "", true, nil
}
if strings.HasPrefix(dsn, "file:") {
dsn = strings.TrimPrefix(strings.SplitN(dsn, "?", 2)[0], "file:")
}
if dsn == "" {
return "", false, errors.New("SQLite 数据库路径不能为空")
}
return filepath.Clean(filepath.FromSlash(dsn)), false, nil
}
func validateRestoreCompatibility(current, backup config.Config) error {
if current.Database.Driver != backup.Database.Driver {
return fmt.Errorf("备份数据库类型(%s)与当前配置数据库类型(%s)不一致,拒绝恢复", backup.Database.Driver, current.Database.Driver)
}
for name, values := range map[string][2]string{
"配置目录": {current.Paths.Config, backup.Paths.Config},
"数据目录": {current.Paths.Data, backup.Paths.Data},
"证书目录": {current.Paths.Certificate, backup.Paths.Certificate},
"备份目录": {current.Paths.Backup, backup.Paths.Backup},
} {
if !samePath(values[0], values[1]) {
return fmt.Errorf("备份%s与当前配置不一致,拒绝跨目录恢复", name)
}
}
if backup.Database.Driver == "sqlite" {
currentPath, currentMemory, err := sqliteDatabasePath(current.Database.DSN)
if err != nil {
return fmt.Errorf("解析当前 SQLite 数据库路径失败:%w", err)
}
backupPath, backupMemory, err := sqliteDatabasePath(backup.Database.DSN)
if err != nil {
return fmt.Errorf("解析备份 SQLite 数据库路径失败:%w", err)
}
if currentMemory != backupMemory || (!currentMemory && !samePath(currentPath, backupPath)) {
return errors.New("备份 SQLite 数据库路径与当前配置不一致,拒绝跨数据库恢复")
}
}
if backup.Database.Driver == "mysql" && strings.TrimSpace(current.Database.DSN) != strings.TrimSpace(backup.Database.DSN) {
return errors.New("备份 MySQL 连接配置与当前配置不一致,拒绝跨数据库恢复")
}
return nil
}
func validateBackupSecretStore(ctx context.Context, directory string, cfg config.Config) error {
masterPath := filepath.Join(directory, "master.key")
secretsPath := filepath.Join(directory, "secrets.json")
masterExists := isRegularFile(masterPath)
secretsExists := isRegularFile(secretsPath)
if !masterExists {
if secretsExists {
return errors.New("敏感配置包含 secrets.json,但缺少 master.key")
}
if cfg.SetupReady {
return errors.New("已初始化配置缺少 master.key")
}
return nil
}
store, err := secretstore.Open(directory)
if err != nil {
return fmt.Errorf("校验敏感配置主密钥失败:%w", err)
}
metadata, err := store.List(ctx, "")
if err != nil {
return fmt.Errorf("校验敏感配置文件失败:%w", err)
}
available := make(map[string]struct{}, len(metadata))
for _, item := range metadata {
if _, err := store.Get(ctx, item.Reference); err != nil {
return fmt.Errorf("校验敏感配置引用失败:%s:%w", item.Reference, err)
}
available[item.Reference] = struct{}{}
}
for _, reference := range []string{cfg.DNS.CredentialRef, cfg.Notification.HTTPCredentialRef, cfg.Notification.SMTPCredentialRef} {
reference = strings.TrimSpace(reference)
if reference == "" {
continue
}
if _, exists := available[reference]; !exists {
return fmt.Errorf("敏感配置缺少配置引用:%s", reference)
}
}
if cfg.SetupReady && !secretsExists {
return errors.New("已初始化配置缺少 secrets.json")
}
return nil
}
func restoreAdditionalAssets(cfg config.Config, input string) error {
timestamp := time.Now().UTC().Format("20060102-150405.000000000")
rollbacks := make([]func() error, 0, 3)
rollbackAll := func() error {
var rollbackErr error
for index := len(rollbacks) - 1; index >= 0; index-- {
rollbackErr = errors.Join(rollbackErr, rollbacks[index]())
}
return rollbackErr
}
for _, name := range []string{"master.key", "secrets.json"} {
source := filepath.Join(input, name)
target := filepath.Join(cfg.Paths.Config, name)
info, err := os.Lstat(source)
if err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
return errors.Join(fmt.Errorf("备份敏感配置文件不是普通文件:%s", name), rollbackAll())
}
rollback, restoreErr := restoreFileWithRollback(source, target, 0o600, timestamp)
if restoreErr != nil {
return errors.Join(restoreErr, rollbackAll())
}
rollbacks = append(rollbacks, rollback)
continue
}
if !errors.Is(err, os.ErrNotExist) {
return errors.Join(fmt.Errorf("检查备份敏感配置文件失败:%w", err), rollbackAll())
}
rollback, removeErr := removeFileWithRollback(target, 0o600, timestamp)
if removeErr != nil {
return errors.Join(removeErr, rollbackAll())
}
rollbacks = append(rollbacks, rollback)
}
certificateSource := filepath.Join(input, "certificates")
if info, err := os.Lstat(certificateSource); err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return errors.Join(errors.New("备份证书路径必须是普通目录"), rollbackAll())
}
rollback, err := restoreDirectoryWithRollback(certificateSource, cfg.Paths.Certificate, timestamp)
if err != nil {
return errors.Join(err, rollbackAll())
}
rollbacks = append(rollbacks, rollback)
} else if errors.Is(err, os.ErrNotExist) {
rollback, removeErr := removeDirectoryWithRollback(cfg.Paths.Certificate, timestamp)
if removeErr != nil {
return errors.Join(removeErr, rollbackAll())
}
rollbacks = append(rollbacks, rollback)
} else {
return errors.Join(fmt.Errorf("检查备份证书目录失败:%w", err), rollbackAll())
}
return nil
}
func restoreFileWithRollback(source, target string, mode os.FileMode, timestamp string) (func() error, error) {
if !isRegularFile(source) {
return nil, errors.New("恢复源文件必须是普通文件")
}
if err := os.MkdirAll(filepath.Dir(target), 0o700); err != nil {
return nil, fmt.Errorf("创建恢复目标目录失败:%w", err)
}
backupPath := ""
if info, err := os.Lstat(target); err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
return nil, errors.New("恢复目标文件不是普通文件")
}
backupPath = target + ".before-restore-" + timestamp
if err := copyFileExclusive(target, backupPath, mode); err != nil {
return nil, err
}
} else if !errors.Is(err, os.ErrNotExist) {
return nil, fmt.Errorf("检查恢复目标文件失败:%w", err)
}
if err := copyFile(source, target, mode); err != nil {
if backupPath != "" {
_ = copyFile(backupPath, target, mode)
}
return nil, err
}
return func() error {
if backupPath != "" {
return copyFile(backupPath, target, mode)
}
return os.Remove(target)
}, nil
}
func removeFileWithRollback(target string, mode os.FileMode, timestamp string) (func() error, error) {
info, err := os.Lstat(target)
if errors.Is(err, os.ErrNotExist) {
return func() error { return nil }, nil
}
if err != nil {
return nil, fmt.Errorf("检查恢复目标文件失败:%w", err)
}
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
return nil, errors.New("恢复目标文件不是普通文件")
}
backupPath := target + ".before-restore-" + timestamp
if err := copyFileExclusive(target, backupPath, mode); err != nil {
return nil, err
}
if err := os.Remove(target); err != nil {
return nil, fmt.Errorf("移除备份中不存在的当前文件失败:%w", err)
}
return func() error { return copyFile(backupPath, target, mode) }, nil
}
func removeDirectoryWithRollback(target, timestamp string) (func() error, error) {
info, err := os.Lstat(target)
if errors.Is(err, os.ErrNotExist) {
return func() error { return nil }, nil
}
if err != nil {
return nil, fmt.Errorf("检查证书恢复目标失败:%w", err)
}
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return nil, errors.New("证书恢复目标必须是普通目录")
}
backupPath := target + ".before-restore-" + timestamp
if err := os.Rename(target, backupPath); err != nil {
return nil, fmt.Errorf("保留现有证书目录失败:%w", err)
}
return func() error { return os.Rename(backupPath, target) }, nil
}
func restoreDirectoryWithRollback(source, target, timestamp string) (func() error, error) {
if pathsOverlap(source, target) {
return nil, errors.New("证书恢复源目录和目标目录不能互相包含")
}
if err := os.MkdirAll(filepath.Dir(target), 0o750); err != nil {
return nil, fmt.Errorf("创建证书恢复父目录失败:%w", err)
}
backupPath := ""
if info, err := os.Lstat(target); err == nil {
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return nil, errors.New("证书恢复目标必须是普通目录")
}
backupPath = target + ".before-restore-" + timestamp
if err := os.Rename(target, backupPath); err != nil {
return nil, fmt.Errorf("保留现有证书目录失败:%w", err)
}
} else if !errors.Is(err, os.ErrNotExist) {
return nil, fmt.Errorf("检查证书恢复目标失败:%w", err)
}
if err := copyDirectoryExclusive(source, target); err != nil {
_ = os.RemoveAll(target)
if backupPath != "" {
_ = os.Rename(backupPath, target)
}
return nil, fmt.Errorf("恢复证书目录失败:%w", err)
}
return func() error {
if err := os.RemoveAll(target); err != nil {
return err
}
if backupPath != "" {
return os.Rename(backupPath, target)
}
return nil
}, nil
}
func copyDirectoryExclusive(source, target string) error {
if pathsOverlap(source, target) {
return errors.New("复制源目录和目标目录不能互相包含")
}
rootInfo, err := os.Lstat(source)
if err != nil {
return fmt.Errorf("检查源目录失败:%w", err)
}
if rootInfo.Mode()&os.ModeSymlink != 0 || !rootInfo.IsDir() {
return errors.New("复制源路径必须是普通目录")
}
if _, err := os.Lstat(target); err == nil {
return errors.New("复制目标目录已存在")
} else if !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("检查复制目标目录失败:%w", err)
}
return filepath.WalkDir(source, func(path string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
info, err := entry.Info()
if err != nil {
return err
}
if info.Mode()&os.ModeSymlink != 0 {
return fmt.Errorf("目录中不允许包含符号链接:%s", path)
}
relative, err := filepath.Rel(source, path)
if err != nil {
return err
}
destination := filepath.Join(target, relative)
if entry.IsDir() {
mode := info.Mode().Perm()
if mode == 0 {
mode = 0o750
}
return os.Mkdir(destination, mode)
}
if !info.Mode().IsRegular() {
return fmt.Errorf("目录中包含不支持的文件类型:%s", path)
}
return copyFileExclusive(path, destination, info.Mode().Perm())
})
}
func pathsOverlap(left, right string) bool {
leftAbs, leftErr := filepath.Abs(filepath.Clean(left))
rightAbs, rightErr := filepath.Abs(filepath.Clean(right))
if leftErr != nil || rightErr != nil {
return true
}
return pathContains(leftAbs, rightAbs) || pathContains(rightAbs, leftAbs)
}
func pathContains(parent, child string) bool {
relative, err := filepath.Rel(parent, child)
if err != nil {
return false
}
return relative == "." || (relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)))
}
func writeBackupManifest(directory string) error {
manifest, err := buildBackupManifest(directory)
if err != nil {
return err
}
data, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return fmt.Errorf("生成备份清单失败:%w", err)
}
data = append(data, '\n')
path := filepath.Join(directory, "manifest.json")
file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err != nil {
return fmt.Errorf("创建备份清单失败:%w", err)
}
if _, err := file.Write(data); err != nil {
_ = file.Close()
return fmt.Errorf("写入备份清单失败:%w", err)
}
if err := file.Sync(); err != nil {
_ = file.Close()
return fmt.Errorf("同步备份清单失败:%w", err)
}
if err := file.Close(); 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 buildBackupManifest(directory string) (backupManifest, error) {
manifest := backupManifest{Version: backupManifestVersion, CreatedAt: time.Now().UTC()}
err := filepath.WalkDir(directory, func(path string, entry fs.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
if path == directory || entry.IsDir() {
return nil
}
if entry.Type()&os.ModeSymlink != 0 {
return fmt.Errorf("备份中不允许包含符号链接:%s", path)
}
info, err := entry.Info()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return fmt.Errorf("备份中包含不支持的文件类型:%s", path)
}
relative, err := filepath.Rel(directory, path)
if err != nil {
return err
}
digest, err := fileSHA256(path)
if err != nil {
return err
}
manifest.Files = append(manifest.Files, backupManifestFile{
Path: filepath.ToSlash(relative), Mode: uint32(info.Mode().Perm()), Size: info.Size(), SHA256: digest,
})
return nil
})
if err != nil {
return backupManifest{}, fmt.Errorf("生成备份文件清单失败:%w", err)
}
sort.Slice(manifest.Files, func(i, j int) bool { return manifest.Files[i].Path < manifest.Files[j].Path })
return manifest, nil
}
func validateBackupManifest(directory string) error {
path := filepath.Join(directory, "manifest.json")
info, err := os.Lstat(path)
if errors.Is(err, os.ErrNotExist) {
return errors.New("备份目录缺少 manifest.json,拒绝恢复未校验的备份")
}
if err != nil {
return fmt.Errorf("检查备份清单失败:%w", err)
}
if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
return errors.New("备份清单必须是普通文件")
}
if info.Size() > 8<<20 {
return errors.New("备份清单超过 8 MiB 安全上限")
}
data, err := os.ReadFile(path)
if err != nil {
return fmt.Errorf("读取备份清单失败:%w", err)
}
var expected backupManifest
if err := json.Unmarshal(data, &expected); err != nil {
return fmt.Errorf("解析备份清单失败:%w", err)
}
if expected.Version != backupManifestVersion {
return fmt.Errorf("不支持的备份清单版本:%d", expected.Version)
}
if expected.CreatedAt.IsZero() {
return errors.New("备份清单缺少创建时间")
}
if len(expected.Files) == 0 {
return errors.New("备份清单不包含任何文件")
}
actual, err := buildBackupManifestExcludingManifest(directory)
if err != nil {
return err
}
if len(actual.Files) != len(expected.Files) {
return errors.New("备份文件数量与清单不一致")
}
for index := range expected.Files {
left, right := expected.Files[index], actual.Files[index]
if left.Path != right.Path || left.Mode != right.Mode || left.Size != right.Size || !strings.EqualFold(left.SHA256, right.SHA256) {
return fmt.Errorf("备份文件校验失败:%s", left.Path)
}
}
return nil
}
func buildBackupManifestExcludingManifest(directory string) (backupManifest, error) {
manifest, err := buildBackupManifest(directory)
if err != nil {
return backupManifest{}, err
}
filtered := manifest.Files[:0]
for _, item := range manifest.Files {
if item.Path != "manifest.json" {
filtered = append(filtered, item)
}
}
manifest.Files = filtered
return manifest, nil
}
func fileSHA256(path string) (string, error) {
file, err := os.Open(path)
if err != nil {
return "", err
}
defer file.Close()
hash := sha256.New()
if _, err := io.Copy(hash, file); err != nil {
return "", err
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
func removeIfExists(path string) error {
if err := os.Remove(path); err != nil && !errors.Is(err, os.ErrNotExist) {
return err
}
return nil
}
+493
View File
@@ -0,0 +1,493 @@
package cli
import (
"context"
"database/sql"
"errors"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
)
func TestCreateBackupIncludesSecretsCertificatesAndSQLiteSnapshot(t *testing.T) {
base := t.TempDir()
cfg := config.Default(base)
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data, cfg.Paths.Certificate, cfg.Paths.Backup} {
if err := os.MkdirAll(directory, 0o700); err != nil {
t.Fatalf("创建测试目录失败:%v", err)
}
}
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
if err := cfg.Save(configPath); err != nil {
t.Fatalf("保存测试配置失败:%v", err)
}
if err := createTestSecretStore(cfg.Paths.Config); err != nil {
t.Fatalf("创建敏感配置失败:%v", err)
}
versionDirectory := filepath.Join(cfg.Paths.Certificate, "example.com", "20260831-V1.0")
if err := os.MkdirAll(versionDirectory, 0o750); err != nil {
t.Fatalf("创建证书版本目录失败:%v", err)
}
if err := os.WriteFile(filepath.Join(versionDirectory, "fullchain.pem"), []byte("certificate"), 0o644); err != nil {
t.Fatalf("写入证书失败:%v", err)
}
if err := os.WriteFile(filepath.Join(versionDirectory, "privkey.pem"), []byte("private-key"), 0o600); err != nil {
t.Fatalf("写入私钥失败:%v", err)
}
db, err := database.Open(context.Background(), cfg.Database)
if err != nil {
t.Fatalf("打开测试数据库失败:%v", err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatalf("迁移测试数据库失败:%v", err)
}
if _, err := db.DB.Exec(`INSERT INTO audit_logs (action, resource_type, resource_id, status, message, created_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`, "backup_test", "test", "1", "success", "备份测试"); err != nil {
t.Fatalf("写入测试数据失败:%v", err)
}
output := filepath.Join(base, "backup-output")
if err := createBackup(context.Background(), cfg, configPath, output); err != nil {
t.Fatalf("创建完整备份失败:%v", err)
}
if err := validateBackupManifest(output); err != nil {
t.Fatalf("备份清单校验失败:%v", err)
}
for _, relative := range []string{
"scert.json",
"master.key",
"secrets.json",
"scert.db",
"manifest.json",
filepath.Join("certificates", "example.com", "20260831-V1.0", "fullchain.pem"),
filepath.Join("certificates", "example.com", "20260831-V1.0", "privkey.pem"),
} {
if _, err := os.Stat(filepath.Join(output, relative)); err != nil {
t.Fatalf("完整备份缺少文件 %s:%v", relative, err)
}
}
snapshot, err := sql.Open("sqlite", filepath.Join(output, "scert.db"))
if err != nil {
t.Fatalf("打开 SQLite 快照失败:%v", err)
}
defer snapshot.Close()
var count int
if err := snapshot.QueryRow(`SELECT COUNT(*) FROM audit_logs WHERE action = 'backup_test'`).Scan(&count); err != nil {
t.Fatalf("读取 SQLite 快照失败:%v", err)
}
if count != 1 {
t.Fatalf("SQLite 快照缺少备份时数据:%d", count)
}
if runtime.GOOS != "windows" {
for _, relative := range []string{"master.key", "secrets.json", "scert.db", "manifest.json"} {
info, err := os.Stat(filepath.Join(output, relative))
if err != nil {
t.Fatal(err)
}
if info.Mode().Perm() != 0o600 {
t.Fatalf("敏感备份文件权限不正确 %s:%o", relative, info.Mode().Perm())
}
}
}
}
func TestBackupManifestRejectsTampering(t *testing.T) {
directory := t.TempDir()
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("original"), 0o600); err != nil {
t.Fatal(err)
}
if err := writeBackupManifest(directory); err != nil {
t.Fatalf("写入备份清单失败:%v", err)
}
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("tampered"), 0o600); err != nil {
t.Fatal(err)
}
if err := validateBackupManifest(directory); err == nil || !strings.Contains(err.Error(), "校验失败") {
t.Fatalf("被篡改的备份未被拒绝:%v", err)
}
}
func TestBackupManifestIsRequired(t *testing.T) {
directory := t.TempDir()
if err := os.WriteFile(filepath.Join(directory, "scert.json"), []byte("{}"), 0o600); err != nil {
t.Fatal(err)
}
if err := validateBackupManifest(directory); err == nil || !strings.Contains(err.Error(), "缺少 manifest.json") {
t.Fatalf("缺少清单的备份未被拒绝:%v", err)
}
}
func TestCreateBackupDoesNotChangeExistingParentPermissions(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("Windows 不提供 POSIX 目录权限语义")
}
base := t.TempDir()
parent := filepath.Join(base, "shared")
if err := os.Mkdir(parent, 0o755); err != nil {
t.Fatal(err)
}
cfg := config.Default(filepath.Join(base, "scert"))
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data} {
if err := os.MkdirAll(directory, 0o700); err != nil {
t.Fatal(err)
}
}
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
if err := cfg.Save(configPath); err != nil {
t.Fatal(err)
}
if err := createSQLiteTestDatabase(cfg.Database.DSN, "parent_mode"); err != nil {
t.Fatal(err)
}
if err := createBackup(context.Background(), cfg, configPath, filepath.Join(parent, "backup")); err != nil {
t.Fatal(err)
}
info, err := os.Stat(parent)
if err != nil {
t.Fatal(err)
}
if info.Mode().Perm() != 0o755 {
t.Fatalf("备份操作修改了既有父目录权限:%o", info.Mode().Perm())
}
}
func TestCreateBackupRequiresSecretsWhenInitialized(t *testing.T) {
base := t.TempDir()
cfg := config.Default(base)
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data} {
if err := os.MkdirAll(directory, 0o700); err != nil {
t.Fatal(err)
}
}
configPath := filepath.Join(cfg.Paths.Config, "scert.json")
if err := cfg.Save(configPath); err != nil {
t.Fatal(err)
}
if err := createSQLiteTestDatabase(cfg.Database.DSN, "missing_secrets"); err != nil {
t.Fatal(err)
}
cfg.SetupReady = true
if err := createBackup(context.Background(), cfg, configPath, filepath.Join(base, "backup")); err == nil || !strings.Contains(err.Error(), "缺少 master.key") {
t.Fatalf("已初始化系统缺少敏感文件时仍创建了备份:%v", err)
}
}
func TestRestoreAdditionalAssetsKeepsRollbackCopies(t *testing.T) {
base := t.TempDir()
cfg := config.Default(filepath.Join(base, "target"))
input := filepath.Join(base, "backup")
if err := os.MkdirAll(filepath.Join(input, "certificates", "example.com"), 0o700); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(cfg.Paths.Config, 0o700); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(cfg.Paths.Certificate, "old.example.com"), 0o750); err != nil {
t.Fatal(err)
}
for path, value := range map[string]string{
filepath.Join(input, "master.key"): "new-master",
filepath.Join(input, "secrets.json"): "new-secrets",
filepath.Join(input, "certificates", "example.com", "privkey.pem"): "new-private-key",
filepath.Join(cfg.Paths.Config, "master.key"): "old-master",
filepath.Join(cfg.Paths.Config, "secrets.json"): "old-secrets",
filepath.Join(cfg.Paths.Certificate, "old.example.com", "cert.pem"): "old-certificate",
} {
if err := os.WriteFile(path, []byte(value), 0o600); err != nil {
t.Fatalf("写入测试恢复文件失败:%v", err)
}
}
if err := restoreAdditionalAssets(cfg, input); err != nil {
t.Fatalf("恢复敏感配置和证书失败:%v", err)
}
for path, expected := range map[string]string{
filepath.Join(cfg.Paths.Config, "master.key"): "new-master",
filepath.Join(cfg.Paths.Config, "secrets.json"): "new-secrets",
filepath.Join(cfg.Paths.Certificate, "example.com", "privkey.pem"): "new-private-key",
} {
data, err := os.ReadFile(path)
if err != nil || string(data) != expected {
t.Fatalf("恢复结果不正确 %s:data=%q err=%v", path, data, err)
}
}
for _, pattern := range []string{
filepath.Join(cfg.Paths.Config, "master.key.before-restore-*"),
filepath.Join(cfg.Paths.Config, "secrets.json.before-restore-*"),
cfg.Paths.Certificate + ".before-restore-*",
} {
matches, err := filepath.Glob(pattern)
if err != nil || len(matches) != 1 {
t.Fatalf("恢复前副本不正确 %s:matches=%v err=%v", pattern, matches, err)
}
}
}
func TestRestoreAdditionalAssetsRestoresAbsentState(t *testing.T) {
base := t.TempDir()
cfg := config.Default(filepath.Join(base, "target"))
input := filepath.Join(base, "backup")
if err := os.MkdirAll(input, 0o700); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(cfg.Paths.Config, 0o700); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(cfg.Paths.Certificate, 0o750); err != nil {
t.Fatal(err)
}
for _, path := range []string{
filepath.Join(cfg.Paths.Config, "master.key"),
filepath.Join(cfg.Paths.Config, "secrets.json"),
filepath.Join(cfg.Paths.Certificate, "current.pem"),
} {
if err := os.WriteFile(path, []byte("current"), 0o600); err != nil {
t.Fatal(err)
}
}
if err := restoreAdditionalAssets(cfg, input); err != nil {
t.Fatalf("恢复缺失状态失败:%v", err)
}
for _, path := range []string{
filepath.Join(cfg.Paths.Config, "master.key"),
filepath.Join(cfg.Paths.Config, "secrets.json"),
cfg.Paths.Certificate,
} {
if _, err := os.Lstat(path); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("备份中不存在的资产仍保留在当前路径:%s err=%v", path, err)
}
}
for _, pattern := range []string{
filepath.Join(cfg.Paths.Config, "master.key.before-restore-*"),
filepath.Join(cfg.Paths.Config, "secrets.json.before-restore-*"),
cfg.Paths.Certificate + ".before-restore-*",
} {
matches, err := filepath.Glob(pattern)
if err != nil || len(matches) != 1 {
t.Fatalf("缺失状态恢复未保留恢复前副本 %s:matches=%v err=%v", pattern, matches, err)
}
}
}
func TestValidateRestoreCompatibilityRejectsCrossDatabase(t *testing.T) {
current := config.Default(t.TempDir())
backup := current
backup.Database.DSN = filepath.Join(t.TempDir(), "other.db")
if err := validateRestoreCompatibility(current, backup); err == nil || !strings.Contains(err.Error(), "跨数据库") {
t.Fatalf("跨数据库恢复未被拒绝:%v", err)
}
}
func TestRestoreCommandRestoresCompleteSQLiteBackup(t *testing.T) {
cfg, currentPath, input := prepareRestoreCommandFixture(t, false)
expectedMaster, err := os.ReadFile(filepath.Join(input, "master.key"))
if err != nil {
t.Fatal(err)
}
expectedSecrets, err := os.ReadFile(filepath.Join(input, "secrets.json"))
if err != nil {
t.Fatal(err)
}
expectedConfig, err := os.ReadFile(filepath.Join(input, "scert.json"))
if err != nil {
t.Fatal(err)
}
previousConfigPath := configPath
configPath = currentPath
defer func() { configPath = previousConfigPath }()
command := newRestoreCommand()
var output strings.Builder
command.SetOut(&output)
command.SetErr(&output)
command.SetArgs([]string{"--input", input})
if err := command.Execute(); err != nil {
t.Fatalf("执行完整恢复失败:%v\n%s", err, output.String())
}
restored, err := config.Load(currentPath)
if err != nil {
t.Fatal(err)
}
if restored.Server.Port != 9005 {
t.Fatalf("配置未恢复:%d", restored.Server.Port)
}
actualConfig, err := os.ReadFile(currentPath)
if err != nil {
t.Fatal(err)
}
if string(actualConfig) != string(expectedConfig) {
t.Fatal("恢复后的配置文件与备份内容不一致")
}
for path, expected := range map[string][]byte{
filepath.Join(cfg.Paths.Config, "master.key"): expectedMaster,
filepath.Join(cfg.Paths.Config, "secrets.json"): expectedSecrets,
filepath.Join(cfg.Paths.Certificate, "example.com", "cert.pem"): []byte("new-certificate"),
} {
data, err := os.ReadFile(path)
if err != nil || string(data) != string(expected) {
t.Fatalf("恢复文件不正确 %s:data=%q err=%v", path, data, err)
}
}
if count, err := auditActionCount(cfg.Database.DSN, "restored"); err != nil || count != 1 {
t.Fatalf("SQLite 数据未恢复:count=%d err=%v", count, err)
}
if count, err := auditActionCount(cfg.Database.DSN, "current"); err != nil || count != 0 {
t.Fatalf("恢复后仍存在当前数据:count=%d err=%v", count, err)
}
}
func TestRestoreCommandRollsBackCoreAndSecretsOnCertificateFailure(t *testing.T) {
cfg, currentPath, input := prepareRestoreCommandFixture(t, true)
previousConfigPath := configPath
configPath = currentPath
defer func() { configPath = previousConfigPath }()
command := newRestoreCommand()
var output strings.Builder
command.SetOut(&output)
command.SetErr(&output)
command.SetArgs([]string{"--input", input})
err := command.Execute()
if err == nil || !strings.Contains(err.Error(), "证书恢复目标必须是普通目录") {
t.Fatalf("证书恢复失败未触发:err=%v output=%s", err, output.String())
}
restored, loadErr := config.Load(currentPath)
if loadErr != nil {
t.Fatal(loadErr)
}
if restored.Server.Port != 9004 {
t.Fatalf("失败后配置未回滚:%d", restored.Server.Port)
}
master, readErr := os.ReadFile(filepath.Join(cfg.Paths.Config, "master.key"))
if readErr != nil || string(master) != "old-master" {
t.Fatalf("失败后主密钥未回滚:data=%q err=%v", master, readErr)
}
certificateTarget, readErr := os.ReadFile(cfg.Paths.Certificate)
if readErr != nil || string(certificateTarget) != "blocked-certificate-target" {
t.Fatalf("失败后证书目标被破坏:data=%q err=%v", certificateTarget, readErr)
}
if count, countErr := auditActionCount(cfg.Database.DSN, "current"); countErr != nil || count != 1 {
t.Fatalf("失败后 SQLite 数据未回滚:count=%d err=%v", count, countErr)
}
if count, countErr := auditActionCount(cfg.Database.DSN, "restored"); countErr != nil || count != 0 {
t.Fatalf("失败后仍残留恢复数据:count=%d err=%v", count, countErr)
}
}
func TestSQLiteDatabasePathSupportsFileURI(t *testing.T) {
path, memory, err := sqliteDatabasePath("file:/var/lib/scert/scert.db?_pragma=busy_timeout(5000)")
if err != nil || memory {
t.Fatalf("SQLite 文件 URI 解析失败:path=%s memory=%t err=%v", path, memory, err)
}
if filepath.ToSlash(path) != "/var/lib/scert/scert.db" {
t.Fatalf("SQLite 文件 URI 路径不正确:%s", path)
}
if _, memory, err := sqliteDatabasePath("file::memory:?cache=shared"); err != nil || !memory {
t.Fatalf("SQLite 内存 URI 识别失败:memory=%t err=%v", memory, err)
}
}
func createSQLiteTestDatabase(path, action string) error {
db, err := sql.Open("sqlite", path)
if err != nil {
return err
}
defer db.Close()
if err := database.Migrate(context.Background(), db, "sqlite"); err != nil {
return err
}
_, err = db.Exec(`INSERT INTO audit_logs (action, resource_type, resource_id, status, message, created_at) VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`, action, "test", "1", "success", action)
return err
}
func prepareRestoreCommandFixture(t *testing.T, blockedCertificate bool) (config.Config, string, string) {
t.Helper()
base := t.TempDir()
cfg := config.Default(filepath.Join(base, "target"))
for _, directory := range []string{cfg.Paths.Config, cfg.Paths.Data, cfg.Paths.Backup} {
if err := os.MkdirAll(directory, 0o700); err != nil {
t.Fatal(err)
}
}
if blockedCertificate {
if err := os.MkdirAll(filepath.Dir(cfg.Paths.Certificate), 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(cfg.Paths.Certificate, []byte("blocked-certificate-target"), 0o600); err != nil {
t.Fatal(err)
}
} else {
if err := os.MkdirAll(filepath.Join(cfg.Paths.Certificate, "old.example.com"), 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(cfg.Paths.Certificate, "old.example.com", "cert.pem"), []byte("old-certificate"), 0o600); err != nil {
t.Fatal(err)
}
}
cfg.Server.Port = 9004
currentPath := filepath.Join(cfg.Paths.Config, "scert.json")
if err := cfg.Save(currentPath); err != nil {
t.Fatal(err)
}
if err := createSQLiteTestDatabase(cfg.Database.DSN, "current"); err != nil {
t.Fatal(err)
}
for path, value := range map[string]string{
filepath.Join(cfg.Paths.Config, "master.key"): "old-master",
filepath.Join(cfg.Paths.Config, "secrets.json"): "old-secrets",
} {
if err := os.WriteFile(path, []byte(value), 0o600); err != nil {
t.Fatal(err)
}
}
input := filepath.Join(base, "restore-input")
if err := os.MkdirAll(filepath.Join(input, "certificates", "example.com"), 0o700); err != nil {
t.Fatal(err)
}
backupConfig := cfg
backupConfig.Server.Port = 9005
if err := backupConfig.Save(filepath.Join(input, "scert.json")); err != nil {
t.Fatal(err)
}
if err := createSQLiteTestDatabase(filepath.Join(input, "scert.db"), "restored"); err != nil {
t.Fatal(err)
}
if err := createTestSecretStore(input); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(input, "certificates", "example.com", "cert.pem"), []byte("new-certificate"), 0o600); err != nil {
t.Fatal(err)
}
if err := writeBackupManifest(input); err != nil {
t.Fatal(err)
}
return cfg, currentPath, input
}
func auditActionCount(path, action string) (int, error) {
db, err := sql.Open("sqlite", path)
if err != nil {
return 0, err
}
defer db.Close()
var count int
err = db.QueryRow(`SELECT COUNT(*) FROM audit_logs WHERE action = ?`, action).Scan(&count)
return count, err
}
func createTestSecretStore(directory string) error {
store, err := secretstore.Open(directory)
if err != nil {
return err
}
return store.Put(context.Background(), "secret://test/backup", map[string]string{"token": "encrypted-test-value"})
}
+165 -56
View File
@@ -17,6 +17,7 @@ import (
"git.pcux.cn/xuans/Scert/backend/internal/app"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/processlock"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
)
@@ -330,29 +331,18 @@ func newBackupCommand() *cobra.Command {
if err != nil {
return err
}
lock, err := acquireProcessLock(cfg, "服务正在运行或另一个备份恢复任务正在执行;请先停止 Scert 服务")
if err != nil {
return err
}
defer lock.Close()
if strings.TrimSpace(output) == "" {
output = filepath.Join(cfg.Paths.Backup, "scert-"+time.Now().UTC().Format("20060102-150405.000000000"))
}
output = filepath.Clean(output)
if err := ensureBackupDestination(output); err != nil {
if err := createBackup(cmd.Context(), cfg, resolveConfigPath(), output); err != nil {
return err
}
if err := os.MkdirAll(output, 0o700); err != nil {
return fmt.Errorf("创建备份目录失败:%w", err)
}
if err := copyFileExclusive(resolveConfigPath(), filepath.Join(output, "scert.json"), 0o600); err != nil {
return err
}
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" {
if err := copyFileExclusive(cfg.Database.DSN, filepath.Join(output, "scert.db"), 0o600); err != nil {
return err
}
}
if cfg.Database.Driver == "mysql" {
if err := backupMySQL(cmd.Context(), cfg, filepath.Join(output, "scert.sql")); err != nil {
return err
}
}
_, err = fmt.Fprintf(cmd.OutOrStdout(), "备份已创建:%s\n", output)
return err
},
@@ -371,21 +361,42 @@ func newRestoreCommand() *cobra.Command {
if err != nil {
return err
}
if err := validateBackupManifest(input); err != nil {
return err
}
configFile := filepath.Join(input, "scert.json")
cfg, err := config.Load(configFile)
if err != nil {
return fmt.Errorf("读取备份配置失败:%w", err)
}
if err := validateBackupSecretStore(cmd.Context(), input, cfg); err != nil {
return err
}
currentPath := filepath.Clean(resolveConfigPath())
expectedConfigPath := filepath.Join(cfg.Paths.Config, "scert.json")
if !samePath(currentPath, expectedConfigPath) {
return fmt.Errorf("恢复目标配置路径必须与备份配置目录一致:%s", expectedConfigPath)
}
currentConfig, currentConfigErr := config.Load(currentPath)
if currentConfigErr != nil && !errors.Is(currentConfigErr, os.ErrNotExist) {
return fmt.Errorf("读取当前配置失败:%w", currentConfigErr)
}
if currentConfigErr == nil && currentConfig.Database.Driver != cfg.Database.Driver {
return fmt.Errorf("备份数据库类型(%s)与当前配置数据库类型(%s)不一致,拒绝恢复", cfg.Database.Driver, currentConfig.Database.Driver)
if currentConfigErr == nil {
if err := validateRestoreCompatibility(currentConfig, cfg); err != nil {
return err
}
}
if info, statErr := os.Stat(currentPath); statErr == nil && !info.Mode().IsRegular() {
lockConfig := cfg
if currentConfigErr == nil {
lockConfig = currentConfig
}
lock, err := acquireProcessLock(lockConfig, "服务正在运行或另一个备份恢复任务正在执行;请先停止 Scert 服务")
if err != nil {
return err
}
defer lock.Close()
if info, statErr := os.Lstat(currentPath); statErr == nil && (info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular()) {
return errors.New("当前配置路径不是普通文件")
} else if statErr != nil && !errors.Is(statErr, os.ErrNotExist) {
return fmt.Errorf("检查当前配置失败:%w", statErr)
@@ -397,25 +408,36 @@ func newRestoreCommand() *cobra.Command {
}
databaseSource := filepath.Join(input, "scert.db")
databaseSourceInfo, databaseSourceErr := os.Stat(databaseSource)
databaseSourceExists := databaseSourceErr == nil
databaseSourceInfo, databaseSourceErr := os.Lstat(databaseSource)
databaseSourceExists := databaseSourceErr == nil && databaseSourceInfo.Mode().IsRegular()
if databaseSourceErr != nil && !errors.Is(databaseSourceErr, os.ErrNotExist) {
return fmt.Errorf("检查备份数据库失败:%w", databaseSourceErr)
}
if databaseSourceExists && !databaseSourceInfo.Mode().IsRegular() {
if databaseSourceErr == nil && !databaseSourceInfo.Mode().IsRegular() {
return errors.New("备份数据库不是普通文件")
}
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && !databaseSourceExists {
databaseTarget := ""
sqliteMemory := false
if cfg.Database.Driver == "sqlite" {
databaseTarget, sqliteMemory, err = sqliteDatabasePath(cfg.Database.DSN)
if err != nil {
return err
}
}
if cfg.Database.Driver == "sqlite" && !sqliteMemory && !databaseSourceExists {
return errors.New("SQLite 备份目录缺少有效的 scert.db 文件")
}
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists {
if samePath(databaseSource, cfg.Database.DSN) {
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists {
if err := validateSQLiteDatabase(cmd.Context(), databaseSource); err != nil {
return err
}
if samePath(databaseSource, databaseTarget) {
return errors.New("备份数据库与当前数据库路径相同")
}
if err := ensureParentDirectory(cfg.Database.DSN); err != nil {
if err := ensureParentDirectory(databaseTarget); err != nil {
return fmt.Errorf("创建当前数据库父目录失败:%w", err)
}
if databaseTargetInfo, statErr := os.Stat(cfg.Database.DSN); statErr == nil && !databaseTargetInfo.Mode().IsRegular() {
if databaseTargetInfo, statErr := os.Lstat(databaseTarget); statErr == nil && (databaseTargetInfo.Mode()&os.ModeSymlink != 0 || !databaseTargetInfo.Mode().IsRegular()) {
return errors.New("当前数据库不是普通文件")
} else if statErr != nil && !errors.Is(statErr, os.ErrNotExist) {
return fmt.Errorf("检查当前数据库失败:%w", statErr)
@@ -431,9 +453,9 @@ func newRestoreCommand() *cobra.Command {
}
databaseBackupPath := ""
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists && isRegularFile(cfg.Database.DSN) {
databaseBackupPath = cfg.Database.DSN + ".before-restore-" + time.Now().UTC().Format("20060102-150405.000000000")
if err := copyFileExclusive(cfg.Database.DSN, databaseBackupPath, 0o600); err != nil {
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists && isRegularFile(databaseTarget) {
databaseBackupPath = databaseTarget + ".before-restore-" + time.Now().UTC().Format("20060102-150405.000000000")
if err := copyFileExclusive(databaseTarget, databaseBackupPath, 0o600); err != nil {
return err
}
}
@@ -446,34 +468,50 @@ func newRestoreCommand() *cobra.Command {
}
}
if err := cfg.Save(currentPath); err != nil {
return err
}
if cfg.Database.Driver == "sqlite" && cfg.Database.DSN != ":memory:" && databaseSourceExists {
if err := copyFile(databaseSource, cfg.Database.DSN, 0o600); err != nil {
if configBackupPath != "" {
_ = copyFile(configBackupPath, currentPath, 0o600)
}
configRestoreAttempted := false
sqliteRestoreAttempted := false
mysqlRestoreAttempted := false
rollbackCore := func() error {
var rollbackErr error
if mysqlRestoreAttempted && mysqlBackupPath != "" {
rollbackErr = errors.Join(rollbackErr, restoreMySQL(cmd.Context(), cfg, mysqlBackupPath))
}
if sqliteRestoreAttempted {
if databaseBackupPath != "" {
_ = copyFile(databaseBackupPath, cfg.Database.DSN, 0o600)
rollbackErr = errors.Join(rollbackErr, copyFileAtomic(databaseBackupPath, databaseTarget, 0o600))
} else {
rollbackErr = errors.Join(rollbackErr, removeIfExists(databaseTarget))
}
return fmt.Errorf("恢复 SQLite 数据库失败:%w", err)
}
if configRestoreAttempted {
if configBackupPath != "" {
rollbackErr = errors.Join(rollbackErr, copyFileAtomic(configBackupPath, currentPath, 0o600))
} else {
rollbackErr = errors.Join(rollbackErr, removeIfExists(currentPath))
}
}
return rollbackErr
}
configRestoreAttempted = true
if err := copyFileAtomic(configFile, currentPath, 0o600); err != nil {
return errors.Join(err, rollbackCore())
}
if cfg.Database.Driver == "sqlite" && !sqliteMemory && databaseSourceExists {
sqliteRestoreAttempted = true
if err := copyFileAtomic(databaseSource, databaseTarget, 0o600); err != nil {
return errors.Join(fmt.Errorf("恢复 SQLite 数据库失败:%w", err), rollbackCore())
}
}
if cfg.Database.Driver == "mysql" {
mysqlRestoreAttempted = true
if err := restoreMySQL(cmd.Context(), cfg, mysqlSource); err != nil {
restoreFailure := fmt.Errorf("恢复 MySQL 数据库失败:%w", err)
if mysqlBackupPath != "" {
if rollbackErr := restoreMySQL(cmd.Context(), cfg, mysqlBackupPath); rollbackErr != nil {
restoreFailure = fmt.Errorf("%w;MySQL 数据库回滚失败:%v", restoreFailure, rollbackErr)
}
}
if configBackupPath != "" {
_ = copyFile(configBackupPath, currentPath, 0o600)
}
return restoreFailure
return errors.Join(fmt.Errorf("恢复 MySQL 数据库失败:%w", err), rollbackCore())
}
}
if err := restoreAdditionalAssets(cfg, input); err != nil {
return errors.Join(fmt.Errorf("恢复敏感配置或证书失败:%w", err), rollbackCore())
}
_, err = fmt.Fprintf(cmd.OutOrStdout(), "恢复已完成:%s\n", input)
return err
},
@@ -491,6 +529,17 @@ func openApp(ctx context.Context) (*app.App, error) {
return app.NewWithConfigPath(ctx, cfg, resolveConfigPath())
}
func acquireProcessLock(cfg config.Config, busyMessage string) (*processlock.Lock, error) {
lock, err := processlock.Acquire(filepath.Join(cfg.Paths.Data, "scert.lock"))
if errors.Is(err, processlock.ErrLocked) {
return nil, errors.New(busyMessage)
}
if err != nil {
return nil, err
}
return lock, nil
}
func tailLines(reader io.Reader, count int) ([]string, error) {
values := make([]string, 0, count)
scanner := bufio.NewScanner(reader)
@@ -687,12 +736,59 @@ func copyFile(source, target string, mode os.FileMode) error {
_ = output.Close()
return fmt.Errorf("复制文件失败:%w", err)
}
if err := output.Sync(); err != nil {
_ = output.Close()
return fmt.Errorf("同步目标文件失败:%w", err)
}
if err := output.Close(); err != nil {
return fmt.Errorf("关闭目标文件失败:%w", err)
}
return os.Chmod(target, mode)
}
func copyFileAtomic(source, target string, mode os.FileMode) error {
input, err := os.Open(source)
if err != nil {
return fmt.Errorf("打开文件失败:%w", err)
}
defer input.Close()
if err := os.MkdirAll(filepath.Dir(target), 0o700); err != nil {
return fmt.Errorf("创建目标目录失败:%w", err)
}
output, err := os.CreateTemp(filepath.Dir(target), ".scert-restore-")
if err != nil {
return fmt.Errorf("创建恢复暂存文件失败:%w", err)
}
temporaryPath := output.Name()
completed := false
defer func() {
if !completed {
_ = output.Close()
_ = os.Remove(temporaryPath)
}
}()
if err := output.Chmod(mode); err != nil {
return fmt.Errorf("设置恢复暂存文件权限失败:%w", err)
}
if _, err := io.Copy(output, input); err != nil {
return fmt.Errorf("复制文件失败:%w", err)
}
if err := output.Sync(); err != nil {
return fmt.Errorf("同步恢复暂存文件失败:%w", err)
}
if err := output.Close(); err != nil {
return fmt.Errorf("关闭恢复暂存文件失败:%w", err)
}
if err := os.Rename(temporaryPath, target); err != nil {
return fmt.Errorf("原子替换恢复文件失败:%w", err)
}
if err := syncDirectory(filepath.Dir(target)); err != nil {
return fmt.Errorf("同步恢复目标目录失败:%w", err)
}
completed = true
return nil
}
func copyFileExclusive(source, target string, mode os.FileMode) error {
input, err := os.Open(source)
if err != nil {
@@ -706,14 +802,27 @@ func copyFileExclusive(source, target string, mode os.FileMode) error {
if err != nil {
return fmt.Errorf("创建目标文件失败:%w", err)
}
completed := false
defer func() {
if !completed {
_ = output.Close()
_ = os.Remove(target)
}
}()
if _, err := io.Copy(output, input); err != nil {
_ = output.Close()
return fmt.Errorf("复制文件失败:%w", err)
}
if err := output.Sync(); err != nil {
return fmt.Errorf("同步目标文件失败:%w", err)
}
if err := output.Close(); err != nil {
return fmt.Errorf("关闭目标文件失败:%w", err)
}
return os.Chmod(target, mode)
if err := os.Chmod(target, mode); err != nil {
return err
}
completed = true
return nil
}
func ensureBackupDestination(path string) error {
@@ -733,12 +842,12 @@ func validateRestoreInput(path string) (string, error) {
if path == "." || path == "" {
return "", errors.New("备份目录不能为空")
}
info, err := os.Stat(path)
info, err := os.Lstat(path)
if err != nil {
return "", fmt.Errorf("检查备份目录失败:%w", err)
}
if !info.IsDir() {
return "", errors.New("备份路径必须是目录")
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return "", errors.New("备份路径必须是普通目录,不能使用符号链接")
}
configFile := filepath.Join(path, "scert.json")
if !isRegularFile(configFile) {
@@ -56,6 +56,17 @@ func TestCopyFileExclusiveRefusesOverwrite(t *testing.T) {
}
}
func TestCopyFileExclusiveRemovesPartialTargetOnCopyFailure(t *testing.T) {
dir := t.TempDir()
target := filepath.Join(dir, "target")
if err := copyFileExclusive(dir, target, 0o600); err == nil {
t.Fatal("复制目录时没有返回错误")
}
if _, err := os.Lstat(target); !os.IsNotExist(err) {
t.Fatalf("复制失败后残留了不完整目标文件:%v", err)
}
}
func TestSamePathNormalizesAbsolutePaths(t *testing.T) {
dir := t.TempDir()
path := filepath.Join(dir, "file")
+5
View File
@@ -653,6 +653,11 @@ func newServeCommand() *cobra.Command {
if cfg.SetupReady && !cfg.Web.Enabled {
return fmt.Errorf("管理页面已关闭")
}
lock, err := acquireProcessLock(cfg, "Scert 服务已在运行或备份恢复任务正在执行")
if err != nil {
return err
}
defer lock.Close()
service, err := app.NewWithConfigPath(cmd.Context(), cfg, resolveConfigPath())
if err != nil {
return err
+18 -8
View File
@@ -3,6 +3,7 @@ package cli
import (
"fmt"
"strings"
"time"
"github.com/spf13/cobra"
@@ -60,6 +61,9 @@ func newServerAddCommand() *cobra.Command {
}
defer service.Close()
item := value.server()
now := time.Now().UTC()
item.CreatedAt = now
item.UpdatedAt = now
item.ID = domain.NewID()
if _, err := service.SSHKeys.ValidateReference(cmd.Context(), item.PrivateKeyRef); err != nil {
return fmt.Errorf("SSH 私钥引用无效:%w", err)
@@ -89,6 +93,7 @@ func newServerEditCommand() *cobra.Command {
item := value.server()
item.ID = existing.ID
item.CreatedAt = existing.CreatedAt
item.UpdatedAt = time.Now().UTC()
if _, err := service.SSHKeys.ValidateReference(cmd.Context(), item.PrivateKeyRef); err != nil {
return fmt.Errorf("SSH 私钥引用无效:%w", err)
}
@@ -180,7 +185,7 @@ func newDomainServersSetCommand() *cobra.Command {
type serverFlags struct {
name, address, username, privateKeyRef, fingerprint string
certificatePath, privateKeyPath, chainPath, webServer string
reloadCommand []string
validationCommand, reloadCommand []string
port int
}
@@ -195,6 +200,7 @@ func (f *serverFlags) bind(command *cobra.Command) {
command.Flags().StringVar(&f.privateKeyPath, "private-key-path", deployment.DefaultPrivateKeyPath, "远程私钥文件路径模板")
command.Flags().StringVar(&f.chainPath, "chain-path", deployment.DefaultCertificateChainPath, "远程完整证书链路径模板")
command.Flags().StringVar(&f.webServer, "web-server", string(deployment.WebServerNginx), "Web 服务类型:nginx、caddy、apache、custom")
command.Flags().StringSliceVar(&f.validationCommand, "validation-command", nil, "自定义配置校验命令及参数")
command.Flags().StringSliceVar(&f.reloadCommand, "reload-command", nil, "自定义 reload 命令及参数")
for _, name := range []string{"name", "address", "username", "private-key-ref", "host-key-fingerprint"} {
_ = command.MarkFlagRequired(name)
@@ -202,20 +208,24 @@ func (f *serverFlags) bind(command *cobra.Command) {
}
func (f serverFlags) server() deployment.Server {
command := make([]string, 0, len(f.reloadCommand))
for _, value := range f.reloadCommand {
if value = strings.TrimSpace(value); value != "" {
command = append(command, value)
}
}
return deployment.Server{
Name: f.name, Address: f.address, Port: f.port, Username: f.username,
PrivateKeyRef: f.privateKeyRef, HostKeyFingerprint: f.fingerprint,
CertificatePath: f.certificatePath, PrivateKeyPath: f.privateKeyPath,
CertificateChainPath: f.chainPath, WebServer: deployment.WebServer(f.webServer), ReloadCommand: command,
CertificateChainPath: f.chainPath, WebServer: deployment.WebServer(f.webServer),
ValidationCommand: normalizeCommand(f.validationCommand), ReloadCommand: normalizeCommand(f.reloadCommand),
}
}
func normalizeCommand(values []string) []string {
command := make([]string, 0, len(values))
for _, value := range values {
if value = strings.TrimSpace(value); value != "" {
command = append(command, value)
}
}
return command
}
func openApplication(cmd *cobra.Command) (*app.App, error) {
cfg, err := loadConfig()
if err != nil {