完善证书管理与初始化流程

This commit is contained in:
xuans committed 2026-08-27 22:16:10 +08:00
1 parent 07636abe44
commit c74372284a
84 files changed
+10151 -3502

No files matched your search

+192 -44
View File
@@ -1,67 +1,215 @@
package admin
import (
"context"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base32"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
"strconv"
"os"
"path/filepath"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
type Server struct {
config config.Config
http *http.Server
const (
ResetPath = "/reset"
stateFileName = "scert-admin-reset.json"
defaultLease = 90 * time.Second
RefreshInterval = 30 * time.Second
)
var ErrResetSessionClosed = errors.New("密码重置会话已关闭")
type State struct {
Active bool `json:"active"`
ResetURL string `json:"reset_url"`
CodeHash string `json:"code_hash"`
ProcessID int `json:"process_id"`
StartedAt time.Time `json:"started_at"`
ExpiresAt time.Time `json:"expires_at"`
}
func New(cfg config.Config) *Server {
mux := http.NewServeMux()
mux.HandleFunc("/healthz", health)
mux.HandleFunc("/api/v1/admin/status", func(writer http.ResponseWriter, request *http.Request) {
if request.Method != http.MethodGet {
writer.WriteHeader(http.StatusMethodNotAllowed)
return
}
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
_ = json.NewEncoder(writer).Encode(map[string]any{
"service": "scert-admin",
"reset_enabled": false,
"listen_scope": "local_only",
"message": "密码重置协议尚未启用,当前仅提供受保护服务入口",
})
})
return &Server{config: cfg, http: &http.Server{
Addr: net.JoinHostPort(cfg.Admin.ResetServiceHost, strconv.Itoa(cfg.Admin.ResetServicePort)),
Handler: mux,
ReadHeaderTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
}}
type Session struct {
State State
Code string
}
func (s *Server) ListenAndServe() error {
if s.config.Admin.ResetServiceHost != "127.0.0.1" && s.config.Admin.ResetServiceHost != "::1" {
return fmt.Errorf("Scert-admin 仅允许监听本机回环地址")
type Controller struct {
config config.Config
statePath string
leaseDuration time.Duration
now func() time.Time
state State
}
func New(cfg config.Config) *Controller {
return &Controller{
config: cfg,
statePath: StatePath(cfg.Paths.Data),
leaseDuration: defaultLease,
now: time.Now,
}
return s.http.ListenAndServe()
}
func (s *Server) Shutdown(ctx context.Context) error {
if s == nil || s.http == nil {
func StatePath(dataDir string) string {
return filepath.Join(dataDir, stateFileName)
}
func (c *Controller) Start() (Session, error) {
if c == nil {
return Session{}, fmt.Errorf("Scert-admin 控制器不能为空")
}
if !c.config.SetupReady {
return Session{}, fmt.Errorf("Scert 尚未完成初始化,不能启用密码重置入口")
}
resetURL := c.config.ResetURL()
if resetURL == "" {
return Session{}, fmt.Errorf("未配置管理页面域名或公网 IP,无法生成密码重置地址")
}
if active, err := IsActive(c.statePath, c.now()); err != nil {
return Session{}, err
} else if active {
return Session{}, fmt.Errorf("密码重置入口已经启用")
}
code, err := generateCode()
if err != nil {
return Session{}, err
}
now := c.now().UTC()
c.state = State{
Active: true, ResetURL: resetURL, CodeHash: hashCode(code), ProcessID: os.Getpid(),
StartedAt: now, ExpiresAt: now.Add(c.leaseDuration),
}
if err := writeState(c.statePath, c.state); err != nil {
return Session{}, err
}
return Session{State: c.state, Code: code}, nil
}
func (c *Controller) Refresh() error {
if c == nil || !c.state.Active {
return fmt.Errorf("密码重置入口尚未启用")
}
latest, err := ReadState(c.statePath)
if err != nil {
return err
}
if !latest.Active || latest.CodeHash != c.state.CodeHash || !c.now().UTC().Before(latest.ExpiresAt) {
c.state.Active = false
return ErrResetSessionClosed
}
c.state = latest
c.state.ExpiresAt = c.now().UTC().Add(c.leaseDuration)
return writeState(c.statePath, c.state)
}
func (c *Controller) Stop() error {
if c == nil || !c.state.Active {
return nil
}
return s.http.Shutdown(ctx)
c.state.Active = false
c.state.ExpiresAt = c.now().UTC()
return writeState(c.statePath, c.state)
}
func health(writer http.ResponseWriter, request *http.Request) {
if request.Method != http.MethodGet {
writer.WriteHeader(http.StatusMethodNotAllowed)
return
func IsActive(path string, now time.Time) (bool, error) {
state, err := ReadState(path)
if errors.Is(err, os.ErrNotExist) {
return false, nil
}
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
_ = json.NewEncoder(writer).Encode(map[string]string{"status": "ok", "service": "scert-admin"})
if err != nil {
return false, err
}
return state.Active && now.UTC().Before(state.ExpiresAt), nil
}
func VerifyCode(path, code string, now time.Time) (State, error) {
state, err := ReadState(path)
if err != nil {
return State{}, err
}
if !state.Active || state.CodeHash == "" || !now.UTC().Before(state.ExpiresAt) {
return State{}, ErrResetSessionClosed
}
expected := hashCode(code)
if subtle.ConstantTimeCompare([]byte(expected), []byte(state.CodeHash)) != 1 {
return State{}, ErrResetSessionClosed
}
return state, nil
}
func Consume(path string, session State, now time.Time) error {
latest, err := ReadState(path)
if err != nil {
return err
}
if !latest.Active || latest.CodeHash == "" || !now.UTC().Before(latest.ExpiresAt) {
return ErrResetSessionClosed
}
if subtle.ConstantTimeCompare([]byte(latest.CodeHash), []byte(session.CodeHash)) != 1 {
return ErrResetSessionClosed
}
latest.Active = false
latest.CodeHash = ""
latest.ExpiresAt = now.UTC()
return writeState(path, latest)
}
func ReadState(path string) (State, error) {
data, err := os.ReadFile(path)
if err != nil {
return State{}, err
}
var state State
if err := json.Unmarshal(data, &state); err != nil {
return State{}, fmt.Errorf("解析密码重置激活状态失败:%w", err)
}
return state, nil
}
func writeState(path string, state State) error {
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return fmt.Errorf("创建密码重置状态目录失败:%w", err)
}
data, err := json.MarshalIndent(state, "", " ")
if err != nil {
return fmt.Errorf("编码密码重置激活状态失败:%w", err)
}
data = append(data, '\n')
tmpPath := path + ".tmp"
if err := os.WriteFile(tmpPath, data, 0o600); err != nil {
return fmt.Errorf("保存密码重置临时状态失败:%w", err)
}
if err := os.Chmod(tmpPath, 0o600); err != nil {
_ = os.Remove(tmpPath)
return fmt.Errorf("设置密码重置临时状态权限失败:%w", err)
}
if err := os.Rename(tmpPath, path); err != nil {
_ = os.Remove(tmpPath)
return fmt.Errorf("保存密码重置激活状态失败:%w", err)
}
if err := os.Chmod(path, 0o600); err != nil {
return fmt.Errorf("设置密码重置状态文件权限失败:%w", err)
}
return nil
}
func generateCode() (string, error) {
buffer := make([]byte, 10)
if _, err := rand.Read(buffer); err != nil {
return "", fmt.Errorf("生成一次性重置校验码失败:%w", err)
}
value := base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(buffer)
return strings.ToUpper(value[:5] + "-" + value[5:10] + "-" + value[10:]), nil
}
func hashCode(value string) string {
sum := sha256.Sum256([]byte(strings.TrimSpace(strings.ToUpper(value))))
return hex.EncodeToString(sum[:])
}
+74 -9
View File
@@ -6,6 +6,7 @@ import (
"runtime"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
@@ -28,9 +29,11 @@ func TestScertAdminSystemdUnitKeepsManualOnlyPolicy(t *testing.T) {
"Group=Scert",
"ExecStart=/scert/scert-admin --config /scert/conf/scert.json",
"Restart=no",
"RuntimeMaxSec=30min",
"UMask=0077",
"ProtectHome=yes",
"NoNewPrivileges=yes",
"RestrictAddressFamilies=AF_UNIX",
} {
if !strings.Contains(unit, required) {
t.Errorf("Scert-admin systemd unit 缺少必要策略:%s", required)
@@ -42,6 +45,8 @@ func TestScertAdminSystemdUnitKeepsManualOnlyPolicy(t *testing.T) {
"Restart=always",
"Restart=on-failure",
"ExecReload=",
"AF_INET",
"AF_INET6",
} {
if strings.Contains(unit, forbidden) {
t.Errorf("Scert-admin systemd unit 不得包含:%s", forbidden)
@@ -49,20 +54,80 @@ func TestScertAdminSystemdUnitKeepsManualOnlyPolicy(t *testing.T) {
}
}
func TestListenAndServeRejectsNonLoopbackHost(t *testing.T) {
func TestControllerActivatesAndStopsResetPath(t *testing.T) {
cfg := config.Default(t.TempDir())
cfg.Admin.ResetServiceHost = "0.0.0.0"
server := New(cfg)
if err := server.ListenAndServe(); err == nil {
t.Fatal("Scert-admin 必须拒绝非回环监听地址")
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
cfg.Server.Port = 8443
controller := New(cfg)
fixedNow := time.Date(2026, 8, 27, 12, 0, 0, 0, time.UTC)
controller.now = func() time.Time { return fixedNow }
session, err := controller.Start()
if err != nil {
t.Fatalf("启用密码重置入口失败:%v", err)
}
if session.State.ResetURL != "https://scert.example.test/reset" || session.Code == "" {
t.Fatalf("密码重置会话内容不正确:%+v", session)
}
if session.State.CodeHash == session.Code || session.State.CodeHash == "" {
t.Fatal("状态文件只能保存一次性校验码摘要")
}
active, err := IsActive(StatePath(cfg.Paths.Data), fixedNow.Add(time.Second))
if err != nil || !active {
t.Fatalf("密码重置入口应处于激活状态:active=%t err=%v", active, err)
}
if err := controller.Stop(); err != nil {
t.Fatalf("关闭密码重置入口失败:%v", err)
}
active, err = IsActive(StatePath(cfg.Paths.Data), fixedNow.Add(time.Second))
if err != nil || active {
t.Fatalf("停止 Scert-admin 后入口必须关闭:active=%t err=%v", active, err)
}
}
func TestConfigRejectsLocalhostAlias(t *testing.T) {
func TestControllerRequiresCompletedSetup(t *testing.T) {
cfg := config.Default(t.TempDir())
cfg.Admin.ResetServiceHost = "localhost"
if err := cfg.Validate(); err == nil {
t.Fatal("Scert-admin 不得依赖 localhost 名称解析")
if _, err := New(cfg).Start(); err == nil {
t.Fatal("Scert 未初始化时不得启用密码重置入口")
}
}
func TestExpiredLeaseIsInactive(t *testing.T) {
path := StatePath(t.TempDir())
now := time.Date(2026, 8, 27, 12, 0, 0, 0, time.UTC)
if err := writeState(path, State{Active: true, ExpiresAt: now.Add(-time.Second)}); err != nil {
t.Fatalf("写入过期租约失败:%v", err)
}
active, err := IsActive(path, now)
if err != nil || active {
t.Fatalf("过期租约不得保持激活:active=%t err=%v", active, err)
}
}
func TestResetCodeCanOnlyBeConsumedOnce(t *testing.T) {
cfg := config.Default(t.TempDir())
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
controller := New(cfg)
now := time.Date(2026, 8, 27, 12, 0, 0, 0, time.UTC)
controller.now = func() time.Time { return now }
session, err := controller.Start()
if err != nil {
t.Fatalf("启动密码重置会话失败:%v", err)
}
verified, err := VerifyCode(StatePath(cfg.Paths.Data), session.Code, now)
if err != nil || verified.CodeHash != session.State.CodeHash {
t.Fatalf("校验一次性校验码失败:state=%+v err=%v", verified, err)
}
if err := Consume(StatePath(cfg.Paths.Data), verified, now); err != nil {
t.Fatalf("消费一次性校验码失败:%v", err)
}
if _, err := VerifyCode(StatePath(cfg.Paths.Data), session.Code, now); err != ErrResetSessionClosed {
t.Fatalf("已消费校验码必须拒绝再次使用:%v", err)
}
if err := controller.Refresh(); err != ErrResetSessionClosed {
t.Fatalf("Scert-admin 刷新已消费会话必须停止:%v", err)
}
}