fix(auth): honour JWT tenant_id claim in middleware

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.
This commit is contained in:
wizardchen
2026-05-13 20:40:17 +08:00
committed by lyingbug
parent f3d1210577
commit af23483433
5 changed files with 143 additions and 14 deletions
+51 -7
View File
@@ -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
@@ -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)
}
})
}
}
+1 -1
View File
@@ -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())
+8 -4
View File
@@ -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
+7 -2
View File
@@ -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