Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix: reset password check (#21045)

ecmadaob28dad0d7f4c
diff --git a/backend/api/auth/auth.go b/backend/api/auth/auth.go
index 6248d3157a..c6d1ec0d2f 100644
--- a/backend/api/auth/auth.go
+++ b/backend/api/auth/auth.go
@@ -295,6 +295,12 @@ func (in *APIAuthInterceptor) getUserConnect(ctx context.Context, accessTokenStr
// GetUserEmailFromMFATempToken returns the user email from the MFA temp token.
func GetUserEmailFromMFATempToken(token string, secret string) (string, error) {
+ userEmail, _, err := GetUserEmailAndLoginMethodFromMFATempToken(token, secret)
+ return userEmail, err
+}
+
+// GetUserEmailAndLoginMethodFromMFATempToken returns the user email and original login method from the MFA temp token.
+func GetUserEmailAndLoginMethodFromMFATempToken(token, secret string) (string, string, error) {
claims := &claimsMessage{}
_, err := jwt.ParseWithClaims(token, claims, func(t *jwt.Token) (any, error) {
if t.Method.Alg() != jwt.SigningMethodHS256.Name {
@@ -308,12 +314,12 @@ func GetUserEmailFromMFATempToken(token string, secret string) (string, error) {
return nil, connect.NewError(connect.CodeUnauthenticated, errs.Errorf("unexpected MFA temp token kid=%v", t.Header["kid"]))
})
if err != nil {
- return "", connect.NewError(connect.CodeUnauthenticated, errs.New("failed to parse claim"))
+ return "", "", connect.NewError(connect.CodeUnauthenticated, errs.New("failed to parse claim"))
}
if !audienceContains(claims.Audience, MFATempTokenAudience) {
- return "", connect.NewError(connect.CodeUnauthenticated, errs.New("invalid MFA temp token, audience mismatch"))
+ return "", "", connect.NewError(connect.CodeUnauthenticated, errs.New("invalid MFA temp token, audience mismatch"))
}
- return claims.Subject, nil
+ return claims.Subject, claims.LoginMethod, nil
}
// AuthenticateToken validates a JWT access token and returns the user and token expiry.
diff --git a/backend/api/auth/tokens.go b/backend/api/auth/tokens.go
index 51cd96bebb..1cc094bc22 100644
--- a/backend/api/auth/tokens.go
+++ b/backend/api/auth/tokens.go
@@ -30,6 +30,7 @@ func HashToken(token string) string {
type claimsMessage struct {
jwt.RegisteredClaims
WorkspaceID string `json:"workspace_id,omitempty"`
+ LoginMethod string `json:"login_method,omitempty"`
}
// oauth2ClaimsMessage extends claimsMessage with OAuth2-specific fields.
@@ -52,12 +53,21 @@ func GenerateAccessToken(userEmail string, workspaceID string, secret string, to
// GenerateMFATempToken generates a temporary token for MFA.
func GenerateMFATempToken(userEmail string, secret string, tokenDuration time.Duration) (string, error) {
+ return GenerateMFATempTokenWithLoginMethod(userEmail, "", secret, tokenDuration)
+}
+
+// GenerateMFATempTokenWithLoginMethod generates a temporary token for MFA with the original login method.
+func GenerateMFATempTokenWithLoginMethod(userEmail string, loginMethod string, secret string, tokenDuration time.Duration) (string, error) {
expirationTime := time.Now().Add(tokenDuration)
- return generateToken(userEmail, "", MFATempTokenAudience, expirationTime, []byte(secret))
+ return generateTokenWithLoginMethod(userEmail, "", MFATempTokenAudience, expirationTime, []byte(secret), loginMethod)
}
// generateToken creates a JWT token for web authentication.
func generateToken(userEmail string, workspaceID string, aud string, expirationTime time.Time, secret []byte) (string, error) {
+ return generateTokenWithLoginMethod(userEmail, workspaceID, aud, expirationTime, secret, "")
+}
+
+func generateTokenWithLoginMethod(userEmail string, workspaceID string, aud string, expirationTime time.Time, secret []byte, loginMethod string) (string, error) {
claims := &claimsMessage{
RegisteredClaims: jwt.RegisteredClaims{
Audience: jwt.ClaimStrings{aud},
@@ -67,6 +77,7 @@ func generateToken(userEmail string, workspaceID string, aud string, expirationT
Subject: userEmail,
},
WorkspaceID: workspaceID,
+ LoginMethod: loginMethod,
}
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index 4d28139815..644a84028d 100644
--- a/backend/api/v1/auth_service.go
+++ b/backend/api/v1/auth_service.go
@@ -74,6 +74,47 @@ var (
invalidCredentialsError = connect.NewError(connect.CodeUnauthenticated, errors.Errorf(errMsgInvalidCredentials))
)
+type loginAuthMethod string
+
+const (
+ loginAuthMethodPassword loginAuthMethod = "password"
+ loginAuthMethodIDP loginAuthMethod = "idp"
+ loginAuthMethodEmailCode loginAuthMethod = "email_code"
+)
+
+func loginAuthMethodFromRequest(request *v1pb.LoginRequest) loginAuthMethod {
+ if request.GetIdpName() != "" {
+ return loginAuthMethodIDP
+ }
+ if request.EmailCode != nil && *request.EmailCode != "" {
+ return loginAuthMethodEmailCode
+ }
+ return loginAuthMethodPassword
+}
+
+func loginAuthMethodFromString(method string) loginAuthMethod {
+ switch loginAuthMethod(method) {
+ case loginAuthMethodIDP:
+ return loginAuthMethodIDP
+ case loginAuthMethodEmailCode:
+ return loginAuthMethodEmailCode
+ default:
+ return loginAuthMethodPassword
+ }
+}
+
+func loginAuthMethodFromMFATempToken(token, secret string) (string, loginAuthMethod, error) {
+ email, method, err := auth.GetUserEmailAndLoginMethodFromMFATempToken(token, secret)
+ if err != nil {
+ return "", loginAuthMethodPassword, err
+ }
+ return email, loginAuthMethodFromString(method), nil
+}
+
+func (m loginAuthMethod) requiresPasswordReset() bool {
+ return m == loginAuthMethodPassword
+}
+
// AuthService implements the auth service.
type AuthService struct {
v1connect.UnimplementedAuthServiceHandler
@@ -101,7 +142,7 @@ func (s *AuthService) Login(ctx context.Context, req *connect.Request[v1pb.Login
mfaSecondLogin := request.GetMfaTempToken() != ""
// 1. Authenticate user (password, IDP, or MFA completion)
- loginUser, err := s.authenticateLogin(ctx, request)
+ loginUser, loginMethod, err := s.authenticateLogin(ctx, request)
if err != nil {
return nil, err
}
@@ -133,7 +174,7 @@ func (s *AuthService) Login(ctx context.Context, req *connect.Request[v1pb.Login
}
// 4. Check if MFA challenge needed (returns early with temp token)
- if resp, err := s.checkMFARequired(ctx, loginUser, workspaceID, mfaSecondLogin); err != nil {
+ if resp, err := s.checkMFARequired(ctx, loginUser, workspaceID, mfaSecondLogin, loginMethod); err != nil {
return nil, err
} else if resp != nil {
return resp, nil
@@ -146,7 +187,7 @@ func (s *AuthService) Login(ctx context.Context, req *connect.Request[v1pb.Login
}
// 6. Build response and finalize
- requireResetPassword := s.needResetPassword(ctx, loginUser, workspaceID)
+ requireResetPassword := loginMethod.requiresPasswordReset() && s.needResetPassword(ctx, loginUser, workspaceID)
return s.finalizeLogin(ctx, req, loginUser, token, workspaceID, requireResetPassword)
}
@@ -934,55 +975,58 @@ func (s *AuthService) syncUserGroups(ctx context.Context, user *store.UserMessag
}
// authenticateLogin handles all authentication paths: password, IDP, or MFA completion.
-// Returns the authenticated user and whether password reset is required.
-func (s *AuthService) authenticateLogin(ctx context.Context, request *v1pb.LoginRequest) (*store.UserMessage, error) {
+func (s *AuthService) authenticateLogin(ctx context.Context, request *v1pb.LoginRequest) (*store.UserMessage, loginAuthMethod, error) {
mfaSecondLogin := request.GetMfaTempToken() != ""
if mfaSecondLogin {
return s.completeMFALogin(ctx, request)
}
- if request.GetIdpName() != "" {
- return s.getOrCreateUserWithIDP(ctx, request)
+ loginMethod := loginAuthMethodFromRequest(request)
+ if loginMethod == loginAuthMethodIDP {
+ user, err := s.getOrCreateUserWithIDP(ctx, request)
+ return user, loginAuthMethodIDP, err
}
- if request.EmailCode != nil && *request.EmailCode != "" {
- return s.authenticateEmailCodeLogin(ctx, request)
+ if loginMethod == loginAuthMethodEmailCode {
+ user, err := s.authenticateEmailCodeLogin(ctx, request)
+ return user, loginAuthMethodEmailCode, err
}
- return s.getAndVerifyUser(ctx, request)
+ user, err := s.getAndVerifyUser(ctx, request)
+ return user, loginAuthMethodPassword, err
}
// completeMFALogin validates MFA temp token and verifies OTP or recovery code.
-func (s *AuthService) completeMFALogin(ctx context.Context, request *v1pb.LoginRequest) (*store.UserMessage, error) {
- userEmail, err := auth.GetUserEmailFromMFATempToken(*request.MfaTempToken, s.secret)
+func (s *AuthService) completeMFALogin(ctx context.Context, request *v1pb.LoginRequest) (*store.UserMessage, loginAuthMethod, error) {
+ userEmail, loginMethod, err := loginAuthMethodFromMFATempToken(*request.MfaTempToken, s.secret)
if err != nil {
- return nil, err
+ return nil, loginAuthMethodPassword, err
}
user, err := s.store.GetUserByEmail(ctx, userEmail)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to find user"))
+ return nil, loginAuthMethodPassword, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to find user"))
}
if user == nil {
- return nil, invalidCredentialsError
+ return nil, loginAuthMethodPassword, invalidCredentialsError
}
if err := s.checkMFALockout(ctx, user.Email); err != nil {
- return nil, err
+ return nil, loginAuthMethodPassword, err
}
if request.OtpCode != nil {
if err := challengeMFACode(user, *request.OtpCode); err != nil {
- return nil, err
+ return nil, loginAuthMethodPassword, err
}
} else if request.RecoveryCode != nil {
if err := s.challengeRecoveryCode(ctx, user, *request.RecoveryCode); err != nil {
- return nil, err
+ return nil, loginAuthMethodPassword, err
}
} else {
- return nil, connect.NewError(connect.CodeUnauthenticated, errors.Errorf("OTP or recovery code is required for MFA"))
+ return nil, loginAuthMethodPassword, connect.NewError(connect.CodeUnauthenticated, errors.Errorf("OTP or recovery code is required for MFA"))
}
- return user, nil
+ return user, loginMethod, nil
}
// validateLoginPermissions checks if the user is allowed to login.
@@ -1036,7 +1080,7 @@ func (s *AuthService) validateLoginPermissions(ctx context.Context, user *store.
// checkMFARequired checks if MFA is required and returns a response with temp token if so.
// Returns (nil, nil) if MFA is not required or already completed.
-func (s *AuthService) checkMFARequired(ctx context.Context, user *store.UserMessage, workspaceID string, mfaSecondLogin bool) (*connect.Response[v1pb.LoginResponse], error) {
+func (s *AuthService) checkMFARequired(ctx context.Context, user *store.UserMessage, workspaceID string, mfaSecondLogin bool, loginMethod loginAuthMethod) (*connect.Response[v1pb.LoginResponse], error) {
if mfaSecondLogin {
return nil, nil
}
@@ -1047,7 +1091,7 @@ func (s *AuthService) checkMFARequired(ctx context.Context, user *store.UserMess
return nil, nil
}
- mfaTempToken, err := auth.GenerateMFATempToken(user.Email, s.secret, mfaTempTokenDuration)
+ mfaTempToken, err := auth.GenerateMFATempTokenWithLoginMethod(user.Email, string(loginMethod), s.secret, mfaTempTokenDuration)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to generate MFA temp token"))
}
@@ -1229,7 +1273,7 @@ func (s *AuthService) SwitchWorkspace(ctx context.Context, req *connect.Request[
}
} else {
// First step: check if MFA is required for the target workspace.
- if resp, err := s.checkMFARequired(ctx, user, workspaceID, false); err != nil {
+ if resp, err := s.checkMFARequired(ctx, user, workspaceID, false, loginAuthMethodPassword); err != nil {
return nil, err
} else if resp != nil {
return resp, nil
diff --git a/backend/api/v1/auth_service_test.go b/backend/api/v1/auth_service_test.go
index 2c9883f5b1..8fe629da81 100644
--- a/backend/api/v1/auth_service_test.go
+++ b/backend/api/v1/auth_service_test.go
@@ -2,6 +2,12 @@ package v1
import (
"testing"
+ "time"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/api/auth"
+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
)
func TestExtractDomain(t *testing.T) {
@@ -34,3 +40,85 @@ func TestExtractDomain(t *testing.T) {
}
}
}
+
+func TestLoginAuthMethodRequiresPasswordReset(t *testing.T) {
+ emailCode := "123456"
+ tests := []struct {
+ name string
+ request *v1pb.LoginRequest
+ want bool
+ }{
+ {
+ name: "password login enforces password reset",
+ request: &v1pb.LoginRequest{Email: "[email protected]", Password: "password"},
+ want: true,
+ },
+ {
+ name: "idp login skips password reset",
+ request: &v1pb.LoginRequest{IdpName: "idps/okta"},
+ want: false,
+ },
+ {
+ name: "email code login skips password reset",
+ request: &v1pb.LoginRequest{Email: "[email protected]", EmailCode: &emailCode},
+ want: false,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ got := loginAuthMethodFromRequest(test.request).requiresPasswordReset()
+ require.Equal(t, test.want, got)
+ })
+ }
+}
+
+func TestMFATempTokenPreservesLoginAuthMethod(t *testing.T) {
+ const secret = "test-secret"
+
+ tests := []struct {
+ name string
+ method loginAuthMethod
+ wantReset bool
+ wantMethod loginAuthMethod
+ }{
+ {
+ name: "password mfa completion enforces password reset",
+ method: loginAuthMethodPassword,
+ wantReset: true,
+ wantMethod: loginAuthMethodPassword,
+ },
+ {
+ name: "idp mfa completion skips password reset",
+ method: loginAuthMethodIDP,
+ wantReset: false,
+ wantMethod: loginAuthMethodIDP,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ token, err := auth.GenerateMFATempTokenWithLoginMethod("[email protected]", string(test.method), secret, time.Minute)
+ require.NoError(t, err)
+
+ email, method, err := loginAuthMethodFromMFATempToken(token, secret)
+ require.NoError(t, err)
+ require.Equal(t, "[email protected]", email)
+ require.Equal(t, test.wantMethod, method)
+ require.Equal(t, test.wantReset, method.requiresPasswordReset())
+ })
+ }
+}
+
+func TestLegacyMFATempTokenDefaultsToPasswordLoginAuthMethod(t *testing.T) {
+ const secret = "test-secret"
+
+ token, err := auth.GenerateMFATempToken("[email protected]", secret, time.Minute)
+ require.NoError(t, err)
+
+ email, method, err := loginAuthMethodFromMFATempToken(token, secret)
+ require.NoError(t, err)
+ require.Equal(t, "[email protected]", email)
+ require.Equal(t, loginAuthMethodPassword, method)
+ require.True(t, method.requiresPasswordReset())
+}
diff --git a/frontend/src/hooks/useAppState.test.tsx b/frontend/src/hooks/useAppState.test.tsx
index e8cea7d169..db5de71676 100644
--- a/frontend/src/hooks/useAppState.test.tsx
+++ b/frontend/src/hooks/useAppState.test.tsx
@@ -58,12 +58,39 @@ describe("useRecentProjects", () => {
const { result } = renderHook(() => useRecentProjects());
await waitFor(() => {
- expect(mocks.batchFetchProjects).toHaveBeenCalledWith(["projects/app"]);
+ expect(mocks.batchFetchProjects).toHaveBeenCalledWith(
+ ["projects/app"],
+ true
+ );
});
expect(result.current.projects).toEqual([]);
});
+ test("loads recent projects silently and omits inaccessible cached projects", async () => {
+ const accessibleProject = { name: "projects/app" } as Project;
+ localStorage.setItem(
+ recentProjectsKey,
+ JSON.stringify(["projects/app", "projects/removed"])
+ );
+ mocks.getProjectByName.mockImplementation((name: string) =>
+ name === accessibleProject.name
+ ? accessibleProject
+ : { name: "projects/-1" }
+ );
+
+ const { result } = renderHook(() => useRecentProjects());
+
+ await waitFor(() => {
+ expect(mocks.batchFetchProjects).toHaveBeenCalledWith(
+ ["projects/app", "projects/removed"],
+ true
+ );
+ });
+
+ expect(result.current.projects).toEqual([accessibleProject]);
+ });
+
test("keeps the synthesized default project when requested", async () => {
localStorage.setItem(
recentProjectsKey,
diff --git a/frontend/src/hooks/useAppState.ts b/frontend/src/hooks/useAppState.ts
index 0474154e2f..cf65110d58 100644
--- a/frontend/src/hooks/useAppState.ts
+++ b/frontend/src/hooks/useAppState.ts
@@ -456,7 +456,7 @@ export function useRecentProjects({
useEffect(() => {
if (projectNames.length > 0) {
- void batchFetchProjects(projectNames);
+ void batchFetchProjects(projectNames, true);
}
}, [batchFetchProjects, projectNames]);