From f385e43a950dbdc6ba819e8caed87154645eb16f Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 14:25:00 +0800 Subject: [PATCH 1/6] =?UTF-8?q?fix:=20=E5=88=9B=E5=BB=BA=E7=94=A8=E6=88=B7?= =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E8=A1=A5=E5=85=85=E8=A7=92=E8=89=B2=E5=88=86?= =?UTF-8?q?=E9=85=8D=E5=AE=88=E5=8D=AB=EF=BC=8C=E9=98=BB=E6=96=AD=E7=AE=A1?= =?UTF-8?q?=E7=90=86=E5=91=98=E9=93=B8=E9=80=A0=E8=B6=85=E7=BA=A7=E7=AE=A1?= =?UTF-8?q?=E7=90=86=E5=91=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- server/internal/handler/user.go | 11 ++ .../handler/user_create_guard_test.go | 146 ++++++++++++++++++ 2 files changed, 157 insertions(+) create mode 100644 server/internal/handler/user_create_guard_test.go diff --git a/server/internal/handler/user.go b/server/internal/handler/user.go index e851d04..f02c9be 100644 --- a/server/internal/handler/user.go +++ b/server/internal/handler/user.go @@ -64,6 +64,17 @@ func (h *UserHandler) CreateUser(c *gin.Context) { return } + // 拥有 user:create 权限的管理员可借此创建超级管理员,从而获得 system:config 等管理员不具备的权限,因此在调用服务层前按角色可分配范围拦截。 + currentUserRole, exists := c.Get("userRole") + if !exists { + response.Unauthorized(c, "无法获取用户权限信息") + return + } + if req.Role != "" && !h.userService.CanUserManageRole(currentUserRole.(string), req.Role) { + response.Forbidden(c, "权限不足,无法分配该角色") + return + } + // 调用服务层创建用户 user, err := h.userService.CreateUser(&req) if err != nil { diff --git a/server/internal/handler/user_create_guard_test.go b/server/internal/handler/user_create_guard_test.go new file mode 100644 index 0000000..4ccdf81 --- /dev/null +++ b/server/internal/handler/user_create_guard_test.go @@ -0,0 +1,146 @@ +package handler + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" + + "MyBlog/internal/domain" + "MyBlog/internal/service" + "MyBlog/pkg/response" + + "github.com/gin-gonic/gin" +) + +// operatorRoleContextKey 认证中间件写入操作者角色的上下文键。 +const operatorRoleContextKey = "userRole" + +// createUserGuardUserService 创建用户角色守卫用例的测试替身。 +// 内嵌 sessionUserService 复用其余接口实现,仅覆盖需要观察与配置的方法。 +type createUserGuardUserService struct { + sessionUserService + + createCalls int + createUser *domain.User + manageRole func(managerRole, targetRole string) bool +} + +// CreateUser 记录服务层被触达的次数,供断言拦截路径未调用服务层。 +func (f *createUserGuardUserService) CreateUser(req *domain.CreateUserRequest) (*domain.User, error) { + f.createCalls++ + return f.createUser, nil +} + +// CanUserManageRole 按用例注入的判定规则返回结果,用于分别覆盖拦截与放行路径。 +func (f *createUserGuardUserService) CanUserManageRole(managerRole, targetRole string) bool { + return f.manageRole(managerRole, targetRole) +} + +// adminManageableRoles 与 RBAC 服务的管理范围一致,管理员只能管理编辑者与普通用户。 +func adminManageableRoles(managerRole, targetRole string) bool { + if managerRole != string(service.RoleAdmin) { + return false + } + return targetRole == string(service.RoleEditor) || targetRole == string(service.RoleUser) +} + +// operatorRoleMiddleware 模拟认证层向上下文写入操作者角色。 +func operatorRoleMiddleware(role string) gin.HandlerFunc { + return func(c *gin.Context) { + c.Set(operatorRoleContextKey, role) + } +} + +// performCreateUserRequest 在带操作者角色的路由上下文中执行一次创建用户请求。 +func performCreateUserRequest( + userService service.UserService, + setOperatorRole gin.HandlerFunc, + body string, +) *httptest.ResponseRecorder { + gin.SetMode(gin.TestMode) + router := gin.New() + router.POST("/api/users/create", setOperatorRole, NewUserHandler(userService, testSessionCookieConfig()).CreateUser) + + request := httptest.NewRequest(http.MethodPost, "/api/users/create", strings.NewReader(body)) + request.Header.Set("Content-Type", "application/json") + recorder := httptest.NewRecorder() + router.ServeHTTP(recorder, request) + return recorder +} + +// TestCreateUserRejectsSuperAdminAssignment 管理员提交超级管理员角色时拒绝创建,服务层不会被调用。 +func TestCreateUserRejectsSuperAdminAssignment(t *testing.T) { + fake := &createUserGuardUserService{ + manageRole: adminManageableRoles, + createUser: &domain.User{ID: 1}, + } + + recorder := performCreateUserRequest( + fake, + operatorRoleMiddleware(string(service.RoleAdmin)), + `{"username":"intruder","email":"intruder@example.com","password":"secret123","role":"superadmin"}`, + ) + + assertResponseCode(t, recorder, response.CodeForbid) + if fake.createCalls != 0 { + t.Errorf("服务层创建调用次数 = %d,期望拦截路径不调用服务层", fake.createCalls) + } +} + +// TestCreateUserAllowsEditorAssignment 管理员的角色可分配范围包含编辑者时请求放行至服务层。 +func TestCreateUserAllowsEditorAssignment(t *testing.T) { + fake := &createUserGuardUserService{ + manageRole: adminManageableRoles, + createUser: &domain.User{ID: 2, Username: "editor", Role: string(service.RoleEditor)}, + } + + recorder := performCreateUserRequest( + fake, + operatorRoleMiddleware(string(service.RoleAdmin)), + `{"username":"editor","email":"editor@example.com","password":"secret123","role":"editor"}`, + ) + + assertResponseCode(t, recorder, response.CodeSuccess) + if fake.createCalls != 1 { + t.Errorf("服务层创建调用次数 = %d,期望 1", fake.createCalls) + } +} + +// TestCreateUserWithoutOperatorRole 上下文缺少操作者角色时返回未授权,服务层不会被调用。 +func TestCreateUserWithoutOperatorRole(t *testing.T) { + fake := &createUserGuardUserService{ + manageRole: adminManageableRoles, + createUser: &domain.User{ID: 3}, + } + + recorder := performCreateUserRequest( + fake, + func(*gin.Context) {}, + `{"username":"nobody","email":"nobody@example.com","password":"secret123","role":"user"}`, + ) + + assertResponseCode(t, recorder, response.CodeAuth) + if fake.createCalls != 0 { + t.Errorf("服务层创建调用次数 = %d,期望拦截路径不调用服务层", fake.createCalls) + } +} + +// TestCreateUserWithoutRoleSkipsAssignmentGuard 请求体未提交角色时由服务层取默认角色,不进入分配校验。 +func TestCreateUserWithoutRoleSkipsAssignmentGuard(t *testing.T) { + fake := &createUserGuardUserService{ + manageRole: func(managerRole, targetRole string) bool { return false }, + createUser: &domain.User{ID: 4, Username: "plain", Role: string(service.RoleUser)}, + } + + recorder := performCreateUserRequest( + fake, + operatorRoleMiddleware(string(service.RoleAdmin)), + `{"username":"plain","email":"plain@example.com","password":"secret123"}`, + ) + + assertResponseCode(t, recorder, response.CodeSuccess) + if fake.createCalls != 1 { + t.Errorf("服务层创建调用次数 = %d,期望 1", fake.createCalls) + } +} From bc2cedb0397c1f8d96f932de9c2ead3841399c55 Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 15:11:40 +0800 Subject: [PATCH 2/6] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=20admin=20?= =?UTF-8?q?=E5=9B=9B=E4=B8=AA=E8=A1=A8=E5=8D=95=E5=BC=B9=E7=AA=97=E7=9A=84?= =?UTF-8?q?=E5=9B=9E=E5=A1=AB=20effect=20=E8=87=AA=E8=AF=BB=E8=87=AA?= =?UTF-8?q?=E5=86=99=E8=A6=86=E7=9B=96=E7=94=A8=E6=88=B7=E8=BE=93=E5=85=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../category/category-form-dialog.svelte | 40 ++++++++++--------- .../admin/dict/dict-item-form-dialog.svelte | 28 +++++++------ .../admin/dict/dict-type-form-dialog.svelte | 28 +++++++------ .../admin/tag/tag-form-dialog.svelte | 30 ++++++++------ 4 files changed, 71 insertions(+), 55 deletions(-) diff --git a/apps/admin/src/lib/components/admin/category/category-form-dialog.svelte b/apps/admin/src/lib/components/admin/category/category-form-dialog.svelte index 8862b6c..6abeee9 100644 --- a/apps/admin/src/lib/components/admin/category/category-form-dialog.svelte +++ b/apps/admin/src/lib/components/admin/category/category-form-dialog.svelte @@ -7,6 +7,7 @@ import { Switch } from '$ui/switch' import { Button } from '$ui/button' import { Label } from '$ui/label' import { Input } from '$ui/input' +import { untrack } from 'svelte' interface Props { open: boolean @@ -47,25 +48,28 @@ let formError = $state('') */ $effect(() => { if (!open) return - name = target?.name ?? '' - slug = target?.slug ?? '' - description = target?.description ?? '' - coverImage = target?.coverImage ?? '' - parentId = target?.parentId != null ? String(target.parentId) : '' - sortOrder = target?.sortOrder ?? 0 - status = target?.status ?? 1 - isFeatured = target?.isFeatured ?? false - seoTitle = target?.seoTitle ?? '' - seoDescription = target?.seoDescription ?? '' + // 回填写入不参与依赖收集,否则表单字段会被 effect 订阅,键入即触发重跑并覆盖用户输入。 + untrack(() => { + name = target?.name ?? '' + slug = target?.slug ?? '' + description = target?.description ?? '' + coverImage = target?.coverImage ?? '' + parentId = target?.parentId != null ? String(target.parentId) : '' + sortOrder = target?.sortOrder ?? 0 + status = target?.status ?? 1 + isFeatured = target?.isFeatured ?? false + seoTitle = target?.seoTitle ?? '' + seoDescription = target?.seoDescription ?? '' - // 英文翻译行允许按字段缺失,缺失字段回填为空串。 - const en = target?.translations?.find(row => row.locale === 'en') ?? null - enName = en?.name ?? '' - enDescription = en?.description ?? '' - enSeoTitle = en?.seoTitle ?? '' - enSeoDescription = en?.seoDescription ?? '' - enSnapshot = JSON.stringify([enName, enDescription, enSeoTitle, enSeoDescription]) - formError = '' + // 英文翻译行允许按字段缺失,缺失字段回填为空串。 + const en = target?.translations?.find(row => row.locale === 'en') ?? null + enName = en?.name ?? '' + enDescription = en?.description ?? '' + enSeoTitle = en?.seoTitle ?? '' + enSeoDescription = en?.seoDescription ?? '' + enSnapshot = JSON.stringify([enName, enDescription, enSeoTitle, enSeoDescription]) + formError = '' + }) }) /** diff --git a/apps/admin/src/lib/components/admin/dict/dict-item-form-dialog.svelte b/apps/admin/src/lib/components/admin/dict/dict-item-form-dialog.svelte index cba3d83..2a02e2d 100644 --- a/apps/admin/src/lib/components/admin/dict/dict-item-form-dialog.svelte +++ b/apps/admin/src/lib/components/admin/dict/dict-item-form-dialog.svelte @@ -6,6 +6,7 @@ import { Switch } from '$ui/switch' import { Button } from '$ui/button' import { Label } from '$ui/label' import { Input } from '$ui/input' +import { untrack } from 'svelte' interface Props { open: boolean @@ -34,18 +35,21 @@ let formError = $state('') $effect(() => { if (!open) return - value = target?.value ?? '' - label = target?.label ?? '' - description = target?.description ?? '' - status = (target?.status ?? 1) as DictStatus - sortOrder = target?.sortOrder ?? 0 - - // 英文翻译行允许按字段缺失,缺失字段回填为空串。 - const en = target?.translations?.find(row => row.locale === 'en') ?? null - enLabel = en?.label ?? '' - enDescription = en?.description ?? '' - enSnapshot = JSON.stringify([enLabel, enDescription]) - formError = '' + // 回填写入不参与依赖收集,否则表单字段会被 effect 订阅,键入即触发重跑并覆盖用户输入。 + untrack(() => { + value = target?.value ?? '' + label = target?.label ?? '' + description = target?.description ?? '' + status = (target?.status ?? 1) as DictStatus + sortOrder = target?.sortOrder ?? 0 + + // 英文翻译行允许按字段缺失,缺失字段回填为空串。 + const en = target?.translations?.find(row => row.locale === 'en') ?? null + enLabel = en?.label ?? '' + enDescription = en?.description ?? '' + enSnapshot = JSON.stringify([enLabel, enDescription]) + formError = '' + }) }) // 组装英文翻译补丁,存在既有翻译或任一字段非空时携带。 diff --git a/apps/admin/src/lib/components/admin/dict/dict-type-form-dialog.svelte b/apps/admin/src/lib/components/admin/dict/dict-type-form-dialog.svelte index d7ec765..12226bd 100644 --- a/apps/admin/src/lib/components/admin/dict/dict-type-form-dialog.svelte +++ b/apps/admin/src/lib/components/admin/dict/dict-type-form-dialog.svelte @@ -6,6 +6,7 @@ import { Switch } from '$ui/switch' import { Button } from '$ui/button' import { Label } from '$ui/label' import { Input } from '$ui/input' +import { untrack } from 'svelte' interface Props { open: boolean @@ -34,18 +35,21 @@ let formError = $state('') $effect(() => { if (!open) return - code = target?.code ?? '' - name = target?.name ?? '' - description = target?.description ?? '' - status = (target?.status ?? 1) as DictStatus - sortOrder = target?.sortOrder ?? 0 - - // 英文翻译行允许按字段缺失,缺失字段回填为空串。 - const en = target?.translations?.find(row => row.locale === 'en') ?? null - enName = en?.name ?? '' - enDescription = en?.description ?? '' - enSnapshot = JSON.stringify([enName, enDescription]) - formError = '' + // 回填写入不参与依赖收集,否则表单字段会被 effect 订阅,键入即触发重跑并覆盖用户输入。 + untrack(() => { + code = target?.code ?? '' + name = target?.name ?? '' + description = target?.description ?? '' + status = (target?.status ?? 1) as DictStatus + sortOrder = target?.sortOrder ?? 0 + + // 英文翻译行允许按字段缺失,缺失字段回填为空串。 + const en = target?.translations?.find(row => row.locale === 'en') ?? null + enName = en?.name ?? '' + enDescription = en?.description ?? '' + enSnapshot = JSON.stringify([enName, enDescription]) + formError = '' + }) }) // 组装英文翻译补丁,存在既有翻译或任一字段非空时携带。 diff --git a/apps/admin/src/lib/components/admin/tag/tag-form-dialog.svelte b/apps/admin/src/lib/components/admin/tag/tag-form-dialog.svelte index 37ba8b9..5ba735f 100644 --- a/apps/admin/src/lib/components/admin/tag/tag-form-dialog.svelte +++ b/apps/admin/src/lib/components/admin/tag/tag-form-dialog.svelte @@ -7,6 +7,7 @@ import { Switch } from '$ui/switch' import { Button } from '$ui/button' import { Label } from '$ui/label' import { Input } from '$ui/input' +import { untrack } from 'svelte' interface Props { open: boolean @@ -39,19 +40,22 @@ let formError = $state('') */ $effect(() => { if (!open) return - name = target?.name ?? '' - slug = target?.slug ?? '' - color = target?.color || '#808080' - description = target?.description ?? '' - status = target?.status ?? 1 - isHot = target?.isHot ?? false - - // 英文翻译行允许按字段缺失,缺失字段回填为空串。 - const en = target?.translations?.find(row => row.locale === 'en') ?? null - enName = en?.name ?? '' - enDescription = en?.description ?? '' - enSnapshot = JSON.stringify([enName, enDescription]) - formError = '' + // 回填写入不参与依赖收集,否则表单字段会被 effect 订阅,键入即触发重跑并覆盖用户输入。 + untrack(() => { + name = target?.name ?? '' + slug = target?.slug ?? '' + color = target?.color || '#808080' + description = target?.description ?? '' + status = target?.status ?? 1 + isHot = target?.isHot ?? false + + // 英文翻译行允许按字段缺失,缺失字段回填为空串。 + const en = target?.translations?.find(row => row.locale === 'en') ?? null + enName = en?.name ?? '' + enDescription = en?.description ?? '' + enSnapshot = JSON.stringify([enName, enDescription]) + formError = '' + }) }) /** From adc7aeba342ec30aa3fe48be8b16a909a02c6fd9 Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 15:26:45 +0800 Subject: [PATCH 3/6] =?UTF-8?q?fix:=20=E5=88=B7=E6=96=B0=E4=BB=A4=E7=89=8C?= =?UTF-8?q?=E5=85=91=E6=8D=A2=E6=94=B6=E8=BF=9B=E5=90=8C=E4=B8=80=E5=86=99?= =?UTF-8?q?=E9=94=81=E4=B8=B4=E7=95=8C=E5=8C=BA=EF=BC=8C=E9=98=BB=E6=96=AD?= =?UTF-8?q?=E5=B9=B6=E5=8F=91=E9=87=8D=E5=A4=8D=E5=85=91=E6=8D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 并发提交同一刷新令牌时,原先「校验、签发、撤销」三步各自独立取锁, 校验与撤销之间存在窗口,两个请求可同时通过校验并各得一份新令牌对, 破坏刷新即旋转的单次使用语义。 现在校验、摘除旧刷新令牌与签发新令牌对处于同一写锁临界区, 并发兑换只有最先进入临界区的一次能够完成。 签发失败时不恢复已摘除的旧刷新令牌,选择不可回退的失效, 避免失败重试期间的并发兑换重新可行。 抽取 issueTokenLocked、issueTokenPairLocked 与 validateTokenLocked, 校验与签发逻辑各保留一处实现;新增并发兑换用例锚定单次使用语义。 --- server/internal/service/token.go | 77 +++++++++++++++---- .../service/token_refresh_concurrency_test.go | 58 ++++++++++++++ 2 files changed, 119 insertions(+), 16 deletions(-) create mode 100644 server/internal/service/token_refresh_concurrency_test.go diff --git a/server/internal/service/token.go b/server/internal/service/token.go index ff7ddce..b765f40 100644 --- a/server/internal/service/token.go +++ b/server/internal/service/token.go @@ -86,13 +86,22 @@ func NewTokenService(cfg *config.Config) TokenServiceInterface { func (s *tokenService) GenerateTokenPair(user *domain.User) (*TokenPair, error) { now := time.Now() - accessToken, err := s.issueToken(user.ID, AccessToken, now, + s.mu.Lock() + defer s.mu.Unlock() + + return s.issueTokenPairLocked(user.ID, now) +} + +// issueTokenPairLocked 在同一签发时刻生成访问令牌与刷新令牌。 +// 调用方必须已持有写锁。 +func (s *tokenService) issueTokenPairLocked(userID uint, issuedAt time.Time) (*TokenPair, error) { + accessToken, err := s.issueTokenLocked(userID, AccessToken, issuedAt, time.Duration(s.config.Token.AccessExpire)*time.Minute) if err != nil { return nil, fmt.Errorf("生成访问令牌失败: %w", err) } - refreshToken, err := s.issueToken(user.ID, RefreshToken, now, + refreshToken, err := s.issueTokenLocked(userID, RefreshToken, issuedAt, time.Duration(s.config.Token.RefreshExpire)*time.Hour) if err != nil { return nil, fmt.Errorf("生成刷新令牌失败: %w", err) @@ -109,14 +118,22 @@ func (s *tokenService) GenerateTokenPair(user *domain.User) (*TokenPair, error) func (s *tokenService) issueToken(userID uint, tokenType TokenType, issuedAt time.Time, duration time.Duration) (string, error) { + s.mu.Lock() + defer s.mu.Unlock() + + return s.issueTokenLocked(userID, tokenType, issuedAt, duration) +} + +// issueTokenLocked 生成随机令牌串并登记到令牌表。 +// 调用方必须已持有写锁。 +func (s *tokenService) issueTokenLocked(userID uint, tokenType TokenType, issuedAt time.Time, + duration time.Duration) (string, error) { + tokenString, err := newTokenString() if err != nil { return "", err } - s.mu.Lock() - defer s.mu.Unlock() - s.tokens[tokenString] = tokenRecord{ userID: userID, tokenType: tokenType, @@ -154,44 +171,72 @@ func (s *tokenService) ValidateRefreshToken(tokenString string) (*TokenIdentity, // validateToken 查表校验令牌并核对类型,访问令牌与刷新令牌不可互换使用。 func (s *tokenService) validateToken(tokenString string, tokenType TokenType) (*TokenIdentity, error) { + s.mu.RLock() + defer s.mu.RUnlock() + + return s.validateTokenLocked(tokenString, tokenType, time.Now()) +} + +// validateTokenLocked 查表校验令牌并核对类型。 +// 调用方必须已持有令牌表锁。 +func (s *tokenService) validateTokenLocked(tokenString string, tokenType TokenType, + now time.Time) (*TokenIdentity, error) { + if tokenString == "" { return nil, fmt.Errorf("%w:令牌为空", ErrUnauthenticated) } - s.mu.RLock() record, exists := s.tokens[tokenString] - s.mu.RUnlock() - if !exists { return nil, fmt.Errorf("%w:令牌无效或已失效", ErrUnauthenticated) } if record.tokenType != tokenType { return nil, fmt.Errorf("%w:令牌类型不符", ErrUnauthenticated) } - if !record.expiresAt.After(time.Now()) { + if !record.expiresAt.After(now) { return nil, fmt.Errorf("%w:令牌已过期", ErrUnauthenticated) } return &TokenIdentity{UserID: record.userID, ExpiresAt: record.expiresAt}, nil } +// consumeRefreshTokenLocked 校验刷新令牌并将其从令牌表摘除,返回该令牌承载的身份。 +// 校验与摘除处于同一临界区,令同一刷新令牌只能被摘除一次。 +// 调用方必须已持有写锁。 +func (s *tokenService) consumeRefreshTokenLocked(refreshTokenString string, + now time.Time) (*TokenIdentity, error) { + + identity, err := s.validateTokenLocked(refreshTokenString, RefreshToken, now) + if err != nil { + return nil, err + } + + s.removeTokenLocked(refreshTokenString) + + return identity, nil +} + // RefreshAccessToken 使用刷新令牌换取新令牌对,旧刷新令牌随即撤销。 +// 校验、摘除旧刷新令牌与签发新令牌对同处一个写锁临界区, +// 并发提交同一刷新令牌时只有最先进入临界区的一次能够完成兑换。 +// 签发失败时不恢复已摘除的旧刷新令牌,该用户需要重新登录; +// 保留旧令牌会使失败重试期间的并发兑换重新可行,故选择不可回退的失效。 func (s *tokenService) RefreshAccessToken(refreshTokenString string) (*TokenPair, error) { - identity, err := s.ValidateRefreshToken(refreshTokenString) + now := time.Now() + + s.mu.Lock() + defer s.mu.Unlock() + + identity, err := s.consumeRefreshTokenLocked(refreshTokenString, now) if err != nil { return nil, fmt.Errorf("刷新令牌验证失败: %w", err) } - tokenPair, err := s.GenerateTokenPair(&domain.User{ID: identity.UserID}) + tokenPair, err := s.issueTokenPairLocked(identity.UserID, now) if err != nil { return nil, fmt.Errorf("生成新令牌对失败: %w", err) } - // 刷新即旋转:旧刷新令牌立即失效,防止同一刷新令牌被重复兑换。 - if err := s.RevokeToken(refreshTokenString); err != nil { - return nil, fmt.Errorf("撤销旧刷新令牌失败: %w", err) - } - return tokenPair, nil } diff --git a/server/internal/service/token_refresh_concurrency_test.go b/server/internal/service/token_refresh_concurrency_test.go new file mode 100644 index 0000000..30ea83c --- /dev/null +++ b/server/internal/service/token_refresh_concurrency_test.go @@ -0,0 +1,58 @@ +package service + +import ( + "sync" + "testing" + + "MyBlog/internal/domain" +) + +const ( + // refreshRaceRounds 并发兑换的重复轮数,逐轮更换刷新令牌以覆盖不同的调度交错。 + refreshRaceRounds = 300 + // refreshRaceGoroutines 单轮内争抢同一刷新令牌的并发调用方数量。 + refreshRaceGoroutines = 8 +) + +// TestRefreshAccessTokenConcurrentSingleUse 验证同一刷新令牌被并发兑换时恰有一次成功。 +// 刷新即旋转要求旧刷新令牌单次使用,多于一次成功即意味着同一凭据换出了多份新令牌对。 +func TestRefreshAccessTokenConcurrentSingleUse(t *testing.T) { + svc := newTestTokenService(t) + user := &domain.User{ID: 21} + + for round := 0; round < refreshRaceRounds; round++ { + pair, err := svc.GenerateTokenPair(user) + if err != nil { + t.Fatalf("第 %d 轮生成令牌对失败: %v", round, err) + } + + // 所有调用方阻塞在同一闸门上,令它们尽可能同时进入兑换流程。 + startGate := make(chan struct{}) + grantedPairs := make(chan *TokenPair, refreshRaceGoroutines) + + var wg sync.WaitGroup + wg.Add(refreshRaceGoroutines) + for i := 0; i < refreshRaceGoroutines; i++ { + go func() { + defer wg.Done() + <-startGate + newPair, err := svc.RefreshAccessToken(pair.RefreshToken) + if err == nil { + grantedPairs <- newPair + } + }() + } + + close(startGate) + wg.Wait() + close(grantedPairs) + + successCount := 0 + for range grantedPairs { + successCount++ + } + if successCount != 1 { + t.Fatalf("第 %d 轮同一刷新令牌兑换成功 %d 次,期望 1 次", round, successCount) + } + } +} From 1e296a5252c4751e5b75c27947df135ac01c6b23 Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 15:52:27 +0800 Subject: [PATCH 4/6] =?UTF-8?q?fix(server):=20=E5=AA=92=E4=BD=93=E7=A7=92?= =?UTF-8?q?=E4=BC=A0=E5=8E=BB=E9=87=8D=E9=99=90=E5=AE=9A=E4=B8=BA=E5=90=8C?= =?UTF-8?q?=E4=B8=80=E4=B8=8A=E4=BC=A0=E8=80=85=EF=BC=8C=E9=81=BF=E5=85=8D?= =?UTF-8?q?=E8=B7=A8=E7=94=A8=E6=88=B7=E8=BF=94=E5=9B=9E=E4=BB=96=E4=BA=BA?= =?UTF-8?q?=E8=AE=B0=E5=BD=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 去重命中仅在记录归属于调用方时复用,他人同哈希记录按新文件落盘落库 - 服务层保留显式归属判断,仓储实现忽略过滤条件时仍拒绝跨用户复用 - 仓储新增 GetByFileHashAndUploader,按文件哈希与上传者限定查询 - 该限定使命中确定地落在调用方自己的记录上,消除非首位上传者重复上传同内容反复新建副本的退化 - 新增仓储层查询语句断言,补充跨上传者复用与同哈希多记录的服务层用例 - 同步 media-api.md 中的方法名与秒传去重适用范围 --- server/docs/api/media-api.md | 4 +- server/internal/repository/media.go | 10 +- server/internal/repository/media_test.go | 93 ++++++++++++++++++ server/internal/service/media.go | 7 +- server/internal/service/media_test.go | 115 +++++++++++++++++++++-- 5 files changed, 210 insertions(+), 19 deletions(-) create mode 100644 server/internal/repository/media_test.go diff --git a/server/docs/api/media-api.md b/server/docs/api/media-api.md index b505888..156c45a 100644 --- a/server/docs/api/media-api.md +++ b/server/docs/api/media-api.md @@ -81,7 +81,7 @@ curl -X POST http://localhost:3000/api/media/upload \ | data.uploader | object | 否 | 上传者窄化视图,仅普通上传路径输出 | > `data.uploader` 为 `domain.UploaderPublic` 窄化视图,仅含 `id`、`username`、`nickname`、`avatar`; -> 秒传去重路径复用 `GetByFileHash` 查询结果,未预加载上传者关联,该键整体省略。 +> 秒传去重路径复用 `GetByFileHashAndUploader` 查询结果,未预加载上传者关联,该键整体省略。 > 上传者 IP `uploadIP` 在实体上为 `json:"-"`,任何响应都不输出。 #### 响应示例 @@ -115,7 +115,7 @@ curl -X POST http://localhost:3000/api/media/upload \ | 401 | 未登录或令牌无效 | | 500 | 打开或读取上传文件失败、创建目录或写入文件失败、保存媒体记录失败(错误原文仅落日志) | -> 相同内容的文件会通过 SHA256 哈希命中已有记录,返回已存在的媒体文件(秒传去重); +> 同一上传者重复上传相同内容时会通过 SHA256 哈希命中已有记录,返回已存在的媒体文件(秒传去重); > 哈希比对先于类型白名单校验,白名单调整后旧文件仍可按哈希命中。 ### 2. 获取文件详情 diff --git a/server/internal/repository/media.go b/server/internal/repository/media.go index 110da6b..0498a7d 100644 --- a/server/internal/repository/media.go +++ b/server/internal/repository/media.go @@ -16,7 +16,7 @@ type MediaRepositoryInterface interface { // 基础CRUD操作 Create(media *model.MediaFile) error GetByID(id uint) (*model.MediaFile, error) - GetByFileHash(hash string) (*model.MediaFile, error) + GetByFileHashAndUploader(hash string, uploaderID uint) (*model.MediaFile, error) Update(media *model.MediaFile) error Delete(id uint) error @@ -60,10 +60,12 @@ func (r *MediaRepository) GetByID(id uint) (*model.MediaFile, error) { return &media, nil } -// GetByFileHash 根据文件哈希获取媒体文件,用于去重与秒传。 -func (r *MediaRepository) GetByFileHash(hash string) (*model.MediaFile, error) { +// GetByFileHashAndUploader 按文件哈希与上传者查询媒体文件,用于同一上传者范围内的秒传去重。 +// 同一内容可能被多个上传者各持一份记录,限定上传者使命中落在调用方自己的记录上, +// 避免非首位上传者每次重复上传都新建副本。 +func (r *MediaRepository) GetByFileHashAndUploader(hash string, uploaderID uint) (*model.MediaFile, error) { var media model.MediaFile - if err := r.db.Where("file_hash = ?", hash).First(&media).Error; err != nil { + if err := r.db.Where("file_hash = ?", hash).Where("uploader_id = ?", uploaderID).First(&media).Error; err != nil { if errors.Is(err, gorm.ErrRecordNotFound) { return nil, domain.ErrMediaNotFound } diff --git a/server/internal/repository/media_test.go b/server/internal/repository/media_test.go new file mode 100644 index 0000000..5e4ff17 --- /dev/null +++ b/server/internal/repository/media_test.go @@ -0,0 +1,93 @@ +package repository + +import ( + "errors" + "regexp" + "testing" + + "MyBlog/internal/domain" + + "github.com/DATA-DOG/go-sqlmock" + "gorm.io/driver/mysql" + "gorm.io/gorm" + "gorm.io/gorm/logger" +) + +// mediaHashQuery 为按哈希与上传者查询单行的期望语句,取自实现实际生成的 SQL。 +// 语句锚定 uploader_id 条件,条件被移除时期望不再匹配。 +const mediaHashQuery = "SELECT * FROM `media_files` WHERE file_hash = ? AND uploader_id = ? AND `media_files`.`deleted_at` IS NULL ORDER BY `media_files`.`id` LIMIT ?" + +// newMockMediaRepo 创建基于 sqlmock 的媒体仓储,用于锁定哈希查询的上传者限定条件。 +func newMockMediaRepo(t *testing.T) (MediaRepositoryInterface, sqlmock.Sqlmock) { + t.Helper() + + db, mock, err := sqlmock.New() + if err != nil { + t.Fatalf("创建 sqlmock 失败: %v", err) + } + + gormDB, err := gorm.Open(mysql.New(mysql.Config{ + Conn: db, + SkipInitializeWithVersion: true, + }), &gorm.Config{ + Logger: logger.Default.LogMode(logger.Silent), + }) + if err != nil { + t.Fatalf("创建 GORM 实例失败: %v", err) + } + + return NewMediaRepository(gormDB), mock +} + +// expectMediaQueryByHashAndUploader 登记一项按哈希与上传者查询单行的期望。 +// 末位参数为 First 追加的 LIMIT 值。 +func expectMediaQueryByHashAndUploader(mock sqlmock.Sqlmock, hash string, uploaderID uint) *sqlmock.ExpectedQuery { + return mock.ExpectQuery(regexp.QuoteMeta(mediaHashQuery)).WithArgs(hash, uploaderID, 1) +} + +// TestGetByFileHashAndUploaderReturnsOwnRecord 验证哈希查询按上传者限定并回出命中行。 +func TestGetByFileHashAndUploaderReturnsOwnRecord(t *testing.T) { + repo, mock := newMockMediaRepo(t) + + const uploaderID uint = 2 + rows := sqlmock.NewRows([]string{"id", "filename", "file_path", "file_url", "file_hash", "uploader_id"}). + AddRow(2, "mine.png", "/srv/uploads/2026/01/mine.png", "/uploads/2026/01/mine.png", "hash-value", uploaderID) + expectMediaQueryByHashAndUploader(mock, "hash-value", uploaderID).WillReturnRows(rows) + + media, err := repo.GetByFileHashAndUploader("hash-value", uploaderID) + if err != nil { + t.Fatalf("查询失败: %v", err) + } + if media == nil { + t.Fatal("命中时应返回实体") + } + if media.ID != 2 { + t.Errorf("返回记录 ID 不符合预期,实际 %d", media.ID) + } + if media.UploaderID != uploaderID { + t.Errorf("返回记录应归属于查询的上传者,实际 uploaderId = %d", media.UploaderID) + } + if media.Filename != "mine.png" || media.FilePath != "/srv/uploads/2026/01/mine.png" { + t.Errorf("返回记录字段不符合预期: filename=%s filePath=%s", media.Filename, media.FilePath) + } + if err := mock.ExpectationsWereMet(); err != nil { + t.Errorf("查询期望未满足: %v", err) + } +} + +// TestGetByFileHashAndUploaderNotFound 验证未命中时返回不存在的哨兵错误。 +func TestGetByFileHashAndUploaderNotFound(t *testing.T) { + repo, mock := newMockMediaRepo(t) + + const uploaderID uint = 2 + // 空结果集模拟数据库无匹配行,GORM 据此返回 ErrRecordNotFound。 + emptyRows := sqlmock.NewRows([]string{"id", "filename", "file_path", "file_url", "file_hash", "uploader_id"}) + expectMediaQueryByHashAndUploader(mock, "absent-hash", uploaderID).WillReturnRows(emptyRows) + + if _, err := repo.GetByFileHashAndUploader("absent-hash", uploaderID); !errors.Is(err, domain.ErrMediaNotFound) { + t.Errorf("未命中应返回 domain.ErrMediaNotFound,实际 %v", err) + } + if err := mock.ExpectationsWereMet(); err != nil { + t.Errorf("查询期望未满足: %v", err) + } +} diff --git a/server/internal/service/media.go b/server/internal/service/media.go index 4d1876f..ba278be 100644 --- a/server/internal/service/media.go +++ b/server/internal/service/media.go @@ -77,7 +77,7 @@ func NewMediaService(mediaRepo repository.MediaRepositoryInterface, cfg *config. } } -// UploadFile 上传文件到本地存储并落库,文件哈希相同则复用已有记录。 +// UploadFile 上传文件到本地存储并落库,同一上传者的文件哈希一致时复用已有记录。 func (s *MediaService) UploadFile(filename string, reader io.Reader, size int64, uploaderID uint, ipAddress string) (*model.MediaFile, error) { // 校验文件大小是否超限。 maxSize := int64(s.cfg.Media.MaxSizeMB) * 1024 * 1024 @@ -93,8 +93,9 @@ func (s *MediaService) UploadFile(filename string, reader io.Reader, size int64, fileHash := sha256.Sum256(content) hashHex := hex.EncodeToString(fileHash[:]) - // 文件哈希一致时直接复用已有记录,实现秒传去重。 - if existing, err := s.mediaRepo.GetByFileHash(hashHex); err == nil { + // 查询按上传者限定,使命中确定地落在调用方自己的记录上。 + // 显式归属判断是拒绝跨用户复用的安全边界,仓储实现忽略过滤条件时依然生效。 + if existing, err := s.mediaRepo.GetByFileHashAndUploader(hashHex, uploaderID); err == nil && existing.UploaderID == uploaderID { return existing, nil } diff --git a/server/internal/service/media_test.go b/server/internal/service/media_test.go index 1b54ac8..93632d3 100644 --- a/server/internal/service/media_test.go +++ b/server/internal/service/media_test.go @@ -21,7 +21,7 @@ import ( type fakeMediaRepo struct { repository.MediaRepositoryInterface media []*model.MediaFile - getByHash func(hash string) (*model.MediaFile, error) + getByHash func(hash string, uploaderID uint) (*model.MediaFile, error) getByID func(id uint) (*model.MediaFile, error) } @@ -31,12 +31,13 @@ func (f *fakeMediaRepo) Create(media *model.MediaFile) error { return nil } -func (f *fakeMediaRepo) GetByFileHash(hash string) (*model.MediaFile, error) { +// GetByFileHashAndUploader 默认按上传者过滤,与生产仓储的限定语义一致。 +func (f *fakeMediaRepo) GetByFileHashAndUploader(hash string, uploaderID uint) (*model.MediaFile, error) { if f.getByHash != nil { - return f.getByHash(hash) + return f.getByHash(hash, uploaderID) } for _, media := range f.media { - if media.FileHash == hash { + if media.FileHash == hash && media.UploaderID == uploaderID { return media, nil } } @@ -93,18 +94,19 @@ func TestUploadFileOversize(t *testing.T) { } } -// TestUploadFileDeduplicates 验证相同内容文件通过哈希去重复用已有记录。 +// TestUploadFileDeduplicates 验证同一上传者的相同内容文件通过哈希去重复用已有记录。 func TestUploadFileDeduplicates(t *testing.T) { - // 计算与上传内容一致的哈希,模拟文件已存在的场景。 + // 计算与上传内容一致的哈希,模拟同一上传者已上传过该内容的场景。 content := []byte("same content") hashBytes := sha256.Sum256(content) contentHash := hex.EncodeToString(hashBytes[:]) - existing := &model.MediaFile{ID: 1, FileHash: contentHash, FileURL: "/uploads/2026/01/a.png", Filename: "a.png"} + const uploaderID uint = 1 + existing := &model.MediaFile{ID: 1, FileHash: contentHash, FileURL: "/uploads/2026/01/a.png", Filename: "a.png", UploaderID: uploaderID} repo := &fakeMediaRepo{ media: []*model.MediaFile{existing}, - getByHash: func(hash string) (*model.MediaFile, error) { - if hash == contentHash { + getByHash: func(hash string, ownerID uint) (*model.MediaFile, error) { + if hash == contentHash && ownerID == uploaderID { return existing, nil } return nil, domain.ErrMediaNotFound @@ -113,7 +115,7 @@ func TestUploadFileDeduplicates(t *testing.T) { svc := newTestMediaService(t, repo) // 上传相同内容,应命中已有记录。 - media, err := svc.UploadFile("b.png", bytes.NewReader(content), int64(len(content)), 1, "127.0.0.1") + media, err := svc.UploadFile("b.png", bytes.NewReader(content), int64(len(content)), uploaderID, "127.0.0.1") if err != nil { t.Fatalf("上传失败: %v", err) } @@ -121,6 +123,99 @@ func TestUploadFileDeduplicates(t *testing.T) { if media.ID != 1 { t.Errorf("去重后应返回已有记录,实际 ID = %d", media.ID) } + if got := len(repo.media); got != 1 { + t.Errorf("去重命中不应新建记录,实际记录数 = %d", got) + } +} + +// TestUploadFileDoesNotReuseOtherUploaderRecord 验证仓储忽略上传者过滤时服务层仍拒绝跨用户复用。 +// 仓储实现不受业务层信任,归属判断由业务层独立承担。 +// 该场景下调用方必须获得属于自己的记录,不得回出他人的存储路径、归属与原始文件名。 +func TestUploadFileDoesNotReuseOtherUploaderRecord(t *testing.T) { + content := []byte("shared bytes across uploaders") + hashBytes := sha256.Sum256(content) + contentHash := hex.EncodeToString(hashBytes[:]) + + const otherUploaderID uint = 1 + const currentUploaderID uint = 2 + otherRecord := &model.MediaFile{ + ID: 1, + Filename: "other-owner.png", + FilePath: `C:\srv\uploads\2026\01\other-owner.png`, + FileHash: contentHash, + UploaderID: otherUploaderID, + } + // 钩子无视上传者参数并强行返回他人记录,模拟忽略过滤条件的仓储实现。 + repo := &fakeMediaRepo{ + media: []*model.MediaFile{otherRecord}, + getByHash: func(hash string, _ uint) (*model.MediaFile, error) { + if hash == contentHash { + return otherRecord, nil + } + return nil, domain.ErrMediaNotFound + }, + } + svc := newTestMediaService(t, repo) + + media, err := svc.UploadFile("mine.png", bytes.NewReader(content), int64(len(content)), currentUploaderID, "127.0.0.1") + if err != nil { + t.Fatalf("上传失败: %v", err) + } + + if media.UploaderID != currentUploaderID { + t.Errorf("上传结果应归属于当前上传者,实际 uploaderId = %d", media.UploaderID) + } + if media.FilePath == otherRecord.FilePath { + t.Errorf("上传结果不应回出他人存储路径,实际 filePath = %s", media.FilePath) + } + if media.Filename != "mine.png" { + t.Errorf("上传结果应保留本次提交的原始文件名,实际 filename = %s", media.Filename) + } + if got := len(repo.media); got != 2 { + t.Errorf("跨上传者命中应新增属于本人的记录,实际记录数 = %d", got) + } +} + +// TestUploadFileDeduplicatesOwnRecordAmongOthers 验证同哈希存在多位上传者记录时,去重落在调用方自己的记录上。 +// 限定上传者之前,查询只会返回主键最小的一行,非首位上传者每次重复上传都会新建副本。 +func TestUploadFileDeduplicatesOwnRecordAmongOthers(t *testing.T) { + content := []byte("content held by two uploaders") + hashBytes := sha256.Sum256(content) + contentHash := hex.EncodeToString(hashBytes[:]) + + const otherUploaderID uint = 1 + const currentUploaderID uint = 2 + otherRecord := &model.MediaFile{ID: 1, Filename: "other.png", FileHash: contentHash, UploaderID: otherUploaderID} + ownRecord := &model.MediaFile{ID: 2, Filename: "mine.png", FileURL: "/uploads/2026/01/mine.png", FileHash: contentHash, UploaderID: currentUploaderID} + // 钩子按上传者分流,模拟按上传者限定查询的生产仓储。 + repo := &fakeMediaRepo{ + media: []*model.MediaFile{otherRecord, ownRecord}, + getByHash: func(hash string, ownerID uint) (*model.MediaFile, error) { + if hash != contentHash { + return nil, domain.ErrMediaNotFound + } + if ownerID == otherUploaderID { + return otherRecord, nil + } + if ownerID == currentUploaderID { + return ownRecord, nil + } + return nil, domain.ErrMediaNotFound + }, + } + svc := newTestMediaService(t, repo) + + media, err := svc.UploadFile("mine.png", bytes.NewReader(content), int64(len(content)), currentUploaderID, "127.0.0.1") + if err != nil { + t.Fatalf("上传失败: %v", err) + } + + if media.ID != ownRecord.ID { + t.Errorf("去重应命中调用方自己的记录,实际 ID = %d", media.ID) + } + if got := len(repo.media); got != 2 { + t.Errorf("去重命中不应新建记录,实际记录数 = %d", got) + } } // TestDeleteMediaPermission 验证非上传者删除他人文件被拒绝。 From 7aed00c8147297504803d87709e7f1f18d66e50d Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 16:18:36 +0800 Subject: [PATCH 5/6] =?UTF-8?q?fix(server):=20=E4=B8=8A=E4=BC=A0=E5=A4=A7?= =?UTF-8?q?=E5=B0=8F=E4=B8=8A=E9=99=90=E9=9D=9E=E6=AD=A3=E6=97=B6=E6=8B=92?= =?UTF-8?q?=E7=BB=9D=E5=90=AF=E5=8A=A8=EF=BC=8C=E8=90=BD=E5=BA=93=E5=A4=A7?= =?UTF-8?q?=E5=B0=8F=E6=94=B9=E5=8F=96=E5=AE=9E=E9=99=85=E5=AD=97=E8=8A=82?= =?UTF-8?q?=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - media.max_size_mb 非正由 validateConfig 在加载期拒绝,结构体注释同步标明必须为正 - 服务层对非正上限返回未分类错误,经 handler 脱敏为 500,不伪装成客户端 400 - 超限判定以实际读取字节数为准,读取前后的两处检查共用同一业务错误构造 - 落库 FileSize 改取实际存储字节数,避免磁盘内容截断而记录声明值的不一致 - 新增配置拒绝用例与三条服务层用例,配置模块校验清单同步补录 --- server/internal/config/README.md | 1 + server/internal/config/config.go | 7 ++- server/internal/config/config_test.go | 14 ++++++ server/internal/service/media.go | 35 ++++++++++++--- server/internal/service/media_test.go | 65 +++++++++++++++++++++++++++ 5 files changed, 115 insertions(+), 7 deletions(-) diff --git a/server/internal/config/README.md b/server/internal/config/README.md index 522cadf..15a1bc1 100644 --- a/server/internal/config/README.md +++ b/server/internal/config/README.md @@ -15,6 +15,7 @@ - `server.port` 超出 1 至 65535。 - `database.host`、`database.username`、`database.dbname` 为空。 - `token.access_expire` 或 `token.refresh_expire` 不为正数。 +- `media.max_size_mb` 不为正数。 - `rbac.role_hierarchy` 或 `rbac.role_permissions` 缺少 superadmin、admin、editor、user 任一类角色的定义。 - `i18n.supported_languages` 为空,或 `i18n.default_language` 不在该列表内。 - `security.trusted_proxies` 含空项、非法 IP 或 CIDR,或出现 `0.0.0.0/0` 与 `::/0` 这类覆盖全部地址的取值。 diff --git a/server/internal/config/config.go b/server/internal/config/config.go index 94dd57a..a387780 100644 --- a/server/internal/config/config.go +++ b/server/internal/config/config.go @@ -56,7 +56,7 @@ type RBACConfig struct { type MediaConfig struct { UploadDir string `mapstructure:"upload_dir"` // 本地存储目录 BaseURL string `mapstructure:"base_url"` // 文件访问 URL 前缀 - MaxSizeMB int `mapstructure:"max_size_mb"` // 单文件大小上限,单位 MB + MaxSizeMB int `mapstructure:"max_size_mb"` // 单文件大小上限,单位 MB,必须为正数 AllowedTypes []string `mapstructure:"allowed_types"` // 允许的 MIME 类型,空表示不限制 } @@ -388,6 +388,11 @@ func validateConfig(cfg *Config) error { return fmt.Errorf("刷新令牌过期时间必须大于0") } + // 媒体大小上限必须为正,非正取值会让上传读取被截断而声明大小照原样落库。 + if cfg.Media.MaxSizeMB <= 0 { + return fmt.Errorf("无效的媒体单文件大小上限: %dMB", cfg.Media.MaxSizeMB) + } + // RBAC 配置校验:四类角色必须全部登记层级与权限。 for _, role := range []string{"superadmin", "admin", "editor", "user"} { if _, ok := cfg.RBAC.RoleHierarchy[role]; !ok { diff --git a/server/internal/config/config_test.go b/server/internal/config/config_test.go index c815dfb..23aebb4 100644 --- a/server/internal/config/config_test.go +++ b/server/internal/config/config_test.go @@ -81,6 +81,7 @@ func validTestConfig() *Config { return &Config{ Server: ServerConfig{Port: 3000}, Database: DatabaseConfig{Host: "localhost", Username: "root", DBName: "blog"}, + Media: MediaConfig{MaxSizeMB: 10}, Token: TokenConfig{ AccessExpire: 15, RefreshExpire: 168, @@ -113,6 +114,19 @@ func TestValidateConfigAcceptsValidConfig(t *testing.T) { } } +// TestValidateConfigRejectsNonPositiveMediaMaxSize 验证媒体单文件大小上限非正即拒绝启动。 +// 上限为零会让上传读取被截断为一个字节,而声明大小照原样落库,存储内容与记录大小不一致。 +func TestValidateConfigRejectsNonPositiveMediaMaxSize(t *testing.T) { + for _, maxSizeMB := range []int{0, -1} { + cfg := validTestConfig() + cfg.Media.MaxSizeMB = maxSizeMB + + if err := validateConfig(cfg); err == nil { + t.Errorf("media.max_size_mb = %d,应返回错误", maxSizeMB) + } + } +} + // TestValidateConfigRejectsEmptyI18NSupportedLanguages 验证 i18n 白名单为空即拒绝启动。 func TestValidateConfigRejectsEmptyI18NSupportedLanguages(t *testing.T) { cfg := validTestConfig() diff --git a/server/internal/service/media.go b/server/internal/service/media.go index ba278be..fb1735b 100644 --- a/server/internal/service/media.go +++ b/server/internal/service/media.go @@ -77,19 +77,41 @@ func NewMediaService(mediaRepo repository.MediaRepositoryInterface, cfg *config. } } +// bytesPerMegabyte 大小上限配置项到字节的换算基准,配置项以 MB 为单位声明。 +const bytesPerMegabyte = 1024 * 1024 + +// truncationProbeBytes 读取上限之外额外读取的字节数,用于判定内容是否超过上限。 +const truncationProbeBytes = 1 + +// fileSizeExceededError 构造文件超过大小上限的业务错误,读取前的声明值检查与读取后的实际长度检查共用。 +func fileSizeExceededError(maxSizeMB int) error { + return fmt.Errorf("%w:文件大小超过限制 %dMB", ErrInvalidRequest, maxSizeMB) +} + // UploadFile 上传文件到本地存储并落库,同一上传者的文件哈希一致时复用已有记录。 func (s *MediaService) UploadFile(filename string, reader io.Reader, size int64, uploaderID uint, ipAddress string) (*model.MediaFile, error) { - // 校验文件大小是否超限。 - maxSize := int64(s.cfg.Media.MaxSizeMB) * 1024 * 1024 - if maxSize > 0 && size > maxSize { - return nil, fmt.Errorf("%w:文件大小超过限制 %dMB", ErrInvalidRequest, s.cfg.Media.MaxSizeMB) + // 上限必须为正,配置校验已在加载期拦截非法取值,此处防御直接构造服务实例的调用路径。 + // 该情形属服务端配置错误,返回未分类错误使响应脱敏为 500,避免误判为客户端请求问题。 + maxSize := int64(s.cfg.Media.MaxSizeMB) * bytesPerMegabyte + if maxSize <= 0 { + return nil, fmt.Errorf("媒体单文件大小上限配置无效: %dMB", s.cfg.Media.MaxSizeMB) + } + + // 入参大小由调用方提供,先按声明值拦截明显超限的上传,避免无谓读取。 + if size > maxSize { + return nil, fileSizeExceededError(s.cfg.Media.MaxSizeMB) } // 读取文件内容并计算哈希。 - content, err := io.ReadAll(io.LimitReader(reader, maxSize+1)) + content, err := io.ReadAll(io.LimitReader(reader, maxSize+truncationProbeBytes)) if err != nil { return nil, fmt.Errorf("读取上传文件失败: %w", err) } + + // 声明值可能与实际内容不符,超限判定以实际读取字节数为准,与读取前的检查返回同一业务错误。 + if int64(len(content)) > maxSize { + return nil, fileSizeExceededError(s.cfg.Media.MaxSizeMB) + } fileHash := sha256.Sum256(content) hashHex := hex.EncodeToString(fileHash[:]) @@ -123,13 +145,14 @@ func (s *MediaService) UploadFile(filename string, reader io.Reader, size int64, // 构建访问 URL。 fileURL := strings.TrimRight(s.cfg.Media.BaseURL, "/") + "/" + filepath.ToSlash(relativePath) + // 落库大小取实际存储的字节数,声明值可能大于实际内容,据此记录会使读取结果与实际不符。 media := &model.MediaFile{ Filename: filename, StoredName: storedName, FilePath: fullPath, FileURL: fileURL, MimeType: mimeType, - FileSize: uint64(size), + FileSize: uint64(len(content)), FileHash: hashHex, Status: model.MediaStatusActive, UploaderID: uploaderID, diff --git a/server/internal/service/media_test.go b/server/internal/service/media_test.go index 93632d3..f50e371 100644 --- a/server/internal/service/media_test.go +++ b/server/internal/service/media_test.go @@ -94,6 +94,71 @@ func TestUploadFileOversize(t *testing.T) { } } +// testBytesPerMegabyte 单兆字节的字节数,供测试构造大小上限的边界内容。 +const testBytesPerMegabyte = 1024 * 1024 + +// TestUploadFileRejectsNonPositiveMaxSizeConfig 验证大小上限非正时上传被拒绝。 +// 服务实例可被直接构造,配置校验不覆盖该路径,上限合法性的判定必须在服务层独立成立。 +func TestUploadFileRejectsNonPositiveMaxSizeConfig(t *testing.T) { + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + svc.cfg.Media.MaxSizeMB = 0 + + _, err := svc.UploadFile("pic.png", bytes.NewReader(pngTestContent), int64(len(pngTestContent)), 1, "127.0.0.1") + if err == nil { + t.Fatal("大小上限为零时上传应返回错误") + } + // 上限非法属服务端配置错误,handler 据此分档为 500 而非客户端 400。 + if errors.Is(err, ErrInvalidRequest) { + t.Errorf("大小上限非法不应分类为请求参数错误,实际为 %v", err) + } + if len(repo.media) != 0 { + t.Error("被拒绝的文件不应落库") + } +} + +// TestUploadFileRecordsActualStoredSize 验证落库大小取自实际读取字节数而非入参声明值。 +// 声明值远大于实际内容时,记录大小必须与存储内容一致,否则读回的大小与实际不符。 +func TestUploadFileRecordsActualStoredSize(t *testing.T) { + const maxSizeMB = 1 + declaredSizeBytes := int64(testBytesPerMegabyte) / 2 + + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + svc.cfg.Media.MaxSizeMB = maxSizeMB + + media, err := svc.UploadFile("pic.png", bytes.NewReader(pngTestContent), declaredSizeBytes, 1, "127.0.0.1") + if err != nil { + t.Fatalf("上传失败: %v", err) + } + if media.FileSize != uint64(len(pngTestContent)) { + t.Errorf("FileSize = %d, 期望等于实际字节数 %d", media.FileSize, len(pngTestContent)) + } +} + +// TestUploadFileRejectsContentExceedingMaxSize 验证声明大小在上限内但实际内容超限时被拒绝。 +// 声明值由调用方提供,不能作为放行依据,超限判定以实际读取字节数为准。 +func TestUploadFileRejectsContentExceedingMaxSize(t *testing.T) { + const maxSizeMB = 1 + declaredSizeBytes := int64(testBytesPerMegabyte) + content := bytes.Repeat([]byte("a"), testBytesPerMegabyte+1) + + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + svc.cfg.Media.MaxSizeMB = maxSizeMB + + _, err := svc.UploadFile("note.txt", bytes.NewReader(content), declaredSizeBytes, 1, "127.0.0.1") + if err == nil { + t.Fatal("实际内容超过上限的上传应返回错误") + } + if !errors.Is(err, ErrInvalidRequest) { + t.Errorf("超限上传应包装 ErrInvalidRequest,实际为 %v", err) + } + if len(repo.media) != 0 { + t.Error("被拒绝的文件不应落库") + } +} + // TestUploadFileDeduplicates 验证同一上传者的相同内容文件通过哈希去重复用已有记录。 func TestUploadFileDeduplicates(t *testing.T) { // 计算与上传内容一致的哈希,模拟同一上传者已上传过该内容的场景。 From a5d84b5871923bc816224138d277a0926cacf36a Mon Sep 17 00:00:00 2001 From: idleRain Date: Thu, 15 Oct 2026 16:44:26 +0800 Subject: [PATCH 6/6] =?UTF-8?q?fix(server):=20=E5=AD=98=E5=82=A8=E6=89=A9?= =?UTF-8?q?=E5=B1=95=E5=90=8D=E5=8F=AA=E7=94=B1=E5=86=85=E5=AE=B9=E5=97=85?= =?UTF-8?q?=E6=8E=A2=E6=8E=A8=E5=AF=BC=EF=BC=8C=E6=98=A0=E5=B0=84=E7=BC=BA?= =?UTF-8?q?=E5=A4=B1=E5=8D=B3=E6=8B=92=E7=BB=9D=E4=B8=8A=E4=BC=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - storedExtensionForMime 不再回退客户端扩展名,未命中映射时以 ErrInvalidRequest 拒绝 - 拒绝发生在创建目录与写盘之前,不可安全命名的内容不会落盘并被同源静态服务下发 - 移除已不参与判定的原始扩展名形参,调用点同步清理 - 订正映射与推导函数的注释,删除「命中白名单时必然存在映射」这一失实表述 - 翻转把回退行为当预期的既有用例,新增脚本类型内容与白名单放行但映射缺失两组用例 - 同步 media-api.md 的存储扩展名口径与 400 错误分档表 --- server/docs/api/media-api.md | 4 +- server/internal/service/media.go | 26 ++++-- server/internal/service/media_test.go | 118 ++++++++++++++++++++++++-- 3 files changed, 131 insertions(+), 17 deletions(-) diff --git a/server/docs/api/media-api.md b/server/docs/api/media-api.md index 156c45a..588b10f 100644 --- a/server/docs/api/media-api.md +++ b/server/docs/api/media-api.md @@ -11,7 +11,7 @@ - **静态访问**: 服务启动时按 `media.base_url` 挂载静态目录(`internal/router/router.go` 的 `engine.Static`),`fileUrl` 可直接公开访问且目录列表关闭;生产部署经 `deploy/nginx.conf` 的 `location /uploads/` 反代到该静态服务 - **单文件上限**: `media.max_size_mb` 配置,默认 10MB - **允许类型**: `media.allowed_types` 白名单,默认 `image/jpeg`、`image/png`、`image/gif`、`image/webp`、`application/pdf`;校验对象是内容嗅探结果(`http.DetectContentType`),客户端声明的文件名与 Content-Type 均不参与判定,白名单为空表示不限制 -- **存储扩展名**: 命中白名单映射的上述 5 种类型按嗅探结果推导扩展名,其余类型沿用原始扩展名;`svg`、`html` 等可承载脚本的类型不在映射内 +- **存储扩展名**: 一律由内容嗅探结果推导,仅上述 5 种类型可确定存储扩展名,客户端提供的文件名不参与存储命名;命中白名单但无法确定存储扩展名的类型会被拒绝,`svg`、`html` 等可承载脚本的类型刻意不在映射内 - **文件命名**: 上传后以 UUID 重命名,按年月分目录归档 - **目录创建**: 上传目录由上传动作按 `0755` 创建;就绪探针 `pkg/storage.CheckWritable` 以真实写入探测目录可写性 @@ -111,7 +111,7 @@ curl -X POST http://localhost:3000/api/media/upload \ | 状态码 | 说明 | |--------|------| -| 400 | 表单缺少 file 字段、请求参数不合法:文件大小超过限制 / 文件类型不在白名单(哨兵错误 `ErrInvalidRequest`) | +| 400 | 表单缺少 file 字段、请求参数不合法:文件大小超过限制 / 文件类型不在白名单 / 内容类型无法确定安全的存储扩展名(后两者哨兵错误均为 `ErrInvalidRequest`,文案可区分) | | 401 | 未登录或令牌无效 | | 500 | 打开或读取上传文件失败、创建目录或写入文件失败、保存媒体记录失败(错误原文仅落日志) | diff --git a/server/internal/service/media.go b/server/internal/service/media.go index fb1735b..384e6a9 100644 --- a/server/internal/service/media.go +++ b/server/internal/service/media.go @@ -53,8 +53,9 @@ type MediaListResponse struct { } // allowedMimeExtensions 白名单 MIME 类型到标准存储扩展名的映射。 -// 存储扩展名一律由内容嗅探结果推导,防止伪造扩展名使静态服务以可执行类型响应。 -// svg 与 html 等可承载脚本的类型刻意不在映射内,杜绝存储型 XSS。 +// 该映射是存储扩展名的唯一来源,也是杜绝存储型 XSS 的唯一安全闸门: +// 只有能安全命名与安全下发的类型才在键集合内,映射之外的类型无法推导出可落盘的扩展名。 +// svg 与 html 等可承载脚本的类型刻意不在映射内。 var allowedMimeExtensions = map[string]string{ "image/jpeg": ".jpg", "image/png": ".png", @@ -127,8 +128,13 @@ func (s *MediaService) UploadFile(filename string, reader io.Reader, size int64, return nil, err } - // 生成存储文件名与相对路径,按月分目录便于归档;存储扩展名由嗅探类型推导。 - storedName := uuid.NewString() + storedExtensionForMime(mimeType, filepath.Ext(filename)) + // 生成存储文件名与相对路径,按月分目录便于归档。 + // 存储扩展名只能由内容嗅探结果推导,客户端提供的文件名不参与存储命名。 + storedExt, err := storedExtensionForMime(mimeType) + if err != nil { + return nil, err + } + storedName := uuid.NewString() + storedExt subDir := timeNowStr() relativePath := filepath.Join(subDir, storedName) uploadDir := filepath.Join(s.cfg.Media.UploadDir, subDir) @@ -255,13 +261,15 @@ func (s *MediaService) validateUploadType(mimeType string) error { return fmt.Errorf("%w:不支持的文件类型 %s", ErrInvalidRequest, mimeType) } -// storedExtensionForMime 从白名单映射推导存储扩展名,映射缺失时回退原始扩展名。 -// 回退仅发生在白名单关闭或运维显式放行新类型的场景,命中白名单时必然存在映射。 -func storedExtensionForMime(mimeType, originalExt string) string { +// storedExtensionForMime 依据内容嗅探结果推导存储扩展名。 +// 客户端提供的文件名一律不参与存储命名,命中映射时返回映射后缀。 +// 映射缺失时拒绝上传,不采用中性后缀,否则任意字节仍会被接受并落盘。 +// 该拒绝与白名单拒绝语义不同,便于运维区分类型无法安全落地存储与类型未放行两种原因。 +func storedExtensionForMime(mimeType string) (string, error) { if ext, ok := allowedMimeExtensions[mimeType]; ok { - return ext + return ext, nil } - return originalExt + return "", fmt.Errorf("%w:内容类型 %s 无法确定安全的存储扩展名", ErrInvalidRequest, mimeType) } // detectContentType 通过嗅探文件内容推断 MIME 类型。 diff --git a/server/internal/service/media_test.go b/server/internal/service/media_test.go index f50e371..ad1c78a 100644 --- a/server/internal/service/media_test.go +++ b/server/internal/service/media_test.go @@ -197,7 +197,8 @@ func TestUploadFileDeduplicates(t *testing.T) { // 仓储实现不受业务层信任,归属判断由业务层独立承担。 // 该场景下调用方必须获得属于自己的记录,不得回出他人的存储路径、归属与原始文件名。 func TestUploadFileDoesNotReuseOtherUploaderRecord(t *testing.T) { - content := []byte("shared bytes across uploaders") + // 内容取真实 PNG,使上传落在映射内类型上,用例聚焦跨上传者复用而非类型判定。 + content := pngTestContent hashBytes := sha256.Sum256(content) contentHash := hex.EncodeToString(hashBytes[:]) @@ -349,6 +350,29 @@ func TestGetMediaOwnership(t *testing.T) { // pngTestContent 构造可被内容嗅探识别为 image/png 的最小内容。 var pngTestContent = append([]byte("\x89PNG\r\n\x1a\n"), bytes.Repeat([]byte{0}, 8)...) +// htmlTestContent 构造可被内容嗅探识别为 text/html 的脚本片段,用于验证脚本类型内容不会以客户端扩展名落盘。 +var htmlTestContent = []byte("") + +// mp4TestContent 构造偏移 4 处为 ftyp 标记的内容,供内容嗅探识别为 video/mp4。 +var mp4TestContent = append([]byte{0x00, 0x00, 0x00, 0x18}, []byte("ftypmp42\x00\x00\x00\x00mp42isom")...) + +// requireEmptyDir 断言目录内没有任何文件,用于验证被拒绝的上传未落盘。 +func requireEmptyDir(t *testing.T, dir string) { + t.Helper() + err := filepath.WalkDir(dir, func(path string, entry os.DirEntry, walkErr error) error { + if walkErr != nil { + return walkErr + } + if !entry.IsDir() { + t.Errorf("被拒绝的上传不应落盘,发现文件 %s", path) + } + return nil + }) + if err != nil { + t.Fatalf("遍历上传目录失败: %v", err) + } +} + // TestUploadFileRejectsDisallowedType 验证白名单开启后非白名单类型被拒绝且不落库。 func TestUploadFileRejectsDisallowedType(t *testing.T) { repo := &fakeMediaRepo{} @@ -391,18 +415,100 @@ func TestUploadFileDerivesStoredExtension(t *testing.T) { } } -// TestUploadFileKeepsExtensionWhenUnrestricted 验证白名单关闭时保持原始扩展名。 -func TestUploadFileKeepsExtensionWhenUnrestricted(t *testing.T) { +// TestUploadFileRejectsUnmappedTypeWhenUnrestricted 验证白名单关闭时嗅探类型不在存储映射内的上传被拒绝。 +// 白名单关闭只放行类型校验,存储扩展名仍只能由嗅探结果推导,客户端扩展名不参与存储命名。 +func TestUploadFileRejectsUnmappedTypeWhenUnrestricted(t *testing.T) { repo := &fakeMediaRepo{} svc := newTestMediaService(t, repo) content := []byte("plain text content") - media, err := svc.UploadFile("note.txt", bytes.NewReader(content), int64(len(content)), 1, "127.0.0.1") + _, err := svc.UploadFile("note.txt", bytes.NewReader(content), int64(len(content)), 1, "127.0.0.1") + if err == nil { + t.Fatal("白名单关闭时嗅探类型不在存储映射内的上传应返回错误") + } + if !errors.Is(err, ErrInvalidRequest) { + t.Errorf("该拒绝属业务校验失败,应包装 ErrInvalidRequest,实际为 %v", err) + } + // 拒绝原因须指出嗅探到的内容类型,运维据此判断是类型无法安全落地存储而非类型未放行。 + if !strings.Contains(err.Error(), detectContentType(content)) { + t.Errorf("拒绝原因应指出嗅探到的内容类型 %s,实际为 %v", detectContentType(content), err) + } + if got := len(repo.media); got != 0 { + t.Errorf("被拒绝的文件不应落库,实际记录数 = %d", got) + } + requireEmptyDir(t, svc.cfg.Media.UploadDir) +} + +// TestUploadFileRejectsHtmlPayloadWhenUnrestricted 验证白名单关闭时脚本类型内容不会以客户端扩展名落盘。 +// 该内容与 x.html 文件名叠加后经静态服务以 text/html 下发即构成存储型 XSS, +// 因此拒绝必须发生在写入磁盘之前。 +func TestUploadFileRejectsHtmlPayloadWhenUnrestricted(t *testing.T) { + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + + // 前置断言:内容确实被嗅探为 text/html,确保本用例覆盖的是脚本类型内容的落盘路径。 + if sniffed := detectContentType(htmlTestContent); !strings.HasPrefix(sniffed, "text/html") { + t.Fatalf("测试内容嗅探结果为 %s,不构成脚本类型内容", sniffed) + } + + _, err := svc.UploadFile("x.html", bytes.NewReader(htmlTestContent), int64(len(htmlTestContent)), 1, "127.0.0.1") + if err == nil { + t.Fatal("无法确定安全存储扩展名的上传应返回错误") + } + if !errors.Is(err, ErrInvalidRequest) { + t.Errorf("该拒绝属业务校验失败,应包装 ErrInvalidRequest,实际为 %v", err) + } + // 该拒绝与白名单拒绝是两种原因,文案必须可区分。 + if strings.Contains(err.Error(), "不支持的文件类型") { + t.Errorf("拒绝原因应为无法确定存储扩展名,不应与白名单拒绝同文案,实际为 %v", err) + } + if got := len(repo.media); got != 0 { + t.Errorf("被拒绝的文件不应落库,实际记录数 = %d", got) + } + requireEmptyDir(t, svc.cfg.Media.UploadDir) +} + +// TestUploadFileRejectsWhitelistedTypeWithoutStorageMapping 验证白名单放行不足以放行落盘。 +// 白名单条目与存储扩展名映射相互独立,运维在白名单中新增映射外类型时上传仍被拒绝, +// 因此白名单放行不会使落盘扩展名回退为客户端提供的扩展名。 +func TestUploadFileRejectsWhitelistedTypeWithoutStorageMapping(t *testing.T) { + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + svc.cfg.Media.AllowedTypes = []string{"video/mp4"} + + // 前置断言:内容确实被嗅探为白名单内的 video/mp4,确保本用例验证的是映射缺失而非白名单拒绝。 + if sniffed := detectContentType(mp4TestContent); sniffed != "video/mp4" { + t.Fatalf("测试内容嗅探结果为 %s,不构成白名单放行但映射缺失的场景", sniffed) + } + + _, err := svc.UploadFile("x.html", bytes.NewReader(mp4TestContent), int64(len(mp4TestContent)), 1, "127.0.0.1") + if err == nil { + t.Fatal("白名单放行但无法确定存储扩展名的上传应返回错误") + } + if !errors.Is(err, ErrInvalidRequest) { + t.Errorf("该拒绝属业务校验失败,应包装 ErrInvalidRequest,实际为 %v", err) + } + if got := len(repo.media); got != 0 { + t.Errorf("被拒绝的文件不应落库,实际记录数 = %d", got) + } + requireEmptyDir(t, svc.cfg.Media.UploadDir) +} + +// TestUploadFileDerivesStoredExtensionWhenUnrestricted 验证白名单关闭时存储扩展名同样只由嗅探结果推导。 +// 与白名单开启路径互补:客户端文件名不参与存储命名的约束与白名单开关无关。 +func TestUploadFileDerivesStoredExtensionWhenUnrestricted(t *testing.T) { + repo := &fakeMediaRepo{} + svc := newTestMediaService(t, repo) + + media, err := svc.UploadFile("polyglot.html", bytes.NewReader(pngTestContent), int64(len(pngTestContent)), 1, "127.0.0.1") if err != nil { t.Fatalf("上传失败: %v", err) } - if !strings.HasSuffix(media.StoredName, ".txt") { - t.Errorf("白名单关闭时应保留原始扩展名,实际为 %s", media.StoredName) + if !strings.HasSuffix(media.StoredName, ".png") { + t.Errorf("白名单关闭时存储扩展名仍应由嗅探类型推导为 .png,实际为 %s", media.StoredName) + } + if got := len(repo.media); got != 1 { + t.Errorf("放行的上传应落库一条记录,实际记录数 = %d", got) } }