检查点:保存成员接口分页与失败审计专项通过候选

This commit is contained in:
xuans committed 2026-09-28 18:57:10 +08:00
1 parent 66422bbac0
commit 3857dac5c8
12 files changed
+822 -2

No files matched your search

+5 -1
View File
@@ -15,6 +15,7 @@ import (
const requestIDHeader = "X-Scert-Request-ID"
const jsonRequestBodyLimit = 64 * 1024
const authenticatedActorKey = "authenticated_actor_id"
func (s *Server) requestMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
@@ -85,13 +86,16 @@ func (s *Server) requireAuthenticated(c *gin.Context) {
})
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
}
// 仅保存本次已验证身份,供失败审计使用;业务权限仍须在仓储内实时判定。
c.Set(authenticatedActorKey, session.UserID)
if !s.sameOriginForAPI(c.Request) {
c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
"error": "请求来源校验失败",
@@ -0,0 +1,154 @@
package httpapi
import (
"errors"
"io"
"net/http"
"net/url"
"strconv"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
const projectMemberTargetKey = "project_member_target_id"
func (s *Server) registerProjectMemberRoutes() {
api := s.router.Group("/api/v1/projects/:projectID/members")
api.GET("", s.projectMemberFailureAudit("project_member.list"), s.requireAuthenticated, s.listProjectMembers)
api.POST("", s.projectMemberFailureAudit("project_member.grant"), s.requireAuthenticated, s.grantProjectMember)
api.DELETE("/:userID/roles/:role", s.projectMemberFailureAudit("project_member.revoke"), s.requireAuthenticated, s.revokeProjectMember)
}
func (s *Server) projectMemberRequestReady(c *gin.Context) bool {
if s.projectMembers == nil {
s.writeError(c, http.StatusServiceUnavailable, "项目成员服务尚未就绪", nil)
return false
}
if !validMemberIdentifier(c.Param("projectID")) {
s.writeError(c, http.StatusBadRequest, "项目标识无效", nil)
return false
}
return true
}
func (s *Server) listProjectMembers(c *gin.Context) {
if !s.projectMemberRequestReady(c) {
return
}
query, err := projectMemberPageQuery(c)
if err != nil {
s.writeError(c, http.StatusBadRequest, "分页参数无效,每页仅支持 5、10、15 或 30 位成员", nil)
return
}
page, err := s.projectMembers.ListProjectMembers(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("projectID"), query.After, query.Size)
if err != nil {
s.writeProjectMemberError(c, err)
return
}
c.JSON(http.StatusOK, page)
}
func (s *Server) grantProjectMember(c *gin.Context) {
if !s.projectMemberRequestReady(c) {
return
}
var request struct {
UserID string `json:"user_id"`
Role domain.ProjectRole `json:"role"`
}
if err := bindJSON(c, &request, jsonRequestBodyLimit); err != nil || !validMemberIdentifier(request.UserID) || !request.Role.Valid() || c.Request.URL.RawQuery != "" {
s.writeError(c, http.StatusBadRequest, "项目成员参数无效", nil)
return
}
c.Set(projectMemberTargetKey, request.UserID)
if err := s.projectMembers.GrantProjectRole(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("projectID"), request.UserID, request.Role); err != nil {
s.writeProjectMemberError(c, err)
return
}
c.JSON(http.StatusCreated, gin.H{"message": "项目角色已授予"})
}
func (s *Server) revokeProjectMember(c *gin.Context) {
if !s.projectMemberRequestReady(c) {
return
}
role := domain.ProjectRole(c.Param("role"))
if c.Request.Body != nil {
body, err := io.ReadAll(io.LimitReader(c.Request.Body, 1))
if err != nil || len(body) != 0 {
s.writeError(c, http.StatusBadRequest, "撤销角色请求不接受请求体", nil)
return
}
}
if !validMemberIdentifier(c.Param("userID")) || !role.Valid() || c.Request.URL.RawQuery != "" {
s.writeError(c, http.StatusBadRequest, "项目成员参数无效", nil)
return
}
c.Set(projectMemberTargetKey, c.Param("userID"))
if err := s.projectMembers.RevokeProjectRole(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("projectID"), c.Param("userID"), role); err != nil {
s.writeProjectMemberError(c, err)
return
}
c.Status(http.StatusNoContent)
}
func (s *Server) writeProjectMemberError(c *gin.Context, err error) {
switch {
case errors.Is(err, repository.ErrProjectAccessDenied):
// 不区分无权限、项目不存在或目标不满足条件,避免泄露其他项目与账户信息。
s.writeError(c, http.StatusForbidden, "无权访问项目或执行此操作", nil)
case errors.Is(err, repository.ErrProjectMemberConflict):
s.writeError(c, http.StatusConflict, "项目成员关系冲突,请刷新后重试", nil)
default:
s.writeError(c, http.StatusInternalServerError, "项目成员操作失败,请稍后重试", nil)
}
}
type projectMemberQuery struct {
After string
Size int
}
func projectMemberPageQuery(c *gin.Context) (projectMemberQuery, error) {
result := projectMemberQuery{Size: 10}
values, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil {
return result, err
}
for key, entries := range values {
if (key != "after" && key != "page_size") || len(entries) != 1 {
return result, errors.New("分页参数重复或未知")
}
}
if values.Has("page_size") {
result.Size, err = strconv.Atoi(values.Get("page_size"))
if err != nil {
return result, err
}
}
switch result.Size {
case 5, 10, 15, 30:
default:
return result, errors.New("每页成员数量无效")
}
result.After = values.Get("after")
if result.After != "" && !validMemberIdentifier(result.After) {
return result, errors.New("分页游标无效")
}
return result, nil
}
func validMemberIdentifier(value string) bool {
if len(value) == 0 || len(value) > 128 {
return false
}
for _, ch := range value {
if !(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0' && ch <= '9' || ch == '-' || ch == '_') {
return false
}
}
return true
}
@@ -0,0 +1,181 @@
package httpapi
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
const memberTestPath = "/api/v1/projects/project-a/members"
func TestProjectMemberAPIAuthorizationAndFailureAudit(t *testing.T) {
f := newProjectMemberAPIFixture(t)
for _, tc := range []struct {
name, actor, path string
status int
}{
{"anonymous", "", memberTestPath, http.StatusUnauthorized},
{"global_admin_is_not_project_admin", "global-admin", memberTestPath, http.StatusForbidden},
{"read_only_cannot_list_members", "viewer", memberTestPath, http.StatusForbidden},
{"other_project", "manager", "/api/v1/projects/project-b/members", http.StatusForbidden},
{"missing_project", "primary-super-admin", "/api/v1/projects/missing/members", http.StatusForbidden},
{"project_admin_is_regular_user", "manager", memberTestPath, http.StatusOK},
{"super_admin_empty_project", "primary-super-admin", "/api/v1/projects/project-b/members", http.StatusOK},
} {
t.Run(tc.name, func(t *testing.T) {
response := serveUserRequest(f.server, f.cookies[tc.actor], http.MethodGet, tc.path, "")
if response.Code != tc.status {
t.Fatalf("成员列表权限错误:%d,%s", response.Code, response.Body.String())
}
for _, secret := range []string{"password_hash", "FixturePass123", "email", "groups", "example.test"} {
if strings.Contains(response.Body.String(), secret) {
t.Fatalf("成员列表暴露非必要账户字段:%s", response.Body.String())
}
}
if tc.status >= 400 {
log := f.lastAudit(t)
if log.OperatorID != tc.actor || log.Status != "failed" || log.Action != "project_member.list" || !strings.Contains(log.Message, response.Header().Get(requestIDHeader)) {
t.Fatalf("失败审计身份或关联错误:%+v", log)
}
if tc.name == "missing_project" && (log.ScopeType != repository.ScopeUnknown || log.ProjectID != "") {
t.Fatalf("不存在项目被伪造归属:%+v", log)
}
} else {
var page repository.ProjectMemberPage
if err := json.Unmarshal(response.Body.Bytes(), &page); err != nil || page.Items == nil {
t.Fatalf("成员列表不是稳定数组响应:%s,%v", response.Body.String(), err)
}
}
})
}
t.Run("cross_origin_identity_is_verified", func(t *testing.T) {
request := httptest.NewRequest(http.MethodPost, memberTestPath, strings.NewReader(`{"user_id":"target","role":"dns_admin"}`))
request.AddCookie(f.cookies["manager"])
request.Header.Set("Origin", "https://untrusted.example.test")
response := httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
log := f.lastAudit(t)
if response.Code != http.StatusForbidden || log.OperatorID != "manager" || log.Status != "failed" {
t.Fatalf("来源拒绝丢失已验证身份:%d,%+v", response.Code, log)
}
})
}
func TestProjectMemberAPIMutations(t *testing.T) {
f := newProjectMemberAPIFixture(t)
body := `{"user_id":"target","role":"dns_admin"}`
for _, actor := range []string{"global-admin", "viewer"} {
response := serveUserRequest(f.server, f.cookies[actor], http.MethodPost, memberTestPath, body)
log := f.lastAudit(t)
if response.Code != http.StatusForbidden || log.OperatorID != actor || log.ResourceID != "target" || log.Status != "failed" {
t.Fatalf("未授权授予或审计错误:%d,%+v", response.Code, log)
}
}
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodPost, memberTestPath, body)
log := f.lastAudit(t)
if response.Code != http.StatusCreated || log.OperatorID != "manager" || log.ProjectID != "project-a" || log.Status != "success" || log.Action != "project_member.grant" {
t.Fatalf("授予角色或事务审计错误:%d,%+v", response.Code, log)
}
duplicate := serveUserRequest(f.server, f.cookies["manager"], http.MethodPost, memberTestPath, body)
if duplicate.Code != http.StatusConflict || f.lastAudit(t).Status != "failed" {
t.Fatalf("重复授予未明确拒绝:%d,%s", duplicate.Code, duplicate.Body.String())
}
response = serveUserRequest(f.server, f.cookies["manager"], http.MethodDelete, memberTestPath+"/target/roles/dns_admin", "")
log = f.lastAudit(t)
if response.Code != http.StatusNoContent || log.Status != "success" || log.Action != "project_member.revoke" || log.OperatorID != "manager" {
t.Fatalf("撤销角色或审计错误:%d,%+v", response.Code, log)
}
response = serveUserRequest(f.server, f.cookies["manager"], http.MethodDelete, memberTestPath+"/manager/roles/project_admin", "")
if response.Code != http.StatusNoContent || f.lastAudit(t).OperatorID != "manager" {
t.Fatalf("自我撤权丢失身份:%d", response.Code)
}
for _, method := range []string{http.MethodGet, http.MethodPost} {
response = serveUserRequest(f.server, f.cookies["manager"], method, memberTestPath, body)
if response.Code != http.StatusForbidden {
t.Fatalf("自我撤权后仍可读取或授权:%s,%d", method, response.Code)
}
}
}
func TestProjectMemberAPIPageAndInputValidation(t *testing.T) {
f := newProjectMemberAPIFixture(t)
for i := 0; i < 11; i++ {
id := fmt.Sprintf("paged-%02d", i)
httpUserSessionCookie(f.server, id, repository.UserRoleUser)
for _, role := range []domain.ProjectRole{domain.ProjectRoleDNSAdmin, domain.ProjectRoleReadOnly} {
if err := f.members.GrantProjectRole(t.Context(), "primary-super-admin", "project-a", id, role); err != nil {
t.Fatal(err)
}
}
}
for _, size := range []int{5, 10, 15, 30} {
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodGet, fmt.Sprintf("%s?page_size=%d", memberTestPath, size), "")
var page repository.ProjectMemberPage
if response.Code != http.StatusOK || json.Unmarshal(response.Body.Bytes(), &page) != nil || len(page.Items) != min(size, 13) || page.PageSize != size || page.HasMore != (size < 13) {
t.Fatalf("成员分页响应错误:%d,%s", response.Code, response.Body.String())
}
if page.HasMore {
next := serveUserRequest(f.server, f.cookies["manager"], http.MethodGet, fmt.Sprintf("%s?page_size=%d&after=%s", memberTestPath, size, page.NextCursor), "")
var nextPage repository.ProjectMemberPage
if next.Code != http.StatusOK || json.Unmarshal(next.Body.Bytes(), &nextPage) != nil || len(nextPage.Items) == 0 || nextPage.Items[0].UserID <= page.NextCursor {
t.Fatalf("成员下一页游标错误:%s", next.Body.String())
}
}
}
for _, query := range []string{"page_size=0", "page_size=100000", "page_size=-5", "page_size=abc", "page_size=5&page_size=10", "after=a&after=b", "after=%ZZ", "after=x;bad=y", "actor_id=primary-super-admin", "after=" + strings.Repeat("a", 129)} {
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodGet, memberTestPath+"?"+query, "")
if response.Code != http.StatusBadRequest || f.lastAudit(t).Status != "failed" {
t.Fatalf("非法分页参数未拒绝:%s,%d", query, response.Code)
}
}
for _, body := range []string{
`{"user_id":"target","role":"dns_admin","actor_id":"primary-super-admin"}`,
`{"user_id":"target","role":"super_admin"}`, `{"user_id":"target","role":"dns_admin"} {}`,
`{"user_id":"sensitive-marker","role":"invalid"}`, strings.Repeat("x", 70*1024),
} {
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodPost, memberTestPath, body)
log := f.lastAudit(t)
if response.Code != http.StatusBadRequest || log.OperatorID != "manager" || strings.Contains(log.Message, "sensitive-marker") || strings.Contains(log.Message, "actor_id") || strings.Contains(log.ResourceID, "sensitive-marker") {
t.Fatalf("非法授权参数未拒绝或审计泄漏正文:%d,%+v", response.Code, log)
}
}
}
func TestProjectMemberAPIStaleSessionAndAuditRollback(t *testing.T) {
t.Run("disabled_session_is_not_attributed", func(t *testing.T) {
f := newProjectMemberAPIFixture(t)
if _, err := f.db.ExecContext(t.Context(), "UPDATE users SET status='disabled' WHERE id='manager'"); err != nil {
t.Fatal(err)
}
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodPost, memberTestPath, `{"user_id":"target","role":"dns_admin"}`)
if response.Code != http.StatusUnauthorized || f.lastAudit(t).OperatorID != "" {
t.Fatalf("无效会话仍被记录为已验证身份:%d,%+v", response.Code, f.lastAudit(t))
}
})
t.Run("success_audit_failure_rolls_back_membership", func(t *testing.T) {
f := newProjectMemberAPIFixture(t)
if _, err := f.db.ExecContext(t.Context(), `CREATE TRIGGER reject_member_success BEFORE INSERT ON audit_logs
WHEN NEW.resource_type='project_member' AND NEW.status='success'
BEGIN SELECT RAISE(ABORT, 'sensitive-marker'); END`); err != nil {
t.Fatal(err)
}
response := serveUserRequest(f.server, f.cookies["manager"], http.MethodPost, memberTestPath, `{"user_id":"target","role":"dns_admin"}`)
if response.Code != http.StatusInternalServerError || strings.Contains(response.Body.String(), "sensitive-marker") {
t.Fatalf("审计失败误报成功或泄露底层错误:%d,%s", response.Code, response.Body.String())
}
var count int
if err := f.db.QueryRowContext(t.Context(), "SELECT COUNT(*) FROM project_members WHERE user_id='target'").Scan(&count); err != nil || count != 0 {
t.Fatalf("审计失败仍留下成员授权:%d,%v", count, err)
}
log := f.lastAudit(t)
if log.Status != "failed" || log.OperatorID != "manager" || strings.Contains(log.Message, "sensitive-marker") {
t.Fatalf("事务回滚后失败审计缺失或泄密:%+v", log)
}
})
}
@@ -0,0 +1,39 @@
package httpapi
import (
"context"
"time"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
// 失败审计覆盖会话、来源、参数及仓储拒绝;成功审计由仓储在成员变更事务内保证。
func (s *Server) projectMemberFailureAudit(action string) gin.HandlerFunc {
return func(c *gin.Context) {
c.Next()
if c.Writer.Status() < 400 || s.projectMembers == nil {
return
}
projectID := c.Param("projectID")
if !validMemberIdentifier(projectID) {
projectID = ""
}
target := c.GetString(projectMemberTargetKey)
if target == "" && validMemberIdentifier(c.Param("userID")) {
target = c.Param("userID")
}
// 客户端取消请求不能取消已发生失败的审计;独立等待有上限,不无限阻塞关闭。
ctx, cancel := context.WithTimeout(context.WithoutCancel(c.Request.Context()), 3*time.Second)
defer cancel()
err := s.projectMembers.RecordProjectMemberFailure(ctx, repository.ProjectMemberFailure{
ActorID: c.GetString(authenticatedActorKey), ProjectID: projectID, UserID: target,
Action: action, StatusCode: c.Writer.Status(), RequestID: requestIDFromContext(c),
})
if err != nil && s.logger != nil {
// 原失败响应已经确定,不能补发成功;存储故障只记录稳定诊断,不打印请求体和数据库原始错误。
s.logger.Error("项目成员失败审计未保存", "request_id", requestIDFromContext(c), "status", c.Writer.Status())
}
}
}
@@ -0,0 +1,73 @@
package httpapi
import (
"database/sql"
"net/http"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
type projectMemberAPIFixture struct {
server *Server
db *sql.DB
members *repository.SQLProjectMemberRepository
audit *repository.SQLAuditRepository
cookies map[string]*http.Cookie
}
func newProjectMemberAPIFixture(t *testing.T) projectMemberAPIFixture {
t.Helper()
cfg := readyTestConfig(t.TempDir())
cfg.Admin.Username = "owner"
cfg.Admin.Email = "owner@example.test"
cfg.Admin.PasswordHash = httpUserPasswordHash(t, "FixturePass123")
db, err := database.Open(t.Context(), cfg.Database)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = db.Close() })
if err := database.Migrate(t.Context(), db.DB, cfg.Database.Driver); err != nil {
t.Fatal(err)
}
users := repository.NewSQLUserRepository(db.DB, cfg.Database.Driver)
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.Fatal(err)
}
projects := repository.NewSQLProjectRepository(db.DB, cfg.Database.Driver)
for _, id := range []string{"project-a", "project-b"} {
if err := projects.CreateProject(t.Context(), domain.Project{ID: id, Name: id}); err != nil {
t.Fatal(err)
}
}
f := projectMemberAPIFixture{
db: db.DB, members: repository.NewSQLProjectMemberRepository(db.DB, cfg.Database.Driver),
audit: repository.NewSQLAuditRepository(db.DB, cfg.Database.Driver), cookies: make(map[string]*http.Cookie),
}
f.server = New(Dependencies{Config: cfg, Users: users, ProjectMembers: f.members, Audit: f.audit})
for _, account := range []struct{ id, role string }{
{"primary-super-admin", repository.UserRoleSuperAdmin}, {"manager", repository.UserRoleUser},
{"global-admin", repository.UserRoleAdmin}, {"viewer", repository.UserRoleUser}, {"target", repository.UserRoleUser},
} {
f.cookies[account.id] = httpUserSessionCookie(f.server, account.id, account.role)
}
for user, role := range map[string]domain.ProjectRole{"manager": domain.ProjectRoleAdmin, "viewer": domain.ProjectRoleReadOnly} {
if err := f.members.GrantProjectRole(t.Context(), "primary-super-admin", "project-a", user, role); err != nil {
t.Fatal(err)
}
}
return f
}
func (f projectMemberAPIFixture) lastAudit(t *testing.T) repository.AuditLog {
t.Helper()
logs, err := f.audit.ListAuditLogs(t.Context(), 1)
if err != nil || len(logs) != 1 {
t.Fatalf("成员审计缺失:%+v,%v", logs, err)
}
return logs[0]
}
+4
View File
@@ -48,6 +48,7 @@ type Dependencies struct {
Repository repository.DomainRepository
Servers repository.ServerRepository
Users repository.UserRepository
ProjectMembers repository.ProjectMemberRepository
SSHKeys *sshkey.Service
DeploymentFactory deployment.ClientFactory
SetupDNS setupDNSVerifier
@@ -79,6 +80,7 @@ type Server struct {
repository repository.DomainRepository
servers repository.ServerRepository
users repository.UserRepository
projectMembers repository.ProjectMemberRepository
sshKeys *sshkey.Service
deploymentFactory deployment.ClientFactory
setupDNS setupDNSVerifier
@@ -139,6 +141,7 @@ func New(deps Dependencies) *Server {
repository: deps.Repository, setupDNS: deps.SetupDNS, secrets: deps.Secrets, firewall: deps.Firewall, router: router,
servers: deps.Servers,
users: deps.Users,
projectMembers: deps.ProjectMembers,
sshKeys: deps.SSHKeys,
deploymentFactory: deps.DeploymentFactory,
issueCertificate: deps.IssueCertificate,
@@ -186,6 +189,7 @@ func (s *Server) registerRoutes() {
userAPI.GET("/:id", s.getUser)
userAPI.PUT("/:id", s.requireSuperAdmin, s.updateUser)
userAPI.DELETE("/:id", s.requireSuperAdmin, s.deleteUser)
s.registerProjectMemberRoutes()
adminAPI.GET("/domains", s.listDomains)
adminAPI.POST("/domains", s.dnsOperation, s.createDomain)
adminAPI.PUT("/domains/:id", s.dnsOperation, s.updateDomain)