接入管理证书续期调度并记录任务审计通知

This commit is contained in:
xuans committed 2026-09-18 01:17:24 +08:00
1 parent 5597dd7cc2
commit c8c712131d
13 files changed
+943 -27

No files matched your search

+4
View File
@@ -201,6 +201,10 @@ func (s *Server) cancelTask(c *gin.Context) {
c.JSON(http.StatusConflict, gin.H{"error": "任务当前无法取消", "task": item})
return
}
if item.TaskType == "management_renewal" {
c.JSON(http.StatusConflict, gin.H{"error": "管理证书任务由续期调度控制,不能单独修改取消状态", "task": item})
return
}
finished := time.Now().UTC()
if err := s.tasks.CancelTask(c.Request.Context(), taskID, "任务已由用户取消", &finished); err != nil {
s.writeError(c, http.StatusConflict, "取消任务失败", err)
+18
View File
@@ -195,6 +195,24 @@ func TestTaskAPIRejectsUnknownTask(t *testing.T) {
}
}
func TestTaskAPICannotCancelManagementTaskWithoutExecutionControl(t *testing.T) {
server, tasks, _, closeDB := newTaskAPITestServer(t, nil)
defer closeDB()
item := repository.Task{ID: "management-task", DomainID: "management-certificate", TaskType: "management_renewal", Status: "running", Stage: "activate"}
if err := tasks.CreateTask(t.Context(), item); err != nil {
t.Fatal(err)
}
response := httptest.NewRecorder()
serveAdminHTTP(server, response, httptest.NewRequest(http.MethodDelete, "/api/v1/tasks/"+item.ID, nil))
if response.Code != http.StatusConflict {
t.Fatalf("不应仅修改管理任务取消状态:%d %s", response.Code, response.Body.String())
}
stored, err := tasks.GetTask(t.Context(), item.ID)
if err != nil || stored.Status != "running" {
t.Fatalf("拒绝取消后任务状态变化:%+v %v", stored, err)
}
}
func TestTaskAPICanCancelRunningIssue(t *testing.T) {
started := make(chan struct{})
server, taskRepo, _, closeDB := newTaskAPITestServer(t, func(ctx context.Context, id string) (certificate.IssueResult, deployment.Report, error) {
+43 -5
View File
@@ -7,6 +7,7 @@ import (
"encoding/pem"
"errors"
"fmt"
"reflect"
"strings"
"time"
@@ -18,17 +19,17 @@ type ManagementCertificateState struct {
CertificatePath string
PrivateKeyPath string
NotAfter time.Time
HTTPSMode string
ManagementURL string
DNSVerified bool
Request certificate.SetupCertificateRequest
}
// ManagementCertificate 返回实际配置的管理证书,不依赖业务域名仓储。
func (s *Server) ManagementCertificate() (ManagementCertificateState, error) {
s.configMu.RLock()
defer s.configMu.RUnlock()
state := ManagementCertificateState{
Hostname: strings.TrimSpace(s.config.Web.Hostname),
CertificatePath: s.config.Server.TLSCert,
PrivateKeyPath: s.config.Server.TLSKey,
}
state := s.managementCertificateState()
pair, err := tls.LoadX509KeyPair(state.CertificatePath, state.PrivateKeyPath)
if err != nil {
return state, fmt.Errorf("读取管理证书失败:%w", err)
@@ -41,13 +42,47 @@ func (s *Server) ManagementCertificate() (ManagementCertificateState, error) {
return state, nil
}
// 调用方持有配置锁;只返回续期需要的值,不暴露完整配置或通知凭据。
func (s *Server) managementCertificateState() ManagementCertificateState {
return ManagementCertificateState{
Hostname: strings.TrimSpace(s.config.Web.Hostname),
CertificatePath: s.config.Server.TLSCert,
PrivateKeyPath: s.config.Server.TLSKey,
HTTPSMode: s.config.Server.HTTPSMode,
ManagementURL: s.config.ManagementURL(),
DNSVerified: s.config.DNS.VerificationState == "verified",
Request: certificate.SetupCertificateRequest{
Domains: []string{strings.TrimSpace(s.config.Web.Hostname)}, CertificateType: "single",
ProviderID: s.config.DNS.Provider, CredentialRef: s.config.DNS.CredentialRef,
AccountEmail: s.config.ACME.AccountEmail, Environment: s.config.ACME.Environment,
CertificateRoot: s.config.Paths.Certificate, BackupRoot: s.config.Paths.Backup,
},
}
}
// ActivateTLSCertificate 先持久化完整证书路径,再切换不可变快照;失败不影响旧连接。
// 此方法仅供进程内部续期流程调用,不提供上传或任意路径的 HTTP 接口。
func (s *Server) ActivateTLSCertificate(certificatePath, privateKeyPath string) error {
return s.activateTLSCertificate(certificatePath, privateKeyPath, nil)
}
// ActivateManagementCertificate 拒绝覆盖签发期间发生的配置或证书变化。
func (s *Server) ActivateManagementCertificate(expected ManagementCertificateState, saved certificate.SavedResource) error {
return s.activateTLSCertificate(saved.FullChainPath, saved.PrivateKeyPath, &expected)
}
func (s *Server) activateTLSCertificate(certificatePath, privateKeyPath string, expected *ManagementCertificateState) error {
s.tlsMu.Lock()
defer s.tlsMu.Unlock()
s.configMu.Lock()
defer s.configMu.Unlock()
if expected != nil {
previous := *expected
previous.NotAfter = time.Time{}
if !reflect.DeepEqual(previous, s.managementCertificateState()) {
return errors.New("管理证书签发期间配置已变化,已拒绝覆盖")
}
}
if !s.config.SetupReady || strings.TrimSpace(s.configPath) == "" {
return errors.New("管理证书热更新需要已初始化的持久化配置")
}
@@ -65,6 +100,9 @@ func (s *Server) ActivateTLSCertificate(certificatePath, privateKeyPath string)
if now.Before(leaf.NotBefore) || !now.Before(leaf.NotAfter) {
return errors.New("新的管理证书不在有效期内")
}
if expected != nil && !leaf.NotAfter.After(expected.NotAfter) {
return errors.New("新的管理证书未延长实际有效期")
}
host := strings.TrimSpace(s.config.Web.Hostname)
if host == "" {
host = strings.TrimSpace(s.config.Web.PublicIP)
@@ -20,6 +20,7 @@ import (
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
@@ -176,6 +177,75 @@ func TestTLSCertificateRotationPersistsAndServesWithoutRestart(t *testing.T) {
}
}
func TestManagementActivationRejectsChangedConfiguration(t *testing.T) {
for _, field := range []string{"hostname", "dns", "mode", "certificate", "root"} {
t.Run(field, func(t *testing.T) {
f := newRotationFixture(t)
state, err := f.server.ManagementCertificate()
if err != nil {
t.Fatal(err)
}
certificatePath, keyPath := f.issue(t, 3, state.Hostname, time.Now().Add(-time.Hour), time.Now().Add(30*time.Hour))
f.server.configMu.Lock()
switch field {
case "hostname":
f.server.config.Web.Hostname = "changed.example.test"
case "dns":
f.server.config.DNS.CredentialRef = "secret://dns/changed"
case "mode":
f.server.config.Server.HTTPSMode = "proxy"
case "certificate":
f.server.config.Server.TLSCert = "changed.pem"
case "root":
f.server.config.Paths.Certificate = "changed-root"
}
f.server.configMu.Unlock()
if err := f.server.ActivateManagementCertificate(state, certificate.SavedResource{FullChainPath: certificatePath, PrivateKeyPath: keyPath}); err == nil {
t.Fatal("签发期间配置变化未阻止覆盖")
}
if serial, err := f.serial(); err != nil || serial != 2 {
t.Fatalf("拒绝更新后旧证书不可用:%d %v", serial, err)
}
})
}
}
func TestManagementActivationUsesCurrentSnapshot(t *testing.T) {
f := newRotationFixture(t)
state, err := f.server.ManagementCertificate()
if err != nil {
t.Fatal(err)
}
if !state.DNSVerified || len(state.Request.Domains) != 1 || state.Request.Domains[0] != state.Hostname {
t.Fatalf("管理续期状态不完整:%+v", state)
}
certificatePath, keyPath := f.issue(t, 3, state.Hostname, time.Now().Add(-time.Hour), time.Now().Add(30*time.Hour))
if err := f.server.ActivateManagementCertificate(state, certificate.SavedResource{FullChainPath: certificatePath, PrivateKeyPath: keyPath}); err != nil {
t.Fatal(err)
}
if serial, err := f.serial(); err != nil || serial != 3 {
t.Fatalf("管理证书未激活:%d %v", serial, err)
}
}
func TestManagementActivationChecksActualExpiryInsteadOfSavedMetadata(t *testing.T) {
f := newRotationFixture(t)
state, err := f.server.ManagementCertificate()
if err != nil {
t.Fatal(err)
}
certificatePath, keyPath := f.issue(t, 3, state.Hostname, time.Now().Add(-time.Hour), state.NotAfter.Add(-time.Hour))
err = f.server.ActivateManagementCertificate(state, certificate.SavedResource{
FullChainPath: certificatePath, PrivateKeyPath: keyPath, NotAfter: state.NotAfter.Add(time.Hour),
})
if err == nil {
t.Fatal("候选元数据不能替代证书实际有效期检查")
}
if serial, err := f.serial(); err != nil || serial != 2 {
t.Fatalf("拒绝短有效期候选后旧证书不可用:%d %v", serial, err)
}
}
func TestTLSCertificateRotationRejectsInvalidCandidates(t *testing.T) {
f := newRotationFixture(t)
now := time.Now()