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

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

+254
View File
@@ -0,0 +1,254 @@
package httpapi
import (
"crypto/rand"
"encoding/hex"
"net"
"net/http"
"strings"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/auth"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
const (
authCookieName = "scert_session"
authSessionLifetime = 30 * time.Minute
rememberSessionLife = 14 * 24 * time.Hour
loginWindow = 15 * time.Minute
loginBlockDuration = 5 * time.Minute
loginFailureLimit = 5
authRequestBodyLimit = 16 * 1024
)
type authSession struct {
Username string
Email string
Role string
ExpiresAt time.Time
}
type loginAttempt struct {
Failures int
WindowStart time.Time
BlockedTill time.Time
}
type authLoginRequest struct {
Identifier string `json:"identifier"`
Password string `json:"password"`
Remember bool `json:"remember"`
}
func (s *Server) authLogin(c *gin.Context) {
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, authRequestBodyLimit)
var request authLoginRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "\u767b\u5f55\u8bf7\u6c42\u53c2\u6570\u65e0\u6548", err)
return
}
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if !cfg.SetupReady {
s.writeError(c, http.StatusConflict, "\u8bf7\u5148\u5b8c\u6210\u521d\u59cb\u5316\u914d\u7f6e", nil)
return
}
key := loginAttemptKey(c.Request, request.Identifier)
if !s.allowLogin(key) {
s.writeError(c, http.StatusTooManyRequests, "\u767b\u5f55\u5931\u8d25\u6b21\u6570\u8fc7\u591a\uff0c\u8bf7\u7a0d\u540e\u518d\u8bd5", nil)
return
}
account, err := auth.AuthenticateAdmin(
request.Identifier,
request.Password,
cfg.Admin.Username,
cfg.Admin.Email,
cfg.Admin.PasswordHash,
)
if err != nil {
s.recordLoginFailure(key)
s.recordAuthAudit(c, "\u767b\u5f55\u5931\u8d25", "failed", "\u767b\u5f55\u51ed\u636e\u6821\u9a8c\u5931\u8d25")
s.writeError(c, http.StatusUnauthorized, "\u8d26\u53f7\u6216\u5bc6\u7801\u9519\u8bef", nil)
return
}
s.clearLoginFailures(key)
token, err := newAuthToken()
if err != nil {
s.writeError(c, http.StatusInternalServerError, "\u65e0\u6cd5\u521b\u5efa\u767b\u5f55\u4f1a\u8bdd\uff0c\u8bf7\u7a0d\u540e\u91cd\u8bd5", err)
return
}
lifetime := authSessionLifetime
if request.Remember {
lifetime = rememberSessionLife
}
expiresAt := s.now().Add(lifetime)
s.authMu.Lock()
s.authSessions[token] = authSession{
Username: account.Username,
Email: account.Email,
Role: account.Role,
ExpiresAt: expiresAt,
}
s.authMu.Unlock()
s.setAuthCookie(c, token, expiresAt)
s.recordAuthAudit(c, "\u767b\u5f55\u6210\u529f", "success", "\u8d85\u7ea7\u7ba1\u7406\u5458\u767b\u5f55\u6210\u529f")
c.JSON(http.StatusOK, gin.H{
"authenticated": true,
"account": account.Username,
"email": account.Email,
"role": account.Role,
"is_admin": true,
"next_step": "complete",
"required_steps": []string{},
"expires_at": expiresAt,
})
}
func (s *Server) authSession(c *gin.Context) {
session, ok := s.currentAuthSession(c)
if !ok {
c.JSON(http.StatusUnauthorized, gin.H{"authenticated": false})
return
}
c.JSON(http.StatusOK, gin.H{
"authenticated": true,
"account": session.Username,
"email": session.Email,
"role": session.Role,
"is_admin": session.Role == "super_admin" || session.Role == "admin",
"next_step": "complete",
"required_steps": []string{},
"expires_at": session.ExpiresAt,
})
}
func (s *Server) authLogout(c *gin.Context) {
if token, err := c.Cookie(authCookieName); err == nil && token != "" {
s.authMu.Lock()
delete(s.authSessions, token)
s.authMu.Unlock()
}
http.SetCookie(c.Writer, &http.Cookie{
Name: authCookieName, Value: "", Path: "/", MaxAge: -1,
HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: requestIsHTTPS(c.Request),
})
c.JSON(http.StatusOK, gin.H{"authenticated": false, "message": "\u5df2\u9000\u51fa\u767b\u5f55"})
}
func (s *Server) currentAuthSession(c *gin.Context) (authSession, bool) {
token, err := c.Cookie(authCookieName)
if err != nil || strings.TrimSpace(token) == "" {
return authSession{}, false
}
now := s.now()
s.authMu.RLock()
session, ok := s.authSessions[token]
s.authMu.RUnlock()
if !ok {
return authSession{}, false
}
if !session.ExpiresAt.After(now) {
s.authMu.Lock()
delete(s.authSessions, token)
s.authMu.Unlock()
return authSession{}, false
}
return session, true
}
func (s *Server) setAuthCookie(c *gin.Context, token string, expiresAt time.Time) {
http.SetCookie(c.Writer, &http.Cookie{
Name: authCookieName, Value: token, Path: "/",
Expires: expiresAt, MaxAge: max(1, int(time.Until(expiresAt).Seconds())),
HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: requestIsHTTPS(c.Request),
})
}
func (s *Server) allowLogin(key string) bool {
now := s.now()
s.loginMu.Lock()
defer s.loginMu.Unlock()
attempt, ok := s.loginAttempts[key]
if !ok {
return true
}
if !attempt.BlockedTill.IsZero() && attempt.BlockedTill.After(now) {
return false
}
if attempt.WindowStart.IsZero() || now.Sub(attempt.WindowStart) >= loginWindow {
delete(s.loginAttempts, key)
}
return true
}
func (s *Server) recordLoginFailure(key string) {
now := s.now()
s.loginMu.Lock()
defer s.loginMu.Unlock()
attempt := s.loginAttempts[key]
if attempt.WindowStart.IsZero() || now.Sub(attempt.WindowStart) >= loginWindow {
attempt = loginAttempt{WindowStart: now}
}
attempt.Failures++
if attempt.Failures >= loginFailureLimit {
attempt.BlockedTill = now.Add(loginBlockDuration)
}
s.loginAttempts[key] = attempt
}
func (s *Server) clearLoginFailures(key string) {
s.loginMu.Lock()
delete(s.loginAttempts, key)
s.loginMu.Unlock()
}
func (s *Server) recordAuthAudit(c *gin.Context, action, status, message string) {
if s.audit == nil {
return
}
if err := s.audit.CreateAuditLog(c.Request.Context(), repository.AuditLog{
Action: action, ResourceType: "auth", ResourceID: "login", Status: status, Message: message,
}); err != nil && s.logger != nil {
s.logger.Warn("\u4fdd\u5b58\u767b\u5f55\u5ba1\u8ba1\u65e5\u5fd7\u5931\u8d25", "error", err)
}
}
func loginAttemptKey(request *http.Request, identifier string) string {
remote := "unknown"
if request != nil {
remote = request.RemoteAddr
if host, _, err := net.SplitHostPort(remote); err == nil {
remote = host
}
}
return strings.ToLower(strings.TrimSpace(remote + "|" + identifier))
}
func newAuthToken() (string, error) {
buffer := make([]byte, 32)
if _, err := rand.Read(buffer); err != nil {
return "", err
}
return hex.EncodeToString(buffer), nil
}
func requestIsHTTPS(request *http.Request) bool {
if request == nil {
return false
}
return request.TLS != nil || strings.EqualFold(strings.TrimSpace(request.Header.Get("X-Forwarded-Proto")), "https")
}
func max(left, right int) int {
if left > right {
return left
}
return right
}
+251
View File
@@ -0,0 +1,251 @@
package httpapi
import (
"crypto/rand"
"crypto/subtle"
"encoding/hex"
"html/template"
"mime"
"net"
"net/http"
"net/url"
"strings"
"time"
"github.com/gin-gonic/gin"
"golang.org/x/crypto/bcrypt"
"git.pcux.cn/xuans/Scert/backend/internal/admin"
"git.pcux.cn/xuans/Scert/backend/internal/passwordpolicy"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
type resetPageData struct {
CSRFToken string
Message string
Success bool
}
func (s *Server) currentResetSession() (admin.State, bool) {
state, err := admin.ReadState(s.resetStatePath)
if err != nil || !state.Active || state.CodeHash == "" || !s.now().UTC().Before(state.ExpiresAt) {
return admin.State{}, false
}
if state.CodeHash == s.resetClosedHash {
return admin.State{}, false
}
return state, true
}
func newCSRFToken() (string, error) {
buffer := make([]byte, 32)
if _, err := rand.Read(buffer); err != nil {
return "", err
}
return hex.EncodeToString(buffer), nil
}
func (s *Server) setResetCSRFCookie(c *gin.Context, token string, expiresAt time.Time) {
maxAge := int(expiresAt.Sub(s.now().UTC()).Seconds())
if maxAge < 1 {
maxAge = 1
}
c.SetSameSite(http.SameSiteStrictMode)
c.SetCookie(resetCSRFTokenName, token, maxAge, admin.ResetPath, "", resetCookieSecure(c.Request), true)
}
func resetCookieSecure(request *http.Request) bool {
if request == nil {
return true
}
if request.TLS != nil {
return true
}
host := request.Host
if parsedHost, _, err := net.SplitHostPort(request.Host); err == nil {
host = parsedHost
}
host = strings.Trim(host, "[]")
return host != "localhost" && host != "127.0.0.1" && host != "::1"
}
func (s *Server) resetSubmit(c *gin.Context) {
s.resetMu.Lock()
defer s.resetMu.Unlock()
session, ok := s.currentResetSession()
if !ok {
c.Status(http.StatusNotFound)
return
}
ip := resetClientIP(c.Request)
now := s.now().UTC()
if !s.resetLimiter.allowed(ip, now) {
s.recordResetAudit(c, "blocked", "密码重置请求超过失败频率限制")
c.Status(http.StatusTooManyRequests)
return
}
if !sameOrigin(c.Request) {
s.resetLimiter.failed(ip, now)
s.recordResetAudit(c, "rejected", "密码重置请求来源校验失败")
s.writeResetFailure(c, http.StatusForbidden, "请求来源校验失败,请从重置页面重新提交")
return
}
mediaType, _, err := mime.ParseMediaType(c.GetHeader("Content-Type"))
if err != nil || mediaType != "application/x-www-form-urlencoded" {
s.resetLimiter.failed(ip, now)
s.recordResetAudit(c, "rejected", "密码重置请求类型无效")
s.writeResetFailure(c, http.StatusBadRequest, "请求格式无效,请从重置页面重新提交")
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, resetMaxBodyBytes)
if err := c.Request.ParseForm(); err != nil {
s.resetLimiter.failed(ip, now)
s.recordResetAudit(c, "rejected", "密码重置请求内容无效")
s.writeResetFailure(c, http.StatusBadRequest, "请求内容无效,请稍后重试")
return
}
token := c.Request.PostForm.Get("csrf_token")
cookie, err := c.Request.Cookie(resetCSRFTokenName)
if err != nil || subtle.ConstantTimeCompare([]byte(token), []byte(cookie.Value)) != 1 || token == "" {
s.resetLimiter.failed(ip, now)
s.recordResetAudit(c, "rejected", "密码重置 CSRF 校验失败")
s.writeResetFailure(c, http.StatusForbidden, "安全校验失败,请刷新页面后重试")
return
}
code := c.Request.PostForm.Get("reset_code")
verified, err := admin.VerifyCode(s.resetStatePath, code, now)
if err != nil || verified.CodeHash != session.CodeHash {
s.resetLimiter.failed(ip, now)
s.recordResetAudit(c, "failed", "密码重置校验码无效或已失效")
s.writeResetFailure(c, http.StatusBadRequest, "重置校验失败,请检查一次性校验码")
return
}
password := c.Request.PostForm.Get("new_password")
confirmation := c.Request.PostForm.Get("confirm_password")
s.configMu.RLock()
cfg := s.config
s.configMu.RUnlock()
if password != confirmation {
s.recordResetAudit(c, "failed", "密码重置两次输入不一致")
s.renderResetPage(c, http.StatusBadRequest, token, "两次输入的新密码不一致")
return
}
if err := passwordpolicy.Validate(password, cfg.Admin.Username); err != nil {
s.recordResetAudit(c, "failed", "密码重置新密码不符合安全规则")
s.renderResetPage(c, http.StatusBadRequest, token, err.Error())
return
}
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
s.recordResetAudit(c, "error", "生成新密码摘要失败")
s.writeResetFailure(c, http.StatusInternalServerError, "暂时无法保存新密码,请稍后重试")
return
}
cfg.Admin.PasswordHash = string(hash)
if strings.TrimSpace(s.configPath) == "" {
s.recordResetAudit(c, "error", "密码重置配置路径未配置")
s.writeResetFailure(c, http.StatusInternalServerError, "服务配置路径未就绪,请联系管理员")
return
}
if err := cfg.Save(s.configPath); err != nil {
s.recordResetAudit(c, "error", "保存密码重置配置失败")
s.writeResetFailure(c, http.StatusInternalServerError, "暂时无法保存新密码,请稍后重试")
return
}
if err := admin.Consume(s.resetStatePath, verified, now); err != nil {
s.resetClosedHash = session.CodeHash
s.configMu.Lock()
s.config = cfg
s.configMu.Unlock()
s.recordResetAudit(c, "error", "新密码已保存但重置入口关闭失败")
s.clearResetCookie(c)
s.renderResetSuccess(c, "密码已更新,但重置入口关闭状态需要由 Scert-admin 停止后完成")
return
}
s.configMu.Lock()
s.config = cfg
s.configMu.Unlock()
s.resetClosedHash = session.CodeHash
s.resetLimiter.clear(ip)
s.recordResetAudit(c, "success", "超级管理员密码重置成功")
s.clearResetCookie(c)
s.renderResetSuccess(c, "密码重置成功,请停止 Scert-admin 以结束本次维护窗口")
}
func sameOrigin(request *http.Request) bool {
if request == nil || strings.TrimSpace(request.Host) == "" {
return false
}
scheme := "http"
if request.TLS != nil {
scheme = "https"
}
origin := strings.TrimSpace(request.Header.Get("Origin"))
if origin == "" {
origin = strings.TrimSpace(request.Header.Get("Referer"))
}
if origin == "" {
return false
}
parsed, err := url.Parse(origin)
if err != nil || parsed.Host == "" || !strings.EqualFold(parsed.Scheme, scheme) {
return false
}
return strings.EqualFold(parsed.Host, request.Host)
}
func (s *Server) clearResetCookie(c *gin.Context) {
c.SetSameSite(http.SameSiteStrictMode)
c.SetCookie(resetCSRFTokenName, "", -1, admin.ResetPath, "", resetCookieSecure(c.Request), true)
}
func (s *Server) writeResetFailure(c *gin.Context, status int, message string) {
token := ""
if cookie, err := c.Request.Cookie(resetCSRFTokenName); err == nil {
token = cookie.Value
}
s.renderResetPage(c, status, token, message)
}
func (s *Server) renderResetPage(c *gin.Context, status int, token, message string) {
s.setResetHeaders(c)
data := resetPageData{CSRFToken: token, Message: message}
c.Status(status)
if err := resetTemplate.Execute(c.Writer, data); err != nil && s.logger != nil {
s.logger.Error("渲染密码重置页面失败", "error", err)
}
}
func (s *Server) renderResetSuccess(c *gin.Context, message string) {
s.setResetHeaders(c)
if err := resetSuccessTemplate.Execute(c.Writer, resetPageData{Message: message, Success: true}); err != nil && s.logger != nil {
s.logger.Error("渲染密码重置成功页面失败", "error", err)
}
c.Status(http.StatusOK)
}
func (s *Server) setResetHeaders(c *gin.Context) {
c.Header("Cache-Control", "no-store, no-cache, must-revalidate")
c.Header("Pragma", "no-cache")
c.Header("X-Robots-Tag", "noindex, nofollow, noarchive")
c.Header("Referrer-Policy", "no-referrer")
c.Header("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'")
c.Header("Content-Type", "text/html; charset=utf-8")
}
func (s *Server) recordResetAudit(c *gin.Context, status, message string) {
if s.audit == nil {
return
}
err := s.audit.CreateAuditLog(c.Request.Context(), repository.AuditLog{
Action: "admin_password_reset", ResourceType: "super_admin", ResourceID: "super-admin",
Status: status, Message: message, CreatedAt: s.now().UTC(),
})
if err != nil && s.logger != nil {
s.logger.Warn("写入密码重置审计日志失败", "error", err)
}
}
var resetTemplate = template.Must(template.New("reset").Parse(`<!doctype html>
<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="robots" content="noindex,nofollow,noarchive"><title>Scert 超级管理员密码重置</title><style>body{margin:0;min-height:100vh;display:grid;place-items:center;background:#f4f7fb;color:#172033;font-family:system-ui,-apple-system,"Segoe UI",sans-serif}.card{width:min(520px,calc(100% - 40px));padding:34px;border:1px solid #dce5f1;border-radius:20px;background:#fff;box-shadow:0 18px 60px rgba(31,50,87,.12)}h1{margin:0 0 14px;font-size:26px}p{margin:8px 0;color:#52637b;line-height:1.7}label{display:block;margin-top:16px;font-weight:700}input{box-sizing:border-box;width:100%;margin-top:8px;padding:12px;border:1px solid #c8d4e3;border-radius:10px;font:inherit}.button{width:100%;margin-top:22px;padding:12px;border:0;border-radius:10px;background:#2167d5;color:#fff;font:inherit;font-weight:700;cursor:pointer}.notice{margin-top:18px;padding:14px 16px;border-radius:12px;background:#edf5ff;color:#285a99;font-weight:700}.error{background:#fff1f0;color:#a12b22}</style></head><body><main class="card"><h1>超级管理员密码重置</h1><p>本入口由 Scert-admin 临时开启,仅允许使用一次性校验码重置密码。</p>{{if .Message}}<div class="notice {{if not .Success}}error{{end}}">{{.Message}}</div>{{end}}<form method="post" action="/reset" autocomplete="off"><input type="hidden" name="csrf_token" value="{{.CSRFToken}}"><label for="reset-code">一次性校验码</label><input id="reset-code" name="reset_code" required maxlength="32" autocomplete="one-time-code"><label for="new-password">新密码</label><input id="new-password" name="new_password" required minlength="8" maxlength="128" type="password" autocomplete="new-password"><label for="confirm-password">确认新密码</label><input id="confirm-password" name="confirm_password" required minlength="8" maxlength="128" type="password" autocomplete="new-password"><button class="button" type="submit">确认重置密码</button></form></main></body></html>`))
var resetSuccessTemplate = template.Must(template.New("reset-success").Parse(`<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Scert 密码重置完成</title></head><body><main><h1>密码重置完成</h1><p>{{.Message}}</p></main></body></html>`))
@@ -0,0 +1,84 @@
package httpapi
import (
"net"
"net/http"
"strings"
"sync"
"time"
)
const (
resetCSRFTokenName = "scert_reset_csrf"
resetRateWindow = 15 * time.Minute
resetRateLimit = 5
resetMaxBodyBytes = 16 << 10
)
type resetRateLimiter struct {
mu sync.Mutex
failure map[string][]time.Time
}
func newResetRateLimiter() *resetRateLimiter {
return &resetRateLimiter{failure: make(map[string][]time.Time)}
}
func (l *resetRateLimiter) allowed(ip string, now time.Time) bool {
if l == nil {
return true
}
l.mu.Lock()
defer l.mu.Unlock()
l.pruneLocked(ip, now)
return len(l.failure[ip]) < resetRateLimit
}
func (l *resetRateLimiter) failed(ip string, now time.Time) {
if l == nil {
return
}
l.mu.Lock()
defer l.mu.Unlock()
l.pruneLocked(ip, now)
l.failure[ip] = append(l.failure[ip], now)
}
func (l *resetRateLimiter) clear(ip string) {
if l == nil {
return
}
l.mu.Lock()
delete(l.failure, ip)
l.mu.Unlock()
}
func (l *resetRateLimiter) pruneLocked(ip string, now time.Time) {
cutoff := now.Add(-resetRateWindow)
items := l.failure[ip]
keep := items[:0]
for _, item := range items {
if item.After(cutoff) {
keep = append(keep, item)
}
}
if len(keep) == 0 {
delete(l.failure, ip)
return
}
l.failure[ip] = keep
}
func resetClientIP(request *http.Request) string {
if request == nil {
return "unknown"
}
host, _, err := net.SplitHostPort(strings.TrimSpace(request.RemoteAddr))
if err == nil && host != "" {
return host
}
if value := strings.TrimSpace(request.RemoteAddr); value != "" {
return value
}
return "unknown"
}
+19
View File
@@ -12,7 +12,9 @@ import (
"time"
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
@@ -166,3 +168,20 @@ func TestUpdateDomainRejectsInvalidEnvironment(t *testing.T) {
t.Fatalf("非法 ACME 环境响应错误:%d %s", response.Code, response.Body.String())
}
}
func TestIssueDomainUsesCertificateWorkflow(t *testing.T) {
cfg := config.Default(t.TempDir())
calledID := ""
server := New(Dependencies{
Config: cfg, Repository: &stubDomainRepository{},
IssueCertificate: func(_ context.Context, id string) (certificate.IssueResult, deployment.Report, error) {
calledID = id
return certificate.IssueResult{DomainID: id}, deployment.Report{Status: "success"}, nil
},
})
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, httptest.NewRequest(http.MethodPost, "/api/v1/domains/domain-1/issue", nil))
if response.Code != http.StatusOK || calledID != "domain-1" || !strings.Contains(response.Body.String(), `"status":"success"`) {
t.Fatalf("证书申请接口响应错误:%d %s", response.Code, response.Body.String())
}
}
+297 -15
View File
@@ -6,38 +6,61 @@ import (
"net"
"net/http"
"strconv"
"strings"
"sync"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/admin"
"git.pcux.cn/xuans/Scert/backend/internal/buildinfo"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/firewall"
"git.pcux.cn/xuans/Scert/backend/internal/logging"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
"git.pcux.cn/xuans/Scert/backend/internal/sshkey"
)
type Dependencies struct {
Config config.Config
ConfigPath string
Logger *logging.Logger
Repository repository.DomainRepository
SetupDNS setupDNSVerifier
Firewall firewall.Manager
Config config.Config
ConfigPath string
Logger *logging.Logger
Repository repository.DomainRepository
Servers repository.ServerRepository
SSHKeys *sshkey.Service
SetupDNS setupDNSVerifier
Firewall firewall.Manager
IssueCertificate func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
ResetStatePath string
Audit repository.AuditRepository
}
type Server struct {
configMu sync.RWMutex
config config.Config
configPath string
logger *logging.Logger
repository repository.DomainRepository
setupDNS setupDNSVerifier
firewall firewall.Manager
httpServer *http.Server
router *gin.Engine
configMu sync.RWMutex
config config.Config
configPath string
logger *logging.Logger
repository repository.DomainRepository
servers repository.ServerRepository
sshKeys *sshkey.Service
setupDNS setupDNSVerifier
firewall firewall.Manager
issueCertificate func(context.Context, string) (certificate.IssueResult, deployment.Report, error)
resetStatePath string
audit repository.AuditRepository
resetMu sync.Mutex
resetClosedHash string
resetLimiter *resetRateLimiter
authSessions map[string]authSession
authMu sync.RWMutex
loginAttempts map[string]loginAttempt
loginMu sync.Mutex
now func() time.Time
httpServer *http.Server
router *gin.Engine
}
func New(deps Dependencies) *Server {
@@ -47,6 +70,15 @@ func New(deps Dependencies) *Server {
server := &Server{
config: deps.Config, configPath: deps.ConfigPath, logger: deps.Logger,
repository: deps.Repository, setupDNS: deps.SetupDNS, firewall: deps.Firewall, router: router,
servers: deps.Servers,
sshKeys: deps.SSHKeys,
issueCertificate: deps.IssueCertificate,
resetStatePath: deps.ResetStatePath,
audit: deps.Audit,
resetLimiter: newResetRateLimiter(),
authSessions: make(map[string]authSession),
loginAttempts: make(map[string]loginAttempt),
now: time.Now,
}
server.registerRoutes()
server.registerSetupRoutes()
@@ -56,11 +88,27 @@ func New(deps Dependencies) *Server {
func (s *Server) registerRoutes() {
// 主路由保持独立,初始化路由由专用模块注册。
s.router.GET("/healthz", s.health)
s.router.GET(admin.ResetPath, s.resetPage)
s.router.POST(admin.ResetPath, s.resetSubmit)
s.router.GET("/api/v1/status", s.status)
s.router.GET("/api/v1/auth/session", s.authSession)
s.router.POST("/api/v1/auth/login", s.authLogin)
s.router.POST("/api/v1/auth/logout", s.authLogout)
s.router.GET("/api/v1/domains", s.listDomains)
s.router.POST("/api/v1/domains", s.createDomain)
s.router.PUT("/api/v1/domains/:id", s.updateDomain)
s.router.DELETE("/api/v1/domains/:id", s.deleteDomain)
s.router.POST("/api/v1/domains/:id/issue", s.issueDomain)
s.router.GET("/api/v1/domains/:id/servers", s.listDomainServers)
s.router.PUT("/api/v1/domains/:id/servers", s.replaceDomainServers)
s.router.GET("/api/v1/servers", s.listServers)
s.router.POST("/api/v1/servers", s.createServer)
s.router.GET("/api/v1/servers/:id", s.getServer)
s.router.PUT("/api/v1/servers/:id", s.updateServer)
s.router.DELETE("/api/v1/servers/:id", s.deleteServer)
s.router.GET("/api/v1/ssh-keys", s.listSSHKeys)
s.router.POST("/api/v1/ssh-keys", s.createSSHKey)
s.router.DELETE("/api/v1/ssh-keys/:id", s.deleteSSHKey)
}
func (s *Server) Handler() http.Handler {
@@ -105,10 +153,45 @@ type domainRequest struct {
DNSProvider string `json:"dns_provider"`
}
type serverRequest struct {
Name string `json:"name" binding:"required"`
Address string `json:"address" binding:"required"`
Port int `json:"port"`
Username string `json:"username" binding:"required"`
PrivateKeyRef string `json:"private_key_ref" binding:"required"`
HostKeyFingerprint string `json:"host_key_fingerprint" binding:"required"`
CertificatePath string `json:"certificate_path"`
PrivateKeyPath string `json:"private_key_path"`
CertificateChainPath string `json:"certificate_chain_path"`
WebServer string `json:"web_server" binding:"required"`
ReloadCommand []string `json:"reload_command"`
}
type domainServersRequest struct {
ServerIDs []string `json:"server_ids"`
}
func (s *Server) health(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"status": "ok", "service": "scert"})
}
func (s *Server) resetPage(c *gin.Context) {
s.resetMu.Lock()
defer s.resetMu.Unlock()
session, ok := s.currentResetSession()
if !ok {
c.Status(http.StatusNotFound)
return
}
token, err := newCSRFToken()
if err != nil {
s.writeResetFailure(c, http.StatusInternalServerError, "暂时无法生成安全校验信息,请稍后重试")
return
}
s.setResetCSRFCookie(c, token, session.ExpiresAt)
s.renderResetPage(c, http.StatusOK, token, "")
}
func (s *Server) status(c *gin.Context) {
s.configMu.RLock()
cfg := s.config
@@ -120,6 +203,7 @@ func (s *Server) status(c *gin.Context) {
"setup_ready": cfg.SetupReady,
"https_mode": cfg.Server.HTTPSMode,
"database_driver": cfg.Database.Driver,
"reset_url": cfg.ResetURL(),
})
}
@@ -217,6 +301,204 @@ func (s *Server) deleteDomain(c *gin.Context) {
c.Status(http.StatusNoContent)
}
func (s *Server) issueDomain(c *gin.Context) {
if s.issueCertificate == nil {
s.writeError(c, http.StatusNotImplemented, "证书申请接口尚未配置", errors.New("证书申请工作流未配置"))
return
}
certificateResult, deploymentReport, err := s.issueCertificate(c.Request.Context(), c.Param("id"))
if err != nil {
s.writeError(c, http.StatusBadGateway, "证书申请或部署失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"certificate": certificateResult, "deployment": deploymentReport})
}
func (s *Server) listServers(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
items, err := s.servers.ListServers(c.Request.Context())
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询服务器失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}
func (s *Server) getServer(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
item, err := s.servers.GetServerByID(c.Request.Context(), c.Param("id"))
if err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "服务器不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取服务器失败", err)
return
}
c.JSON(http.StatusOK, item)
}
func (s *Server) createServer(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
var request serverRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
item := serverFromRequest(request)
item = item.Normalize()
if err := s.validateSSHKeyReference(c.Request.Context(), item.PrivateKeyRef); err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥引用无效", err)
return
}
if err := s.servers.CreateServer(c.Request.Context(), item); err != nil {
s.writeError(c, serverErrorStatus(err), "保存服务器失败", err)
return
}
c.JSON(http.StatusCreated, item)
}
func (s *Server) updateServer(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
var request serverRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
item := serverFromRequest(request)
item.ID = c.Param("id")
item = item.Normalize()
existing, err := s.servers.GetServerByID(c.Request.Context(), item.ID)
if err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "服务器不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取服务器失败", err)
return
}
item.CreatedAt = existing.CreatedAt
if err := s.validateSSHKeyReference(c.Request.Context(), item.PrivateKeyRef); err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥引用无效", err)
return
}
if err := s.servers.UpdateServer(c.Request.Context(), item); err != nil {
s.writeError(c, serverErrorStatus(err), "更新服务器失败", err)
return
}
c.JSON(http.StatusOK, item)
}
func (s *Server) validateSSHKeyReference(ctx context.Context, reference string) error {
if s.sshKeys == nil {
return errors.New("SSH 私钥管理服务未配置")
}
_, err := s.sshKeys.ValidateReference(ctx, reference)
return err
}
func (s *Server) deleteServer(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
if err := s.servers.DeleteServer(c.Request.Context(), c.Param("id")); err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "服务器不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "删除服务器失败", err)
return
}
c.Status(http.StatusNoContent)
}
func (s *Server) listDomainServers(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
if _, err := s.repository.GetByID(c.Request.Context(), c.Param("id")); err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "域名不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取域名失败", err)
return
}
items, err := s.servers.ListServersByDomainID(c.Request.Context(), c.Param("id"))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询域名部署服务器失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}
func (s *Server) replaceDomainServers(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
if _, err := s.repository.GetByID(c.Request.Context(), c.Param("id")); err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "域名不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取域名失败", err)
return
}
var request domainServersRequest
if err := c.ShouldBindJSON(&request); err != nil {
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
if err := s.servers.ReplaceDomainServers(c.Request.Context(), c.Param("id"), request.ServerIDs); err != nil {
s.writeError(c, serverErrorStatus(err), "保存域名部署服务器失败", err)
return
}
items, err := s.servers.ListServersByDomainID(c.Request.Context(), c.Param("id"))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "读取域名部署服务器失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}
func serverFromRequest(request serverRequest) deployment.Server {
return deployment.Server{
ID: domain.NewID(), Name: request.Name, Address: request.Address, Port: request.Port,
Username: request.Username, PrivateKeyRef: request.PrivateKeyRef, HostKeyFingerprint: request.HostKeyFingerprint,
CertificatePath: request.CertificatePath, PrivateKeyPath: request.PrivateKeyPath,
CertificateChainPath: request.CertificateChainPath, WebServer: deployment.WebServer(request.WebServer),
ReloadCommand: request.ReloadCommand,
}
}
func serverErrorStatus(err error) int {
if repository.IsConflict(err) {
return http.StatusConflict
}
if repository.IsNotFound(err) {
return http.StatusNotFound
}
if strings.Contains(err.Error(), "不存在") || strings.Contains(err.Error(), "不能为空") || strings.Contains(err.Error(), "无效") {
return http.StatusBadRequest
}
return http.StatusInternalServerError
}
func (s *Server) writeError(c *gin.Context, status int, message string, err error) {
if s.logger != nil {
s.logger.Error(message, "error", err)
+418
View File
@@ -2,16 +2,26 @@ package httpapi
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"golang.org/x/crypto/bcrypt"
"git.pcux.cn/xuans/Scert/backend/internal/admin"
"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/logging"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/sshkey"
)
func TestHealthAndDomainAPI(t *testing.T) {
@@ -53,3 +63,411 @@ func TestHealthAndDomainAPI(t *testing.T) {
t.Fatalf("域名列表响应错误:%d %s", list.Code, list.Body.String())
}
}
func TestResetPathRequiresScertAdminActivation(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir)
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
cfg.Server.Port = 8443
statePath := admin.StatePath(cfg.Paths.Data)
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, ResetStatePath: statePath})
inactive := httptest.NewRecorder()
server.Handler().ServeHTTP(inactive, httptest.NewRequest(http.MethodGet, "/reset", nil))
if inactive.Code != http.StatusNotFound {
t.Fatalf("Scert-admin 未启动时 /reset 应返回 404:%d", inactive.Code)
}
controller := admin.New(cfg)
if _, err := controller.Start(); err != nil {
t.Fatalf("启用测试密码重置入口失败:%v", err)
}
active := httptest.NewRecorder()
server.Handler().ServeHTTP(active, httptest.NewRequest(http.MethodGet, "/reset", nil))
if active.Code != http.StatusOK || !strings.Contains(active.Body.String(), "超级管理员密码重置") {
t.Fatalf("Scert-admin 启用后 /reset 页面错误:%d %s", active.Code, active.Body.String())
}
if active.Header().Get("Cache-Control") != "no-store, no-cache, must-revalidate" || !strings.Contains(active.Header().Get("X-Robots-Tag"), "noindex") {
t.Fatalf("密码重置页面缺少安全响应头:%v", active.Header())
}
if err := controller.Stop(); err != nil {
t.Fatalf("关闭测试密码重置入口失败:%v", err)
}
stopped := httptest.NewRecorder()
server.Handler().ServeHTTP(stopped, httptest.NewRequest(http.MethodGet, "/reset", nil))
if stopped.Code != http.StatusNotFound {
t.Fatalf("Scert-admin 停止后 /reset 应恢复 404:%d", stopped.Code)
}
}
func TestResetPasswordUpdatesConfigAndConsumesSession(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir)
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
cfg.DNS.VerificationState = "verified"
cfg.Admin.Username = "admin"
cfg.Admin.Email = "admin@example.test"
oldHash, err := bcrypt.GenerateFromPassword([]byte("OldPassword123"), bcrypt.DefaultCost)
if err != nil {
t.Fatalf("生成旧密码摘要失败:%v", err)
}
cfg.Admin.PasswordHash = string(oldHash)
configPath := filepath.Join(dir, "config", "scert.json")
if err := cfg.Save(configPath); err != nil {
t.Fatalf("保存测试配置失败:%v", err)
}
controller := admin.New(cfg)
session, err := controller.Start()
if err != nil {
t.Fatalf("启动测试重置会话失败:%v", err)
}
server := New(Dependencies{Config: cfg, ConfigPath: configPath, Repository: &stubDomainRepository{}, ResetStatePath: admin.StatePath(cfg.Paths.Data)})
get := httptest.NewRecorder()
server.Handler().ServeHTTP(get, httptest.NewRequest(http.MethodGet, "http://scert.example.test/reset", nil))
if get.Code != http.StatusOK {
t.Fatalf("获取密码重置页面失败:%d", get.Code)
}
cookie := get.Result().Cookies()[0]
form := url.Values{
"csrf_token": {cookie.Value},
"reset_code": {session.Code},
"new_password": {"NewPassword123"},
"confirm_password": {"NewPassword123"},
}
request := httptest.NewRequest(http.MethodPost, "http://scert.example.test/reset", strings.NewReader(form.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "http://scert.example.test")
request.AddCookie(cookie)
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK || !strings.Contains(response.Body.String(), "密码重置成功") {
t.Fatalf("密码重置响应错误:%d %s", response.Code, response.Body.String())
}
state, err := admin.ReadState(admin.StatePath(cfg.Paths.Data))
if err != nil {
t.Fatalf("读取重置状态失败:%v", err)
}
if state.Active || state.CodeHash != "" {
t.Fatalf("密码重置成功后会话必须失效:%+v", state)
}
loaded, err := config.Load(configPath)
if err != nil {
t.Fatalf("读取重置后的配置失败:%v", err)
}
if bcrypt.CompareHashAndPassword([]byte(loaded.Admin.PasswordHash), []byte("NewPassword123")) != nil {
t.Fatal("新密码摘要无法验证新密码")
}
if bcrypt.CompareHashAndPassword([]byte(loaded.Admin.PasswordHash), []byte("OldPassword123")) == nil {
t.Fatal("旧密码不应继续有效")
}
second := httptest.NewRecorder()
server.Handler().ServeHTTP(second, httptest.NewRequest(http.MethodGet, "http://scert.example.test/reset", nil))
if second.Code != http.StatusNotFound {
t.Fatalf("密码重置成功后入口必须关闭:%d", second.Code)
}
if err := controller.Refresh(); err != admin.ErrResetSessionClosed {
t.Fatalf("Scert-admin 不得刷新已消费会话:%v", err)
}
}
func TestResetRejectsCrossSiteAndLimitsFailures(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir)
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
cfg.DNS.VerificationState = "verified"
cfg.Admin.Username = "admin"
cfg.Admin.Email = "admin@example.test"
cfg.Admin.PasswordHash = "not-used-in-this-test"
controller := admin.New(cfg)
session, err := controller.Start()
if err != nil {
t.Fatalf("启动测试重置会话失败:%v", err)
}
server := New(Dependencies{Config: cfg, ConfigPath: filepath.Join(dir, "config", "scert.json"), Repository: &stubDomainRepository{}, ResetStatePath: admin.StatePath(cfg.Paths.Data)})
get := httptest.NewRecorder()
server.Handler().ServeHTTP(get, httptest.NewRequest(http.MethodGet, "http://scert.example.test/reset", nil))
cookie := get.Result().Cookies()[0]
base := url.Values{"csrf_token": {cookie.Value}, "reset_code": {session.Code}, "new_password": {"NewPassword123"}, "confirm_password": {"NewPassword123"}}
for i := 0; i < 5; i++ {
request := httptest.NewRequest(http.MethodPost, "http://scert.example.test/reset", strings.NewReader(base.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "http://evil.example.test")
request.AddCookie(cookie)
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusForbidden {
t.Fatalf("跨站请求应被拒绝:第 %d 次状态码为 %d", i+1, response.Code)
}
}
request := httptest.NewRequest(http.MethodPost, "http://scert.example.test/reset", strings.NewReader(base.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "http://scert.example.test")
request.AddCookie(cookie)
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusTooManyRequests {
t.Fatalf("超过失败次数后应限流:%d", response.Code)
}
}
func TestServerAndDomainAssociationAPI(t *testing.T) {
dir := t.TempDir()
cfg := config.Default(dir)
cfg.Database.DSN = filepath.Join(dir, "data", "servers.db")
db, err := database.Open(context.Background(), cfg.Database)
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)
}
secretStore, err := secretstore.Open(filepath.Join(dir, "config"))
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
sshKeys := sshkey.NewService(secretStore)
key, err := sshKeys.Create(t.Context(), "测试部署私钥", testSSHPrivateKey(t), "")
if err != nil {
t.Fatalf("创建测试 SSH 私钥失败:%v", err)
}
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB),
Servers: repository.NewSQLServerRepository(db.DB), SSHKeys: sshKeys,
})
domainRequest := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"single"}`))
domainRequest.Header.Set("Content-Type", "application/json")
domainResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(domainResponse, domainRequest)
if domainResponse.Code != http.StatusCreated {
t.Fatalf("创建测试域名失败:%d %s", domainResponse.Code, domainResponse.Body.String())
}
var item struct {
ID string `json:"id"`
}
if err := json.Unmarshal(domainResponse.Body.Bytes(), &item); err != nil || item.ID == "" {
t.Fatalf("测试域名响应无效:%v %s", err, domainResponse.Body.String())
}
serverRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(`{"name":"测试服务器","address":"192.0.2.50","port":22,"username":"deploy","private_key_ref":"`+key.Reference+`","host_key_fingerprint":"SHA256:test","web_server":"nginx"}`))
serverRequest.Header.Set("Content-Type", "application/json")
serverResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(serverResponse, serverRequest)
if serverResponse.Code != http.StatusCreated {
t.Fatalf("创建测试服务器失败:%d %s", serverResponse.Code, serverResponse.Body.String())
}
var created deployment.Server
if err := json.Unmarshal(serverResponse.Body.Bytes(), &created); err != nil || created.ID == "" || len(created.ReloadCommand) != 3 {
t.Fatalf("测试服务器响应无效:%v %+v", err, created)
}
if created.CertificatePath != deployment.DefaultCertificatePath || created.CertificateChainPath != deployment.DefaultCertificateChainPath || created.PrivateKeyPath != deployment.DefaultPrivateKeyPath {
t.Fatalf("服务器 API 未使用默认远程证书路径模板:%+v", created)
}
associationRequest := httptest.NewRequest(http.MethodPut, "/api/v1/domains/"+item.ID+"/servers", strings.NewReader(`{"server_ids":["`+created.ID+`"]}`))
associationRequest.Header.Set("Content-Type", "application/json")
associationResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(associationResponse, associationRequest)
if associationResponse.Code != http.StatusOK || !strings.Contains(associationResponse.Body.String(), created.ID) {
t.Fatalf("保存域名服务器关联失败:%d %s", associationResponse.Code, associationResponse.Body.String())
}
deleteResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(deleteResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/servers/"+created.ID, nil))
if deleteResponse.Code != http.StatusNoContent {
t.Fatalf("删除测试服务器失败:%d %s", deleteResponse.Code, deleteResponse.Body.String())
}
listResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(listResponse, httptest.NewRequest(http.MethodGet, "/api/v1/domains/"+item.ID+"/servers", nil))
if listResponse.Code != http.StatusOK || strings.Contains(listResponse.Body.String(), created.ID) {
t.Fatalf("服务器删除后域名关联未清理:%d %s", listResponse.Code, listResponse.Body.String())
}
}
func TestResetConfigSaveFailureKeepsSessionAndPassword(t *testing.T) {
fixture := newResetTestFixture(t)
blockedPath := filepath.Join(t.TempDir(), "config-target")
if err := os.MkdirAll(blockedPath, 0o700); err != nil {
t.Fatalf("创建无效配置目标失败:%v", err)
}
fixture.server.configPath = blockedPath
form := resetForm(fixture.session.Code, fixture.cookie.Value, "NewPassword123")
request := httptest.NewRequest(http.MethodPost, "https://scert.example.test/reset", strings.NewReader(form.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "https://scert.example.test")
request.AddCookie(fixture.cookie)
response := httptest.NewRecorder()
fixture.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusInternalServerError {
t.Fatalf("配置保存失败时应返回 500:%d %s", response.Code, response.Body.String())
}
state, err := admin.ReadState(admin.StatePath(fixture.cfg.Paths.Data))
if err != nil {
t.Fatalf("读取配置保存失败后的重置状态失败:%v", err)
}
if !state.Active || state.CodeHash != fixture.session.State.CodeHash {
t.Fatalf("配置保存失败时不得消费重置会话:%+v", state)
}
fixture.server.configMu.RLock()
passwordHash := fixture.server.config.Admin.PasswordHash
fixture.server.configMu.RUnlock()
if passwordHash != fixture.oldPasswordHash {
t.Fatal("配置保存失败时不得更新内存中的密码摘要")
}
active := httptest.NewRecorder()
fixture.server.Handler().ServeHTTP(active, httptest.NewRequest(http.MethodGet, "https://scert.example.test/reset", nil))
if active.Code != http.StatusOK {
t.Fatalf("配置保存失败后 /reset 应继续可访问:%d", active.Code)
}
}
func TestResetRejectsOversizedRequestBody(t *testing.T) {
fixture := newResetTestFixture(t)
form := resetForm(fixture.session.Code, fixture.cookie.Value, "NewPassword123")
form.Set("padding", strings.Repeat("x", resetMaxBodyBytes))
request := httptest.NewRequest(http.MethodPost, "https://scert.example.test/reset", strings.NewReader(form.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "https://scert.example.test")
request.AddCookie(fixture.cookie)
response := httptest.NewRecorder()
fixture.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest {
t.Fatalf("超过请求体限制时应返回 400:%d %s", response.Code, response.Body.String())
}
state, err := admin.ReadState(admin.StatePath(fixture.cfg.Paths.Data))
if err != nil {
t.Fatalf("读取超限请求后的重置状态失败:%v", err)
}
if !state.Active {
t.Fatal("请求体超限时不得消费重置会话")
}
}
func TestResetCSRFCookieHasRestrictedAttributes(t *testing.T) {
fixture := newResetTestFixture(t)
cookie := fixture.cookie
if !cookie.Secure || !cookie.HttpOnly || cookie.SameSite != http.SameSiteStrictMode {
t.Fatalf("CSRF Cookie 安全属性不完整:%+v", cookie)
}
if cookie.Path != admin.ResetPath {
t.Fatalf("CSRF Cookie 路径错误:%q", cookie.Path)
}
if cookie.MaxAge <= 0 || cookie.MaxAge > 90 {
t.Fatalf("CSRF Cookie 有效期必须限制在重置租约内:%d", cookie.MaxAge)
}
}
func TestResetConcurrentSubmissionsAllowOnlyOneSuccess(t *testing.T) {
fixture := newResetTestFixture(t)
form := resetForm(fixture.session.Code, fixture.cookie.Value, "NewPassword123")
start := make(chan struct{})
responses := make(chan int, 2)
var waitGroup sync.WaitGroup
for i := 0; i < 2; i++ {
waitGroup.Add(1)
go func() {
defer waitGroup.Done()
<-start
request := httptest.NewRequest(http.MethodPost, "https://scert.example.test/reset", strings.NewReader(form.Encode()))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
request.Header.Set("Origin", "https://scert.example.test")
request.AddCookie(fixture.cookie)
response := httptest.NewRecorder()
fixture.server.Handler().ServeHTTP(response, request)
responses <- response.Code
}()
}
close(start)
waitGroup.Wait()
close(responses)
successes := 0
failures := 0
for status := range responses {
if status == http.StatusOK {
successes++
} else {
failures++
}
}
if successes != 1 || failures != 1 {
t.Fatalf("并发提交必须恰好一个成功、一个失败:successes=%d failures=%d", successes, failures)
}
state, err := admin.ReadState(admin.StatePath(fixture.cfg.Paths.Data))
if err != nil {
t.Fatalf("读取并发提交后的重置状态失败:%v", err)
}
if state.Active || state.CodeHash != "" {
t.Fatalf("并发提交成功后重置会话必须关闭:%+v", state)
}
loaded, err := config.Load(fixture.configPath)
if err != nil {
t.Fatalf("读取并发提交后的配置失败:%v", err)
}
if bcrypt.CompareHashAndPassword([]byte(loaded.Admin.PasswordHash), []byte("NewPassword123")) != nil {
t.Fatal("并发提交后的密码摘要无法验证新密码")
}
}
type resetTestFixture struct {
server *Server
cfg config.Config
controller *admin.Controller
session admin.Session
cookie *http.Cookie
configPath string
oldPasswordHash string
}
func newResetTestFixture(t *testing.T) resetTestFixture {
t.Helper()
dir := t.TempDir()
cfg := config.Default(dir)
cfg.SetupReady = true
cfg.Web.Hostname = "scert.example.test"
cfg.DNS.VerificationState = "verified"
cfg.Admin.Username = "admin"
cfg.Admin.Email = "admin@example.test"
oldPasswordHash, err := bcrypt.GenerateFromPassword([]byte("OldPassword123"), bcrypt.DefaultCost)
if err != nil {
t.Fatalf("生成测试密码摘要失败:%v", err)
}
cfg.Admin.PasswordHash = string(oldPasswordHash)
configPath := filepath.Join(dir, "config", "scert.json")
if err := cfg.Save(configPath); err != nil {
t.Fatalf("保存测试配置失败:%v", err)
}
controller := admin.New(cfg)
session, err := controller.Start()
if err != nil {
t.Fatalf("启动测试重置会话失败:%v", err)
}
server := New(Dependencies{Config: cfg, ConfigPath: configPath, Repository: &stubDomainRepository{}, ResetStatePath: admin.StatePath(cfg.Paths.Data)})
get := httptest.NewRecorder()
server.Handler().ServeHTTP(get, httptest.NewRequest(http.MethodGet, "https://scert.example.test/reset", nil))
if get.Code != http.StatusOK {
t.Fatalf("获取测试重置页面失败:%d", get.Code)
}
cookies := get.Result().Cookies()
if len(cookies) != 1 {
t.Fatalf("测试重置页面应返回一个 CSRF Cookie:%d", len(cookies))
}
return resetTestFixture{
server: server, cfg: cfg, controller: controller, session: session,
cookie: cookies[0], configPath: configPath, oldPasswordHash: cfg.Admin.PasswordHash,
}
}
func resetForm(code, csrfToken, password string) url.Values {
return url.Values{
"csrf_token": {csrfToken},
"reset_code": {code},
"new_password": {password},
"confirm_password": {password},
}
}
+10 -10
View File
@@ -26,9 +26,9 @@ type setupDNSVerifier interface {
type setupRequest struct {
AdminUsername string `json:"admin_username"`
AdminEmail string `json:"admin_email"`
AdminPassword string `json:"admin_password"`
ServerPort int `json:"server_port"`
ResetServicePort int `json:"reset_service_port"`
EmailProvider string `json:"email_provider"`
EmailEndpoint string `json:"email_endpoint"`
Recipients []string `json:"recipients"`
@@ -78,7 +78,7 @@ func (s *Server) setupStatus(c *gin.Context) {
"phase": phase,
"blockers": blockers,
"server_port": cfg.Server.Port,
"reset_service_port": cfg.Admin.ResetServicePort,
"reset_url": cfg.ResetURL(),
"https_mode": cfg.Server.HTTPSMode,
"web_enabled": cfg.Web.Enabled,
"web_hostname": cfg.Web.Hostname,
@@ -172,9 +172,9 @@ func (s *Server) applySetup(c *gin.Context) {
updated := s.config
err := setup.Apply(&updated, setup.Input{
AdminUsername: request.AdminUsername,
AdminEmail: request.AdminEmail,
AdminPassword: request.AdminPassword,
ServerPort: request.ServerPort,
ResetServicePort: request.ResetServicePort,
EmailProvider: request.EmailProvider,
EmailEndpoint: request.EmailEndpoint,
EmailRecipients: request.Recipients,
@@ -231,15 +231,15 @@ func (s *Server) applySetup(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{
"initialized": true,
"message": fmt.Sprintf(
"初始化配置已保存,DNS API 已完成在线验证且凭据已加密保存。%s。请确认云安全组已放行主服务端口 %d;Scert-admin 仅允许本机访问。证书申请和 HTTPS 切换将在后续任务中完成。",
firewallResult.Message, updated.Server.Port,
"初始化配置已保存,DNS API 已完成在线验证且凭据已加密保存。%s。请确认云安全组已放行主服务端口 %d;Scert-admin 默认关闭,启动后通过 %s 使用临时重置入口。证书申请和 HTTPS 切换将在后续任务中完成。",
firewallResult.Message, updated.Server.Port, updated.ResetURL(),
),
"status": gin.H{
"server_port": updated.Server.Port,
"reset_service_port": updated.Admin.ResetServicePort,
"web_enabled": updated.Web.Enabled,
"https_mode": updated.Server.HTTPSMode,
"firewall": firewallResult,
"server_port": updated.Server.Port,
"reset_url": updated.ResetURL(),
"web_enabled": updated.Web.Enabled,
"https_mode": updated.Server.HTTPSMode,
"firewall": firewallResult,
},
})
}
+6 -3
View File
@@ -149,9 +149,9 @@ func TestSetupApplyPersistsConfigurationWithoutPlainPassword(t *testing.T) {
})
payload := `{
"admin_username":"root-admin",
"admin_email":"admin@example.test",
"admin_password":"secure-pass-123",
"server_port":8443,
"reset_service_port":8091,
"email_provider":"mail-api",
"email_endpoint":"https://mail.example.test/send",
"recipients":["ops@example.test","ops@example.test"],
@@ -181,6 +181,9 @@ func TestSetupApplyPersistsConfigurationWithoutPlainPassword(t *testing.T) {
if !strings.Contains(response.Body.String(), `"firewall"`) || !strings.Contains(response.Body.String(), `"created":true`) {
t.Fatalf("初始化响应应返回本机防火墙结果:%s", response.Body.String())
}
if !strings.Contains(response.Body.String(), `"reset_url":"https://scert.example.test/reset"`) {
t.Fatalf("初始化响应应返回根据 Web 地址生成的密码重置路径:%s", response.Body.String())
}
data, err := os.ReadFile(configPath)
if err != nil {
@@ -193,7 +196,7 @@ func TestSetupApplyPersistsConfigurationWithoutPlainPassword(t *testing.T) {
if err := json.Unmarshal(data, &saved); err != nil {
t.Fatalf("解析保存后的配置失败:%v", err)
}
if !saved.SetupReady || saved.Admin.Username != "root-admin" || saved.Server.Port != 8443 {
if !saved.SetupReady || saved.Admin.Username != "root-admin" || saved.Admin.Email != "admin@example.test" || saved.Server.Port != 8443 {
t.Fatalf("保存后的初始化配置不正确:%+v", saved)
}
if len(saved.Notification.Recipients) != 1 {
@@ -385,9 +388,9 @@ func TestSetupFirewallFailureDoesNotSaveOrConsumeToken(t *testing.T) {
func setupPayload(baseDir, password string) string {
return `{
"admin_username":"root-admin",
"admin_email":"admin@example.test",
"admin_password":"` + password + `",
"server_port":8443,
"reset_service_port":8091,
"dns_provider":"cloudflare",
"dns_credential_ref":"secret://dns/cloudflare/test",
"dns_verification_token":"verified-token",
+79
View File
@@ -0,0 +1,79 @@
package httpapi
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
)
const maxSSHKeyRequestBytes = 2 * 1024 * 1024
type sshKeyRequest struct {
Name string `json:"name" binding:"required"`
PrivateKey string `json:"private_key" binding:"required"`
Passphrase string `json:"passphrase"`
}
func (s *Server) listSSHKeys(c *gin.Context) {
if s.sshKeys == nil {
s.writeError(c, http.StatusNotImplemented, "SSH 私钥管理接口尚未配置", errors.New("SSH 私钥管理服务未配置"))
return
}
items, err := s.sshKeys.List(c.Request.Context())
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询 SSH 私钥失败", err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}
func (s *Server) createSSHKey(c *gin.Context) {
if s.sshKeys == nil {
s.writeError(c, http.StatusNotImplemented, "SSH 私钥管理接口尚未配置", errors.New("SSH 私钥管理服务未配置"))
return
}
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxSSHKeyRequestBytes)
var request sshKeyRequest
if err := c.ShouldBindJSON(&request); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
s.writeError(c, http.StatusRequestEntityTooLarge, "SSH 私钥请求内容过大", err)
return
}
s.writeError(c, http.StatusBadRequest, "请求参数无效", err)
return
}
item, err := s.sshKeys.Create(c.Request.Context(), request.Name, request.PrivateKey, request.Passphrase)
if err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥无效", err)
return
}
c.JSON(http.StatusCreated, item)
}
func (s *Server) deleteSSHKey(c *gin.Context) {
if s.sshKeys == nil || s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "SSH 私钥管理接口尚未配置", errors.New("SSH 私钥或服务器管理服务未配置"))
return
}
reference, err := s.sshKeys.Reference(c.Param("id"))
if err != nil {
s.writeError(c, http.StatusBadRequest, "SSH 私钥 ID 无效", err)
return
}
used, err := s.servers.IsPrivateKeyRefUsed(c.Request.Context(), reference)
if err != nil {
s.writeError(c, http.StatusInternalServerError, "检查 SSH 私钥占用状态失败", err)
return
}
if used {
s.writeError(c, http.StatusConflict, "SSH 私钥仍被部署服务器使用", errors.New("SSH 私钥引用正在使用"))
return
}
if err := s.sshKeys.Delete(c.Request.Context(), c.Param("id")); err != nil {
s.writeError(c, http.StatusNotFound, "SSH 私钥不存在", err)
return
}
c.Status(http.StatusNoContent)
}
+173
View File
@@ -0,0 +1,173 @@
package httpapi
import (
"context"
"crypto/ed25519"
"crypto/rand"
"crypto/x509"
"encoding/json"
"encoding/pem"
"net/http"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
"git.pcux.cn/xuans/Scert/backend/internal/secretstore"
"git.pcux.cn/xuans/Scert/backend/internal/sshkey"
)
func TestSSHKeyAPIHidesPrivateKeyAndBlocksDeletingUsedReference(t *testing.T) {
directory := t.TempDir()
cfg := config.Default(directory)
cfg.Database.DSN = filepath.Join(directory, "data", "ssh-keys.db")
db, err := database.Open(context.Background(), cfg.Database)
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)
}
store, err := secretstore.Open(filepath.Join(directory, "config"))
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
serverRepo := repository.NewSQLServerRepository(db.DB)
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB), Servers: serverRepo,
SSHKeys: sshkey.NewService(store),
})
privateKey := testSSHPrivateKey(t)
createBody, err := json.Marshal(sshKeyRequest{Name: "生产私钥", PrivateKey: privateKey})
if err != nil {
t.Fatalf("编码 SSH 私钥请求失败:%v", err)
}
createRequest := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(createBody)))
createRequest.Header.Set("Content-Type", "application/json")
createResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(createResponse, createRequest)
if createResponse.Code != http.StatusCreated {
t.Fatalf("创建 SSH 私钥失败:%d %s", createResponse.Code, createResponse.Body.String())
}
if strings.Contains(createResponse.Body.String(), "PRIVATE KEY") || strings.Contains(createResponse.Body.String(), "private_key") {
t.Fatalf("SSH 私钥创建响应泄露了敏感内容:%s", createResponse.Body.String())
}
var key sshkey.Metadata
if err := json.Unmarshal(createResponse.Body.Bytes(), &key); err != nil || key.ID == "" || key.Reference == "" {
t.Fatalf("SSH 私钥创建响应无效:%v %+v", err, key)
}
listResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(listResponse, httptest.NewRequest(http.MethodGet, "/api/v1/ssh-keys", nil))
if listResponse.Code != http.StatusOK || !strings.Contains(listResponse.Body.String(), key.Reference) || strings.Contains(listResponse.Body.String(), "PRIVATE KEY") {
t.Fatalf("SSH 私钥列表响应无效或泄露敏感内容:%d %s", listResponse.Code, listResponse.Body.String())
}
serverBody := `{"name":"生产服务器","address":"192.0.2.60","port":22,"username":"deploy","private_key_ref":"` + key.Reference + `","host_key_fingerprint":"SHA256:test","certificate_path":"/etc/scert/cert.pem","private_key_path":"/etc/scert/key.pem","certificate_chain_path":"/etc/scert/fullchain.pem","web_server":"nginx"}`
serverRequest := httptest.NewRequest(http.MethodPost, "/api/v1/servers", strings.NewReader(serverBody))
serverRequest.Header.Set("Content-Type", "application/json")
serverResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(serverResponse, serverRequest)
if serverResponse.Code != http.StatusCreated {
t.Fatalf("创建使用 SSH 私钥的服务器失败:%d %s", serverResponse.Code, serverResponse.Body.String())
}
var createdServer struct {
ID string `json:"id"`
}
if err := json.Unmarshal(serverResponse.Body.Bytes(), &createdServer); err != nil || createdServer.ID == "" {
t.Fatalf("服务器创建响应无效:%v %s", err, serverResponse.Body.String())
}
deleteUsedResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(deleteUsedResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/ssh-keys/"+key.ID, nil))
if deleteUsedResponse.Code != http.StatusConflict {
t.Fatalf("仍被使用的 SSH 私钥应禁止删除:%d %s", deleteUsedResponse.Code, deleteUsedResponse.Body.String())
}
deleteServerResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(deleteServerResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/servers/"+createdServer.ID, nil))
if deleteServerResponse.Code != http.StatusNoContent {
t.Fatalf("删除测试服务器失败:%d %s", deleteServerResponse.Code, deleteServerResponse.Body.String())
}
deleteKeyResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(deleteKeyResponse, httptest.NewRequest(http.MethodDelete, "/api/v1/ssh-keys/"+key.ID, nil))
if deleteKeyResponse.Code != http.StatusNoContent {
t.Fatalf("删除未使用的 SSH 私钥失败:%d %s", deleteKeyResponse.Code, deleteKeyResponse.Body.String())
}
}
func TestSSHKeyAPIRejectsInvalidKeyWithoutEchoingIt(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("打开敏感信息存储失败:%v", err)
}
server := New(Dependencies{Config: config.Default(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
secret := "invalid-private-key-sensitive-content"
body, _ := json.Marshal(sshKeyRequest{Name: "错误私钥", PrivateKey: secret})
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(body)))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadRequest || strings.Contains(response.Body.String(), secret) {
t.Fatalf("无效 SSH 私钥响应不安全:%d %s", response.Code, response.Body.String())
}
}
func TestSSHKeyAPIRejectsOversizedRequestBody(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("failed to open secret store: %v", err)
}
server := New(Dependencies{Config: config.Default(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
body := `{"name":"oversized request","private_key":"` + strings.Repeat("a", maxSSHKeyRequestBytes) + `"}`
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(body))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("oversized SSH key request should return 413: %d %s", response.Code, response.Body.String())
}
}
func TestSSHKeyAPIRejectsOversizedPrivateKeyAndPassphrase(t *testing.T) {
store, err := secretstore.Open(t.TempDir())
if err != nil {
t.Fatalf("failed to open secret store: %v", err)
}
server := New(Dependencies{Config: config.Default(t.TempDir()), Repository: &stubDomainRepository{}, SSHKeys: sshkey.NewService(store)})
requests := []sshKeyRequest{
{Name: "oversized key", PrivateKey: strings.Repeat("a", sshkey.MaxPrivateKeyBytes+1)},
{Name: "oversized passphrase", PrivateKey: testSSHPrivateKey(t), Passphrase: strings.Repeat("p", 4097)},
}
for _, input := range requests {
body, err := json.Marshal(input)
if err != nil {
t.Fatalf("failed to encode limit test request: %v", err)
}
request := httptest.NewRequest(http.MethodPost, "/api/v1/ssh-keys", strings.NewReader(string(body)))
request.Header.Set("Content-Type", "application/json")
response := httptest.NewRecorder()
server.Handler().ServeHTTP(response, request)
leaksPassphrase := input.Passphrase != "" && strings.Contains(response.Body.String(), input.Passphrase)
if response.Code != http.StatusBadRequest || strings.Contains(response.Body.String(), input.PrivateKey) || leaksPassphrase {
t.Fatalf("oversized input should be rejected safely: %d %s", response.Code, response.Body.String())
}
}
}
func testSSHPrivateKey(t *testing.T) string {
t.Helper()
_, key, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
t.Fatalf("生成测试 SSH 私钥失败:%v", err)
}
encoded, err := x509.MarshalPKCS8PrivateKey(key)
if err != nil {
t.Fatalf("编码测试 SSH 私钥失败:%v", err)
}
return string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: encoded}))
}