完善 Scert 前后端与部署支持

This commit is contained in:
xuans committed 2026-08-30 17:44:54 +08:00
1 parent afdb947bea
commit 7f0af703ed
85 files changed
+7530 -800

No files matched your search

+397 -77
View File
@@ -14,6 +14,7 @@ import (
"path/filepath"
"runtime"
"sort"
"strconv"
"strings"
"time"
)
@@ -39,20 +40,21 @@ type Resource struct {
}
type SavedResource struct {
Domain string `json:"domain"`
CertificateType string `json:"certificate_type,omitempty"`
Version string `json:"version,omitempty"`
SANs []string `json:"sans,omitempty"`
SerialNumber string `json:"serial_number,omitempty"`
FingerprintSHA256 string `json:"fingerprint_sha256,omitempty"`
ChainLength int `json:"chain_length,omitempty"`
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"`
Domain string `json:"domain"`
CertificateType string `json:"certificate_type,omitempty"`
CertificateIdentifier string `json:"certificate_identifier,omitempty"`
Version string `json:"version,omitempty"`
SANs []string `json:"sans,omitempty"`
SerialNumber string `json:"serial_number,omitempty"`
FingerprintSHA256 string `json:"fingerprint_sha256,omitempty"`
ChainLength int `json:"chain_length,omitempty"`
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 {
@@ -158,7 +160,7 @@ func (s FileStore) Save(ctx context.Context, domain string, resource Resource) (
return s.save(ctx, domain, "", resource)
}
// SaveForType 按证书类型保存当前证书和历史版本。
// SaveForType 按证书类型保存唯一的当前证书版本。
func (s FileStore) SaveForType(ctx context.Context, domain, certificateType string, resource Resource) (SavedResource, error) {
return s.save(ctx, domain, certificateType, resource)
}
@@ -183,59 +185,66 @@ func (s FileStore) save(ctx context.Context, domain, certificateType string, res
return SavedResource{}, errors.New("证书存储根目录不能为空")
}
baseDirectory := filepath.Join(root, directoryName(primary))
typeDirectory := baseDirectory
directory := baseDirectory
certificateIdentifier := ""
if certificateType != "" {
certificateType = strings.ToLower(strings.TrimSpace(certificateType))
if certificateType != "single" && certificateType != "wildcard" && certificateType != "san" {
return SavedResource{}, fmt.Errorf("证书类型无效:%s", certificateType)
}
directory = filepath.Join(baseDirectory, certificateType)
typeDirectory = filepath.Join(baseDirectory, certificateType)
directory = typeDirectory
if certificateType == "san" {
certificateIdentifier = sanCertificateIdentifier(resource.Domains)
directory = filepath.Join(typeDirectory, certificateIdentifier)
}
}
activeDirectory := directory
currentDirectory := directory
version := ""
if certificateType != "" {
currentDirectory = filepath.Join(directory, "current")
activeDirectory, err = s.activeCertificateDirectoryForType(typeDirectory, certificateType)
if err != nil {
return SavedResource{}, err
}
if !directoryContainsCertificateFiles(activeDirectory) {
activeDirectory = ""
}
now := time.Now().UTC()
if s.Now != nil {
now = s.Now().UTC()
}
version, err = nextCertificateVersion(directory, now)
if err != nil {
return SavedResource{}, err
}
currentDirectory = filepath.Join(directory, version)
}
backupDirectory := ""
if activeDirectory != "" {
backupDirectory, err = s.backupExisting(activeDirectory, primary)
if err != nil {
return SavedResource{}, err
}
}
if err := os.MkdirAll(currentDirectory, 0o700); err != nil {
return SavedResource{}, fmt.Errorf("创建证书目录失败:%w", err)
}
backupDirectory, err := s.backupExisting(currentDirectory, primary)
if err != nil {
return SavedResource{}, err
}
fullChain := resource.Certificate
if len(resource.IssuerCertificate) > 0 && !bytes.Contains(resource.Certificate, resource.IssuerCertificate) {
fullChain = append(append([]byte(nil), resource.Certificate...), resource.IssuerCertificate...)
}
version := ""
if certificateType != "" {
now := time.Now
if s.Now != nil {
now = s.Now
}
version = now().UTC().Format("20060102-150405.000000000")
versionDirectory := filepath.Join(directory, "versions", version)
for suffix := 1; ; suffix++ {
if _, statErr := os.Stat(versionDirectory); errors.Is(statErr, os.ErrNotExist) {
break
} else if statErr != nil {
return SavedResource{}, fmt.Errorf("读取证书版本目录失败:%w", statErr)
}
version = fmt.Sprintf("%s-%02d", now().UTC().Format("20060102-150405.000000000"), suffix)
versionDirectory = filepath.Join(directory, "versions", version)
}
if err := os.MkdirAll(versionDirectory, 0o700); err != nil {
return SavedResource{}, fmt.Errorf("创建证书版本目录失败:%w", err)
}
if err := writeCertificateFiles(versionDirectory, resource.Certificate, fullChain, resource.PrivateKey); err != nil {
return SavedResource{}, err
}
}
if err := writeCertificateFiles(currentDirectory, resource.Certificate, fullChain, resource.PrivateKey); err != nil {
if certificateType != "" {
_ = os.RemoveAll(currentDirectory)
}
return SavedResource{}, err
}
leaf, _ := parseLeafCertificate(resource.Certificate)
result := SavedResource{
Domain: primary, CertificateType: certificateType, Version: version, SANs: append([]string(nil), resource.Domains...),
Domain: primary, CertificateType: certificateType, CertificateIdentifier: certificateIdentifier,
Version: version, SANs: append([]string(nil), resource.Domains...),
Directory: currentDirectory, CertificatePath: filepath.Join(currentDirectory, "cert.pem"),
FullChainPath: filepath.Join(currentDirectory, "fullchain.pem"), PrivateKeyPath: filepath.Join(currentDirectory, "key.pem"),
NotBefore: resource.NotBefore, NotAfter: resource.NotAfter, BackupDirectory: backupDirectory,
@@ -247,15 +256,20 @@ func (s FileStore) save(ctx context.Context, domain, certificateType string, res
}
metadata, err := json.MarshalIndent(result, "", " ")
if err != nil {
if certificateType != "" {
_ = os.RemoveAll(currentDirectory)
}
return SavedResource{}, fmt.Errorf("生成证书元数据失败:%w", err)
}
if err := atomicWrite(filepath.Join(currentDirectory, "metadata.json"), metadata, 0o600); err != nil {
if certificateType != "" {
_ = os.RemoveAll(currentDirectory)
}
return SavedResource{}, fmt.Errorf("写入证书元数据失败:%w", err)
}
if certificateType != "" {
versionMetadata := filepath.Join(directory, "versions", version, "metadata.json")
if err := atomicWrite(versionMetadata, metadata, 0o600); err != nil {
return SavedResource{}, fmt.Errorf("写入历史证书元数据失败:%w", err)
if certificateType != "" && activeDirectory != "" && activeDirectory != currentDirectory {
if err := removeCertificateDirectory(activeDirectory, typeDirectory); err != nil {
return SavedResource{}, fmt.Errorf("清理旧当前证书目录失败:%w", err)
}
}
return result, nil
@@ -309,7 +323,16 @@ func (s FileStore) backupExisting(directory, domain string) (string, error) {
if s.Now != nil {
now = s.Now
}
backupDirectory := filepath.Join(backupRoot, directoryName(domain), now().UTC().Format("20060102-150405.000000000"))
backupBase := filepath.Join(backupRoot, directoryName(domain), now().UTC().Format("20060102-150405.000000000"))
backupDirectory := backupBase
for suffix := 1; ; suffix++ {
if _, statErr := os.Stat(backupDirectory); errors.Is(statErr, os.ErrNotExist) {
break
} else if statErr != nil {
return "", fmt.Errorf("读取证书备份目录失败:%w", statErr)
}
backupDirectory = fmt.Sprintf("%s-%02d", backupBase, suffix)
}
if err := os.MkdirAll(filepath.Dir(backupDirectory), 0o700); err != nil {
return "", fmt.Errorf("创建证书备份目录失败:%w", err)
}
@@ -395,6 +418,200 @@ func directoryName(domain string) string {
return name
}
func nextCertificateVersion(directory string, now time.Time) (string, error) {
date := now.UTC().Format("20060102")
major := 1
minor := -1
entries, err := os.ReadDir(directory)
if err != nil && !errors.Is(err, os.ErrNotExist) {
return "", fmt.Errorf("读取证书类型目录失败:%w", err)
}
for _, entry := range entries {
if !entry.IsDir() {
continue
}
entryDate, entryMajor, entryMinor, valid := parseCertificateVersion(entry.Name())
if !valid || entryDate != date {
continue
}
if entryMajor > major || entryMajor == major && entryMinor > minor {
major = entryMajor
minor = entryMinor
}
}
if minor < 0 {
minor = 0
} else {
minor++
}
return fmt.Sprintf("%s-V%d.%d", date, major, minor), nil
}
func parseCertificateVersion(version string) (string, int, int, bool) {
if len(version) < len("20060102-V1.0") || filepath.Base(version) != version || strings.ContainsAny(version, `/\\`) {
return "", 0, 0, false
}
if version[8:10] != "-V" {
return "", 0, 0, false
}
date := version[:8]
for _, r := range date {
if r < '0' || r > '9' {
return "", 0, 0, false
}
}
parts := strings.Split(version[10:], ".")
if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
return "", 0, 0, false
}
major, err := strconv.Atoi(parts[0])
if err != nil || major < 1 {
return "", 0, 0, false
}
minor, err := strconv.Atoi(parts[1])
if err != nil || minor < 0 {
return "", 0, 0, false
}
return date, major, minor, true
}
func (s FileStore) activeCertificateDirectory(directory string) (string, error) {
entries, err := os.ReadDir(directory)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
return directory, nil
}
return "", fmt.Errorf("读取证书类型目录失败:%w", err)
}
active := ""
for _, entry := range entries {
if !entry.IsDir() {
continue
}
candidate := filepath.Join(directory, entry.Name())
if _, _, _, valid := parseCertificateVersion(entry.Name()); valid && newerCertificateDirectory(candidate, active) {
active = candidate
}
}
if active != "" {
return active, nil
}
legacyCurrent := filepath.Join(directory, "current")
if info, statErr := os.Stat(legacyCurrent); statErr == nil && info.IsDir() {
return legacyCurrent, nil
} else if statErr != nil && !errors.Is(statErr, os.ErrNotExist) {
return "", fmt.Errorf("读取旧版当前证书目录失败:%w", statErr)
}
return directory, nil
}
func sanCertificateIdentifier(domains []string) string {
sum := sha256.Sum256([]byte(strings.Join(domains, "\n")))
return fmt.Sprintf("san-%x", sum[:8])
}
func directoryContainsCertificateFiles(directory string) bool {
if strings.TrimSpace(directory) == "" {
return false
}
for _, name := range []string{"cert.pem", "fullchain.pem", "key.pem", "metadata.json"} {
if info, err := os.Stat(filepath.Join(directory, name)); err == nil && !info.IsDir() {
return true
}
}
return false
}
func newerCertificateDirectory(candidate, current string) bool {
if current == "" {
return true
}
candidateDate, candidateMajor, candidateMinor, candidateValid := parseCertificateVersion(filepath.Base(candidate))
currentDate, currentMajor, currentMinor, currentValid := parseCertificateVersion(filepath.Base(current))
if !candidateValid {
return false
}
if !currentValid {
return true
}
if candidateDate != currentDate {
return candidateDate > currentDate
}
if candidateMajor != currentMajor {
return candidateMajor > currentMajor
}
if candidateMinor != currentMinor {
return candidateMinor > currentMinor
}
return candidate > current
}
func (s FileStore) activeCertificateDirectoryForType(typeDirectory, certificateType string) (string, error) {
active, err := s.activeCertificateDirectory(typeDirectory)
if err != nil {
return "", err
}
if certificateType != "san" || directoryContainsCertificateFiles(active) {
return active, nil
}
entries, err := os.ReadDir(typeDirectory)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
return typeDirectory, nil
}
return "", err
}
for _, entry := range entries {
if !entry.IsDir() || entry.Name() == "current" {
continue
}
if !strings.HasPrefix(entry.Name(), "san-") {
continue
}
if _, _, _, valid := parseCertificateVersion(entry.Name()); valid {
continue
}
candidate, candidateErr := s.activeCertificateDirectory(filepath.Join(typeDirectory, entry.Name()))
if candidateErr != nil {
return "", candidateErr
}
if directoryContainsCertificateFiles(candidate) && newerCertificateDirectory(candidate, active) {
active = candidate
}
}
return active, nil
}
func removeCertificateDirectory(directory, certificateTypeDirectory string) error {
directory = filepath.Clean(directory)
certificateTypeDirectory = filepath.Clean(certificateTypeDirectory)
parentDirectory := filepath.Dir(directory)
if parentDirectory != certificateTypeDirectory && filepath.Dir(parentDirectory) != certificateTypeDirectory {
return errors.New("旧证书目录超出证书类型目录")
}
name := filepath.Base(directory)
if name != "current" {
if err := validateCertificateVersion(name); err != nil {
return err
}
}
if err := os.RemoveAll(directory); err != nil {
return err
}
if parentDirectory != certificateTypeDirectory {
entries, err := os.ReadDir(parentDirectory)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
return nil
}
return err
}
if len(entries) == 0 {
return os.Remove(parentDirectory)
}
}
return nil
}
func validDomain(value string) bool {
value = strings.TrimPrefix(value, "*.")
if len(value) < 3 || len(value) > 253 || !strings.Contains(value, ".") {
@@ -413,7 +630,7 @@ func validDomain(value string) bool {
return true
}
// CurrentDirectory returns the active certificate directory for a domain and certificate type.
// CurrentDirectory 返回当前唯一使用的证书版本目录。
func (s FileStore) CurrentDirectory(domain, certificateType string) (string, error) {
primary := strings.TrimSpace(domain)
if _, err := NormalizeDomains([]string{primary}); err != nil {
@@ -427,7 +644,8 @@ func (s FileStore) CurrentDirectory(domain, certificateType string) (string, err
if root == "." || root == "" {
return "", errors.New("证书存储根目录不能为空")
}
return filepath.Join(root, directoryName(primary), certificateType, "current"), nil
directory := filepath.Join(root, directoryName(primary), certificateType)
return s.activeCertificateDirectoryForType(directory, certificateType)
}
// LoadCurrent reads the active certificate files and metadata.
@@ -485,41 +703,113 @@ func (s FileStore) LoadCurrent(ctx context.Context, domain, certificateType stri
return saved, resource, nil
}
// ListVersions returns all stored certificate versions in descending order.
// LoadVersion 仅允许读取当前使用的版本,保留该方法用于兼容已有接口。
func (s FileStore) LoadVersion(ctx context.Context, domain, certificateType, version string) (SavedResource, Resource, error) {
if err := ctx.Err(); err != nil {
return SavedResource{}, Resource{}, err
}
if err := validateCertificateVersion(version); err != nil {
return SavedResource{}, Resource{}, err
}
directory, err := s.CurrentDirectory(domain, certificateType)
if err != nil {
return SavedResource{}, Resource{}, err
}
if filepath.Base(directory) != version {
return SavedResource{}, Resource{}, errors.New("指定版本不是当前使用的证书版本")
}
certificateData, err := os.ReadFile(filepath.Join(directory, "cert.pem"))
if err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("读取当前证书失败:%w", err)
}
fullChainData, err := os.ReadFile(filepath.Join(directory, "fullchain.pem"))
if err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("读取当前完整证书链失败:%w", err)
}
privateKeyData, err := os.ReadFile(filepath.Join(directory, "key.pem"))
if err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("读取当前私钥失败:%w", err)
}
var saved SavedResource
metadata, err := os.ReadFile(filepath.Join(directory, "metadata.json"))
if err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("读取当前证书元数据失败:%w", err)
}
if err := json.Unmarshal(metadata, &saved); err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("解析当前证书元数据失败:%w", err)
}
if saved.Version != version {
return SavedResource{}, Resource{}, errors.New("当前证书版本标识不一致")
}
domains := saved.SANs
if len(domains) == 0 {
domains = []string{domain}
}
resource, err := ValidateResourceForDomains(Resource{
Domains: domains,
Certificate: certificateData,
IssuerCertificate: fullChainData,
PrivateKey: privateKeyData,
}, domains)
if err != nil {
return SavedResource{}, Resource{}, fmt.Errorf("当前证书校验失败:%w", err)
}
saved.Directory = directory
saved.CertificatePath = filepath.Join(directory, "cert.pem")
saved.FullChainPath = filepath.Join(directory, "fullchain.pem")
saved.PrivateKeyPath = filepath.Join(directory, "key.pem")
saved.BackupDirectory = ""
resource.IssuerCertificate = nil
return saved, resource, nil
}
// RestoreVersion 已停用,正式证书目录只保留当前使用的版本。
func (s FileStore) RestoreVersion(ctx context.Context, domain, certificateType, version string) (SavedResource, error) {
if err := ctx.Err(); err != nil {
return SavedResource{}, err
}
if err := validateCertificateVersion(version); err != nil {
return SavedResource{}, err
}
return SavedResource{}, errors.New("当前仅保留当前使用的证书版本,不支持历史版本恢复")
}
// ListVersions 返回当前唯一使用的证书版本,保留该方法用于兼容已有接口。
func (s FileStore) ListVersions(ctx context.Context, domain, certificateType string) ([]SavedResource, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
current, err := s.CurrentDirectory(domain, certificateType)
directory, err := s.CurrentDirectory(domain, certificateType)
if err != nil {
return nil, err
}
certificateDirectory := filepath.Dir(current)
versionsDirectory := filepath.Join(certificateDirectory, "versions")
entries, err := os.ReadDir(versionsDirectory)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
if _, statErr := os.Stat(filepath.Join(directory, "metadata.json")); statErr != nil {
if errors.Is(statErr, os.ErrNotExist) {
return []SavedResource{}, nil
}
return nil, fmt.Errorf("读取证书版本失败:%w", err)
return nil, fmt.Errorf("读取当前证书版本失败:%w", statErr)
}
versions := make([]SavedResource, 0, len(entries))
for _, entry := range entries {
if !entry.IsDir() {
continue
}
metadata, readErr := os.ReadFile(filepath.Join(versionsDirectory, entry.Name(), "metadata.json"))
if readErr != nil {
return nil, fmt.Errorf("读取证书版本元数据失败:%w", readErr)
}
var item SavedResource
if err := json.Unmarshal(metadata, &item); err != nil {
return nil, fmt.Errorf("解析证书版本元数据失败:%w", err)
}
versions = append(versions, item)
saved, _, err := s.LoadCurrent(ctx, domain, certificateType)
if err != nil {
return nil, err
}
sort.SliceStable(versions, func(i, j int) bool { return versions[i].Version > versions[j].Version })
return versions, nil
return []SavedResource{saved}, nil
}
func validateCertificateVersion(version string) error {
if _, _, _, valid := parseCertificateVersion(version); !valid {
return errors.New("证书版本标识无效,应使用 YYYYMMDD-Vx.x 格式")
}
return nil
}
func removeCertificateFiles(directory string) error {
for _, name := range []string{"cert.pem", "fullchain.pem", "key.pem", "metadata.json"} {
if err := os.Remove(filepath.Join(directory, name)); err != nil && !errors.Is(err, os.ErrNotExist) {
return err
}
}
return nil
}
// RollbackSavedResource 在初始化后续阶段失败时恢复证书目录。
@@ -543,6 +833,9 @@ func RollbackSavedResource(ctx context.Context, saved SavedResource) error {
if err := restoreCertificateFiles(directory, backupDirectory); err != nil {
return fmt.Errorf("恢复原证书失败:%w", err)
}
if err := rewriteRestoredMetadata(directory); err != nil {
return fmt.Errorf("更新回滚证书元数据失败:%w", err)
}
return nil
}
for _, name := range []string{"cert.pem", "fullchain.pem", "key.pem", "metadata.json"} {
@@ -551,6 +844,11 @@ func RollbackSavedResource(ctx context.Context, saved SavedResource) error {
return fmt.Errorf("清理失败证书文件 %s 失败:%w", name, err)
}
}
if _, _, _, valid := parseCertificateVersion(filepath.Base(directory)); valid {
if err := os.Remove(directory); err != nil && !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("清理失败证书目录失败:%w", err)
}
}
return nil
}
@@ -577,3 +875,25 @@ func restoreCertificateFiles(directory, backupDirectory string) error {
}
return nil
}
func rewriteRestoredMetadata(directory string) error {
path := filepath.Join(directory, "metadata.json")
data, err := os.ReadFile(path)
if err != nil {
return err
}
var saved SavedResource
if err := json.Unmarshal(data, &saved); err != nil {
return err
}
saved.Directory = directory
saved.CertificatePath = filepath.Join(directory, "cert.pem")
saved.FullChainPath = filepath.Join(directory, "fullchain.pem")
saved.PrivateKeyPath = filepath.Join(directory, "key.pem")
saved.BackupDirectory = ""
data, err = json.MarshalIndent(saved, "", " ")
if err != nil {
return err
}
return atomicWrite(path, data, 0o600)
}
@@ -10,7 +10,7 @@ import (
"time"
)
func TestFileStoreVersionedLayoutAndHistory(t *testing.T) {
func TestFileStoreUsesSingleDatedCurrentVersion(t *testing.T) {
root := t.TempDir()
store := FileStore{
Root: filepath.Join(root, "ssl"),
@@ -26,25 +26,28 @@ func TestFileStoreVersionedLayoutAndHistory(t *testing.T) {
if err != nil {
t.Fatalf("保存第二版证书失败:%v", err)
}
if first.Version == second.Version {
t.Fatalf("重复保存不应覆盖历史版本:%q", first.Version)
if first.Version != "20260827-V1.0" || second.Version != "20260827-V1.1" {
t.Fatalf("证书版本命名错误:first=%q second=%q", first.Version, second.Version)
}
wantCurrent := filepath.Join(root, "ssl", "example.com", "single", "current")
wantCurrent := filepath.Join(root, "ssl", "example.com", "single", second.Version)
if second.Directory != wantCurrent {
t.Fatalf("当前目录错误:got=%q want=%q", second.Directory, wantCurrent)
}
for _, path := range []string{
filepath.Join(wantCurrent, "cert.pem"),
filepath.Join(wantCurrent, "fullchain.pem"),
filepath.Join(wantCurrent, "key.pem"),
filepath.Join(wantCurrent, "metadata.json"),
filepath.Join(root, "ssl", "example.com", "single", "versions", first.Version, "metadata.json"),
filepath.Join(root, "ssl", "example.com", "single", "versions", second.Version, "metadata.json"),
} {
if _, err := os.Stat(path); err != nil {
t.Fatalf("证书文件不存在:%s:%v", path, err)
if _, err := os.Stat(first.Directory); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("旧当前版本目录仍存在:%v", err)
}
for _, name := range []string{"cert.pem", "fullchain.pem", "key.pem", "metadata.json"} {
if _, err := os.Stat(filepath.Join(wantCurrent, name)); err != nil {
t.Fatalf("当前证书文件不存在:%s:%v", name, err)
}
}
entries, err := os.ReadDir(filepath.Dir(wantCurrent))
if err != nil {
t.Fatalf("读取证书类型目录失败:%v", err)
}
if len(entries) != 1 || entries[0].Name() != second.Version {
t.Fatalf("正式证书目录应只保留一个版本:%v", entries)
}
if runtime.GOOS != "windows" {
info, err := os.Stat(second.PrivateKeyPath)
if err != nil {
@@ -56,44 +59,47 @@ func TestFileStoreVersionedLayoutAndHistory(t *testing.T) {
}
versions, err := store.ListVersions(context.Background(), "example.com", "single")
if err != nil {
t.Fatalf("读取证书版本失败:%v", err)
t.Fatalf("读取当前证书版本失败:%v", err)
}
if len(versions) != 2 || versions[0].Version != second.Version || versions[1].Version != first.Version {
t.Fatalf("证书版本历史错误:%+v", versions)
if len(versions) != 1 || versions[0].Version != second.Version {
t.Fatalf("当前证书版本列表错误:%+v", versions)
}
metadata, loaded, err := store.LoadCurrent(context.Background(), "example.com", "single")
if err != nil {
t.Fatalf("读取当前证书失败:%v", err)
}
if metadata.Version != second.Version || len(loaded.Certificate) == 0 || len(loaded.PrivateKey) == 0 {
if metadata.Version != second.Version || metadata.Directory != second.Directory || len(loaded.Certificate) == 0 || len(loaded.PrivateKey) == 0 {
t.Fatalf("当前证书内容错误:metadata=%+v", metadata)
}
}
func TestFileStoreListVersionsReturnsEmptyWhenNoHistory(t *testing.T) {
func TestFileStoreListVersionsReturnsEmptyWhenNoCurrentCertificate(t *testing.T) {
store := FileStore{Root: t.TempDir()}
versions, err := store.ListVersions(context.Background(), "example.com", "san")
if err != nil {
t.Fatalf("无版本记录时查询失败:%v", err)
t.Fatalf("无当前证书时查询失败:%v", err)
}
if versions == nil || len(versions) != 0 {
t.Fatalf("无版本记录时应返回空列表:%+v", versions)
t.Fatalf("无当前证书时应返回空列表:%+v", versions)
}
}
func TestRollbackSavedResourceRestoresPreviousCertificate(t *testing.T) {
func TestRollbackSavedResourceRestoresPreviousCertificateInCurrentDirectory(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, 28, 12, 0, 0, 0, time.UTC) },
}
resource := testResource(t, "example.com")
first, err := store.SaveForType(context.Background(), "example.com", "single", resource)
first, err := store.SaveForType(context.Background(), "example.com", "single", testResource(t, "example.com"))
if err != nil {
t.Fatalf("保存初始证书失败:%v", err)
}
second, err := store.SaveForType(context.Background(), "example.com", "single", resource)
firstCertificate, err := os.ReadFile(first.CertificatePath)
if err != nil {
t.Fatalf("读取初始证书失败:%v", err)
}
second, err := store.SaveForType(context.Background(), "example.com", "single", testResource(t, "example.com"))
if err != nil {
t.Fatalf("保存新证书失败:%v", err)
}
@@ -103,11 +109,19 @@ func TestRollbackSavedResourceRestoresPreviousCertificate(t *testing.T) {
if err := RollbackSavedResource(context.Background(), second); err != nil {
t.Fatalf("回滚证书失败:%v", err)
}
if _, err := os.Stat(first.FullChainPath); err != nil {
currentCertificate, err := os.ReadFile(second.CertificatePath)
if err != nil {
t.Fatalf("回滚后当前证书不存在:%v", err)
}
if _, err := os.Stat(second.PrivateKeyPath); err != nil {
t.Fatalf("回滚后当前私钥不存在:%v", err)
if string(currentCertificate) != string(firstCertificate) {
t.Fatal("回滚后当前证书内容不匹配")
}
current, _, err := store.LoadCurrent(context.Background(), "example.com", "single")
if err != nil {
t.Fatalf("读取回滚后的当前证书失败:%v", err)
}
if current.Version != first.Version || current.Directory != second.Directory {
t.Fatalf("回滚后的当前元数据错误:%+v", current)
}
}
@@ -124,9 +138,62 @@ func TestRollbackSavedResourceClearsNewCertificateFiles(t *testing.T) {
if err := RollbackSavedResource(context.Background(), saved); err != nil {
t.Fatalf("清理失败证书失败:%v", err)
}
for _, name := range []string{"cert.pem", "fullchain.pem", "key.pem", "metadata.json"} {
if _, err := os.Stat(filepath.Join(saved.Directory, name)); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("回滚后文件仍存在:%s,错误:%v", name, err)
}
if _, err := os.Stat(saved.Directory); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("回滚后当前版本目录仍存在:%v", err)
}
}
func TestFileStoreDoesNotRestoreHistoricalVersion(t *testing.T) {
store := FileStore{Root: t.TempDir()}
if _, err := store.RestoreVersion(context.Background(), "example.com", "single", "20260830-V1.0"); err == nil {
t.Fatal("仅保留当前版本时不应支持历史版本恢复")
}
}
func TestFileStoreUsesStableSANIdentifierAndRemovesPreviousIdentifier(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, 30, 12, 0, 0, 0, time.UTC) },
}
firstResource := testResource(t, "example.com")
firstResource.Domains = []string{"example.com", "www.example.com"}
first, err := store.SaveForType(context.Background(), "example.com", "san", firstResource)
if err != nil {
t.Fatalf("save first SAN certificate: %v", err)
}
if first.CertificateIdentifier == "" {
t.Fatal("SAN certificate identifier should be stored")
}
if first.Version != "20260830-V1.0" {
t.Fatalf("unexpected first SAN version: %s", first.Version)
}
wantFirst := filepath.Join(root, "ssl", "example.com", "san", first.CertificateIdentifier, first.Version)
if first.Directory != wantFirst {
t.Fatalf("unexpected first SAN directory: got=%q want=%q", first.Directory, wantFirst)
}
secondResource := firstResource
secondResource.Domains = []string{"api.example.com", "example.com"}
second, err := store.SaveForType(context.Background(), "example.com", "san", secondResource)
if err != nil {
t.Fatalf("save second SAN certificate: %v", err)
}
if second.CertificateIdentifier == first.CertificateIdentifier {
t.Fatal("different SAN sets should use different identifiers")
}
if second.Version != "20260830-V1.0" {
t.Fatalf("unexpected second SAN version: %s", second.Version)
}
if _, err := os.Stat(first.Directory); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("previous SAN certificate directory still exists: %v", err)
}
entries, err := os.ReadDir(filepath.Join(root, "ssl", "example.com", "san"))
if err != nil {
t.Fatalf("read SAN directory: %v", err)
}
if len(entries) != 1 || entries[0].Name() != second.CertificateIdentifier {
t.Fatalf("SAN directory should keep only the active identifier: %v", entries)
}
}
+38
View File
@@ -386,3 +386,41 @@ func (s *Service) ListVersions(ctx context.Context, domainID string) ([]SavedRes
}
return s.store.ListVersions(ctx, item.Name, string(item.CertificateType))
}
// RestoreVersion 将指定历史版本恢复为当前证书,并更新域名证书状态。
func (s *Service) RestoreVersion(ctx context.Context, domainID, version string) (IssueResult, error) {
if s == nil || s.repository == nil {
return IssueResult{}, errors.New("证书服务未初始化")
}
item, err := s.repository.GetByID(ctx, strings.TrimSpace(domainID))
if err != nil {
return IssueResult{}, fmt.Errorf("读取域名配置失败:%w", err)
}
domains, err := requestedDomains(item)
if err != nil {
return IssueResult{}, err
}
_, resource, err := s.store.LoadVersion(ctx, item.Name, string(item.CertificateType), strings.TrimSpace(version))
if err != nil {
return IssueResult{}, err
}
if _, err := ValidateResourceForDomains(resource, domains); err != nil {
return IssueResult{}, fmt.Errorf("历史证书不匹配当前域名配置:%w", err)
}
saved, err := s.store.RestoreVersion(ctx, item.Name, string(item.CertificateType), strings.TrimSpace(version))
if err != nil {
return IssueResult{}, err
}
if _, err := ValidateResourceForDomains(resource, domains); err != nil {
return IssueResult{}, fmt.Errorf("恢复后证书校验失败:%w", err)
}
if err := s.repository.UpdateCertificateState(ctx, item.ID, "valid", &saved.NotAfter); err != nil {
rollbackErr := RollbackSavedResource(context.Background(), saved)
if rollbackErr != nil {
return IssueResult{}, errors.Join(err, rollbackErr)
}
return IssueResult{}, fmt.Errorf("certificate state update failed after restore: %w", err)
}
saved.SANs = append([]string(nil), domains...)
return IssueResult{DomainID: item.ID, Domains: domains, Saved: saved}, nil
}
+56 -3
View File
@@ -22,8 +22,9 @@ import (
)
type serviceRepository struct {
item domain.Domain
states []string
item domain.Domain
states []string
updateErr error
}
func (r *serviceRepository) GetByID(_ context.Context, _ string) (domain.Domain, error) {
@@ -31,6 +32,9 @@ func (r *serviceRepository) GetByID(_ context.Context, _ string) (domain.Domain,
}
func (r *serviceRepository) UpdateCertificateState(_ context.Context, _ string, status string, expiresAt *time.Time) error {
if status == "valid" && r.updateErr != nil {
return r.updateErr
}
r.states = append(r.states, status)
r.item.Status = status
r.item.ExpiresAt = expiresAt
@@ -212,6 +216,55 @@ func TestServiceRejectsOwnedCertificateForWrongDomain(t *testing.T) {
}
}
func TestServiceRestoreVersionRollsBackFilesWhenStateUpdateFails(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)
}
store := FileStore{Root: cfg.Paths.Certificate, BackupRoot: cfg.Paths.Backup}
first, err := store.SaveForType(context.Background(), item.Name, "single", testResource(t, "example.com"))
if err != nil {
t.Fatal(err)
}
second, err := store.SaveForType(context.Background(), item.Name, "single", testResource(t, "example.com"))
if err != nil {
t.Fatal(err)
}
beforeCertificate, err := os.ReadFile(second.CertificatePath)
if err != nil {
t.Fatal(err)
}
beforeKey, err := os.ReadFile(second.PrivateKeyPath)
if err != nil {
t.Fatal(err)
}
repository := &serviceRepository{item: item, updateErr: errors.New("simulated state update failure")}
service := NewService(cfg, repository, nil, nil, nil)
if _, err := service.RestoreVersion(context.Background(), item.ID, first.Version); err == nil {
t.Fatal("state update failure should be returned")
}
afterCertificate, err := os.ReadFile(second.CertificatePath)
if err != nil {
t.Fatal(err)
}
afterKey, err := os.ReadFile(second.PrivateKeyPath)
if err != nil {
t.Fatal(err)
}
if string(afterCertificate) != string(beforeCertificate) || string(afterKey) != string(beforeKey) {
t.Fatal("certificate files were not rolled back after state update failure")
}
current, _, err := store.LoadCurrent(context.Background(), item.Name, string(item.CertificateType))
if err != nil {
t.Fatal(err)
}
if current.Version != second.Version {
t.Fatalf("current metadata was not rolled back: got=%s want=%s", current.Version, second.Version)
}
}
func certificateTestConfig(root string) config.Config {
cfg := config.Default(root)
cfg.Paths.Certificate = filepath.Join(root, "ssl")
@@ -261,7 +314,7 @@ func TestServiceIssuesSetupCertificateWithTypedLayout(t *testing.T) {
if err != nil {
t.Fatalf("申请初始化证书失败:%v", err)
}
wantDirectory := filepath.Join(cfg.Paths.Certificate, "scert.example.com", "single", "current")
wantDirectory := filepath.Join(cfg.Paths.Certificate, "scert.example.com", "single", saved.Version)
if saved.Directory != wantDirectory {
t.Fatalf("初始化证书目录错误:got=%q want=%q", saved.Directory, wantDirectory)
}