Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(auth): 令牌写入失败不再当成登录成功,查询失败不再谎称已撤销
linus-liu-web2ec1774623a7
diff --git a/internal/application/service/user.go b/internal/application/service/user.goindex bdbd49547..1fd6e2beb 100644--- a/internal/application/service/user.go+++ b/internal/application/service/user.go@@ -1128,8 +1128,16 @@ func (s *userService) generateTokensForTenant(UpdatedAt: time.Now(),}- _ = s.tokenRepo.CreateToken(ctx, accessTokenRecord)- _ = s.tokenRepo.CreateToken(ctx, refreshTokenRecord)+ // Persist before returning the pair: a signed token the database has no row+ // for is rejected by ValidateToken / RefreshToken on the very next request,+ // so swallowing a write error turns a transient database failure into a+ // login that looks successful and then loses the session immediately.+ if err := s.tokenRepo.CreateToken(ctx, accessTokenRecord); err != nil {+ return "", "", fmt.Errorf("persist access token: %w", err)+ }+ if err := s.tokenRepo.CreateToken(ctx, refreshTokenRecord); err != nil {+ return "", "", fmt.Errorf("persist refresh token: %w", err)+ }return accessToken, refreshToken, nil}@@ -1273,9 +1281,14 @@ func (s *userService) ValidateToken(ctx context.Context, tokenString string) (*treturn nil, 0, errors.New("terminal ticket cannot be used as access token")}- // Check if token is revoked+ // Check if token is revoked. A failed lookup is an infrastructure error and+ // is reported as such: collapsing it into "token is revoked" claims a+ // revocation that never happened and sends operators down the wrong path.tokenRecord, err := s.tokenRepo.GetTokenByValue(ctx, tokenString)- if err != nil || tokenRecord == nil || tokenRecord.IsRevoked {+ if err != nil {+ return nil, 0, fmt.Errorf("look up token: %w", err)+ }+ if tokenRecord == nil || tokenRecord.IsRevoked {return nil, 0, errors.New("token is revoked")}if tokenRecord.TokenType == "refresh_token" {@@ -1425,9 +1438,13 @@ func (s *userService) RefreshToken(return "", "", errors.New("invalid user ID in token")}- // Check if token is revoked+ // Check if token is revoked. See ValidateToken: a lookup failure must not be+ // reported as a revocation.tokenRecord, err := s.tokenRepo.GetTokenByValue(ctx, refreshTokenString)- if err != nil || tokenRecord == nil || tokenRecord.IsRevoked {+ if err != nil {+ return "", "", fmt.Errorf("look up refresh token: %w", err)+ }+ if tokenRecord == nil || tokenRecord.IsRevoked {return "", "", errors.New("refresh token is revoked")}if tokenRecord.TokenType != "refresh_token" {diff --git a/internal/application/service/user_auth_token_test.go b/internal/application/service/user_auth_token_test.goindex 4d3a970f6..bcba68b21 100644--- a/internal/application/service/user_auth_token_test.go+++ b/internal/application/service/user_auth_token_test.go@@ -20,16 +20,40 @@ func init() {type stubAuthTokenRepo struct {tokens map[string]*types.AuthTokenrevokedUserIDs []string+ // getErr, when set, is returned by every GetTokenByValue call, standing in+ // for a database error rather than for a missing row.+ getErr error+ // createErrs, when non-empty, is returned by the matching CreateToken call+ // (1-based); calls past the end succeed. A nil entry means "this one+ // succeeds", so a test can fail only the refresh-token write.+ createErrs []error+ createCalls int+}++func (s *stubAuthTokenRepo) CreateToken(_ context.Context, token *types.AuthToken) error {+ s.createCalls+++ if s.createCalls <= len(s.createErrs) {+ if err := s.createErrs[s.createCalls-1]; err != nil {+ return err+ }+ }+ if s.tokens != nil && token != nil {+ s.tokens[token.Token] = token+ }+ return nil}-func (s *stubAuthTokenRepo) CreateToken(context.Context, *types.AuthToken) error { return nil }func (s *stubAuthTokenRepo) GetTokenByValue(_ context.Context, tokenValue string) (*types.AuthToken, error) {+ if s.getErr != nil {+ return nil, s.getErr+ }token, ok := s.tokens[tokenValue]if !ok {return nil, errors.New("token not found")}return token, nil}+func (s *stubAuthTokenRepo) GetTokenByID(_ context.Context, id string) (*types.AuthToken, error) {for _, token := range s.tokens {if token != nil && token.ID == id {@@ -65,9 +89,15 @@ func (s *stubUserRepoForAuth) GetUserByID(_ context.Context, id string) (*types.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) GetUserByEmail(_ context.Context, email string) (*types.User, error) {+ for _, user := range s.users {+ if user != nil && user.Email == email {+ return user, nil+ }+ }+ return nil, errors.New("user not found")}+func (s *stubUserRepoForAuth) GetUserByUsername(context.Context, string) (*types.User, error) {return nil, nil}diff --git a/internal/application/service/user_token_persistence_test.go b/internal/application/service/user_token_persistence_test.gonew file mode 100644index 000000000..482bdab42--- /dev/null+++ b/internal/application/service/user_token_persistence_test.go@@ -0,0 +1,150 @@+package service++import (+ "context"+ "errors"+ "testing"+ "time"++ "github.com/golang-jwt/jwt/v5"+ "github.com/stretchr/testify/require"+ "golang.org/x/crypto/bcrypt"++ "github.com/Tencent/WeKnora/internal/types"+)++// errTokenWrite stands in for a failed auth_tokens insert: statement timeout,+// exhausted connection pool, connection reset. It is always transient+// infrastructure, never caused by the request.+var errTokenWrite = errors.New("auth_tokens write failed: database is locked")++func persistedTestUser(t *testing.T, tenantID uint64, email, password string) *types.User {+ t.Helper()+ hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.MinCost)+ require.NoError(t, err)+ return &types.User{+ ID: "user-1",+ TenantID: tenantID,+ Email: email,+ IsActive: true,+ PasswordHash: string(hash),+ }+}++// A token the database has no row for is rejected by ValidateToken on the very+// next request, and the client is told its session was revoked. Login must+// therefore fail — and must not hand out the signed pair — when either insert+// fails.+func TestLoginFailsWhenTokensCannotBePersisted(t *testing.T) {+ ctx := context.Background()+ tokenRepo := &stubAuthTokenRepo{+ tokens: map[string]*types.AuthToken{},+ createErrs: []error{errTokenWrite},+ }+ svc := newAuthTestUserService(tokenRepo)+ user := persistedTestUser(t, 0, "[email protected]", "Secure9!")+ svc.userRepo.(*stubUserRepoForAuth).users["user-1"] = user++ resp, err := svc.Login(ctx, &types.LoginRequest{Email: user.Email, Password: "Secure9!"})+ require.NoError(t, err)+ require.NotNil(t, resp)+ require.False(t, resp.Success,+ "login reported success although the token rows were never written")+ require.Empty(t, resp.Token)+ require.Empty(t, resp.RefreshToken)+ require.Equal(t, "Login failed", resp.Message)+}++// Either half of the pair failing must abort issuance: both rows are checked+// before the caller sees a token.+func TestGenerateTokensFailsWhenEitherTokenCannotBePersisted(t *testing.T) {+ ctx := context.Background()+ user := persistedTestUser(t, 1, "[email protected]", "Secure9!")++ for _, tt := range []struct {+ name string+ createErrs []error+ wantErr string+ }{+ {"access token", []error{errTokenWrite}, "persist access token"},+ {"refresh token", []error{nil, errTokenWrite}, "persist refresh token"},+ {"both", []error{errTokenWrite, errTokenWrite}, "persist access token"},+ } {+ t.Run(tt.name, func(t *testing.T) {+ tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}, createErrs: tt.createErrs}+ svc := newAuthTestUserService(tokenRepo)++ access, refresh, err := svc.GenerateTokens(ctx, user)+ require.Error(t, err)+ require.Contains(t, err.Error(), tt.wantErr)+ require.Empty(t, access, "a token that was not persisted must not be handed out")+ require.Empty(t, refresh, "a token that was not persisted must not be handed out")+ })+ }+}++// The normal path must be untouched: both rows land before the pair is+// returned, and the access token validates afterwards.+func TestGenerateTokensPersistsPairBeforeReturning(t *testing.T) {+ ctx := context.Background()+ tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}}+ svc := newAuthTestUserService(tokenRepo)+ user := persistedTestUser(t, 1, "[email protected]", "Secure9!")++ access, refresh, err := svc.GenerateTokens(ctx, user)+ require.NoError(t, err)+ require.NotEmpty(t, access)+ require.NotEmpty(t, refresh)+ require.Equal(t, 2, tokenRepo.createCalls)+ require.Contains(t, tokenRepo.tokens, access)+ require.Contains(t, tokenRepo.tokens, refresh)+ require.Equal(t, "access_token", tokenRepo.tokens[access].TokenType)+ require.Equal(t, "refresh_token", tokenRepo.tokens[refresh].TokenType)++ got, tenantID, err := svc.ValidateToken(ctx, access)+ require.NoError(t, err)+ require.Equal(t, user.ID, got.ID)+ require.Equal(t, uint64(1), tenantID)+}++// A failed lookup is an infrastructure error, not a revocation. Reporting it as+// "token is revoked" sent operators chasing a session revocation that never+// happened, which is exactly the misleading half of the login-token defect.+func TestValidateTokenReportsLookupFailureTruthfully(t *testing.T) {+ ctx := context.Background()+ lookupErr := errors.New("connection reset by peer")+ tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{}, getErr: lookupErr}+ svc := newAuthTestUserService(tokenRepo)++ access := signTestJWT(jwt.MapClaims{+ "user_id": "user-1", "type": "access", "exp": time.Now().Add(time.Hour).Unix(),+ })+ _, _, err := svc.ValidateToken(ctx, access)+ require.Error(t, err)+ require.ErrorIs(t, err, lookupErr)+ require.NotContains(t, err.Error(), "token is revoked")++ refresh := signTestJWT(jwt.MapClaims{+ "user_id": "user-1", "type": "refresh", "exp": time.Now().Add(time.Hour).Unix(),+ })+ _, _, err = svc.RefreshToken(ctx, refresh)+ require.Error(t, err)+ require.ErrorIs(t, err, lookupErr)+ require.NotContains(t, err.Error(), "revoked")+}++// The revocation message must survive where it is true.+func TestValidateTokenStillReportsRevokedTokens(t *testing.T) {+ ctx := context.Background()+ access := signTestJWT(jwt.MapClaims{+ "user_id": "user-1", "type": "access", "exp": time.Now().Add(time.Hour).Unix(),+ })+ tokenRepo := &stubAuthTokenRepo{tokens: map[string]*types.AuthToken{+ access: {ID: "tok-1", UserID: "user-1", Token: access, TokenType: "access_token", IsRevoked: true},+ }}+ svc := newAuthTestUserService(tokenRepo)++ _, _, err := svc.ValidateToken(ctx, access)+ require.Error(t, err)+ require.Contains(t, err.Error(), "token is revoked")+}