检查点:保存双层证书协调进展并准备新主机验收

This commit is contained in:
xuans committed 2026-09-20 01:02:16 +08:00
1 parent 48cee12c4a
commit 2c0d0e8eda
15 files changed
+1190 -9

No files matched your search

@@ -0,0 +1,121 @@
package httpapi
import (
"bytes"
"context"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"errors"
"fmt"
"net"
"strconv"
"sync"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
// ManagementSnapshot 同时证明持久化路径、磁盘材料与当前 TLS 快照一致。
type ManagementSnapshot struct {
State ManagementCertificateState
LeafHash string
UpstreamAddress string
ProxyAddress string
}
// ManagementCertificateSession 只在独占回调内有效,不持有配置读锁跨越网络探测。
type ManagementCertificateSession struct {
mu sync.Mutex
server *Server
}
func (s *Server) WithManagementCertificate(ctx context.Context, operation func(*ManagementCertificateSession) error) error {
if err := ctx.Err(); err != nil {
return err
}
if operation == nil {
return errors.New("管理证书操作不能为空")
}
if !s.tlsMu.TryLock() {
return errors.New("管理证书或配置正在更新,请稍后重试")
}
defer s.tlsMu.Unlock()
session := &ManagementCertificateSession{server: s}
defer func() {
session.mu.Lock()
session.server = nil
session.mu.Unlock()
}()
return operation(session)
}
func (session *ManagementCertificateSession) Snapshot() (ManagementSnapshot, error) {
session.mu.Lock()
defer session.mu.Unlock()
if session.server == nil {
return ManagementSnapshot{}, errors.New("管理证书独占操作已经结束")
}
return session.server.managementSnapshotLocked()
}
func (session *ManagementCertificateSession) Activate(expected ManagementSnapshot, saved certificate.SavedResource, candidateHash string) error {
session.mu.Lock()
defer session.mu.Unlock()
if session.server == nil {
return errors.New("管理证书独占操作已经结束")
}
if candidateHash == "" {
return errors.New("管理证书协调缺少候选摘要")
}
current, err := session.server.managementSnapshotLocked()
if err != nil {
return err
}
if current.LeafHash != expected.LeafHash || current.UpstreamAddress != expected.UpstreamAddress || current.ProxyAddress != expected.ProxyAddress {
return errors.New("管理证书或监听配置在协调期间发生变化")
}
return session.server.activateTLSCertificateLocked(saved.FullChainPath, saved.PrivateKeyPath, &expected.State, candidateHash)
}
func (s *Server) managementSnapshotLocked() (ManagementSnapshot, error) {
s.configMu.RLock()
defer s.configMu.RUnlock()
var snapshot ManagementSnapshot
if !s.config.SetupReady || s.configPath == "" {
return snapshot, errors.New("管理证书协调需要已初始化的持久化配置")
}
persisted, err := config.Load(s.configPath)
if err != nil {
return snapshot, fmt.Errorf("读取管理证书持久化配置失败:%w", err)
}
state := s.managementCertificateState()
if persisted.Server.TLSCert != state.CertificatePath || persisted.Server.TLSKey != state.PrivateKeyPath {
return snapshot, errors.New("管理证书持久化路径与运行配置不一致,请先恢复服务")
}
pair, err := tls.LoadX509KeyPair(state.CertificatePath, state.PrivateKeyPath)
if err != nil {
return snapshot, fmt.Errorf("读取管理证书材料失败:%w", err)
}
live := s.tlsCertificate.Load()
if live == nil || len(live.Certificate) == 0 || !bytes.Equal(live.Certificate[0], pair.Certificate[0]) {
return snapshot, errors.New("管理证书磁盘材料与运行证书不一致,请先恢复服务")
}
leaf, err := x509.ParseCertificate(pair.Certificate[0])
if err != nil {
return snapshot, err
}
address, err := listenAddress(s.config)
if err != nil {
return snapshot, err
}
port := s.config.Server.ProxyHTTPSPort
if port == 0 {
port = 443
}
state.NotAfter = leaf.NotAfter
return ManagementSnapshot{
State: state, LeafHash: fmt.Sprintf("%x", sha256.Sum256(leaf.Raw)),
UpstreamAddress: address, ProxyAddress: net.JoinHostPort("127.0.0.1", strconv.Itoa(port)),
}, nil
}
@@ -0,0 +1,167 @@
package httpapi
import (
"context"
"crypto/sha256"
"crypto/tls"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"os"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
func TestManagementSessionPinsCandidateAndExpires(t *testing.T) {
f := newRotationFixture(t)
certPath, keyPath := f.issue(t, 3, "management.example.test", time.Now().Add(-time.Hour), time.Now().Add(30*time.Hour))
pair, err := tls.LoadX509KeyPair(certPath, keyPath)
if err != nil {
t.Fatal(err)
}
hash := fmt.Sprintf("%x", sha256.Sum256(pair.Certificate[0]))
var escaped *ManagementCertificateSession
err = f.server.WithManagementCertificate(t.Context(), func(session *ManagementCertificateSession) error {
escaped = session
previous, err := session.Snapshot()
if err != nil {
return err
}
if err := f.server.WithManagementCertificate(t.Context(), func(*ManagementCertificateSession) error {
t.Fatal("独占期间不能开始第二次协调")
return nil
}); err == nil {
t.Fatal("重入协调未被拒绝")
}
saved := certificate.SavedResource{FullChainPath: certPath, PrivateKeyPath: keyPath}
if err := session.Activate(previous, saved, previous.LeafHash); err == nil {
t.Fatal("错误的候选摘要不能切换证书")
}
if err := session.Activate(previous, saved, hash); err != nil {
return err
}
current, err := session.Snapshot()
if err != nil {
return err
}
if current.LeafHash != hash || current.State.CertificatePath != certPath {
t.Fatal("切换后快照没有反映候选")
}
return nil
})
if err != nil {
t.Fatal(err)
}
if _, err := escaped.Snapshot(); err == nil {
t.Fatal("回调结束后不能读取独占快照")
}
if err := escaped.Activate(ManagementSnapshot{}, certificate.SavedResource{}, hash); err == nil {
t.Fatal("回调结束后不能切换证书")
}
if serial, err := f.serial(); err != nil || serial != 3 {
t.Fatal("真实 TLS 未切换", serial, err)
}
}
func TestManagementSnapshotRejectsDivergence(t *testing.T) {
for _, layer := range []string{"config", "material", "unstarted"} {
t.Run(layer, func(t *testing.T) {
f := newRotationFixture(t)
certPath, keyPath := f.issue(t, 3, "management.example.test", time.Now().Add(-time.Hour), time.Now().Add(30*time.Hour))
switch layer {
case "config":
cfg, err := config.Load(f.server.configPath)
if err != nil {
t.Fatal(err)
}
cfg.Server.TLSCert, cfg.Server.TLSKey = certPath, keyPath
if err := cfg.Save(f.server.configPath); err != nil {
t.Fatal(err)
}
case "material":
for destination, source := range map[string]string{f.firstCertificate: certPath, f.firstKey: keyPath} {
data, err := os.ReadFile(source)
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(destination, data, 0o600); err != nil {
t.Fatal(err)
}
}
case "unstarted":
f.server.tlsCertificate.Store(nil)
}
if err := f.server.WithManagementCertificate(t.Context(), func(session *ManagementCertificateSession) error {
_, err := session.Snapshot()
return err
}); err == nil {
t.Fatal("配置、材料与运行快照不一致时不能报告可协调")
}
})
}
}
func TestManagementSessionDoesNotBlockTLSOrReadiness(t *testing.T) {
f := newRotationFixture(t)
f.server.secrets = readinessStore(t)
f.server.configMu.Lock()
f.server.config.DNS.Provider = "aliyun"
f.server.config.DNS.CredentialRef = readinessDNSReference
f.server.configMu.Unlock()
if err := f.server.WithManagementCertificate(t.Context(), func(session *ManagementCertificateSession) error {
if _, err := session.Snapshot(); err != nil {
return err
}
if serial, err := f.serial(); err != nil || serial != 2 {
return fmt.Errorf("独占期间握手失败:%d %v", serial, err)
}
request := httptest.NewRequest(http.MethodGet, "/readyz", nil)
request.Host = "management.example.test"
response := httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
return fmt.Errorf("独占期间就绪探测失败:%d %s", response.Code, response.Body.String())
}
return nil
}); err != nil {
t.Fatal(err)
}
}
func TestManagementSessionExcludesConfigurationWriters(t *testing.T) {
f := newRotationFixture(t)
f.server.configMu.Lock()
f.server.config.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
f.server.configMu.Unlock()
cookie := loginAuthTest(t, f.server, "admin", "AdminPass123", false).Result().Cookies()[0]
if err := f.server.WithManagementCertificate(t.Context(), func(*ManagementCertificateSession) error {
response := performChangePasswordRequest(t, f.server, cookie, `{"current_password":"AdminPass123","new_password":"NewAdmin123","confirm_password":"NewAdmin123"}`)
if response.Code != http.StatusConflict {
t.Fatalf("协调期间改密应拒绝并发保存:%d %s", response.Code, response.Body.String())
}
request := httptest.NewRequest(http.MethodPut, "/api/v1/settings", strings.NewReader(`{}`))
request.Header.Set("Content-Type", "application/json")
request.AddCookie(cookie)
response = httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusConflict {
t.Fatalf("协调期间设置应拒绝并发保存:%d %s", response.Code, response.Body.String())
}
return nil
}); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithCancel(t.Context())
cancel()
if err := f.server.WithManagementCertificate(ctx, func(*ManagementCertificateSession) error {
t.Fatal("已取消操作不能进入独占区")
return nil
}); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
}
+10 -6
View File
@@ -41,18 +41,22 @@ func (s *Server) changePassword(c *gin.Context) {
s.writeError(c, http.StatusUnauthorized, "登录状态已失效,请重新登录", nil)
return
}
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if session.UserID == "primary-super-admin" {
s.changePrimarySuperAdminPassword(c, session, cfg, request)
s.changePrimarySuperAdminPassword(c, session, request)
return
}
s.changeDatabaseUserPassword(c, session, request)
}
func (s *Server) changePrimarySuperAdminPassword(c *gin.Context, session authSession, cfg config.Config, request changePasswordRequest) {
func (s *Server) changePrimarySuperAdminPassword(c *gin.Context, session authSession, request changePasswordRequest) {
if !s.tlsMu.TryLock() {
s.writeError(c, http.StatusConflict, "管理证书或配置正在更新,请稍后重试", nil)
return
}
defer s.tlsMu.Unlock()
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if _, err := auth.AuthenticateAdmin(session.Username, request.CurrentPassword, cfg.Admin.Username, cfg.Admin.Email, cfg.Admin.PasswordHash); err != nil {
s.writeError(c, http.StatusUnauthorized, "当前密码错误", nil)
return
+5
View File
@@ -123,6 +123,11 @@ func (s *Server) resetSubmit(c *gin.Context) {
}
password := c.Request.PostForm.Get("new_password")
confirmation := c.Request.PostForm.Get("confirm_password")
if !s.tlsMu.TryLock() {
s.writeResetFailure(c, http.StatusConflict, "管理证书或配置正在更新,请稍后重试")
return
}
defer s.tlsMu.Unlock()
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
+5
View File
@@ -180,6 +180,11 @@ func (s *Server) updateSettings(c *gin.Context) {
return
}
if !s.tlsMu.TryLock() {
s.writeError(c, http.StatusConflict, "管理证书或配置正在更新,请稍后重试", nil)
return
}
defer s.tlsMu.Unlock()
s.configMu.Lock()
previous := s.config
updated := s.config
+5
View File
@@ -237,6 +237,11 @@ func (s *Server) applySetup(c *gin.Context) {
return
}
defer s.setupMu.Unlock()
if !s.tlsMu.TryLock() {
s.writeError(c, http.StatusConflict, "管理证书或配置正在更新,请稍后重试", nil)
return
}
defer s.tlsMu.Unlock()
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
@@ -2,6 +2,7 @@ package httpapi
import (
"context"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"encoding/pem"
@@ -74,6 +75,11 @@ func (s *Server) ActivateManagementCertificate(expected ManagementCertificateSta
func (s *Server) activateTLSCertificate(certificatePath, privateKeyPath string, expected *ManagementCertificateState) error {
s.tlsMu.Lock()
defer s.tlsMu.Unlock()
return s.activateTLSCertificateLocked(certificatePath, privateKeyPath, expected, "")
}
// 调用者必须持有 tlsMu,保持双层协调与配置写入之间的独占边界。
func (s *Server) activateTLSCertificateLocked(certificatePath, privateKeyPath string, expected *ManagementCertificateState, expectedHash string) error {
s.configMu.Lock()
defer s.configMu.Unlock()
if expected != nil {
@@ -92,6 +98,9 @@ func (s *Server) activateTLSCertificate(certificatePath, privateKeyPath string,
if err != nil {
return fmt.Errorf("加载新的管理证书失败:%w", err)
}
if expectedHash != "" && fmt.Sprintf("%x", sha256.Sum256(pair.Certificate[0])) != expectedHash {
return errors.New("候选管理证书在协调期间发生变化,已拒绝切换")
}
leaf, err := x509.ParseCertificate(pair.Certificate[0])
if err != nil {
return fmt.Errorf("解析新的管理证书失败:%w", err)