From 235e86b8761a8a2e8cdc7c55fd0334707672c901 Mon Sep 17 00:00:00 2001 From: wizardchen Date: Thu, 2 Jul 2026 17:06:06 +0800 Subject: [PATCH] fix(security): harden refresh token validation and add auth tests Reject refresh attempts when the DB token type is not refresh_token, and add service-layer tests for bearer refresh rejection, logout revocation, and expired-token logout handling. --- internal/application/service/user.go | 3 + .../service/user_auth_token_test.go | 194 ++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 internal/application/service/user_auth_token_test.go diff --git a/internal/application/service/user.go b/internal/application/service/user.go index fe6ae80d..4dbf7d32 100644 --- a/internal/application/service/user.go +++ b/internal/application/service/user.go @@ -978,6 +978,9 @@ func (s *userService) RefreshToken( if err != nil || tokenRecord == nil || tokenRecord.IsRevoked { return "", "", errors.New("refresh token is revoked") } + if tokenRecord.TokenType != "refresh_token" { + return "", "", errors.New("not a refresh token") + } // Get user user, err := s.userRepo.GetUserByID(ctx, userID) diff --git a/internal/application/service/user_auth_token_test.go b/internal/application/service/user_auth_token_test.go new file mode 100644 index 00000000..d922440b --- /dev/null +++ b/internal/application/service/user_auth_token_test.go @@ -0,0 +1,194 @@ +package service + +import ( + "context" + "errors" + "os" + "testing" + "time" + + "github.com/golang-jwt/jwt/v5" + + "github.com/Tencent/WeKnora/internal/types" +) + +func init() { + _ = os.Setenv("JWT_SECRET", "test-jwt-secret-for-user-auth-token-tests") +} + +type stubAuthTokenRepo struct { + tokens map[string]*types.AuthToken + revokedUserIDs []string +} + +func (s *stubAuthTokenRepo) CreateToken(context.Context, *types.AuthToken) error { return nil } +func (s *stubAuthTokenRepo) GetTokenByValue(_ context.Context, tokenValue string) (*types.AuthToken, error) { + token, ok := s.tokens[tokenValue] + if !ok { + return nil, errors.New("token not found") + } + return token, nil +} +func (s *stubAuthTokenRepo) GetTokensByUserID(context.Context, string) ([]*types.AuthToken, error) { + return nil, nil +} +func (s *stubAuthTokenRepo) UpdateToken(context.Context, *types.AuthToken) error { return nil } +func (s *stubAuthTokenRepo) DeleteToken(context.Context, string) error { return nil } +func (s *stubAuthTokenRepo) DeleteExpiredTokens(context.Context) error { return nil } +func (s *stubAuthTokenRepo) RevokeTokensByUserID(_ context.Context, userID string) error { + s.revokedUserIDs = append(s.revokedUserIDs, userID) + return nil +} + +type stubUserRepoForAuth struct { + users map[string]*types.User +} + +func (s *stubUserRepoForAuth) CreateUser(context.Context, *types.User) error { return nil } +func (s *stubUserRepoForAuth) GetUserByID(_ context.Context, id string) (*types.User, error) { + user, ok := s.users[id] + if !ok { + return nil, errors.New("user not found") + } + return user, nil +} +func (s *stubUserRepoForAuth) GetUsersByIDs(context.Context, []string) (map[string]*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) GetUserByEmail(context.Context, string) (*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) GetUserByUsername(context.Context, string) (*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) GetUserByTenantID(context.Context, uint64) (*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) UpdateUser(context.Context, *types.User) error { return nil } +func (s *stubUserRepoForAuth) DeleteUser(context.Context, string) error { return nil } +func (s *stubUserRepoForAuth) ListUsers(context.Context, int, int) ([]*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) ListSystemAdmins(context.Context, int, int) ([]*types.User, int64, error) { + return nil, 0, nil +} +func (s *stubUserRepoForAuth) RevokeSystemAdmin(context.Context, string, string) (*types.User, error) { + return nil, nil +} +func (s *stubUserRepoForAuth) SearchUsers(context.Context, string, int) ([]*types.User, error) { + return nil, nil +} + +func newAuthTestUserService(tokenRepo *stubAuthTokenRepo) *userService { + return &userService{ + userRepo: &stubUserRepoForAuth{ + users: map[string]*types.User{ + "user-1": {ID: "user-1", TenantID: 1}, + }, + }, + tokenRepo: tokenRepo, + } +} + +func signTestJWT(claims jwt.MapClaims) string { + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) + signed, err := token.SignedString([]byte(getJwtSecret())) + if err != nil { + panic(err) + } + return signed +} + +func TestValidateTokenRejectsRefreshToken(t *testing.T) { + ctx := context.Background() + tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}} + svc := newAuthTestUserService(tokenRepo) + + refreshJWT := signTestJWT(jwt.MapClaims{ + "user_id": "user-1", + "type": "refresh", + "exp": time.Now().Add(time.Hour).Unix(), + }) + tokenRepo.tokens[refreshJWT] = &types.AuthToken{ + UserID: "user-1", + Token: refreshJWT, + TokenType: "refresh_token", + } + + _, _, err := svc.ValidateToken(ctx, refreshJWT) + if err == nil || err.Error() != "refresh token cannot be used as access token" { + t.Fatalf("ValidateToken(refresh JWT) err = %v, want refresh rejection", err) + } + + legacyRefresh := signTestJWT(jwt.MapClaims{ + "user_id": "user-1", + "exp": time.Now().Add(time.Hour).Unix(), + }) + tokenRepo.tokens[legacyRefresh] = &types.AuthToken{ + UserID: "user-1", + Token: legacyRefresh, + TokenType: "refresh_token", + } + + _, _, err = svc.ValidateToken(ctx, legacyRefresh) + if err == nil || err.Error() != "refresh token cannot be used as access token" { + t.Fatalf("ValidateToken(legacy refresh in DB) err = %v, want refresh rejection", err) + } +} + +func TestRefreshTokenRejectsAccessTokenRecord(t *testing.T) { + ctx := context.Background() + tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}} + svc := newAuthTestUserService(tokenRepo) + + refreshJWT := signTestJWT(jwt.MapClaims{ + "user_id": "user-1", + "type": "refresh", + "exp": time.Now().Add(time.Hour).Unix(), + }) + tokenRepo.tokens[refreshJWT] = &types.AuthToken{ + UserID: "user-1", + Token: refreshJWT, + TokenType: "access_token", + } + + _, _, err := svc.RefreshToken(ctx, refreshJWT) + if err == nil || err.Error() != "not a refresh token" { + t.Fatalf("RefreshToken(access token record) err = %v, want not a refresh token", err) + } +} + +func TestLogoutRevokesAllUserTokens(t *testing.T) { + ctx := context.Background() + tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}} + svc := newAuthTestUserService(tokenRepo) + + expiredAccess := signTestJWT(jwt.MapClaims{ + "user_id": "user-1", + "type": "access", + "exp": time.Now().Add(-time.Hour).Unix(), + }) + + if err := svc.Logout(ctx, expiredAccess); err != nil { + t.Fatalf("Logout(expired access token) err = %v", err) + } + if len(tokenRepo.revokedUserIDs) != 1 || tokenRepo.revokedUserIDs[0] != "user-1" { + t.Fatalf("RevokeTokensByUserID calls = %v, want [user-1]", tokenRepo.revokedUserIDs) + } +} + +func TestUserIDFromSignedTokenAcceptsExpiredToken(t *testing.T) { + expired := signTestJWT(jwt.MapClaims{ + "user_id": "user-1", + "type": "access", + "exp": time.Now().Add(-time.Hour).Unix(), + }) + + userID, err := userIDFromSignedToken(expired) + if err != nil { + t.Fatalf("userIDFromSignedToken(expired) err = %v", err) + } + if userID != "user-1" { + t.Fatalf("userIDFromSignedToken(expired) = %q, want user-1", userID) + } +}