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:
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user