完善证书管理与初始化流程
This commit is contained in:
1 parent
07636abe44
commit
c74372284a
84 files changed
+10151
-3502
No files matched your search
@@ -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
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
|
||||
@@ -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},
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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}))
|
||||
}
|
||||
Reference in new issue
Block a user