Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(auth): 令牌写入失败不再当成登录成功,查询失败不再谎称已撤销

linus-liu-web2ec1774623a7
diff --git a/internal/application/service/user.go b/internal/application/service/user.go
index 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) (*t
return 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.go
index 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.AuthToken
revokedUserIDs []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.go
new file mode 100644
index 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")
+}