From af2348343359de4570ffaa05198c72d88f49cdd7 Mon Sep 17 00:00:00 2001 From: wizardchen Date: Wed, 13 May 2026 20:40:17 +0800 Subject: [PATCH] fix(auth): honour JWT tenant_id claim in middleware MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit POST /auth/switch-tenant mints an access token whose `tenant_id` claim points to the target tenant, but the middleware previously discarded that claim entirely: user, err := userService.ValidateToken(ctx, token) // returned only *User targetTenantID := user.TenantID // always the home tenant The session therefore stayed scoped to the user's home tenant despite the supposedly fresh token, making the new endpoint a no-op once the request hit any tenant-scoped query. This change widens the contract: - UserService.ValidateToken now returns (user, activeTenantID, error) where activeTenantID is the JWT's `tenant_id` claim, falling back to user.TenantID when the claim is absent (backward compatibility with pre-RBAC tokens still in the wild). - middleware/auth.go uses activeTenantID as the default target before applying any X-Tenant-ID header override, and recomputes crossTenantSwitch from `activeTenantID != user.TenantID` so the resolveTenantRole branches stay correct for switch-tenant sessions. - The non-middleware /auth/validate handler in handler/auth.go absorbs the new return value (it only cares about user identity). Tests: - internal/application/service/user_jwt_test.go pins the JWT->tenant-id projection (`tenantIDFromClaims`) — claim present beats fallback, zero/negative/string claims fall back, int64/uint64 are accepted for test-built tokens. Required for PR 2 multi-tenant integration tests, where a single user needs to switch between Owner-in-A and Viewer-in-B sessions and observe distinct authority on each side. --- internal/application/service/user.go | 58 ++++++++++++-- internal/application/service/user_jwt_test.go | 76 +++++++++++++++++++ internal/handler/auth.go | 2 +- internal/middleware/auth.go | 12 ++- internal/types/interfaces/user.go | 9 ++- 5 files changed, 143 insertions(+), 14 deletions(-) create mode 100644 internal/application/service/user_jwt_test.go diff --git a/internal/application/service/user.go b/internal/application/service/user.go index 396d74b4..e1766bb0 100644 --- a/internal/application/service/user.go +++ b/internal/application/service/user.go @@ -674,8 +674,12 @@ func (s *userService) SwitchTenant( }, nil } -// ValidateToken validates an access token -func (s *userService) ValidateToken(ctx context.Context, tokenString string) (*types.User, error) { +// ValidateToken validates an access token. The second return value is +// the JWT's `tenant_id` claim — i.e. the tenant the token was minted +// for, which may differ from user.TenantID after a /auth/switch-tenant +// call. Tokens minted before tenant-level RBAC don't carry the claim; +// in that case we fall back to user.TenantID for backward compatibility. +func (s *userService) ValidateToken(ctx context.Context, tokenString string) (*types.User, uint64, error) { token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok { return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"]) @@ -684,26 +688,66 @@ func (s *userService) ValidateToken(ctx context.Context, tokenString string) (*t }) if err != nil || !token.Valid { - return nil, errors.New("invalid token") + return nil, 0, errors.New("invalid token") } claims, ok := token.Claims.(jwt.MapClaims) if !ok { - return nil, errors.New("invalid token claims") + return nil, 0, errors.New("invalid token claims") } userID, ok := claims["user_id"].(string) if !ok { - return nil, errors.New("invalid user ID in token") + return nil, 0, errors.New("invalid user ID in token") } // Check if token is revoked tokenRecord, err := s.tokenRepo.GetTokenByValue(ctx, tokenString) if err != nil || tokenRecord == nil || tokenRecord.IsRevoked { - return nil, errors.New("token is revoked") + return nil, 0, errors.New("token is revoked") } - return s.userRepo.GetUserByID(ctx, userID) + user, err := s.userRepo.GetUserByID(ctx, userID) + if err != nil { + return nil, 0, err + } + + // Extract active tenant from the JWT. Anything missing or unparseable + // falls back to the user's home tenant so old tokens (and tokens issued + // by code paths that don't yet set the claim) keep working. + activeTenantID := tenantIDFromClaims(claims, user.TenantID) + + return user, activeTenantID, nil +} + +// tenantIDFromClaims pulls the active tenant ID out of a parsed JWT +// claim map. Returns fallback when the claim is missing or has an +// unrecognised type. Extracted as a free function so it can be unit +// tested without standing up the full userService dependency graph. +// +// JSON numbers come back as float64 from jwt.MapClaims; the int64 / +// uint64 branches cover legacy code paths and tests that build claims +// directly. Negative values are treated as missing. +func tenantIDFromClaims(claims jwt.MapClaims, fallback uint64) uint64 { + raw, ok := claims["tenant_id"] + if !ok { + return fallback + } + switch v := raw.(type) { + case float64: + if v > 0 { + return uint64(v) + } + case int64: + if v > 0 { + return uint64(v) + } + case uint64: + if v > 0 { + return v + } + } + return fallback } // RefreshToken refreshes access token using refresh token diff --git a/internal/application/service/user_jwt_test.go b/internal/application/service/user_jwt_test.go new file mode 100644 index 00000000..dd138a8c --- /dev/null +++ b/internal/application/service/user_jwt_test.go @@ -0,0 +1,76 @@ +package service + +import ( + "testing" + + "github.com/golang-jwt/jwt/v5" +) + +// tenantIDFromClaims is the JWT->tenant-id projection used by +// userService.ValidateToken. It must: +// - prefer the claim when present (so /auth/switch-tenant takes effect) +// - fall back to the caller-supplied default when the claim is absent +// (backward compatibility with tokens minted before tenant-level RBAC) +// - reject zero / negative claim values rather than scoping the session +// to "tenant 0" +// +// These tests are pure-function so they don't need any DB/repo plumbing. +func TestTenantIDFromClaims(t *testing.T) { + cases := []struct { + name string + claims jwt.MapClaims + fallback uint64 + want uint64 + }{ + { + name: "json number wins over fallback", + claims: jwt.MapClaims{"tenant_id": float64(99)}, + fallback: 1, + want: 99, + }, + { + name: "missing claim falls back to home tenant", + claims: jwt.MapClaims{"user_id": "u1"}, + fallback: 7, + want: 7, + }, + { + name: "zero claim treated as missing", + claims: jwt.MapClaims{"tenant_id": float64(0)}, + fallback: 5, + want: 5, + }, + { + name: "negative claim treated as missing", + claims: jwt.MapClaims{"tenant_id": float64(-3)}, + fallback: 5, + want: 5, + }, + { + name: "string claim treated as missing", + claims: jwt.MapClaims{"tenant_id": "12"}, + fallback: 8, + want: 8, + }, + { + name: "int64 claim accepted (test-built tokens)", + claims: jwt.MapClaims{"tenant_id": int64(42)}, + fallback: 1, + want: 42, + }, + { + name: "uint64 claim accepted", + claims: jwt.MapClaims{"tenant_id": uint64(123)}, + fallback: 1, + want: 123, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + if got := tenantIDFromClaims(tc.claims, tc.fallback); got != tc.want { + t.Fatalf("tenantIDFromClaims(%v, %d) = %d, want %d", + tc.claims, tc.fallback, got, tc.want) + } + }) + } +} diff --git a/internal/handler/auth.go b/internal/handler/auth.go index 1ab5cb56..fda34d9c 100644 --- a/internal/handler/auth.go +++ b/internal/handler/auth.go @@ -707,7 +707,7 @@ func (h *AuthHandler) ValidateToken(c *gin.Context) { token := tokenParts[1] // Validate token - user, err := h.userService.ValidateToken(ctx, token) + user, _, err := h.userService.ValidateToken(ctx, token) if err != nil { logger.Errorf(ctx, "Failed to validate token: %v", err) appErr := errors.NewUnauthorizedError("Token validation failed").WithDetails(err.Error()) diff --git a/internal/middleware/auth.go b/internal/middleware/auth.go index 9e142668..055a4050 100644 --- a/internal/middleware/auth.go +++ b/internal/middleware/auth.go @@ -89,12 +89,16 @@ func Auth( authHeader := c.GetHeader("Authorization") if authHeader != "" && strings.HasPrefix(authHeader, "Bearer ") { token := strings.TrimPrefix(authHeader, "Bearer ") - user, err := userService.ValidateToken(c.Request.Context(), token) + user, jwtTenantID, err := userService.ValidateToken(c.Request.Context(), token) if err == nil && user != nil { // JWT Token认证成功 - // 检查是否有跨租户访问请求 - targetTenantID := user.TenantID - crossTenantSwitch := false + // 默认 target = JWT 里的 tenant_id(来自登录或 /auth/switch-tenant), + // 兼容 ValidateToken 的 fallback:claim 缺失时 jwtTenantID == user.TenantID。 + targetTenantID := jwtTenantID + if targetTenantID == 0 { + targetTenantID = user.TenantID + } + crossTenantSwitch := targetTenantID != user.TenantID tenantHeader := c.GetHeader("X-Tenant-ID") if tenantHeader != "" { // 解析目标租户ID diff --git a/internal/types/interfaces/user.go b/internal/types/interfaces/user.go index 1a4d907e..2a34afa6 100644 --- a/internal/types/interfaces/user.go +++ b/internal/types/interfaces/user.go @@ -45,8 +45,13 @@ type UserService interface { // refresh token (passed in for revocation) is invalidated. Membership // is verified via the TenantMember service before tokens are issued. SwitchTenant(ctx context.Context, user *types.User, targetTenantID uint64, currentRefreshToken string) (*types.LoginResponse, error) - // ValidateToken validates an access token - ValidateToken(ctx context.Context, token string) (*types.User, error) + // ValidateToken validates an access token. It returns the user + // referenced by the token plus the active tenant ID encoded in the + // JWT's `tenant_id` claim — the latter lets the auth middleware + // honour /auth/switch-tenant sessions that were minted with a + // non-home tenant. Falls back to user.TenantID when the claim is + // missing (old tokens issued before tenant-level RBAC). + ValidateToken(ctx context.Context, token string) (*types.User, uint64, error) // RefreshToken refreshes access token using refresh token RefreshToken(ctx context.Context, refreshToken string) (accessToken, newRefreshToken string, err error) // RevokeToken revokes a token