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

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

@@ -0,0 +1,54 @@
package repository
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
)
type AuditLog struct {
Action string
ResourceType string
ResourceID string
Status string
Message string
CreatedAt time.Time
}
type AuditRepository interface {
CreateAuditLog(ctx context.Context, item AuditLog) error
}
type SQLAuditRepository struct {
db *sql.DB
}
func NewSQLAuditRepository(db *sql.DB) *SQLAuditRepository {
return &SQLAuditRepository{db: db}
}
func (r *SQLAuditRepository) CreateAuditLog(ctx context.Context, item AuditLog) error {
if r == nil || r.db == nil {
return errors.New("数据库连接不能为空")
}
item.Action = strings.TrimSpace(item.Action)
item.ResourceType = strings.TrimSpace(item.ResourceType)
item.ResourceID = strings.TrimSpace(item.ResourceID)
item.Status = strings.TrimSpace(item.Status)
if item.Action == "" || item.ResourceType == "" || item.Status == "" {
return errors.New("审计日志必要字段不能为空")
}
if item.CreatedAt.IsZero() {
item.CreatedAt = time.Now().UTC()
}
_, err := r.db.ExecContext(ctx, `INSERT INTO audit_logs
(action, resource_type, resource_id, status, message, created_at)
VALUES (?, ?, ?, ?, ?, ?)`, item.Action, item.ResourceType, item.ResourceID, item.Status, item.Message, item.CreatedAt.UTC())
if err != nil {
return fmt.Errorf("保存审计日志失败:%w", err)
}
return nil
}
@@ -0,0 +1,35 @@
package repository
import (
"context"
"path/filepath"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
)
func TestSQLAuditRepositoryCreatesLog(t *testing.T) {
dir := t.TempDir()
dbConfig := config.Default(dir).Database
dbConfig.DSN = filepath.Join(dir, "data", "audit.db")
db, err := database.Open(context.Background(), dbConfig)
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)
}
repo := NewSQLAuditRepository(db.DB)
if err := repo.CreateAuditLog(context.Background(), AuditLog{Action: "admin_password_reset", ResourceType: "super_admin", ResourceID: "super-admin", Status: "success", Message: "密码重置成功"}); err != nil {
t.Fatalf("写入审计日志失败:%v", err)
}
var count int
if err := db.DB.QueryRow("SELECT COUNT(*) FROM audit_logs WHERE action = ? AND status = ?", "admin_password_reset", "success").Scan(&count); err != nil {
t.Fatalf("查询审计日志失败:%v", err)
}
if count != 1 {
t.Fatalf("审计日志数量不正确:%d", count)
}
}
@@ -0,0 +1,250 @@
package repository
import (
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
type ServerRepository interface {
CreateServer(ctx context.Context, server deployment.Server) error
UpdateServer(ctx context.Context, server deployment.Server) error
GetServerByID(ctx context.Context, id string) (deployment.Server, error)
ListServers(ctx context.Context) ([]deployment.Server, error)
DeleteServer(ctx context.Context, id string) error
IsPrivateKeyRefUsed(ctx context.Context, reference string) (bool, error)
ListServersByDomainID(ctx context.Context, domainID string) ([]deployment.Server, error)
ReplaceDomainServers(ctx context.Context, domainID string, serverIDs []string) error
}
type SQLServerRepository struct {
db *sql.DB
}
func NewSQLServerRepository(db *sql.DB) *SQLServerRepository {
return &SQLServerRepository{db: db}
}
func (r *SQLServerRepository) CreateServer(ctx context.Context, server deployment.Server) error {
server = server.Normalize()
if err := validateServer(server); err != nil {
return err
}
command, err := json.Marshal(server.ReloadCommand)
if err != nil {
return fmt.Errorf("编码 reload 命令失败:%w", err)
}
createdAt := server.CreatedAt
if createdAt.IsZero() {
createdAt = time.Now().UTC()
}
updatedAt := server.UpdatedAt
if updatedAt.IsZero() {
updatedAt = createdAt
}
_, err = r.db.ExecContext(ctx, `INSERT INTO servers
(id, name, address, port, username, private_key_ref, host_key_fingerprint, certificate_path, private_key_path, certificate_chain_path, web_server, reload_command_json, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, server.ID, server.Name, server.Address, server.Port, server.Username, server.PrivateKeyRef,
server.HostKeyFingerprint, server.CertificatePath, server.PrivateKeyPath, server.CertificateChainPath, server.WebServer, string(command), createdAt, updatedAt)
if err != nil {
return fmt.Errorf("保存服务器失败:%w", err)
}
return nil
}
func (r *SQLServerRepository) UpdateServer(ctx context.Context, server deployment.Server) error {
server = server.Normalize()
if err := validateServer(server); err != nil {
return err
}
command, err := json.Marshal(server.ReloadCommand)
if err != nil {
return fmt.Errorf("编码 reload 命令失败:%w", err)
}
result, err := r.db.ExecContext(ctx, `UPDATE servers SET name = ?, address = ?, port = ?, username = ?, private_key_ref = ?, host_key_fingerprint = ?, certificate_path = ?, private_key_path = ?, certificate_chain_path = ?, web_server = ?, reload_command_json = ?, updated_at = ? WHERE id = ?`,
server.Name, server.Address, server.Port, server.Username, server.PrivateKeyRef, server.HostKeyFingerprint, server.CertificatePath, server.PrivateKeyPath, server.CertificateChainPath, server.WebServer, string(command), time.Now().UTC(), server.ID)
if err != nil {
return fmt.Errorf("更新服务器失败:%w", err)
}
count, err := result.RowsAffected()
if err != nil {
return fmt.Errorf("读取服务器更新结果失败:%w", err)
}
if count == 0 {
return sql.ErrNoRows
}
return nil
}
func (r *SQLServerRepository) GetServerByID(ctx context.Context, id string) (deployment.Server, error) {
row := r.db.QueryRowContext(ctx, serverSelect+` WHERE id = ?`, strings.TrimSpace(id))
return scanServer(row)
}
func (r *SQLServerRepository) ListServers(ctx context.Context) ([]deployment.Server, error) {
rows, err := r.db.QueryContext(ctx, serverSelect+` ORDER BY name, id`)
if err != nil {
return nil, fmt.Errorf("查询服务器失败:%w", err)
}
defer rows.Close()
result := make([]deployment.Server, 0)
for rows.Next() {
server, err := scanServer(rows)
if err != nil {
return nil, err
}
result = append(result, server)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取服务器失败:%w", err)
}
return result, nil
}
func (r *SQLServerRepository) DeleteServer(ctx context.Context, id string) error {
id = strings.TrimSpace(id)
if id == "" {
return errors.New("服务器 ID 不能为空")
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("开始删除服务器失败:%w", err)
}
rollback := func(cause error) error {
_ = tx.Rollback()
return cause
}
if _, err := tx.ExecContext(ctx, "DELETE FROM domain_servers WHERE server_id = ?", id); err != nil {
return rollback(fmt.Errorf("删除服务器关联失败:%w", err))
}
result, err := tx.ExecContext(ctx, "DELETE FROM servers WHERE id = ?", id)
if err != nil {
return rollback(fmt.Errorf("删除服务器失败:%w", err))
}
count, err := result.RowsAffected()
if err != nil {
return rollback(fmt.Errorf("读取服务器删除结果失败:%w", err))
}
if count == 0 {
return rollback(sql.ErrNoRows)
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("提交服务器删除失败:%w", err)
}
return nil
}
func (r *SQLServerRepository) IsPrivateKeyRefUsed(ctx context.Context, reference string) (bool, error) {
reference = strings.TrimSpace(reference)
if reference == "" {
return false, errors.New("SSH 私钥引用不能为空")
}
var count int
if err := r.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM servers WHERE private_key_ref = ?", reference).Scan(&count); err != nil {
return false, fmt.Errorf("检查 SSH 私钥引用占用状态失败:%w", err)
}
return count > 0, nil
}
func (r *SQLServerRepository) ListServersByDomainID(ctx context.Context, domainID string) ([]deployment.Server, error) {
rows, err := r.db.QueryContext(ctx, serverSelectQualified+` INNER JOIN domain_servers ds ON ds.server_id = servers.id WHERE ds.domain_id = ? ORDER BY servers.name, servers.id`, strings.TrimSpace(domainID))
if err != nil {
return nil, fmt.Errorf("查询域名部署服务器失败:%w", err)
}
defer rows.Close()
result := make([]deployment.Server, 0)
for rows.Next() {
server, err := scanServer(rows)
if err != nil {
return nil, err
}
result = append(result, server)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取域名部署服务器失败:%w", err)
}
return result, nil
}
func (r *SQLServerRepository) ReplaceDomainServers(ctx context.Context, domainID string, serverIDs []string) error {
if strings.TrimSpace(domainID) == "" {
return errors.New("域名 ID 不能为空")
}
cleaned := make([]string, 0, len(serverIDs))
seen := make(map[string]struct{}, len(serverIDs))
for _, id := range serverIDs {
id = strings.TrimSpace(id)
if id == "" {
return errors.New("服务器 ID 不能为空")
}
if _, ok := seen[id]; ok {
continue
}
seen[id] = struct{}{}
cleaned = append(cleaned, id)
}
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("开始更新域名服务器关联失败:%w", err)
}
rollback := func(cause error) error {
_ = tx.Rollback()
return cause
}
if _, err := tx.ExecContext(ctx, "DELETE FROM domain_servers WHERE domain_id = ?", domainID); err != nil {
return rollback(fmt.Errorf("清理域名服务器关联失败:%w", err))
}
for _, serverID := range cleaned {
var exists int
if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM servers WHERE id = ?", serverID).Scan(&exists); err != nil {
return rollback(fmt.Errorf("校验部署服务器失败:%w", err))
}
if exists == 0 {
return rollback(fmt.Errorf("部署服务器不存在:%s", serverID))
}
if _, err := tx.ExecContext(ctx, "INSERT INTO domain_servers (domain_id, server_id) VALUES (?, ?)", domainID, serverID); err != nil {
return rollback(fmt.Errorf("保存域名服务器关联失败:%w", err))
}
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("提交域名服务器关联失败:%w", err)
}
return nil
}
const serverSelect = `SELECT id, name, address, port, username, private_key_ref, host_key_fingerprint, certificate_path, private_key_path, certificate_chain_path, web_server, reload_command_json, created_at, updated_at FROM servers`
const serverSelectQualified = `SELECT servers.id, servers.name, servers.address, servers.port, servers.username, servers.private_key_ref, servers.host_key_fingerprint, servers.certificate_path, servers.private_key_path, servers.certificate_chain_path, servers.web_server, servers.reload_command_json, servers.created_at, servers.updated_at FROM servers`
type rowScanner interface {
Scan(dest ...any) error
}
func scanServer(row rowScanner) (deployment.Server, error) {
var server deployment.Server
var webServer string
var commandJSON string
if err := row.Scan(&server.ID, &server.Name, &server.Address, &server.Port, &server.Username, &server.PrivateKeyRef, &server.HostKeyFingerprint, &server.CertificatePath, &server.PrivateKeyPath, &server.CertificateChainPath, &webServer, &commandJSON, &server.CreatedAt, &server.UpdatedAt); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return deployment.Server{}, sql.ErrNoRows
}
return deployment.Server{}, fmt.Errorf("读取服务器失败:%w", err)
}
server.WebServer = deployment.WebServer(webServer)
if err := json.Unmarshal([]byte(commandJSON), &server.ReloadCommand); err != nil {
return deployment.Server{}, fmt.Errorf("解析 reload 命令失败:%w", err)
}
return server.Normalize(), nil
}
func validateServer(server deployment.Server) error {
if err := server.Validate(); err != nil {
return err
}
return nil
}
@@ -0,0 +1,159 @@
package repository
import (
"context"
"path/filepath"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
)
func TestServerRepositoryCRUDAndDomainAssociations(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir).Database
cfg.DSN = filepath.Join(dir, "data", "servers.db")
db, err := database.Open(context.Background(), cfg)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatal(err)
}
repo := NewSQLServerRepository(db.DB)
server := deployment.Server{
ID: "server-1", Name: "生产服务器", Address: "192.0.2.10", Port: 22, Username: "deploy",
PrivateKeyRef: "secret://ssh/server-1", HostKeyFingerprint: "SHA256:test",
CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem",
CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx,
}
if err := repo.CreateServer(context.Background(), server); err != nil {
t.Fatalf("创建服务器失败:%v", err)
}
loaded, err := repo.GetServerByID(context.Background(), server.ID)
if err != nil {
t.Fatalf("读取服务器失败:%v", err)
}
if loaded.Name != server.Name || loaded.ReloadCommand[0] != "nginx" || loaded.CreatedAt.IsZero() {
t.Fatalf("服务器内容错误:%+v", loaded)
}
server.Name = "生产服务器-更新"
server.WebServer = deployment.WebServerCaddy
server.ReloadCommand = nil
if err := repo.UpdateServer(context.Background(), server); err != nil {
t.Fatalf("更新服务器失败:%v", err)
}
if err := repo.ReplaceDomainServers(context.Background(), "domain-1", []string{server.ID, server.ID}); err != nil {
t.Fatalf("保存域名服务器关联失败:%v", err)
}
associated, err := repo.ListServersByDomainID(context.Background(), "domain-1")
if err != nil || len(associated) != 1 || associated[0].WebServer != deployment.WebServerCaddy {
t.Fatalf("域名服务器关联错误:%v %+v", err, associated)
}
servers, err := repo.ListServers(context.Background())
if err != nil || len(servers) != 1 {
t.Fatalf("服务器列表错误:%v %+v", err, servers)
}
if err := repo.DeleteServer(context.Background(), server.ID); err != nil {
t.Fatalf("删除服务器失败:%v", err)
}
associated, err = repo.ListServersByDomainID(context.Background(), "domain-1")
if err != nil {
t.Fatalf("读取删除后的域名服务器关联失败:%v", err)
}
if len(associated) != 0 {
t.Fatalf("删除服务器后不应保留悬空关联:%+v", associated)
}
}
func TestServerRepositoryRejectsInvalidServer(t *testing.T) {
db, err := database.Open(context.Background(), config.DatabaseConfig{
Driver: "sqlite", DSN: ":memory:", MaxOpenConns: 1, MaxIdleConns: 1,
})
if err != nil {
t.Fatal(err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatal(err)
}
if err := NewSQLServerRepository(db.DB).CreateServer(context.Background(), deployment.Server{}); err == nil {
t.Fatal("无效服务器配置应被拒绝")
}
}
func TestServerRepositoryReportsPrivateKeyReferenceUsage(t *testing.T) {
db := openServerTestDatabase(t)
defer db.Close()
repo := NewSQLServerRepository(db.DB)
server := validTestServer()
server.ID = "server-private-key-usage"
server.PrivateKeyRef = "secret://ssh/used-key"
if err := repo.CreateServer(t.Context(), server); err != nil {
t.Fatalf("创建测试服务器失败:%v", err)
}
used, err := repo.IsPrivateKeyRefUsed(t.Context(), server.PrivateKeyRef)
if err != nil || !used {
t.Fatalf("未识别已占用的 SSH 私钥引用:used=%t err=%v", used, err)
}
used, err = repo.IsPrivateKeyRefUsed(t.Context(), "secret://ssh/not-used")
if err != nil || used {
t.Fatalf("错误识别未占用的 SSH 私钥引用:used=%t err=%v", used, err)
}
}
func TestReplaceDomainServersRejectsUnknownServerWithoutChangingAssociations(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir).Database
cfg.DSN = filepath.Join(dir, "data", "association.db")
db, err := database.Open(context.Background(), cfg)
if err != nil {
t.Fatal(err)
}
defer db.Close()
if err := database.Migrate(context.Background(), db.DB, "sqlite"); err != nil {
t.Fatal(err)
}
repo := NewSQLServerRepository(db.DB)
server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.20", Username: "deploy", PrivateKeyRef: "secret://ssh/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx}
if err := repo.CreateServer(context.Background(), server); err != nil {
t.Fatal(err)
}
if err := repo.ReplaceDomainServers(context.Background(), "domain-1", []string{server.ID}); err != nil {
t.Fatal(err)
}
if err := repo.ReplaceDomainServers(context.Background(), "domain-1", []string{"missing"}); err == nil {
t.Fatal("未知服务器应被拒绝")
}
items, err := repo.ListServersByDomainID(context.Background(), "domain-1")
if err != nil || len(items) != 1 || items[0].ID != server.ID {
t.Fatalf("失败后原关联应保持不变:%v %+v", err, items)
}
}
func openServerTestDatabase(t *testing.T) *database.Database {
t.Helper()
directory := t.TempDir()
cfg := config.Default(directory).Database
cfg.DSN = filepath.Join(directory, "data", "server-test.db")
db, err := database.Open(t.Context(), cfg)
if err != nil {
t.Fatalf("打开服务器测试数据库失败:%v", err)
}
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
_ = db.Close()
t.Fatalf("迁移服务器测试数据库失败:%v", err)
}
return db
}
func validTestServer() deployment.Server {
return deployment.Server{
Name: "测试服务器", Address: "192.0.2.70", Port: 22, Username: "deploy",
PrivateKeyRef: "secret://ssh/test", HostKeyFingerprint: "SHA256:test",
CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem",
CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx,
}
}
@@ -100,16 +100,30 @@ func (r *SQLDomainRepository) Delete(ctx context.Context, id string) error {
if r == nil || r.db == nil {
return errors.New("数据库连接不能为空")
}
result, err := r.db.ExecContext(ctx, "DELETE FROM domains WHERE id = ?", id)
tx, err := r.db.BeginTx(ctx, nil)
if err != nil {
return fmt.Errorf("删除域名失败:%w", err)
return fmt.Errorf("开始删除域名失败:%w", err)
}
rollback := func(cause error) error {
_ = tx.Rollback()
return cause
}
if _, err := tx.ExecContext(ctx, "DELETE FROM domain_servers WHERE domain_id = ?", id); err != nil {
return rollback(fmt.Errorf("删除域名服务器关联失败:%w", err))
}
result, err := tx.ExecContext(ctx, "DELETE FROM domains WHERE id = ?", id)
if err != nil {
return rollback(fmt.Errorf("删除域名失败:%w", err))
}
count, err := result.RowsAffected()
if err != nil {
return fmt.Errorf("读取删除结果失败:%w", err)
return rollback(fmt.Errorf("读取删除结果失败:%w", err))
}
if count == 0 {
return sql.ErrNoRows
return rollback(sql.ErrNoRows)
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("提交域名删除失败:%w", err)
}
return nil
}
@@ -9,6 +9,7 @@ import (
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
@@ -84,9 +85,21 @@ func TestRepositoryCRUD(t *testing.T) {
if err != nil || len(items) != 1 {
t.Fatalf("域名列表不正确:%v,%+v", err, items)
}
serverRepo := NewSQLServerRepository(db.DB)
server := deployment.Server{ID: "server-1", Name: "服务器", Address: "192.0.2.30", Username: "deploy", PrivateKeyRef: "secret://ssh/1", HostKeyFingerprint: "SHA256:test", CertificatePath: "/etc/scert/cert.pem", PrivateKeyPath: "/etc/scert/key.pem", CertificateChainPath: "/etc/scert/fullchain.pem", WebServer: deployment.WebServerNginx}
if err := serverRepo.CreateServer(context.Background(), server); err != nil {
t.Fatalf("创建关联服务器失败:%v", err)
}
if err := serverRepo.ReplaceDomainServers(context.Background(), item.ID, []string{server.ID}); err != nil {
t.Fatalf("创建域名服务器关联失败:%v", err)
}
if err := repo.Delete(context.Background(), item.ID); err != nil {
t.Fatalf("删除域名失败:%v", err)
}
associated, err := serverRepo.ListServersByDomainID(context.Background(), item.ID)
if err != nil || len(associated) != 0 {
t.Fatalf("删除域名后不应保留服务器关联:%v %+v", err, associated)
}
if err := repo.Delete(context.Background(), item.ID); !IsNotFound(err) {
t.Fatalf("重复删除未返回未找到:%v", err)
}