Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🛂 fix: Rate Limit Authenticated 2FA Management (#16565)

Danny Avilad33c72e6a8b4
diff --git a/api/server/routes/auth.2fa-ratelimit.test.js b/api/server/routes/auth.2fa-ratelimit.test.js
index c352fd64bf..be769e7b37 100644
--- a/api/server/routes/auth.2fa-ratelimit.test.js
+++ b/api/server/routes/auth.2fa-ratelimit.test.js
@@ -7,6 +7,11 @@ const mockCheckBan = jest.fn((req, res, next) => next());
const mockVerify2FAWithTempToken = jest.fn((req, res) => res.status(204).end());
jest.mock('@librechat/api', () => ({
+ limiterCache: jest.fn(() => undefined),
+ createTwoFactorManagementLimiter: (...args) =>
+ require('../../../packages/api/src/middleware/twoFactor').createTwoFactorManagementLimiter(
+ ...args,
+ ),
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
forceRefreshCloudFrontAuthCookies: jest.fn(),
}));
@@ -45,7 +50,7 @@ jest.mock('~/models', () => ({
}));
jest.mock('~/server/services/Config', () => ({
- getAppConfig: jest.fn(),
+ getAppConfig: jest.fn(async () => ({ config: { rateLimits: {} } })),
}));
jest.mock('~/server/middleware', () => {
@@ -66,10 +71,108 @@ jest.mock('~/server/middleware', () => {
resetPasswordLimiter: pass,
resetPasswordSubmissionLimiter: pass,
validatePasswordReset: pass,
- requireJwtAuth: pass,
+ requireJwtAuth: (req, res, next) => {
+ if (!req.headers['x-user']) return res.sendStatus(401);
+ req.user = { id: req.headers['x-user'], tenantId: req.headers['x-tenant'] };
+ next();
+ },
};
});
+describe('authenticated 2FA management budget', () => {
+ let app;
+ const paths = ['enable', 'verify', 'confirm', 'disable', 'backup/regenerate'];
+ beforeEach(() => {
+ require('~/server/services/Config').getAppConfig.mockResolvedValue({
+ config: { rateLimits: {} },
+ });
+ app = express();
+ app.use(express.json());
+ app.use('/api/auth', authRouter);
+ });
+
+ it('shares one budget across routes and rejects before invoking the controller', async () => {
+ for (let i = 0; i < 7; i++) {
+ await request(app)
+ .post(`/api/auth/2fa/${paths[i % paths.length]}`)
+ .set('x-user', 'cross-route-user')
+ .send({ token: '111111' })
+ .expect(204);
+ }
+ const controllers = require('~/server/controllers/TwoFactorController');
+ const calls = controllers.regenerateBackupCodes.mock.calls.length;
+ const blocked = await request(app)
+ .post('/api/auth/2fa/backup/regenerate')
+ .set('x-user', 'cross-route-user')
+ .send({ token: '111111' })
+ .expect(429);
+ expect(blocked.headers['retry-after']).toBeDefined();
+ expect(controllers.regenerateBackupCodes.mock.calls).toHaveLength(calls);
+ await request(app).post('/api/auth/2fa/disable').set('x-user', 'cross-route-user').expect(429);
+ });
+
+ it('isolates accounts and tenants and authenticates before counting', async () => {
+ const controllers = require('~/server/controllers/TwoFactorController');
+ const calls = controllers.regenerateBackupCodes.mock.calls.length;
+ for (let i = 0; i < 8; i++) {
+ await request(app).post('/api/auth/2fa/backup/regenerate').expect(401);
+ }
+ expect(controllers.regenerateBackupCodes.mock.calls).toHaveLength(calls);
+ for (let i = 0; i < 7; i++) {
+ await request(app)
+ .post('/api/auth/2fa/verify')
+ .set('x-user', 'tenant-user')
+ .set('x-tenant', 'one')
+ .expect(204);
+ }
+ await request(app)
+ .post('/api/auth/2fa/verify')
+ .set('x-user', 'tenant-user')
+ .set('x-tenant', 'one')
+ .expect(429);
+ await request(app)
+ .post('/api/auth/2fa/verify')
+ .set('x-user', 'tenant-user')
+ .set('x-tenant', 'two')
+ .expect(204);
+ await request(app)
+ .post('/api/auth/2fa/verify')
+ .set('x-user', 'other-user')
+ .set('x-tenant', 'one')
+ .expect(204);
+ });
+
+ it('admits only seven concurrent requests across operations', async () => {
+ const responses = await Promise.all(
+ Array.from({ length: 20 }, (_, i) =>
+ request(app)
+ .post(`/api/auth/2fa/${paths[i % paths.length]}`)
+ .set('x-user', 'concurrent-user')
+ .send({ token: '111111' }),
+ ),
+ );
+ expect(responses.filter(({ status }) => status === 204)).toHaveLength(7);
+ expect(responses.filter(({ status }) => status === 429)).toHaveLength(13);
+ });
+
+ it('admits the entire setup sequence with the minimum configured budget', async () => {
+ require('~/server/services/Config').getAppConfig.mockResolvedValue({
+ config: { rateLimits: { twoFactorManagement: { requestsPerFiveMinutes: 3 } } },
+ });
+ for (const operation of ['enable', 'verify', 'confirm']) {
+ await request(app)
+ .post(`/api/auth/2fa/${operation}`)
+ .set('x-user', 'minimum-budget-user')
+ .expect(204);
+ }
+ const blocked = await request(app)
+ .post('/api/auth/2fa/verify')
+ .set('x-user', 'minimum-budget-user')
+ .expect(429);
+ expect(blocked.headers['ratelimit-limit']).toBe('3');
+ });
+});
+
const authRouter = require('./auth');
describe('POST /api/auth/2fa/verify-temp rate limiting', () => {
diff --git a/api/server/routes/auth.cloudfront.test.js b/api/server/routes/auth.cloudfront.test.js
index ed7803d573..e5487096a8 100644
--- a/api/server/routes/auth.cloudfront.test.js
+++ b/api/server/routes/auth.cloudfront.test.js
@@ -4,6 +4,8 @@ const request = require('supertest');
const mockForceRefreshCloudFrontAuthCookies = jest.fn();
jest.mock('@librechat/api', () => ({
+ limiterCache: jest.fn(),
+ createTwoFactorManagementLimiter: jest.fn(() => (req, res, next) => next()),
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
forceRefreshCloudFrontAuthCookies: (...args) => mockForceRefreshCloudFrontAuthCookies(...args),
}));
diff --git a/api/server/routes/auth.js b/api/server/routes/auth.js
index 99a2094492..cd5d0347da 100644
--- a/api/server/routes/auth.js
+++ b/api/server/routes/auth.js
@@ -1,5 +1,10 @@
const express = require('express');
-const { createSetBalanceConfig, forceRefreshCloudFrontAuthCookies } = require('@librechat/api');
+const {
+ limiterCache,
+ createSetBalanceConfig,
+ createTwoFactorManagementLimiter,
+ forceRefreshCloudFrontAuthCookies,
+} = require('@librechat/api');
const {
resetPasswordRequestController,
resetPasswordController,
@@ -28,6 +33,10 @@ const setBalanceConfig = createSetBalanceConfig({
});
const router = express.Router();
+const twoFactorManagementLimiter = createTwoFactorManagementLimiter({
+ getAppConfig: () => getAppConfig({ baseOnly: true }),
+ store: limiterCache('two_factor_management_user_limiter'),
+});
const getCloudFrontAuthCookieRefreshResult = (req, res) => {
const warmedResult = req.cloudFrontAuthCookieRefreshResult;
if (warmedResult && (warmedResult.attempted || !warmedResult.enabled)) {
@@ -88,8 +97,8 @@ router.post(
resetPasswordController,
);
-router.post('/2fa/enable', middleware.requireJwtAuth, enable2FA);
-router.post('/2fa/verify', middleware.requireJwtAuth, verify2FA);
+router.post('/2fa/enable', middleware.requireJwtAuth, twoFactorManagementLimiter, enable2FA);
+router.post('/2fa/verify', middleware.requireJwtAuth, twoFactorManagementLimiter, verify2FA);
router.post(
'/2fa/verify-temp',
middleware.requireSameOrigin,
@@ -98,9 +107,14 @@ router.post(
middleware.checkBan,
verify2FAWithTempToken,
);
-router.post('/2fa/confirm', middleware.requireJwtAuth, confirm2FA);
-router.post('/2fa/disable', middleware.requireJwtAuth, disable2FA);
-router.post('/2fa/backup/regenerate', middleware.requireJwtAuth, regenerateBackupCodes);
+router.post('/2fa/confirm', middleware.requireJwtAuth, twoFactorManagementLimiter, confirm2FA);
+router.post('/2fa/disable', middleware.requireJwtAuth, twoFactorManagementLimiter, disable2FA);
+router.post(
+ '/2fa/backup/regenerate',
+ middleware.requireJwtAuth,
+ twoFactorManagementLimiter,
+ regenerateBackupCodes,
+);
router.get('/graph-token', middleware.requireJwtAuth, graphTokenController);
diff --git a/api/server/routes/auth.reset-password-ratelimit.test.js b/api/server/routes/auth.reset-password-ratelimit.test.js
index 5aeebef408..74ea8c923c 100644
--- a/api/server/routes/auth.reset-password-ratelimit.test.js
+++ b/api/server/routes/auth.reset-password-ratelimit.test.js
@@ -7,6 +7,8 @@ const mockValidatePasswordReset = jest.fn((req, res, next) => next());
const mockResetPasswordController = jest.fn((req, res) => res.status(204).end());
jest.mock('@librechat/api', () => ({
+ limiterCache: jest.fn(),
+ createTwoFactorManagementLimiter: jest.fn(() => (req, res, next) => next()),
createSetBalanceConfig: jest.fn(() => (req, res, next) => next()),
forceRefreshCloudFrontAuthCookies: jest.fn(),
}));
diff --git a/client/src/components/Nav/SettingsTabs/Account/BackupCodesItem.tsx b/client/src/components/Nav/SettingsTabs/Account/BackupCodesItem.tsx
index 7427e59753..466da0dda9 100644
--- a/client/src/components/Nav/SettingsTabs/Account/BackupCodesItem.tsx
+++ b/client/src/components/Nav/SettingsTabs/Account/BackupCodesItem.tsx
@@ -26,12 +26,14 @@ import type {
} from 'librechat-data-provider';
import { useRegenerateBackupCodesMutation } from '~/data-provider';
import { useAuthContext, useLocalize } from '~/hooks';
+import { useTwoFactorError } from './errors';
import store from '~/store';
const BackupCodesItem: React.FC = () => {
const localize = useLocalize();
const { user } = useAuthContext();
const { showToast } = useToastContext();
+ const showError = useTwoFactorError();
const setUser = useSetRecoilState(store.user);
const [isDialogOpen, setDialogOpen] = useState<boolean>(false);
const [otpToken, setOtpToken] = useState('');
@@ -69,11 +71,7 @@ const BackupCodesItem: React.FC = () => {
URL.revokeObjectURL(url);
}
},
- onError: () =>
- showToast({
- message: localize('com_ui_backup_codes_regenerate_error'),
- status: 'error',
- }),
+ onError: (error) => showError(error, 'com_ui_backup_codes_regenerate_error'),
});
};
diff --git a/client/src/components/Nav/SettingsTabs/Account/TwoFactorAuthentication.tsx b/client/src/components/Nav/SettingsTabs/Account/TwoFactorAuthentication.tsx
index df860b2b7f..cf3f1b9392 100644
--- a/client/src/components/Nav/SettingsTabs/Account/TwoFactorAuthentication.tsx
+++ b/client/src/components/Nav/SettingsTabs/Account/TwoFactorAuthentication.tsx
@@ -21,6 +21,7 @@ import {
import { SetupPhase, QRPhase, VerifyPhase, BackupPhase, DisablePhase } from './TwoFactorPhases';
import { DisableTwoFactorToggle } from './DisableTwoFactorToggle';
import { useAuthContext, useLocalize } from '~/hooks';
+import { useTwoFactorError } from './errors';
import store from '~/store';
export type Phase = 'setup' | 'qr' | 'verify' | 'backup' | 'disable';
@@ -36,6 +37,7 @@ const TwoFactorAuthentication: React.FC = () => {
const { user } = useAuthContext();
const setUser = useSetRecoilState(store.user);
const { showToast } = useToastContext();
+ const showError = useTwoFactorError();
const buttonRef = useRef<HTMLButtonElement>(null);
const [secret, setSecret] = useState<string>('');
@@ -66,8 +68,7 @@ const TwoFactorAuthentication: React.FC = () => {
const resetState = useCallback(() => {
if (user?.twoFactorEnabled && otpauthUrl) {
disable2FAMutate(undefined, {
- onError: () =>
- showToast({ message: localize('com_ui_2fa_disable_error'), status: 'error' }),
+ onError: (error) => showError(error, 'com_ui_2fa_disable_error'),
});
}
@@ -78,7 +79,7 @@ const TwoFactorAuthentication: React.FC = () => {
setDisableToken('');
setPhase(user?.twoFactorEnabled ? 'disable' : 'setup');
setDownloaded(false);
- }, [user, otpauthUrl, disable2FAMutate, localize, showToast]);
+ }, [user, otpauthUrl, disable2FAMutate, showError]);
const handleGenerateQRCode = useCallback(() => {
enable2FAMutate(undefined, {
@@ -88,9 +89,9 @@ const TwoFactorAuthentication: React.FC = () => {
setBackupCodes(backupCodes);
setPhase('qr');
},
- onError: () => showToast({ message: localize('com_ui_2fa_generate_error'), status: 'error' }),
+ onError: (error) => showError(error, 'com_ui_2fa_generate_error'),
});
- }, [enable2FAMutate, localize, showToast]);
+ }, [enable2FAMutate, showError]);
const handleVerify = useCallback(() => {
if (!verificationToken) {
@@ -106,15 +107,14 @@ const TwoFactorAuthentication: React.FC = () => {
{ token: verificationToken },
{
onSuccess: () => setPhase('backup'),
- onError: () =>
- showToast({ message: localize('com_ui_2fa_invalid'), status: 'error' }),
+ onError: (error) => showError(error, 'com_ui_2fa_invalid'),
},
);
},
- onError: () => showToast({ message: localize('com_ui_2fa_invalid'), status: 'error' }),
+ onError: (error) => showError(error, 'com_ui_2fa_invalid'),
},
);
- }, [verificationToken, verify2FAMutate, confirm2FAMutate, localize, showToast]);
+ }, [verificationToken, verify2FAMutate, confirm2FAMutate, localize, showToast, showError]);
const handleDownload = useCallback(() => {
if (!backupCodes.length) {
@@ -184,10 +184,10 @@ const TwoFactorAuthentication: React.FC = () => {
setPhase('setup');
setOtpauthUrl('');
},
- onError: () => showToast({ message: localize('com_ui_2fa_invalid'), status: 'error' }),
+ onError: (error) => showError(error, 'com_ui_2fa_invalid'),
});
},
- [disable2FAMutate, showToast, localize, setUser],
+ [disable2FAMutate, showToast, localize, setUser, showError],
);
return (
diff --git a/client/src/components/Nav/SettingsTabs/Account/__tests__/errors.spec.ts b/client/src/components/Nav/SettingsTabs/Account/__tests__/errors.spec.ts
new file mode 100644
index 0000000000..deea5bdb52
--- /dev/null
+++ b/client/src/components/Nav/SettingsTabs/Account/__tests__/errors.spec.ts
@@ -0,0 +1,46 @@
+import { getTwoFactorError } from '../errors';
+
+const limited = (retryAfter?: string | number) => ({
+ isAxiosError: true,
+ response: {
+ status: 429,
+ data: { code: 'TWO_FACTOR_RATE_LIMITED' },
+ headers: { 'retry-after': retryAfter },
+ },
+});
+
+describe('2FA error guidance', () => {
+ it('uses the retry interval without labeling a throttled code as invalid', () => {
+ expect(getTwoFactorError(limited('42'), 'com_ui_2fa_invalid')).toEqual({
+ key: 'com_ui_2fa_rate_limited_retry',
+ seconds: 42,
+ });
+ });
+
+ it.each([undefined, '', 'bad', '-1', '0', 'Infinity', '9999999999'])(
+ 'falls back safely for %s',
+ (header) => {
+ expect(getTwoFactorError(limited(header), 'com_ui_2fa_invalid')).toEqual({
+ key: 'com_ui_2fa_rate_limited',
+ });
+ },
+ );
+
+ it('handles an older server without the new error code', () => {
+ const error = limited(5);
+ error.response.data = { code: '' };
+ expect(getTwoFactorError(error, 'com_ui_2fa_invalid').seconds).toBe(5);
+ });
+
+ it('preserves invalid-factor and network error fallbacks without exposing server details', () => {
+ expect(
+ getTwoFactorError(
+ { isAxiosError: true, response: { status: 400, data: { message: 'secret' } } },
+ 'com_ui_2fa_invalid',
+ ),
+ ).toEqual({ key: 'com_ui_2fa_invalid' });
+ expect(getTwoFactorError(new Error('secret'), 'com_ui_backup_codes_regenerate_error')).toEqual({
+ key: 'com_ui_backup_codes_regenerate_error',
+ });
+ });
+});
diff --git a/client/src/components/Nav/SettingsTabs/Account/errors.ts b/client/src/components/Nav/SettingsTabs/Account/errors.ts
new file mode 100644
index 0000000000..f545a7e8ce
--- /dev/null
+++ b/client/src/components/Nav/SettingsTabs/Account/errors.ts
@@ -0,0 +1,36 @@
+import { useCallback } from 'react';
+import axios from 'axios';
+import { useToastContext } from '@librechat/client';
+import type { TranslationKeys } from '~/hooks/useLocalize';
+import { useLocalize } from '~/hooks';
+
+export function getTwoFactorError(
+ error: unknown,
+ fallback: TranslationKeys,
+): {
+ key: TranslationKeys;
+ seconds?: number;
+} {
+ if (!axios.isAxiosError(error) || error.response?.status !== 429) {
+ return { key: fallback };
+ }
+ // Recognize status alone too, for compatibility with an older server during rollout.
+ const raw = error.response.headers?.['retry-after'];
+ const seconds = typeof raw === 'string' || typeof raw === 'number' ? Number(raw) : NaN;
+ if (Number.isFinite(seconds) && seconds > 0 && seconds <= 300) {
+ return { key: 'com_ui_2fa_rate_limited_retry', seconds: Math.ceil(seconds) };
+ }
+ return { key: 'com_ui_2fa_rate_limited' };
+}
+
+export function useTwoFactorError() {
+ const localize = useLocalize();
+ const { showToast } = useToastContext();
+ return useCallback(
+ (error: unknown, fallback: TranslationKeys) => {
+ const { key, seconds } = getTwoFactorError(error, fallback);
+ showToast({ message: localize(key, { seconds }), status: 'error' });
+ },
+ [localize, showToast],
+ );
+}
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index a74bc7141f..2d81936fa7 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -507,6 +507,8 @@
"com_error_auth_banned": "Access is blocked for this account or address. Ask an administrator to review it.",
"com_error_auth_failed": "Your session could not be verified. Sign in again, then resend the message.",
"com_error_auth_rate_limited": "Too many attempts in a short time. Wait a moment and try again.",
+ "com_ui_2fa_rate_limited": "Too many two-factor authentication attempts. Wait a few minutes and try again.",
+ "com_ui_2fa_rate_limited_retry": "Too many two-factor authentication attempts. Try again in {{seconds}} seconds.",
"com_error_ban": "Your account is temporarily banned for violating the terms of service.",
"com_error_code_workspace_invalid": "The workspace selection is invalid; select an available workspace.",
"com_error_code_workspace_locked": "This chat already uses a different code environment. Continue with its original environment or start a new chat.",
diff --git a/e2e/specs/mock/two-factor.spec.ts b/e2e/specs/mock/two-factor.spec.ts
index d1f3245179..40da3dba61 100644
--- a/e2e/specs/mock/two-factor.spec.ts
+++ b/e2e/specs/mock/two-factor.spec.ts
@@ -11,6 +11,53 @@ import { NEW_CHAT_PATH } from './helpers';
* via `e2e:prepare`), matching the original report.
*/
test.describe('account settings · two-factor dialog', () => {
+ test('shows retry guidance when the authenticated account budget is exhausted', async ({
+ page,
+ }) => {
+ test.setTimeout(60000);
+ await page.goto(NEW_CHAT_PATH);
+ await page.getByTestId('nav-user').click();
+ await page.getByRole('menuitem', { name: 'Settings' }).click();
+ await page.getByRole('tab', { name: 'Account' }).click();
+ await page.getByRole('button', { name: 'Enable 2FA' }).click();
+
+ const enabling = page.waitForResponse((response) =>
+ response.url().endsWith('/api/auth/2fa/enable'),
+ );
+ await page.getByRole('button', { name: 'Generate QR Code' }).click();
+ const enabled = await enabling;
+ expect(enabled.status()).toBe(200);
+ const authorization = enabled.request().headers().authorization;
+ expect(authorization).toBeTruthy();
+ await page.getByRole('button', { name: 'Continue', exact: true }).click();
+
+ // The real server has admitted setup once. Consume the remaining six attempts
+ // without producing UI toasts, then exercise the seventh verification in the UI.
+ for (let i = 0; i < 6; i++) {
+ const response = await page.request.post('/api/auth/2fa/verify', {
+ headers: { authorization },
+ data: { token: 'invalid' },
+ });
+ expect(response.status()).toBe(400);
+ }
+ await page.getByRole('textbox').last().fill('000000');
+ const rejected = page.waitForResponse((response) =>
+ response.url().endsWith('/api/auth/2fa/verify'),
+ );
+ await page.getByRole('button', { name: 'Verify', exact: true }).click();
+ const response = await rejected;
+ expect(response.status()).toBe(429);
+ expect((await response.json()).code).toBe('TWO_FACTOR_RATE_LIMITED');
+ await expect(
+ page
+ .getByText(/Too many two-factor authentication attempts\. Try again in \d+ seconds\./)
+ .first(),
+ ).toBeVisible();
+ await expect(
+ page.getByText('Invalid two-factor authentication code', { exact: true }),
+ ).toHaveCount(0);
+ });
+
test('opening the Enable 2FA dialog renders without a framer-motion crash', async ({ page }) => {
test.setTimeout(60000);
diff --git a/librechat.example.yaml b/librechat.example.yaml
index 81322cae58..8d0f893c9b 100644
--- a/librechat.example.yaml
+++ b/librechat.example.yaml
@@ -426,6 +426,11 @@ registration:
# - '127.0.0.1:8080'
# rateLimits:
+# # Shared account budget for all authenticated 2FA management operations.
+# # Always active; successful and failed requests count. Uses Redis when enabled.
+# # Minimum 3, so enable -> verify -> confirm can complete within one window.
+# twoFactorManagement:
+# requestsPerFiveMinutes: 7
# # Authenticated agent-event admission has its own API-key-principal bucket.
# agentEvents:
# userMax: 40
diff --git a/packages/api/src/middleware/index.ts b/packages/api/src/middleware/index.ts
index 6373e1dc96..6aa475a45b 100644
--- a/packages/api/src/middleware/index.ts
+++ b/packages/api/src/middleware/index.ts
@@ -28,3 +28,4 @@ export * from './feedback';
export * from './generationRetry';
export * from './code';
export * from './management';
+export * from './twoFactor';
diff --git a/packages/api/src/middleware/twoFactor.spec.ts b/packages/api/src/middleware/twoFactor.spec.ts
new file mode 100644
index 0000000000..ddd762d4d6
--- /dev/null
+++ b/packages/api/src/middleware/twoFactor.spec.ts
@@ -0,0 +1,63 @@
+import express from 'express';
+import request from 'supertest';
+import type { AppConfig } from '@librechat/data-schemas';
+import { createTwoFactorManagementLimiter } from './twoFactor';
+
+describe('createTwoFactorManagementLimiter', () => {
+ afterEach(() => jest.useRealTimers());
+
+ function createApp(max = 2) {
+ const getAppConfig = jest.fn(
+ async () =>
+ ({
+ config: { rateLimits: { twoFactorManagement: { requestsPerFiveMinutes: max } } },
+ }) as AppConfig,
+ );
+ const app = express();
+ app.use((req, _res, next) => {
+ if (req.headers['x-user']) {
+ Object.assign(req, { user: { _id: req.get('x-user') } });
+ }
+ next();
+ });
+ app.use(createTwoFactorManagementLimiter({ getAppConfig }));
+ app.post('/', (_req, res) => {
+ res.sendStatus(400);
+ });
+ return { app, getAppConfig };
+ }
+
+ it('counts failed verification and respects configured budgets and Mongo-style identity', async () => {
+ const { app } = createApp();
+ await request(app).post('/').set('x-user', 'account').expect(400);
+ await request(app).post('/').set('x-user', 'account').expect(400);
+ const blocked = await request(app).post('/').set('x-user', 'account').expect(429);
+ expect(blocked.body).toEqual({
+ code: 'TWO_FACTOR_RATE_LIMITED',
+ message: 'Too many verification attempts. Try again later.',
+ });
+ });
+
+ it('rejects missing identity without consulting configuration', async () => {
+ const { app, getAppConfig } = createApp();
+ await request(app).post('/').expect(401);
+ expect(getAppConfig).not.toHaveBeenCalled();
+ });
+
+ it('restores the budget after five minutes', async () => {
+ jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate'] });
+ const { app } = createApp(1);
+ await request(app).post('/').set('x-user', 'account').expect(400);
+ await request(app).post('/').set('x-user', 'account').expect(429);
+ jest.advanceTimersByTime(5 * 60 * 1000);
+ const restored = await request(app).post('/').set('x-user', 'account').expect(400);
+ expect(restored.headers['ratelimit-remaining']).toBe('0');
+ });
+
+ it('does not admit verification when configuration loading fails', async () => {
+ const { app, getAppConfig } = createApp();
+ getAppConfig.mockRejectedValueOnce(new Error('unavailable'));
+ await request(app).post('/').set('x-user', 'account').expect(500);
+ expect(getAppConfig).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/api/src/middleware/twoFactor.ts b/packages/api/src/middleware/twoFactor.ts
new file mode 100644
index 0000000000..b061db39fa
--- /dev/null
+++ b/packages/api/src/middleware/twoFactor.ts
@@ -0,0 +1,43 @@
+import { rateLimit } from 'express-rate-limit';
+import type { AppConfig } from '@librechat/data-schemas';
+import type { Store } from 'express-rate-limit';
+import type { RequestHandler } from 'express';
+import type { ServerRequest } from '~/types/http';
+
+/** One admission budget across all authenticated factor checks, including concurrent requests.
+ * Count successes too: resetting on success would let setup/verification replenish the budget.
+ * The five-minute window matches the existing login verification limiter. */
+export function createTwoFactorManagementLimiter({
+ getAppConfig,
+ store,
+}: {
+ getAppConfig: () => Promise<AppConfig>;
+ store?: Store;
+}): RequestHandler {
+ const limiter = rateLimit({
+ windowMs: 5 * 60 * 1000,
+ max: async () =>
+ (await getAppConfig()).config?.rateLimits?.twoFactorManagement?.requestsPerFiveMinutes ?? 7,
+ standardHeaders: true,
+ legacyHeaders: false,
+ keyGenerator: (req) => {
+ const user = (req as ServerRequest).user;
+ return JSON.stringify([user?.tenantId ?? null, user?.id ?? user?._id?.toString()]);
+ },
+ handler: (_req, res) => {
+ res.status(429).json({
+ code: 'TWO_FACTOR_RATE_LIMITED',
+ message: 'Too many verification attempts. Try again later.',
+ });
+ },
+ store,
+ });
+ return (req, res, next) => {
+ const user = (req as ServerRequest).user;
+ if (!user?.id && !user?._id) {
+ res.sendStatus(401);
+ return;
+ }
+ return limiter(req, res, next);
+ };
+}
diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.ts
index dfc4bf8a03..4d0c2648e3 100644
--- a/packages/data-provider/src/config.spec.ts
+++ b/packages/data-provider/src/config.spec.ts
@@ -27,6 +27,30 @@ const endpointsConfig: TEndpointsConfig = {
Gemini: { type: EModelEndpoint.custom, userProvide: false, order: 9999 },
};
+describe('authenticated 2FA management rate limits', () => {
+ it('accepts an account budget and defaults an empty configuration to seven requests', () => {
+ for (const [input, expected] of [
+ [{}, 7],
+ [{ requestsPerFiveMinutes: 3 }, 3],
+ ] as const) {
+ const result = configSchema.parse({
+ version: '1.0',
+ rateLimits: { twoFactorManagement: input },
+ });
+ expect(result.rateLimits?.twoFactorManagement?.requestsPerFiveMinutes).toBe(expected);
+ }
+ });
+
+ it.each([0, -1, 1, 2, 1.5, Infinity, '7'])('rejects an invalid budget: %s', (value) => {
+ expect(
+ configSchema.safeParse({
+ version: '1.0',
+ rateLimits: { twoFactorManagement: { requestsPerFiveMinutes: value } },
+ }).success,
+ ).toBe(false);
+ });
+});
+
describe('tenant-scoped custom endpoints', () => {
const endpoint = {
name: 'Private Gateway',
diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts
index a8e86e9dfe..8f858dd872 100644
--- a/packages/data-provider/src/config.ts
+++ b/packages/data-provider/src/config.ts
@@ -2053,6 +2053,12 @@ export enum RateLimitPrefix {
}
export const rateLimitSchema = z.object({
+ twoFactorManagement: z
+ .object({
+ /** Shared budget; setup needs enable, verify, and confirm within five minutes. */
+ requestsPerFiveMinutes: z.number().int().min(3).optional().default(7),
+ })
+ .optional(),
agentEvents: z
.object({
userMax: z.number().int().positive().optional(),