完善用户管理与凭据事务处理
This commit is contained in:
1 parent
7f0af703ed
commit
0e2222bcfe
33 files changed
+2135
-68
No files matched your search
@@ -1,6 +1,7 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"net"
|
||||
@@ -11,6 +12,7 @@ import (
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/auth"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
@@ -25,10 +27,13 @@ const (
|
||||
)
|
||||
|
||||
type authSession struct {
|
||||
Username string
|
||||
Email string
|
||||
Role string
|
||||
ExpiresAt time.Time
|
||||
UserID string
|
||||
Username string
|
||||
Email string
|
||||
Role string
|
||||
PasswordHash string
|
||||
ExpiresAt time.Time
|
||||
AbsoluteExpiresAt time.Time
|
||||
}
|
||||
|
||||
type loginAttempt struct {
|
||||
@@ -64,13 +69,8 @@ func (s *Server) authLogin(c *gin.Context) {
|
||||
s.writeError(c, http.StatusTooManyRequests, "登录失败次数过多,请稍后再试", nil)
|
||||
return
|
||||
}
|
||||
account, err := auth.AuthenticateAdmin(
|
||||
request.Identifier,
|
||||
request.Password,
|
||||
cfg.Admin.Username,
|
||||
cfg.Admin.Email,
|
||||
cfg.Admin.PasswordHash,
|
||||
)
|
||||
|
||||
account, userID, passwordHash, err := s.authenticateAccount(c.Request.Context(), request, cfg)
|
||||
if err != nil {
|
||||
s.recordLoginFailure(key)
|
||||
s.recordAuthAudit(c, "登录失败", "failed", "登录凭据校验失败")
|
||||
@@ -84,33 +84,56 @@ func (s *Server) authLogin(c *gin.Context) {
|
||||
s.writeError(c, http.StatusInternalServerError, "无法创建登录会话,请稍后重试", err)
|
||||
return
|
||||
}
|
||||
lifetime := authSessionLifetime
|
||||
now := s.now()
|
||||
absoluteExpiresAt := now.Add(authSessionLifetime)
|
||||
if request.Remember {
|
||||
lifetime = rememberSessionLife
|
||||
absoluteExpiresAt = now.Add(rememberSessionLife)
|
||||
}
|
||||
expiresAt := s.now().Add(lifetime)
|
||||
expiresAt := minTime(now.Add(authSessionLifetime), absoluteExpiresAt)
|
||||
s.authMu.Lock()
|
||||
s.authSessions[token] = authSession{
|
||||
Username: account.Username,
|
||||
Email: account.Email,
|
||||
Role: account.Role,
|
||||
ExpiresAt: expiresAt,
|
||||
UserID: userID,
|
||||
Username: account.Username,
|
||||
Email: account.Email,
|
||||
Role: account.Role,
|
||||
PasswordHash: passwordHash,
|
||||
ExpiresAt: expiresAt,
|
||||
AbsoluteExpiresAt: absoluteExpiresAt,
|
||||
}
|
||||
s.authMu.Unlock()
|
||||
s.setAuthCookie(c, token, expiresAt)
|
||||
s.recordAuthAudit(c, "登录成功", "success", "超级管理员登录成功")
|
||||
s.recordAuthAudit(c, "登录成功", "success", "用户登录成功")
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"authenticated": true,
|
||||
"account": account.Username,
|
||||
"email": account.Email,
|
||||
"role": account.Role,
|
||||
"is_admin": true,
|
||||
"is_admin": account.Role == repository.UserRoleSuperAdmin || account.Role == repository.UserRoleAdmin,
|
||||
"next_step": "complete",
|
||||
"required_steps": []string{},
|
||||
"expires_at": expiresAt,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) authenticateAccount(ctx context.Context, request authLoginRequest, cfg config.Config) (auth.AdminAccount, string, string, error) {
|
||||
account, err := auth.AuthenticateAdmin(request.Identifier, request.Password, cfg.Admin.Username, cfg.Admin.Email, cfg.Admin.PasswordHash)
|
||||
if err == nil {
|
||||
return account, "primary-super-admin", cfg.Admin.PasswordHash, nil
|
||||
}
|
||||
if s.users == nil {
|
||||
return auth.AdminAccount{}, "", "", auth.ErrInvalidCredentials
|
||||
}
|
||||
user, lookupErr := s.users.FindByIdentifier(ctx, request.Identifier)
|
||||
if lookupErr != nil || user.Status != repository.UserStatusActive {
|
||||
return auth.AdminAccount{}, "", "", auth.ErrInvalidCredentials
|
||||
}
|
||||
account, err = auth.AuthenticateAccount(request.Identifier, request.Password, user.Username, user.Email, user.PasswordHash, user.Role)
|
||||
if err != nil {
|
||||
return auth.AdminAccount{}, "", "", auth.ErrInvalidCredentials
|
||||
}
|
||||
return account, user.ID, user.PasswordHash, nil
|
||||
}
|
||||
|
||||
func (s *Server) authSession(c *gin.Context) {
|
||||
session, ok := s.currentAuthSession(c)
|
||||
if !ok {
|
||||
@@ -122,7 +145,7 @@ func (s *Server) authSession(c *gin.Context) {
|
||||
"account": session.Username,
|
||||
"email": session.Email,
|
||||
"role": session.Role,
|
||||
"is_admin": session.Role == "super_admin" || session.Role == "admin",
|
||||
"is_admin": session.Role == repository.UserRoleSuperAdmin || session.Role == repository.UserRoleAdmin,
|
||||
"next_step": "complete",
|
||||
"required_steps": []string{},
|
||||
"expires_at": session.ExpiresAt,
|
||||
@@ -151,26 +174,99 @@ func (s *Server) currentAuthSession(c *gin.Context) (authSession, bool) {
|
||||
s.authMu.RLock()
|
||||
session, ok := s.authSessions[token]
|
||||
s.authMu.RUnlock()
|
||||
if !ok {
|
||||
if !ok || !session.ExpiresAt.After(now) || (!session.AbsoluteExpiresAt.IsZero() && !session.AbsoluteExpiresAt.After(now)) {
|
||||
if ok {
|
||||
s.authMu.Lock()
|
||||
delete(s.authSessions, token)
|
||||
s.authMu.Unlock()
|
||||
}
|
||||
return authSession{}, false
|
||||
}
|
||||
if !session.ExpiresAt.After(now) {
|
||||
if !s.authSessionAccountIsValid(c.Request.Context(), session) {
|
||||
s.authMu.Lock()
|
||||
delete(s.authSessions, token)
|
||||
s.authMu.Unlock()
|
||||
s.clearAuthCookie(c)
|
||||
return authSession{}, false
|
||||
}
|
||||
newExpiresAt := minTime(now.Add(authSessionLifetime), session.AbsoluteExpiresAt)
|
||||
if newExpiresAt.After(session.ExpiresAt) {
|
||||
session.ExpiresAt = newExpiresAt
|
||||
s.authMu.Lock()
|
||||
if current, exists := s.authSessions[token]; exists {
|
||||
current.ExpiresAt = newExpiresAt
|
||||
s.authSessions[token] = current
|
||||
session = current
|
||||
}
|
||||
s.authMu.Unlock()
|
||||
s.setAuthCookie(c, token, session.ExpiresAt)
|
||||
}
|
||||
return session, true
|
||||
}
|
||||
|
||||
func (s *Server) authSessionAccountIsValid(ctx context.Context, session authSession) bool {
|
||||
if session.UserID == "" {
|
||||
return true
|
||||
}
|
||||
if session.PasswordHash == "" {
|
||||
return true
|
||||
}
|
||||
if session.UserID == "primary-super-admin" {
|
||||
s.configMu.RLock()
|
||||
cfg := s.config
|
||||
s.configMu.RUnlock()
|
||||
if !cfg.SetupReady || session.Role != repository.UserRoleSuperAdmin {
|
||||
return false
|
||||
}
|
||||
if !strings.EqualFold(strings.TrimSpace(session.Username), strings.TrimSpace(cfg.Admin.Username)) ||
|
||||
!strings.EqualFold(strings.TrimSpace(session.Email), strings.TrimSpace(cfg.Admin.Email)) {
|
||||
return false
|
||||
}
|
||||
return session.PasswordHash == cfg.Admin.PasswordHash
|
||||
}
|
||||
if s.users == nil {
|
||||
return false
|
||||
}
|
||||
user, err := s.users.GetUserByID(ctx, session.UserID)
|
||||
if err != nil || user.Status != repository.UserStatusActive {
|
||||
return false
|
||||
}
|
||||
if user.Role != session.Role || !strings.EqualFold(user.Username, session.Username) || !strings.EqualFold(user.Email, session.Email) {
|
||||
return false
|
||||
}
|
||||
return session.PasswordHash == user.PasswordHash
|
||||
}
|
||||
|
||||
func (s *Server) setAuthCookie(c *gin.Context, token string, expiresAt time.Time) {
|
||||
maxAge := int(expiresAt.Sub(s.now()).Seconds())
|
||||
http.SetCookie(c.Writer, &http.Cookie{
|
||||
Name: authCookieName, Value: token, Path: "/",
|
||||
Expires: expiresAt, MaxAge: max(1, int(time.Until(expiresAt).Seconds())),
|
||||
Expires: expiresAt, MaxAge: max(1, maxAge),
|
||||
HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: s.requestIsHTTPS(c.Request),
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) clearAuthCookie(c *gin.Context) {
|
||||
http.SetCookie(c.Writer, &http.Cookie{
|
||||
Name: authCookieName, Value: "", Path: "/", MaxAge: -1,
|
||||
HttpOnly: true, SameSite: http.SameSiteLaxMode, Secure: s.requestIsHTTPS(c.Request),
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) invalidateUserSessions(userID string) {
|
||||
userID = strings.TrimSpace(userID)
|
||||
if userID == "" {
|
||||
return
|
||||
}
|
||||
s.authMu.Lock()
|
||||
defer s.authMu.Unlock()
|
||||
for token, session := range s.authSessions {
|
||||
if session.UserID == userID {
|
||||
delete(s.authSessions, token)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Server) allowLogin(key string) bool {
|
||||
now := s.now()
|
||||
s.loginMu.Lock()
|
||||
@@ -256,6 +352,13 @@ func (s *Server) requestIsHTTPS(request *http.Request) bool {
|
||||
return strings.EqualFold(forwardedProto, "https")
|
||||
}
|
||||
|
||||
func minTime(left, right time.Time) time.Time {
|
||||
if right.IsZero() || left.Before(right) {
|
||||
return left
|
||||
}
|
||||
return right
|
||||
}
|
||||
|
||||
func max(left, right int) int {
|
||||
if left > right {
|
||||
return left
|
||||
|
||||
@@ -0,0 +1,285 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
func TestAuthLoginSupportsUserNameEmailAndDisabledAccounts(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
cfg.Database.DSN = filepath.Join(directory, "data", "auth-api.db")
|
||||
db, err := database.Open(t.Context(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开认证测试数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移认证测试数据库失败:%v", err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB, "sqlite")
|
||||
if err := users.EnsureSuperAdmin(t.Context(), repository.User{
|
||||
ID: "primary-super-admin", Username: cfg.Admin.Username, Email: cfg.Admin.Email, PasswordHash: cfg.Admin.PasswordHash,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存测试超级管理员失败:%v", err)
|
||||
}
|
||||
if err := users.CreateUser(t.Context(), repository.User{
|
||||
ID: "operator-1", Username: "operator", Email: "operator@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Operator123"), Role: repository.UserRoleAdmin, Status: repository.UserStatusActive,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存测试管理员失败:%v", err)
|
||||
}
|
||||
if err := users.CreateUser(t.Context(), repository.User{
|
||||
ID: "disabled-1", Username: "disabled", Email: "disabled@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Disabled123"), Role: repository.UserRoleUser, Status: repository.UserStatusDisabled,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存测试禁用用户失败:%v", err)
|
||||
}
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, Users: users})
|
||||
|
||||
for _, identifier := range []string{"operator", "OPERATOR@EXAMPLE.TEST"} {
|
||||
response := loginAuthTest(t, server, identifier, "Operator123", false)
|
||||
var payload struct {
|
||||
Account string `json:"account"`
|
||||
Email string `json:"email"`
|
||||
Role string `json:"role"`
|
||||
IsAdmin bool `json:"is_admin"`
|
||||
}
|
||||
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
|
||||
t.Fatalf("解析用户登录响应失败:%v", err)
|
||||
}
|
||||
if payload.Account != "operator" || payload.Email != "operator@example.test" || payload.Role != repository.UserRoleAdmin || !payload.IsAdmin {
|
||||
t.Fatalf("用户登录响应内容错误:%+v", payload)
|
||||
}
|
||||
}
|
||||
|
||||
disabled := loginAuthTest(t, server, "disabled", "Disabled123", false)
|
||||
if disabled.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("禁用用户登录应返回 401,实际为 %d:%s", disabled.Code, disabled.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthSessionSlidesAndHonorsAbsoluteRememberExpiration(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
|
||||
current := time.Date(2026, 8, 30, 10, 0, 0, 0, time.UTC)
|
||||
server.now = func() time.Time { return current }
|
||||
|
||||
login := loginAuthTest(t, server, "admin", "AdminPass123", true)
|
||||
cookies := login.Result().Cookies()
|
||||
if len(cookies) == 0 {
|
||||
t.Fatal("记住登录响应未返回会话 Cookie")
|
||||
}
|
||||
token := cookies[0].Value
|
||||
server.authMu.RLock()
|
||||
initial := server.authSessions[token]
|
||||
server.authMu.RUnlock()
|
||||
if !initial.AbsoluteExpiresAt.Equal(current.Add(rememberSessionLife)) || !initial.ExpiresAt.Equal(current.Add(authSessionLifetime)) {
|
||||
t.Fatalf("记住登录会话期限错误:%+v", initial)
|
||||
}
|
||||
|
||||
current = current.Add(20 * time.Minute)
|
||||
sessionResponse := httptest.NewRecorder()
|
||||
sessionRequest := httptest.NewRequest(http.MethodGet, "/api/v1/auth/session", nil)
|
||||
sessionRequest.AddCookie(cookies[0])
|
||||
server.Handler().ServeHTTP(sessionResponse, sessionRequest)
|
||||
if sessionResponse.Code != http.StatusOK {
|
||||
t.Fatalf("有效会话检查失败:%d %s", sessionResponse.Code, sessionResponse.Body.String())
|
||||
}
|
||||
server.authMu.RLock()
|
||||
sliding := server.authSessions[token]
|
||||
server.authMu.RUnlock()
|
||||
if !sliding.ExpiresAt.Equal(current.Add(authSessionLifetime)) {
|
||||
t.Fatalf("会话未按访问时间滑动续期:%+v", sliding)
|
||||
}
|
||||
|
||||
current = current.Add(rememberSessionLife)
|
||||
expired := httptest.NewRecorder()
|
||||
expiredRequest := httptest.NewRequest(http.MethodGet, "/api/v1/auth/session", nil)
|
||||
expiredRequest.AddCookie(cookies[0])
|
||||
server.Handler().ServeHTTP(expired, expiredRequest)
|
||||
if expired.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("超过绝对期限的会话应返回 401,实际为 %d:%s", expired.Code, expired.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAuthSessionIsInvalidatedWhenUserChanges(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
cfg.Database.DSN = filepath.Join(directory, "data", "auth-invalidation.db")
|
||||
db, err := database.Open(t.Context(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开会话失效测试数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移会话失效测试数据库失败:%v", err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB, "sqlite")
|
||||
if err := users.EnsureSuperAdmin(t.Context(), repository.User{
|
||||
ID: "primary-super-admin", Username: cfg.Admin.Username, Email: cfg.Admin.Email, PasswordHash: cfg.Admin.PasswordHash,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存会话失效测试超级管理员失败:%v", err)
|
||||
}
|
||||
if err := users.CreateUser(t.Context(), repository.User{
|
||||
ID: "operator-1", Username: "operator", Email: "operator@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Operator123"), Role: repository.UserRoleAdmin, Status: repository.UserStatusActive,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存会话失效测试用户失败:%v", err)
|
||||
}
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, Users: users})
|
||||
|
||||
login := loginAuthTest(t, server, "operator", "Operator123", false)
|
||||
cookies := login.Result().Cookies()
|
||||
if len(cookies) == 0 {
|
||||
t.Fatal("会话失效测试未返回 Cookie")
|
||||
}
|
||||
if err := users.UpdateUser(t.Context(), repository.User{
|
||||
ID: "operator-1", Username: "operator", Email: "operator@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Operator123"), Role: repository.UserRoleAdmin, Status: repository.UserStatusDisabled,
|
||||
}); err != nil {
|
||||
t.Fatalf("禁用会话失效测试用户失败:%v", err)
|
||||
}
|
||||
|
||||
response := httptest.NewRecorder()
|
||||
request := httptest.NewRequest(http.MethodGet, "/api/v1/auth/session", nil)
|
||||
request.AddCookie(cookies[0])
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("禁用用户的旧会话应返回 401,实际为 %d:%s", response.Code, response.Body.String())
|
||||
}
|
||||
server.authMu.RLock()
|
||||
_, exists := server.authSessions[cookies[0].Value]
|
||||
server.authMu.RUnlock()
|
||||
if exists {
|
||||
t.Fatal("禁用用户的旧会话未从内存中清理")
|
||||
}
|
||||
}
|
||||
|
||||
func loginAuthTest(t *testing.T, server *Server, identifier, password string, remember bool) *httptest.ResponseRecorder {
|
||||
t.Helper()
|
||||
body := `{"identifier":"` + identifier + `","password":"` + password + `","remember":` + boolString(remember) + `}`
|
||||
request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", strings.NewReader(body))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if remember && response.Code != http.StatusOK {
|
||||
t.Fatalf("记住登录失败:%d %s", response.Code, response.Body.String())
|
||||
}
|
||||
if !remember && identifier != "disabled" && response.Code != http.StatusOK {
|
||||
t.Fatalf("登录失败:%s,状态码=%d,响应=%s", identifier, response.Code, response.Body.String())
|
||||
}
|
||||
return response
|
||||
}
|
||||
|
||||
func boolString(value bool) string {
|
||||
if value {
|
||||
return "true"
|
||||
}
|
||||
return "false"
|
||||
}
|
||||
|
||||
func TestAuthSessionIsInvalidatedWhenUserPasswordChangesOrIsDeleted(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
cfg.Database.DSN = filepath.Join(directory, "data", "auth-invalidation-actions.db")
|
||||
db, err := database.Open(t.Context(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开用户会话操作测试数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移用户会话操作测试数据库失败:%v", err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB, "sqlite")
|
||||
if err := users.EnsureSuperAdmin(t.Context(), repository.User{
|
||||
ID: "primary-super-admin", Username: cfg.Admin.Username, Email: cfg.Admin.Email, PasswordHash: cfg.Admin.PasswordHash,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存用户会话操作测试超级管理员失败:%v", err)
|
||||
}
|
||||
if err := users.CreateUser(t.Context(), repository.User{
|
||||
ID: "operator-1", Username: "operator", Email: "operator@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Operator123"), Role: repository.UserRoleAdmin, Status: repository.UserStatusActive,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存用户会话操作测试用户失败:%v", err)
|
||||
}
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, Users: users})
|
||||
|
||||
passwordLogin := loginAuthTest(t, server, "operator", "Operator123", false)
|
||||
passwordCookie := passwordLogin.Result().Cookies()[0]
|
||||
if err := users.UpdateUser(t.Context(), repository.User{
|
||||
ID: "operator-1", Username: "operator", Email: "operator@example.test",
|
||||
PasswordHash: httpUserPasswordHash(t, "Changed123"), Role: repository.UserRoleAdmin, Status: repository.UserStatusActive,
|
||||
}); err != nil {
|
||||
t.Fatalf("修改用户密码失败:%v", err)
|
||||
}
|
||||
passwordResponse := authSessionRequest(server, passwordCookie)
|
||||
if passwordResponse.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("用户改密后旧会话应返回 401,实际为 %d:%s", passwordResponse.Code, passwordResponse.Body.String())
|
||||
}
|
||||
|
||||
deleteLogin := loginAuthTest(t, server, "operator", "Changed123", false)
|
||||
deleteCookie := deleteLogin.Result().Cookies()[0]
|
||||
if err := users.DeleteUser(t.Context(), "operator-1"); err != nil {
|
||||
t.Fatalf("删除用户失败:%v", err)
|
||||
}
|
||||
deleteResponse := authSessionRequest(server, deleteCookie)
|
||||
if deleteResponse.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("删除用户后旧会话应返回 401,实际为 %d:%s", deleteResponse.Code, deleteResponse.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrimarySuperAdminSessionIsInvalidatedWhenConfigurationPasswordChanges(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
|
||||
|
||||
login := loginAuthTest(t, server, "admin", "AdminPass123", false)
|
||||
cookie := login.Result().Cookies()[0]
|
||||
server.configMu.Lock()
|
||||
server.config.Admin.PasswordHash = httpUserPasswordHash(t, "Changed123")
|
||||
server.configMu.Unlock()
|
||||
|
||||
response := authSessionRequest(server, cookie)
|
||||
if response.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("主超级管理员改密后旧会话应返回 401,实际为 %d:%s", response.Code, response.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func authSessionRequest(server *Server, cookie *http.Cookie) *httptest.ResponseRecorder {
|
||||
response := httptest.NewRecorder()
|
||||
request := httptest.NewRequest(http.MethodGet, "/api/v1/auth/session", nil)
|
||||
request.AddCookie(cookie)
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
return response
|
||||
}
|
||||
@@ -9,6 +9,8 @@ import (
|
||||
"time"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
const requestIDHeader = "X-Scert-Request-ID"
|
||||
@@ -43,13 +45,21 @@ func (s *Server) requireAdmin(c *gin.Context) {
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
if _, ok := s.currentAuthSession(c); !ok {
|
||||
session, ok := s.currentAuthSession(c)
|
||||
if !ok {
|
||||
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
|
||||
"error": "请先登录管理后台",
|
||||
"request_id": requestIDFromContext(c),
|
||||
})
|
||||
return
|
||||
}
|
||||
if session.Role != repository.UserRoleSuperAdmin && session.Role != repository.UserRoleAdmin {
|
||||
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
|
||||
"error": "当前账号没有管理权限",
|
||||
"request_id": requestIDFromContext(c),
|
||||
})
|
||||
return
|
||||
}
|
||||
if !s.sameOriginForAPI(c.Request) {
|
||||
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
|
||||
"error": "请求来源校验失败",
|
||||
|
||||
@@ -10,6 +10,7 @@ import (
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
func TestRequestMiddlewareAddsAndPreservesRequestID(t *testing.T) {
|
||||
@@ -94,3 +95,24 @@ func TestAdminAPIAcceptsAuthenticatedSessionAndRejectsCrossOrigin(t *testing.T)
|
||||
t.Fatalf("跨来源管理请求应返回 403,实际为 %d:%s", crossOriginResponse.Code, crossOriginResponse.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminAPIRejectsAuthenticatedRegularUser(t *testing.T) {
|
||||
cfg := config.Default(t.TempDir())
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.com"
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte("Password123"), bcrypt.MinCost)
|
||||
if err != nil {
|
||||
t.Fatalf("生成测试密码摘要失败:%v", err)
|
||||
}
|
||||
cfg.Admin.PasswordHash = string(hash)
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
|
||||
cookie := httpUserSessionCookie(server, "user-1", repository.UserRoleUser)
|
||||
response := serveUserRequest(server, cookie, http.MethodGet, "/api/v1/domains", "")
|
||||
if response.Code != http.StatusForbidden {
|
||||
t.Fatalf("普通用户访问管理接口应返回 403,实际为 %d:%s", response.Code, response.Body.String())
|
||||
}
|
||||
if !strings.Contains(response.Body.String(), "没有管理权限") {
|
||||
t.Fatalf("普通用户权限错误提示不明确:%s", response.Body.String())
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/hex"
|
||||
@@ -16,6 +17,7 @@ import (
|
||||
"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/passwordpolicy"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
@@ -134,6 +136,7 @@ func (s *Server) resetSubmit(c *gin.Context) {
|
||||
s.renderResetPage(c, http.StatusBadRequest, token, err.Error())
|
||||
return
|
||||
}
|
||||
previousConfig := cfg
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
|
||||
if err != nil {
|
||||
s.recordResetAudit(c, "error", "生成新密码摘要失败")
|
||||
@@ -141,16 +144,26 @@ func (s *Server) resetSubmit(c *gin.Context) {
|
||||
return
|
||||
}
|
||||
cfg.Admin.PasswordHash = string(hash)
|
||||
if err := s.syncPrimarySuperAdmin(c.Request.Context(), cfg); err != nil {
|
||||
s.recordResetAudit(c, "error", "同步超级管理员用户失败")
|
||||
s.writeResetFailure(c, http.StatusInternalServerError, "暂时无法同步管理员账户,请稍后重试")
|
||||
return
|
||||
}
|
||||
if strings.TrimSpace(s.configPath) == "" {
|
||||
_ = s.syncPrimarySuperAdmin(c.Request.Context(), previousConfig)
|
||||
s.recordResetAudit(c, "error", "密码重置配置路径未配置")
|
||||
s.writeResetFailure(c, http.StatusInternalServerError, "服务配置路径未就绪,请联系管理员")
|
||||
return
|
||||
}
|
||||
if err := cfg.Save(s.configPath); err != nil {
|
||||
if restoreErr := s.syncPrimarySuperAdmin(c.Request.Context(), previousConfig); restoreErr != nil && s.logger != nil {
|
||||
s.logger.Error("配置保存失败后恢复超级管理员用户摘要失败", "error", restoreErr)
|
||||
}
|
||||
s.recordResetAudit(c, "error", "保存密码重置配置失败")
|
||||
s.writeResetFailure(c, http.StatusInternalServerError, "暂时无法保存新密码,请稍后重试")
|
||||
return
|
||||
}
|
||||
s.invalidateUserSessions("primary-super-admin")
|
||||
if err := admin.Consume(s.resetStatePath, verified, now); err != nil {
|
||||
s.resetClosedHash = session.CodeHash
|
||||
s.configMu.Lock()
|
||||
@@ -171,6 +184,18 @@ func (s *Server) resetSubmit(c *gin.Context) {
|
||||
s.renderResetSuccess(c, "密码重置成功,请停止 Scert-admin 以结束本次维护窗口")
|
||||
}
|
||||
|
||||
func (s *Server) syncPrimarySuperAdmin(ctx context.Context, cfg config.Config) error {
|
||||
if s.users == nil {
|
||||
return nil
|
||||
}
|
||||
return s.users.EnsureSuperAdmin(ctx, repository.User{
|
||||
ID: "primary-super-admin",
|
||||
Username: cfg.Admin.Username,
|
||||
Email: cfg.Admin.Email,
|
||||
PasswordHash: cfg.Admin.PasswordHash,
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) sameOrigin(request *http.Request) bool {
|
||||
if request == nil || strings.TrimSpace(request.Host) == "" {
|
||||
return false
|
||||
|
||||
@@ -39,6 +39,7 @@ type Dependencies struct {
|
||||
Logger *logging.Logger
|
||||
Repository repository.DomainRepository
|
||||
Servers repository.ServerRepository
|
||||
Users repository.UserRepository
|
||||
SSHKeys *sshkey.Service
|
||||
SetupDNS setupDNSVerifier
|
||||
Secrets setupSecretWriter
|
||||
@@ -65,6 +66,7 @@ type Server struct {
|
||||
logger *logging.Logger
|
||||
repository repository.DomainRepository
|
||||
servers repository.ServerRepository
|
||||
users repository.UserRepository
|
||||
sshKeys *sshkey.Service
|
||||
setupDNS setupDNSVerifier
|
||||
secrets setupSecretWriter
|
||||
@@ -105,6 +107,7 @@ func New(deps Dependencies) *Server {
|
||||
config: deps.Config, configPath: deps.ConfigPath, frontendDir: filepath.Clean(frontendDir), logger: deps.Logger,
|
||||
repository: deps.Repository, setupDNS: deps.SetupDNS, secrets: deps.Secrets, firewall: deps.Firewall, router: router,
|
||||
servers: deps.Servers,
|
||||
users: deps.Users,
|
||||
sshKeys: deps.SSHKeys,
|
||||
issueCertificate: deps.IssueCertificate,
|
||||
issueSetupCertificate: deps.IssueSetupCertificate,
|
||||
@@ -139,6 +142,12 @@ func (s *Server) registerRoutes() {
|
||||
s.router.POST("/api/v1/auth/logout", s.authLogout)
|
||||
s.router.POST("/api/v1/password-reset/resolve", s.resolvePasswordResetAccount)
|
||||
adminAPI := s.router.Group("/api/v1", s.requireAdmin)
|
||||
userAPI := s.router.Group("/api/v1/users", s.requireSuperAdmin)
|
||||
userAPI.GET("", s.listUsers)
|
||||
userAPI.POST("", s.createUser)
|
||||
userAPI.GET("/:id", s.getUser)
|
||||
userAPI.PUT("/:id", s.updateUser)
|
||||
userAPI.DELETE("/:id", s.deleteUser)
|
||||
adminAPI.GET("/domains", s.listDomains)
|
||||
adminAPI.POST("/domains", s.createDomain)
|
||||
adminAPI.PUT("/domains/:id", s.updateDomain)
|
||||
|
||||
@@ -173,6 +173,75 @@ func TestResetPasswordUpdatesConfigAndConsumesSession(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestResetPasswordSynchronizesPrimarySuperAdminUser(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)
|
||||
cfg.Database.DSN = filepath.Join(dir, "data", "reset-users.db")
|
||||
configPath := filepath.Join(dir, "config", "scert.json")
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatalf("保存测试配置失败:%v", err)
|
||||
}
|
||||
db, err := database.Open(t.Context(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开测试用户数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移测试用户数据库失败:%v", err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB, "sqlite")
|
||||
if err := users.EnsureSuperAdmin(t.Context(), repository.User{
|
||||
ID: "primary-super-admin", Username: cfg.Admin.Username, Email: cfg.Admin.Email, PasswordHash: cfg.Admin.PasswordHash,
|
||||
}); 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{}, Users: users,
|
||||
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("密码重置页面 Cookie 数量错误:%d", len(cookies))
|
||||
}
|
||||
form := resetForm(session.Code, cookies[0].Value, "NewPass1234")
|
||||
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(cookies[0])
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusOK {
|
||||
t.Fatalf("密码重置失败:%d %s", response.Code, response.Body.String())
|
||||
}
|
||||
item, err := users.GetUserByID(t.Context(), "primary-super-admin")
|
||||
if err != nil {
|
||||
t.Fatalf("读取同步后的超级管理员失败:%v", err)
|
||||
}
|
||||
if bcrypt.CompareHashAndPassword([]byte(item.PasswordHash), []byte("NewPass1234")) != nil {
|
||||
t.Fatal("用户表中的超级管理员摘要未同步新密码")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResetRejectsCrossSiteAndLimitsFailures(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
|
||||
@@ -165,17 +165,21 @@ func (s *Server) updateSettings(c *gin.Context) {
|
||||
updated := s.config
|
||||
applySettingsRequest(&updated, request)
|
||||
updated.Normalize()
|
||||
if err := s.saveSettingsNotificationCredentials(c.Request.Context(), &updated, request); err != nil {
|
||||
createdCredentialRefs, err := s.saveSettingsNotificationCredentials(c.Request.Context(), &updated, request)
|
||||
if err != nil {
|
||||
s.rollbackSetupCredentialsWithLog(createdCredentialRefs)
|
||||
s.configMu.Unlock()
|
||||
s.writeError(c, http.StatusBadRequest, "保存通知凭据失败", err)
|
||||
return
|
||||
}
|
||||
if err := updated.Validate(); err != nil {
|
||||
s.rollbackSetupCredentialsWithLog(createdCredentialRefs)
|
||||
s.configMu.Unlock()
|
||||
s.writeError(c, http.StatusBadRequest, "设置内容校验失败", err)
|
||||
return
|
||||
}
|
||||
if err := updated.Save(s.configPath); err != nil {
|
||||
s.rollbackSetupCredentialsWithLog(createdCredentialRefs)
|
||||
s.configMu.Unlock()
|
||||
s.writeError(c, http.StatusInternalServerError, "保存设置失败", err)
|
||||
return
|
||||
@@ -193,6 +197,29 @@ func (s *Server) updateSettings(c *gin.Context) {
|
||||
}
|
||||
s.config = updated
|
||||
s.configMu.Unlock()
|
||||
oldCredentialRefs := []string{
|
||||
previous.Notification.HTTPCredentialRef,
|
||||
previous.Notification.SMTPCredentialRef,
|
||||
}
|
||||
newCredentialRefs := map[string]struct{}{
|
||||
updated.Notification.HTTPCredentialRef: {},
|
||||
updated.Notification.SMTPCredentialRef: {},
|
||||
}
|
||||
var obsoleteCredentialRefs []string
|
||||
for _, reference := range oldCredentialRefs {
|
||||
reference = strings.TrimSpace(reference)
|
||||
if reference == "" {
|
||||
continue
|
||||
}
|
||||
if _, stillUsed := newCredentialRefs[reference]; !stillUsed {
|
||||
obsoleteCredentialRefs = append(obsoleteCredentialRefs, reference)
|
||||
}
|
||||
}
|
||||
if len(obsoleteCredentialRefs) > 0 {
|
||||
if err := s.rollbackSetupCredentials(obsoleteCredentialRefs); err != nil && s.logger != nil {
|
||||
s.logger.Warn("\u6e05\u7406\u5df2\u66ff\u6362\u7684\u901a\u77e5\u654f\u611f\u51ed\u636e\u5931\u8d25", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"settings": settingsViewFromConfig(updated),
|
||||
|
||||
@@ -209,3 +209,123 @@ func mustTestPasswordHash(t *testing.T, password string) string {
|
||||
}
|
||||
return string(hash)
|
||||
}
|
||||
|
||||
func TestSettingsAPIRollsBackCredentialsWhenValidationFails(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
cfg.SetupReady = true
|
||||
cfg.DNS.VerificationState = "verified"
|
||||
cfg.Web.Hostname = "scert.example.test"
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = mustTestPasswordHash(t, "Password123")
|
||||
configPath := dir + "\\config\\scert.json"
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatalf("save test config: %v", err)
|
||||
}
|
||||
secrets := &fakeSetupSecretWriter{}
|
||||
server := New(Dependencies{Config: cfg, ConfigPath: configPath, Secrets: secrets})
|
||||
cookie := loginForSettingsTest(t, server)
|
||||
|
||||
request := httptest.NewRequest(http.MethodPut, "/api/v1/settings", strings.NewReader(`{
|
||||
"notification": {
|
||||
"http_auth_mode": "bearer",
|
||||
"http_credentials": {"token": "new-token"},
|
||||
"http_path": "email/send"
|
||||
}
|
||||
}`))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
request.AddCookie(cookie)
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusBadRequest {
|
||||
t.Fatalf("invalid notification settings should fail: %d %s", response.Code, response.Body.String())
|
||||
}
|
||||
if len(secrets.values) != 0 || len(secrets.deleted) != 1 {
|
||||
t.Fatalf("new credentials should be rolled back after validation failure: values=%v deleted=%v", secrets.values, secrets.deleted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSettingsAPICleansReplacedNotificationCredential(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
cfg.SetupReady = true
|
||||
cfg.DNS.VerificationState = "verified"
|
||||
cfg.Web.Hostname = "scert.example.test"
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = mustTestPasswordHash(t, "Password123")
|
||||
cfg.Notification.HTTPAuthMode = "bearer"
|
||||
cfg.Notification.HTTPCredentialRef = "secret://notification/old"
|
||||
configPath := dir + "\\config\\scert.json"
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatalf("save test config: %v", err)
|
||||
}
|
||||
secrets := &fakeSetupSecretWriter{values: map[string]map[string]string{
|
||||
"secret://notification/old": {"token": "old-token"},
|
||||
}}
|
||||
server := New(Dependencies{Config: cfg, ConfigPath: configPath, Secrets: secrets})
|
||||
cookie := loginForSettingsTest(t, server)
|
||||
|
||||
request := httptest.NewRequest(http.MethodPut, "/api/v1/settings", strings.NewReader(`{
|
||||
"notification": {
|
||||
"http_auth_mode": "bearer",
|
||||
"http_credentials": {"token": "new-token"}
|
||||
}
|
||||
}`))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
request.AddCookie(cookie)
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusOK {
|
||||
t.Fatalf("notification credential replacement should succeed: %d %s", response.Code, response.Body.String())
|
||||
}
|
||||
if _, ok := secrets.values["secret://notification/old"]; ok {
|
||||
t.Fatal("replaced notification credential should be deleted")
|
||||
}
|
||||
if len(secrets.values) != 1 {
|
||||
t.Fatalf("new notification credential should remain: %v", secrets.values)
|
||||
}
|
||||
if strings.Contains(response.Body.String(), "new-token") {
|
||||
t.Fatal("notification credential must not be returned in the response")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSettingsAPIRollsBackEarlierCredentialWhenLaterCredentialFails(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
cfg := config.Default(dir)
|
||||
cfg.SetupReady = true
|
||||
cfg.DNS.VerificationState = "verified"
|
||||
cfg.Web.Hostname = "scert.example.test"
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = mustTestPasswordHash(t, "Password123")
|
||||
cfg.Notification.SMTPUsername = "smtp-user"
|
||||
configPath := dir + "\\config\\scert.json"
|
||||
if err := cfg.Save(configPath); err != nil {
|
||||
t.Fatalf("save test config: %v", err)
|
||||
}
|
||||
secrets := &fakeSetupSecretWriter{}
|
||||
server := New(Dependencies{Config: cfg, ConfigPath: configPath, Secrets: secrets})
|
||||
cookie := loginForSettingsTest(t, server)
|
||||
|
||||
request := httptest.NewRequest(http.MethodPut, "/api/v1/settings", strings.NewReader(`{
|
||||
"notification": {
|
||||
"http_auth_mode": "bearer",
|
||||
"http_credentials": {"token": "new-token"},
|
||||
"smtp_enabled": true,
|
||||
"smtp_username": "",
|
||||
"smtp_password": "smtp-password"
|
||||
}
|
||||
}`))
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
request.AddCookie(cookie)
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusBadRequest {
|
||||
t.Fatalf("later SMTP validation should fail: %d %s", response.Code, response.Body.String())
|
||||
}
|
||||
if len(secrets.values) != 0 || len(secrets.deleted) != 1 {
|
||||
t.Fatalf("earlier HTTP credentials should be rolled back: values=%v deleted=%v", secrets.values, secrets.deleted)
|
||||
}
|
||||
}
|
||||
@@ -9,46 +9,49 @@ import (
|
||||
)
|
||||
|
||||
// saveSettingsNotificationCredentials 将页面提交的通知密码写入加密存储,配置文件只保存引用。
|
||||
func (s *Server) saveSettingsNotificationCredentials(ctx context.Context, cfg *config.Config, request settingsRequest) error {
|
||||
func (s *Server) saveSettingsNotificationCredentials(ctx context.Context, cfg *config.Config, request settingsRequest) ([]string, error) {
|
||||
createdCredentialRefs := make([]string, 0, 2)
|
||||
if cfg == nil || request.Notification == nil {
|
||||
return nil
|
||||
return createdCredentialRefs, nil
|
||||
}
|
||||
item := request.Notification
|
||||
if len(item.HTTPCredentials) > 0 {
|
||||
if s.secrets == nil {
|
||||
return errors.New("HTTP 通知敏感凭据存储尚未初始化")
|
||||
return createdCredentialRefs, errors.New("HTTP 通知敏感凭据存储尚未初始化")
|
||||
}
|
||||
values, err := normalizeNotificationCredentials(cfg.Notification.HTTPAuthMode, item.HTTPCredentials)
|
||||
if err != nil {
|
||||
return err
|
||||
return createdCredentialRefs, err
|
||||
}
|
||||
ref, err := newNotificationCredentialReference()
|
||||
if err != nil {
|
||||
return err
|
||||
return createdCredentialRefs, err
|
||||
}
|
||||
if err := s.secrets.Put(ctx, ref, values); err != nil {
|
||||
return err
|
||||
return createdCredentialRefs, err
|
||||
}
|
||||
createdCredentialRefs = append(createdCredentialRefs, ref)
|
||||
cfg.Notification.HTTPCredentialRef = ref
|
||||
}
|
||||
if item.SMTPPassword == nil || *item.SMTPPassword == "" {
|
||||
return nil
|
||||
return createdCredentialRefs, nil
|
||||
}
|
||||
if s.secrets == nil {
|
||||
return errors.New("SMTP 通知敏感凭据存储尚未初始化")
|
||||
return createdCredentialRefs, errors.New("SMTP 通知敏感凭据存储尚未初始化")
|
||||
}
|
||||
username := strings.TrimSpace(cfg.Notification.SMTPUsername)
|
||||
if username == "" {
|
||||
return errors.New("填写 SMTP 密码前必须配置 SMTP 用户名")
|
||||
return createdCredentialRefs, errors.New("填写 SMTP 密码前必须配置 SMTP 用户名")
|
||||
}
|
||||
ref, err := newNotificationCredentialReference()
|
||||
if err != nil {
|
||||
return err
|
||||
return createdCredentialRefs, err
|
||||
}
|
||||
values := map[string]string{"username": username, "password": *item.SMTPPassword}
|
||||
if err := s.secrets.Put(ctx, ref, values); err != nil {
|
||||
return err
|
||||
return createdCredentialRefs, err
|
||||
}
|
||||
createdCredentialRefs = append(createdCredentialRefs, ref)
|
||||
cfg.Notification.SMTPCredentialRef = ref
|
||||
return nil
|
||||
return createdCredentialRefs, nil
|
||||
}
|
||||
@@ -202,6 +202,17 @@ func (s *Server) applySetup(c *gin.Context) {
|
||||
s.writeError(c, http.StatusBadRequest, err.Error(), nil)
|
||||
return
|
||||
}
|
||||
dnsCredentialRetained := false
|
||||
defer func() {
|
||||
if dnsCredentialRetained || s.secrets == nil {
|
||||
return
|
||||
}
|
||||
cleanupContext, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
if err := s.secrets.Delete(cleanupContext, strings.TrimSpace(request.DNSCredentialRef)); err != nil && s.logger != nil {
|
||||
s.logger.Warn("\u521d\u59cb\u5316\u5931\u8d25\u540e\u6e05\u7406 DNS \u51ed\u6362\u5931\u8d25", "error", err)
|
||||
}
|
||||
}()
|
||||
webEnabled := true
|
||||
if request.WebEnabled != nil {
|
||||
webEnabled = *request.WebEnabled
|
||||
@@ -430,6 +441,7 @@ func (s *Server) applySetup(c *gin.Context) {
|
||||
s.writeError(c, http.StatusInternalServerError, "保存初始化配置失败", err)
|
||||
return
|
||||
}
|
||||
dnsCredentialRetained = true
|
||||
if err := s.setupDNS.Consume(request.DNSVerificationToken, request.DNSProvider, request.DNSCredentialRef, testDomain); err != nil && s.logger != nil {
|
||||
s.logger.Warn("初始化配置已保存,但清理 DNS 验证令牌失败", "error", err)
|
||||
}
|
||||
|
||||
@@ -747,3 +747,31 @@ func TestSetupFirewallFailureRollsBackIssuedCertificate(t *testing.T) {
|
||||
t.Fatal("防火墙配置失败时应回滚已保存的初始化证书")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetupFailureDeletesTemporaryDNSCredential(t *testing.T) {
|
||||
baseDir := t.TempDir()
|
||||
configPath := filepath.Join(baseDir, "config", "scert.json")
|
||||
verifier := &fakeSetupDNSVerifier{}
|
||||
secrets := &fakeSetupSecretWriter{values: map[string]map[string]string{
|
||||
"secret://dns/cloudflare/test": {"api_token": "temporary-token"},
|
||||
}}
|
||||
server := New(Dependencies{
|
||||
Config: config.Default(baseDir), ConfigPath: configPath,
|
||||
Repository: &stubDomainRepository{}, SetupDNS: verifier, Secrets: secrets,
|
||||
IssueSetupCertificate: newSetupCertificateIssuer(t, baseDir, errors.New("simulated certificate failure")),
|
||||
})
|
||||
request := httptest.NewRequest(http.MethodPost, "/api/v1/setup", strings.NewReader(setupPayload(baseDir, "secure1234")))
|
||||
request.RemoteAddr = "127.0.0.1:53000"
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
if response.Code != http.StatusBadGateway {
|
||||
t.Fatalf("setup certificate failure should return 502: %d %s", response.Code, response.Body.String())
|
||||
}
|
||||
if _, ok := secrets.values["secret://dns/cloudflare/test"]; ok {
|
||||
t.Fatal("temporary DNS credential should be deleted after setup failure")
|
||||
}
|
||||
if len(secrets.deleted) != 1 || secrets.deleted[0] != "secret://dns/cloudflare/test" {
|
||||
t.Fatalf("unexpected deleted DNS credentials: %v", secrets.deleted)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,270 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/domain"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/passwordpolicy"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
type userRequest struct {
|
||||
Username string `json:"username"`
|
||||
Email string `json:"email"`
|
||||
Password string `json:"password"`
|
||||
Role string `json:"role"`
|
||||
Status string `json:"status"`
|
||||
}
|
||||
|
||||
func (s *Server) requireSuperAdmin(c *gin.Context) {
|
||||
s.configMu.RLock()
|
||||
setupReady := s.config.SetupReady
|
||||
s.configMu.RUnlock()
|
||||
if !setupReady {
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
session, ok := s.currentAuthSession(c)
|
||||
if !ok {
|
||||
c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "请先登录管理后台", "request_id": requestIDFromContext(c)})
|
||||
return
|
||||
}
|
||||
if session.Role != repository.UserRoleSuperAdmin {
|
||||
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "只有超级管理员可以管理用户", "request_id": requestIDFromContext(c)})
|
||||
return
|
||||
}
|
||||
if !s.sameOriginForAPI(c.Request) {
|
||||
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "请求来源校验失败", "request_id": requestIDFromContext(c)})
|
||||
return
|
||||
}
|
||||
c.Next()
|
||||
}
|
||||
|
||||
func (s *Server) listUsers(c *gin.Context) {
|
||||
if s.users == nil {
|
||||
s.writeError(c, http.StatusNotImplemented, "用户管理接口尚未配置", errors.New("用户仓储未配置"))
|
||||
return
|
||||
}
|
||||
items, err := s.users.ListUsers(c.Request.Context())
|
||||
if err != nil {
|
||||
s.writeError(c, http.StatusInternalServerError, "查询用户失败", err)
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"items": items})
|
||||
}
|
||||
|
||||
func (s *Server) getUser(c *gin.Context) {
|
||||
if s.users == nil {
|
||||
s.writeError(c, http.StatusNotImplemented, "用户管理接口尚未配置", errors.New("用户仓储未配置"))
|
||||
return
|
||||
}
|
||||
item, err := s.users.GetUserByID(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) createUser(c *gin.Context) {
|
||||
if s.users == nil {
|
||||
s.writeError(c, http.StatusNotImplemented, "用户管理接口尚未配置", errors.New("用户仓储未配置"))
|
||||
return
|
||||
}
|
||||
var request userRequest
|
||||
if err := c.ShouldBindJSON(&request); err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "用户参数无效", err)
|
||||
return
|
||||
}
|
||||
item, err := userFromRequest(request, "")
|
||||
if err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "用户参数无效", err)
|
||||
return
|
||||
}
|
||||
if err := s.users.CreateUser(c.Request.Context(), item); err != nil {
|
||||
s.writeError(c, userErrorStatus(err), "创建用户失败", err)
|
||||
return
|
||||
}
|
||||
s.recordUserAudit(c, "创建用户", "success", item.ID)
|
||||
c.JSON(http.StatusCreated, item)
|
||||
}
|
||||
|
||||
func (s *Server) updateUser(c *gin.Context) {
|
||||
if s.users == nil {
|
||||
s.writeError(c, http.StatusNotImplemented, "用户管理接口尚未配置", errors.New("用户仓储未配置"))
|
||||
return
|
||||
}
|
||||
id := strings.TrimSpace(c.Param("id"))
|
||||
existing, err := s.users.GetUserByID(c.Request.Context(), id)
|
||||
if err != nil {
|
||||
if repository.IsNotFound(err) {
|
||||
s.writeError(c, http.StatusNotFound, "用户不存在", err)
|
||||
return
|
||||
}
|
||||
s.writeError(c, http.StatusInternalServerError, "读取用户失败", err)
|
||||
return
|
||||
}
|
||||
var request userRequest
|
||||
if err := c.ShouldBindJSON(&request); err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "用户参数无效", err)
|
||||
return
|
||||
}
|
||||
item, err := userFromRequest(request, id)
|
||||
if err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, "用户参数无效", err)
|
||||
return
|
||||
}
|
||||
if request.Password == "" {
|
||||
item.PasswordHash = existing.PasswordHash
|
||||
}
|
||||
if request.Role == "" {
|
||||
item.Role = existing.Role
|
||||
}
|
||||
if request.Status == "" {
|
||||
item.Status = existing.Status
|
||||
}
|
||||
if existing.Role == repository.UserRoleSuperAdmin && item.Role != repository.UserRoleSuperAdmin {
|
||||
s.writeError(c, http.StatusBadRequest, "不能降低超级管理员权限", nil)
|
||||
return
|
||||
}
|
||||
if existing.Role == repository.UserRoleSuperAdmin && item.Status == repository.UserStatusDisabled {
|
||||
if err := s.ensureAnotherSuperAdmin(c, id); err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, err.Error(), err)
|
||||
return
|
||||
}
|
||||
}
|
||||
if err := s.users.UpdateUser(c.Request.Context(), item); err != nil {
|
||||
s.writeError(c, userErrorStatus(err), "更新用户失败", err)
|
||||
return
|
||||
}
|
||||
s.invalidateUserSessions(id)
|
||||
s.recordUserAudit(c, "更新用户", "success", id)
|
||||
c.JSON(http.StatusOK, item)
|
||||
}
|
||||
|
||||
func (s *Server) deleteUser(c *gin.Context) {
|
||||
if s.users == nil {
|
||||
s.writeError(c, http.StatusNotImplemented, "用户管理接口尚未配置", errors.New("用户仓储未配置"))
|
||||
return
|
||||
}
|
||||
id := strings.TrimSpace(c.Param("id"))
|
||||
session, _ := s.currentAuthSession(c)
|
||||
if session.UserID != "" && session.UserID == id {
|
||||
s.writeError(c, http.StatusBadRequest, "不能删除当前登录用户", nil)
|
||||
return
|
||||
}
|
||||
existing, err := s.users.GetUserByID(c.Request.Context(), id)
|
||||
if err != nil {
|
||||
if repository.IsNotFound(err) {
|
||||
s.writeError(c, http.StatusNotFound, "用户不存在", err)
|
||||
return
|
||||
}
|
||||
s.writeError(c, http.StatusInternalServerError, "读取用户失败", err)
|
||||
return
|
||||
}
|
||||
if existing.Role == repository.UserRoleSuperAdmin {
|
||||
if existing.ID == "primary-super-admin" {
|
||||
s.writeError(c, http.StatusBadRequest, "不能删除配置中的主超级管理员", repository.ErrSuperAdminProtected)
|
||||
return
|
||||
}
|
||||
if err := s.ensureAnotherSuperAdmin(c, id); err != nil {
|
||||
s.writeError(c, http.StatusBadRequest, err.Error(), err)
|
||||
return
|
||||
}
|
||||
}
|
||||
if err := s.users.DeleteUser(c.Request.Context(), id); err != nil {
|
||||
if errors.Is(err, repository.ErrSuperAdminProtected) {
|
||||
s.writeError(c, http.StatusBadRequest, err.Error(), err)
|
||||
return
|
||||
}
|
||||
if repository.IsNotFound(err) {
|
||||
s.writeError(c, http.StatusNotFound, "用户不存在", err)
|
||||
return
|
||||
}
|
||||
s.writeError(c, userErrorStatus(err), "删除用户失败", err)
|
||||
return
|
||||
}
|
||||
s.invalidateUserSessions(id)
|
||||
s.recordUserAudit(c, "删除用户", "success", id)
|
||||
c.Status(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (s *Server) ensureAnotherSuperAdmin(c *gin.Context, currentID string) error {
|
||||
items, err := s.users.ListUsers(c.Request.Context())
|
||||
if err != nil {
|
||||
return errors.New("无法确认超级管理员数量")
|
||||
}
|
||||
for _, item := range items {
|
||||
if item.Role == repository.UserRoleSuperAdmin && item.Status == repository.UserStatusActive && item.ID != currentID {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return errors.New("不能禁用最后一个超级管理员")
|
||||
}
|
||||
|
||||
func userFromRequest(request userRequest, id string) (repository.User, error) {
|
||||
username := strings.TrimSpace(strings.ToLower(request.Username))
|
||||
if username == "" {
|
||||
return repository.User{}, errors.New("用户名不能为空")
|
||||
}
|
||||
if request.Password == "" && id == "" {
|
||||
return repository.User{}, errors.New("密码不能为空")
|
||||
}
|
||||
item := repository.User{
|
||||
ID: id, Username: username, Email: request.Email,
|
||||
Role: strings.TrimSpace(strings.ToLower(request.Role)), Status: strings.TrimSpace(strings.ToLower(request.Status)),
|
||||
}
|
||||
if item.Role == "" {
|
||||
item.Role = repository.UserRoleUser
|
||||
}
|
||||
if item.Status == "" {
|
||||
item.Status = repository.UserStatusActive
|
||||
}
|
||||
if request.Password != "" {
|
||||
if err := passwordpolicy.ValidateAccountPassword(request.Password, username); err != nil {
|
||||
return repository.User{}, err
|
||||
}
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte(request.Password), bcrypt.DefaultCost)
|
||||
if err != nil {
|
||||
return repository.User{}, errors.New("生成密码摘要失败")
|
||||
}
|
||||
item.PasswordHash = string(hash)
|
||||
}
|
||||
if item.ID == "" {
|
||||
item.ID = domain.NewID()
|
||||
}
|
||||
return item, nil
|
||||
}
|
||||
|
||||
func (s *Server) recordUserAudit(c *gin.Context, action, status, id string) {
|
||||
if s.audit == nil {
|
||||
return
|
||||
}
|
||||
if err := s.audit.CreateAuditLog(c.Request.Context(), repository.AuditLog{
|
||||
Action: action, ResourceType: "user", ResourceID: id, Status: status, Message: action,
|
||||
}); err != nil && s.logger != nil {
|
||||
s.logger.Warn("保存用户审计日志失败", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
func userErrorStatus(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(), "长度") || strings.Contains(err.Error(), "不能") {
|
||||
return http.StatusBadRequest
|
||||
}
|
||||
return http.StatusInternalServerError
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/config"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/database"
|
||||
"git.pcux.cn/xuans/Scert/backend/internal/repository"
|
||||
)
|
||||
|
||||
func TestUserManagementAuthorizationAndCRUD(t *testing.T) {
|
||||
directory := t.TempDir()
|
||||
cfg := config.Default(directory)
|
||||
cfg.SetupReady = true
|
||||
cfg.Admin.Username = "admin"
|
||||
cfg.Admin.Email = "admin@example.test"
|
||||
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "AdminPass123")
|
||||
cfg.Database.DSN = filepath.Join(directory, "data", "users-api.db")
|
||||
db, err := database.Open(t.Context(), cfg.Database)
|
||||
if err != nil {
|
||||
t.Fatalf("打开用户 API 测试数据库失败:%v", err)
|
||||
}
|
||||
defer db.Close()
|
||||
if err := database.Migrate(t.Context(), db.DB, "sqlite"); err != nil {
|
||||
t.Fatalf("迁移用户 API 测试数据库失败:%v", err)
|
||||
}
|
||||
users := repository.NewSQLUserRepository(db.DB, "sqlite")
|
||||
if err := users.EnsureSuperAdmin(t.Context(), repository.User{
|
||||
ID: "primary-super-admin", Username: cfg.Admin.Username, Email: cfg.Admin.Email,
|
||||
PasswordHash: cfg.Admin.PasswordHash,
|
||||
}); err != nil {
|
||||
t.Fatalf("保存用户 API 测试超级管理员失败:%v", err)
|
||||
}
|
||||
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}, Users: users})
|
||||
|
||||
unauthorized := serveUserRequest(server, nil, http.MethodGet, "/api/v1/users", "")
|
||||
if unauthorized.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("未登录请求应返回 401:%d %s", unauthorized.Code, unauthorized.Body.String())
|
||||
}
|
||||
regularCookie := httpUserSessionCookie(server, "user-1", repository.UserRoleUser)
|
||||
forbidden := serveUserRequest(server, regularCookie, http.MethodGet, "/api/v1/users", "")
|
||||
if forbidden.Code != http.StatusForbidden {
|
||||
t.Fatalf("普通用户请求应返回 403:%d %s", forbidden.Code, forbidden.Body.String())
|
||||
}
|
||||
|
||||
adminCookie := httpUserSessionCookie(server, "primary-super-admin", repository.UserRoleSuperAdmin)
|
||||
created := serveUserRequest(server, adminCookie, http.MethodPost, "/api/v1/users", `{"username":"operator","email":"operator@example.test","password":"UserPass123","role":"user","status":"active"}`)
|
||||
if created.Code != http.StatusCreated {
|
||||
t.Fatalf("创建用户失败:%d %s", created.Code, created.Body.String())
|
||||
}
|
||||
if strings.Contains(created.Body.String(), "password_hash") || strings.Contains(created.Body.String(), "UserPass123") {
|
||||
t.Fatalf("创建用户响应泄露敏感字段:%s", created.Body.String())
|
||||
}
|
||||
var createdUser repository.User
|
||||
if err := json.Unmarshal(created.Body.Bytes(), &createdUser); err != nil || createdUser.ID == "" {
|
||||
t.Fatalf("解析创建用户响应失败:%v %s", err, created.Body.String())
|
||||
}
|
||||
|
||||
listed := serveUserRequest(server, adminCookie, http.MethodGet, "/api/v1/users", "")
|
||||
if listed.Code != http.StatusOK || !strings.Contains(listed.Body.String(), "operator") {
|
||||
t.Fatalf("查询用户失败:%d %s", listed.Code, listed.Body.String())
|
||||
}
|
||||
updated := serveUserRequest(server, adminCookie, http.MethodPut, "/api/v1/users/"+createdUser.ID, `{"username":"operator","email":"operator@example.test","role":"admin","status":"disabled"}`)
|
||||
if updated.Code != http.StatusOK || !strings.Contains(updated.Body.String(), "admin") {
|
||||
t.Fatalf("更新用户失败:%d %s", updated.Code, updated.Body.String())
|
||||
}
|
||||
|
||||
loginDisabled := httptest.NewRecorder()
|
||||
loginRequest := httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", strings.NewReader(`{"identifier":"operator","password":"UserPass123"}`))
|
||||
loginRequest.Header.Set("Content-Type", "application/json")
|
||||
server.Handler().ServeHTTP(loginDisabled, loginRequest)
|
||||
if loginDisabled.Code != http.StatusUnauthorized {
|
||||
t.Fatalf("禁用用户登录应被拒绝:%d %s", loginDisabled.Code, loginDisabled.Body.String())
|
||||
}
|
||||
|
||||
secondSuperAdmin := serveUserRequest(server, adminCookie, http.MethodPost, "/api/v1/users", `{"username":"owner","password":"OwnerPass123","role":"super_admin","status":"active"}`)
|
||||
if secondSuperAdmin.Code != http.StatusCreated {
|
||||
t.Fatalf("创建第二个超级管理员失败:%d %s", secondSuperAdmin.Code, secondSuperAdmin.Body.String())
|
||||
}
|
||||
var second repository.User
|
||||
if err := json.Unmarshal(secondSuperAdmin.Body.Bytes(), &second); err != nil || second.ID == "" {
|
||||
t.Fatalf("解析第二个超级管理员响应失败:%v %s", err, secondSuperAdmin.Body.String())
|
||||
}
|
||||
deleted := serveUserRequest(server, adminCookie, http.MethodDelete, "/api/v1/users/"+second.ID, "")
|
||||
if deleted.Code != http.StatusNoContent {
|
||||
t.Fatalf("删除第二个超级管理员失败:%d %s", deleted.Code, deleted.Body.String())
|
||||
}
|
||||
protected := serveUserRequest(server, adminCookie, http.MethodDelete, "/api/v1/users/primary-super-admin", "")
|
||||
if protected.Code != http.StatusBadRequest {
|
||||
t.Fatalf("删除主超级管理员应被拒绝:%d %s", protected.Code, protected.Body.String())
|
||||
}
|
||||
}
|
||||
|
||||
func serveUserRequest(server *Server, cookie *http.Cookie, method, path, body string) *httptest.ResponseRecorder {
|
||||
request := httptest.NewRequest(method, path, bytes.NewBufferString(body))
|
||||
if body != "" {
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
if cookie != nil {
|
||||
request.AddCookie(cookie)
|
||||
}
|
||||
response := httptest.NewRecorder()
|
||||
server.Handler().ServeHTTP(response, request)
|
||||
return response
|
||||
}
|
||||
|
||||
func httpUserSessionCookie(server *Server, userID, role string) *http.Cookie {
|
||||
token := userID + "-session"
|
||||
now := time.Now()
|
||||
server.authMu.Lock()
|
||||
server.authSessions[token] = authSession{
|
||||
UserID: userID, Username: userID, Role: role,
|
||||
ExpiresAt: now.Add(time.Hour), AbsoluteExpiresAt: now.Add(2 * time.Hour),
|
||||
}
|
||||
server.authMu.Unlock()
|
||||
return &http.Cookie{Name: authCookieName, Value: token, Path: "/"}
|
||||
}
|
||||
|
||||
func httpUserPasswordHash(t *testing.T, password string) string {
|
||||
t.Helper()
|
||||
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.MinCost)
|
||||
if err != nil {
|
||||
t.Fatalf("生成用户测试密码摘要失败:%v", err)
|
||||
}
|
||||
return string(hash)
|
||||
}
|
||||
|
||||
var _ = context.Background
|
||||
Reference in new issue
Block a user