From eefeb2a7f9f0d7b5d642dfd3cdd780f252638e3b Mon Sep 17 00:00:00 2001 From: Marco Beretta <81851188+berry-13@users.noreply.github.com> Date: Fri, 25 Sep 2026 11:34:06 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9A=99=EF=B8=8F=20feat:=20Make=20the=20Per-U?= =?UTF-8?q?ser=20Passkey=20Cap=20Configurable=20(#16259)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit (cherry picked from commit 84180a87e2d43d5b469105cc42db7b447c18a7e2) Original-PR: https://github.com/LibreChat-AI/LibreChat/pull/16259 --- .env.example | 3 + .../controllers/auth/PasskeyController.js | 2 + .../auth/PasskeyController.spec.js | 3 + api/server/routes/__tests__/config.spec.js | 19 ++ api/server/routes/config.js | 2 + .../Account/Passkeys/Passkeys.tsx | 9 +- .../Passkeys/__tests__/Passkeys.spec.tsx | 19 ++ e2e/specs/mock/scenarios/passkeys.spec.ts | 104 ++++++++++ librechat.example.yaml | 5 + packages/api/src/app/AppService.spec.ts | 5 + packages/api/src/auth/passkey.spec.ts | 47 +++++ packages/api/src/auth/passkey.ts | 27 ++- .../api/src/auth/passkey/handlers.spec.ts | 187 +++++++++++++++++- packages/api/src/auth/passkey/handlers.ts | 51 ++++- packages/data-provider/src/config.spec.ts | 16 ++ packages/data-provider/src/config.ts | 10 + packages/data-schemas/src/app/service.ts | 1 + packages/data-schemas/src/types/app.ts | 2 + 18 files changed, 501 insertions(+), 11 deletions(-) diff --git a/.env.example b/.env.example index 5fb11aa22b..19e0e6155a 100644 --- a/.env.example +++ b/.env.example @@ -948,6 +948,9 @@ APPLE_CALLBACK_URL=/oauth/apple/callback # Passkeys (WebAuthn) # Requires HTTPS in production; localhost is exempt. ALLOW_PASSKEY_LOGIN=false +# Optional. Passkeys each account may enroll (1-100). A librechat.yaml +# `passkeys.perUserMax` overrides this; both default to 20. +# MAX_PASSKEYS_PER_USER=20 # Optional. Defaults to the hostname of DOMAIN_CLIENT. Pin this if DOMAIN_CLIENT # may change: existing passkeys stop working when the RP ID changes. # PASSKEY_RP_ID= diff --git a/api/server/controllers/auth/PasskeyController.js b/api/server/controllers/auth/PasskeyController.js index dd6c830755..be868be15a 100644 --- a/api/server/controllers/auth/PasskeyController.js +++ b/api/server/controllers/auth/PasskeyController.js @@ -3,12 +3,14 @@ const { CacheKeys } = require('librechat-data-provider'); const { createPasskeyHandlers } = require('@librechat/api'); const { checkBan } = require('~/server/middleware'); const { getLogStores } = require('~/cache'); +const { getAppConfig } = require('~/server/services/Config/app'); const db = require('~/models'); module.exports = createPasskeyHandlers({ checkBan, compare: bcrypt.compare, getChallengeCache: () => getLogStores(CacheKeys.PASSKEY_CHALLENGE), + getAppConfig, getUserById: db.getUserById, updateUser: db.updateUser, createPasskey: db.createPasskey, diff --git a/api/server/controllers/auth/PasskeyController.spec.js b/api/server/controllers/auth/PasskeyController.spec.js index ee7b317e84..2c3c89b030 100644 --- a/api/server/controllers/auth/PasskeyController.spec.js +++ b/api/server/controllers/auth/PasskeyController.spec.js @@ -1,5 +1,7 @@ const mockCheckBan = jest.fn(); const mockGetLogStores = jest.fn(); +const mockGetAppConfig = jest.fn(); +jest.mock('~/server/services/Config/app', () => ({ getAppConfig: mockGetAppConfig })); const mockModels = { getUserById: jest.fn(), updateUser: jest.fn(), @@ -69,6 +71,7 @@ describe('PasskeyController wiring', () => { it('hands the model methods, bcrypt and the ban check to the handler factory', () => { expect(deps.compare).toBe(bcrypt.compare); + expect(deps.getAppConfig).toBe(mockGetAppConfig); for (const name of Object.keys(mockModels)) { expect(deps[name]).toBe(mockModels[name]); } diff --git a/api/server/routes/__tests__/config.spec.js b/api/server/routes/__tests__/config.spec.js index 42848ffb4a..df9d4eda5b 100644 --- a/api/server/routes/__tests__/config.spec.js +++ b/api/server/routes/__tests__/config.spec.js @@ -1082,3 +1082,22 @@ describe('GET /api/config', () => { }); }); }); + +describe('passkey enrollment cap', () => { + it('publishes the cap normalized from YAML only after authentication', async () => { + const { AppService } = require('@librechat/data-schemas'); + const appConfig = await AppService({ config: { passkeys: { perUserMax: 2 } } }); + mockGetAppConfig.mockResolvedValue(appConfig); + + const authenticated = await request(createApp(mockUser)).get('/api/config'); + expect(authenticated.status).toBe(200); + expect(authenticated.body.maxPasskeysPerUser).toBe(2); + expect(mockGetAppConfig).toHaveBeenCalledWith( + expect.objectContaining({ userId: mockUser.id, role: mockUser.role }), + ); + + const anonymous = await request(createApp()).get('/api/config'); + expect(anonymous.status).toBe(200); + expect(anonymous.body).not.toHaveProperty('maxPasskeysPerUser'); + }); +}); diff --git a/api/server/routes/config.js b/api/server/routes/config.js index f0e5b456a2..1648edd6cf 100644 --- a/api/server/routes/config.js +++ b/api/server/routes/config.js @@ -18,6 +18,7 @@ const { resolveCodeEnvironmentMoveVersion, isPasskeyEnabled, buildPreLoginInterface, + resolveMaxPasskeysPerUser, } = require('@librechat/api'); const { DEFAULT_MCP_APP_CSP_LIMITS, @@ -159,6 +160,7 @@ function buildPostLoginPayload(appConfig) { process.env.ALLOW_ACCOUNT_DELETION === undefined || isEnabled(process.env.ALLOW_ACCOUNT_DELETION), allowEmailChange: resolveEmailChangeSettings(appConfig?.emailChange).enabled, + maxPasskeysPerUser: resolveMaxPasskeysPerUser(appConfig?.passkeys), }; return payload; diff --git a/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx b/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx index d05b8d5d3a..0643721d05 100644 --- a/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx +++ b/client/src/components/Nav/SettingsTabs/Account/Passkeys/Passkeys.tsx @@ -22,6 +22,7 @@ import { import type { PasskeyRemovalResult } from './PasskeyItem'; import { useDeletePasskeyMutation, + useGetStartupConfig, usePasskeysQuery, useRenamePasskeyMutation, } from '~/data-provider'; @@ -48,13 +49,16 @@ function Passkeys() { const renameAfterCloseRef = useRef(null); const { data, isLoading, isError } = usePasskeysQuery({ enabled: isDialogOpen }); + const { data: startupConfig, refetch: refetchStartupConfig } = useGetStartupConfig(); const { registerPasskey, isRegistering, passwordErrorKey, clearPasswordError } = usePasskeyRegistration(); const { mutate: renameMutate } = useRenamePasskeyMutation(); const { mutateAsync: deleteMutate } = useDeletePasskeyMutation(); const passkeys = data?.passkeys ?? []; - const atLimit = passkeys.length >= MAX_PASSKEYS_PER_USER; + /** Falls back to the documented default while the startup config is still loading. */ + const maxPasskeys = startupConfig?.maxPasskeysPerUser ?? MAX_PASSKEYS_PER_USER; + const atLimit = passkeys.length >= maxPasskeys; /** * Removing a passkey is password-confirmed, but an account provisioned by an * identity provider has no password to confirm with. The server waives the @@ -161,6 +165,7 @@ function Passkeys() { (open: boolean) => { setDialogOpen(open); if (open) { + void refetchStartupConfig(); return; } setPassword(''); @@ -169,7 +174,7 @@ function Passkeys() { renameAfterCloseRef.current = null; clearPasswordError(); }, - [clearPasswordError], + [clearPasswordError, refetchStartupConfig], ); return ( diff --git a/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx b/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx index f868033238..387ab663c7 100644 --- a/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx +++ b/client/src/components/Nav/SettingsTabs/Account/Passkeys/__tests__/Passkeys.spec.tsx @@ -5,8 +5,13 @@ import Passkeys from '../Passkeys'; const mockClearPasswordError = jest.fn(); const mockRegisterPasskey = jest.fn(); +const mockRefetchStartupConfig = jest.fn(); jest.mock('~/data-provider', () => ({ + useGetStartupConfig: () => ({ + data: { maxPasskeysPerUser: 20 }, + refetch: mockRefetchStartupConfig, + }), usePasskeysQuery: () => ({ data: { passkeys: [] }, isLoading: false, isError: false }), useRenamePasskeyMutation: () => ({ mutate: jest.fn() }), useDeletePasskeyMutation: () => ({ mutateAsync: jest.fn() }), @@ -44,6 +49,20 @@ describe('Passkeys enrollment dialog', () => { jest.clearAllMocks(); }); + it('refreshes startup configuration on each management dialog open', async () => { + const user = userEvent.setup(); + render(); + expect(mockRefetchStartupConfig).not.toHaveBeenCalled(); + await user.click(screen.getByRole('button', { name: 'Passkeys' })); + expect(mockRefetchStartupConfig).toHaveBeenCalledTimes(1); + await user.keyboard('{Escape}'); + await waitFor(() => + expect(screen.queryByRole('dialog', { name: 'Passkeys' })).not.toBeInTheDocument(), + ); + await user.click(screen.getByRole('button', { name: 'Passkeys' })); + expect(mockRefetchStartupConfig).toHaveBeenCalledTimes(2); + }); + it('opens password confirmation in a separate dialog and restores focus on cancel', async () => { const user = userEvent.setup(); render(); diff --git a/e2e/specs/mock/scenarios/passkeys.spec.ts b/e2e/specs/mock/scenarios/passkeys.spec.ts index 134874ad3f..58f359b0a3 100644 --- a/e2e/specs/mock/scenarios/passkeys.spec.ts +++ b/e2e/specs/mock/scenarios/passkeys.spec.ts @@ -9,6 +9,7 @@ import type { } from '@playwright/test'; import { seedPasskey, deleteUserByEmail, countUserPasskeys, enableTwoFactorFlag } from '../db'; import { NEW_CHAT_PATH } from '../helpers'; +import { getPrimaryE2EUser } from '../../../setup/users.mock'; /** * Passkey sign-in and management, driven through a real WebAuthn ceremony: Chromium's @@ -423,4 +424,107 @@ test.describe('passkeys', () => { await request.dispose(); } }); + + test('a configured per-user cap hides the add control at that cap @scenario:passkey-cap-hides-add-control', async ({ + browser, + playwright, + baseURL, + }) => { + test.setTimeout(60000); + const request = await playwright.request.newContext({ baseURL: passkeyBaseURL(baseURL) }); + user = await createFreshUser(request); + await seedPasskey(user.email, `e2e-cap-${randomUUID()}`, 'Only key'); + context = await openContextFor(browser, request, passkeyBaseURL(baseURL)); + await request.dispose(); + const page = await context.newPage(); + + await page.route('**/api/config', async (route) => { + const response = await route.fetch(); + const config = await response.json(); + await route.fulfill({ response, json: { ...config, maxPasskeysPerUser: 1 } }); + }); + + const cappedDialog = await openPasskeysDialog(page); + const cappedAdd = cappedDialog.getByRole('button', { name: 'Add passkey' }); + await expect(cappedAdd).toBeVisible(); + await expect(cappedAdd).toBeDisabled(); + await expect( + cappedDialog.getByText('You have reached the maximum number of passkeys'), + ).toBeVisible(); + + await page.unroute('**/api/config'); + await page.keyboard.press('Escape'); + await expect(cappedDialog).toBeHidden(); + await page + .getByRole('dialog', { name: /Settings/ }) + .getByRole('button', { name: 'Passkeys', exact: true }) + .click(); + const defaultDialog = page.getByRole('dialog', { name: 'Passkeys', exact: true }); + const defaultAdd = defaultDialog.getByRole('button', { name: 'Add passkey' }); + await expect(defaultAdd).toBeVisible(); + await expect(defaultAdd).toBeEnabled(); + await expect( + defaultDialog.getByText('You have reached the maximum number of passkeys'), + ).toHaveCount(0); + }); + + test('the effective user cap reaches startup and both enrollment routes @scenario:passkey-cap-effective-config', async ({ + playwright, + baseURL, + }) => { + test.setTimeout(60000); + const request = await playwright.request.newContext({ baseURL: passkeyBaseURL(baseURL) }); + user = await createFreshUser(request); + const headers = { Authorization: `Bearer ${user.token}` }; + const admin = getPrimaryE2EUser(); + const login = await request.post('/api/auth/login', { + data: { email: admin.email, password: admin.password }, + }); + expect(login.ok()).toBeTruthy(); + const adminHeaders = { Authorization: `Bearer ${(await login.json()).token}` }; + const overridePath = `/api/admin/config/user/${user.id}`; + try { + const baseline = await request.get('/api/config', { headers }); + expect((await baseline.json()).maxPasskeysPerUser).toBe(20); + await seedPasskey(user.email, `e2e-effective-cap-${randomUUID()}`, 'Existing key'); + const saved = await request.put(overridePath, { + headers: adminHeaders, + data: { overrides: { passkeys: { perUserMax: 1 } } }, + }); + expect(saved.ok()).toBeTruthy(); + await expect + .poll(async () => { + const config = await request.get('/api/config', { headers }); + return (await config.json()).maxPasskeysPerUser; + }) + .toBe(1); + + for (const path of ['options', 'verify']) { + const response = await request.post(`/api/auth/passkey/register/${path}`, { + headers, + data: { password: user.password, credential: { id: 'over-cap' } }, + }); + expect(response.status()).toBe(409); + expect(await response.json()).toEqual({ message: 'Passkey limit reached' }); + } + expect(await countUserPasskeys(user.id)).toBe(1); + const restored = await request.delete(overridePath, { headers: adminHeaders }); + expect(restored.ok()).toBeTruthy(); + await expect + .poll(async () => { + const config = await request.get('/api/config', { headers }); + return (await config.json()).maxPasskeysPerUser; + }) + .toBe(20); + const allowed = await request.post('/api/auth/passkey/register/options', { + headers, + data: { password: user.password }, + }); + expect(allowed.status()).toBe(200); + } finally { + const cleanup = await request.delete(overridePath, { headers: adminHeaders }); + expect([200, 404]).toContain(cleanup.status()); + await request.dispose(); + } + }); }); diff --git a/librechat.example.yaml b/librechat.example.yaml index 84dbc91070..741fe622b3 100644 --- a/librechat.example.yaml +++ b/librechat.example.yaml @@ -390,6 +390,11 @@ interface: # enabled: true # tokenTTLSeconds: 900 +# Passkey (WebAuthn) enrollment limits. +# Omitted, perUserMax falls back to MAX_PASSKEYS_PER_USER, then 20. +# passkeys: +# perUserMax: 20 + registration: socialLogins: ['github', 'google', 'discord', 'openid', 'facebook', 'apple', 'saml'] # allowedDomains: diff --git a/packages/api/src/app/AppService.spec.ts b/packages/api/src/app/AppService.spec.ts index f4f64ef23c..c695344212 100644 --- a/packages/api/src/app/AppService.spec.ts +++ b/packages/api/src/app/AppService.spec.ts @@ -68,6 +68,11 @@ const defaultAgentCapabilitiesWithoutMemory = defaultAgentCapabilities.filter( ); describe('AppService', () => { + it('preserves the YAML passkey cap in the effective configuration', async () => { + const result = await AppService({ config: { passkeys: { perUserMax: 2 } } }); + expect(result?.passkeys).toEqual({ perUserMax: 2 }); + }); + const mockSystemTools: Record = { ExampleTool: { type: 'function', diff --git a/packages/api/src/auth/passkey.spec.ts b/packages/api/src/auth/passkey.spec.ts index 472819a678..e79ca41abc 100644 --- a/packages/api/src/auth/passkey.spec.ts +++ b/packages/api/src/auth/passkey.spec.ts @@ -1,7 +1,9 @@ import Keyv from 'keyv'; import { logger } from '@librechat/data-schemas'; +import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider'; import { createHash, generateKeyPairSync, sign } from 'node:crypto'; import type { AuthenticationResponseJSON, RegistrationResponseJSON } from '@simplewebauthn/server'; +import type { TCustomConfig } from 'librechat-data-provider'; import type { PasskeyChallengeStore, PasskeyConfig } from './passkey'; import { authenticationChallengeKey, @@ -12,6 +14,7 @@ import { getPasskeyConfig, isPasskeyEnabled, registrationChallengeKey, + resolveMaxPasskeysPerUser, verifyPasskeyAuthentication, verifyPasskeyRegistration, } from './passkey'; @@ -107,6 +110,50 @@ function createAuthenticator(credentialId = 'cred-id') { return { assert, credential: { credentialId: id, publicKey: cosePublicKey, counter: 0 } }; } +describe('resolveMaxPasskeysPerUser', () => { + it('prefers the yaml value over the environment and the documented default', () => { + expect( + resolveMaxPasskeysPerUser({ perUserMax: 5 }, { + MAX_PASSKEYS_PER_USER: '9', + } as NodeJS.ProcessEnv), + ).toBe(5); + }); + + it('falls back to the environment, then the documented default', () => { + expect( + resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: '9' } as NodeJS.ProcessEnv), + ).toBe(9); + expect(resolveMaxPasskeysPerUser(undefined, {} as NodeJS.ProcessEnv)).toBe( + MAX_PASSKEYS_PER_USER, + ); + expect( + resolveMaxPasskeysPerUser(undefined, { + MAX_PASSKEYS_PER_USER: 'not-a-number', + } as NodeJS.ProcessEnv), + ).toBe(MAX_PASSKEYS_PER_USER); + }); + + it('applies the schema bounds to the environment value too', () => { + const rejected = ['0', '-1', '101', '9abc', '1.5']; + for (const value of rejected) { + expect( + resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: value } as NodeJS.ProcessEnv), + ).toBe(MAX_PASSKEYS_PER_USER); + } + expect( + resolveMaxPasskeysPerUser(undefined, { MAX_PASSKEYS_PER_USER: '100' } as NodeJS.ProcessEnv), + ).toBe(100); + }); + + it('ignores an out-of-bounds cap from an unvalidated override', () => { + const env = { MAX_PASSKEYS_PER_USER: '9' } as NodeJS.ProcessEnv; + const rejected: unknown[] = [0, -1, 101, 1.5, '5', 'abc', null]; + for (const perUserMax of rejected) { + expect(resolveMaxPasskeysPerUser({ perUserMax } as TCustomConfig['passkeys'], env)).toBe(9); + } + }); +}); + describe('getPasskeyConfig', () => { it('derives the RP ID and origins from DOMAIN_CLIENT', () => { const resolved = getPasskeyConfig({ diff --git a/packages/api/src/auth/passkey.ts b/packages/api/src/auth/passkey.ts index fe067d7984..c266439b83 100644 --- a/packages/api/src/auth/passkey.ts +++ b/packages/api/src/auth/passkey.ts @@ -1,12 +1,12 @@ import { randomUUID } from 'node:crypto'; import { logger } from '@librechat/data-schemas'; +import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider'; import { generateAuthenticationOptions, generateRegistrationOptions, verifyAuthenticationResponse, verifyRegistrationResponse, } from '@simplewebauthn/server'; - import type { AuthenticationResponseJSON, AuthenticatorTransportFuture, @@ -15,7 +15,7 @@ import type { RegistrationResponseJSON, } from '@simplewebauthn/server'; import type { PasskeyDeviceType } from '@librechat/data-schemas'; - +import type { TCustomConfig } from 'librechat-data-provider'; import { isEnabled } from '~/utils'; /** How long a generated challenge stays valid, in milliseconds. */ @@ -147,6 +147,29 @@ export function isPasskeyEnabled(config: PasskeyConfig = getPasskeyConfig()): bo return config.enabled && config.origins.length > 0; } +/** The schema's bounds for `passkeys.perUserMax`, applied to every source of the cap. */ +const isCapWithinBounds = (value: unknown): value is number => + typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 100; + +/** + * yaml wins over the environment, which wins over the documented default, so a + * deployment that sets neither keeps exactly the behavior it has today. Every + * source is held to the schema's bounds: principal-scoped database overrides + * merge in without passing through `configSchema`, and a stray value must + * neither brick enrollment nor lift the cap. + */ +export function resolveMaxPasskeysPerUser( + config?: TCustomConfig['passkeys'], + env: NodeJS.ProcessEnv = process.env, +): number { + const fromConfig: unknown = config?.perUserMax; + if (isCapWithinBounds(fromConfig)) { + return fromConfig; + } + const fromEnv = Number(env.MAX_PASSKEYS_PER_USER); + return isCapWithinBounds(fromEnv) ? fromEnv : MAX_PASSKEYS_PER_USER; +} + /** Namespaced cache key for a pending registration ceremony. */ export const registrationChallengeKey = (userId: string): string => `passkey-reg:${userId}`; diff --git a/packages/api/src/auth/passkey/handlers.spec.ts b/packages/api/src/auth/passkey/handlers.spec.ts index 5f94c80b4b..d16a9ae8a2 100644 --- a/packages/api/src/auth/passkey/handlers.spec.ts +++ b/packages/api/src/auth/passkey/handlers.spec.ts @@ -1,7 +1,7 @@ import mongoose from 'mongoose'; import { createHash } from 'node:crypto'; import { MongoMemoryServer } from 'mongodb-memory-server'; -import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider'; +import { FileSources, MAX_PASSKEYS_PER_USER } from 'librechat-data-provider'; import { logger, createMethods, createModels } from '@librechat/data-schemas'; import type { RegistrationResponseJSON } from '@simplewebauthn/server'; import type { IUser } from '@librechat/data-schemas'; @@ -48,6 +48,7 @@ const ENV_KEYS = [ 'ALLOW_UNVERIFIED_EMAIL_LOGIN', 'EMAIL_SERVICE', 'EMAIL_FROM', + 'MAX_PASSKEYS_PER_USER', ] as const; type MockResponse = Response & { status: jest.Mock; json: jest.Mock }; @@ -259,6 +260,190 @@ describe('passkey registration provider enforcement', () => { expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' }); }); + it('enforces the per-account cap the deployment configures', async () => { + const handlers = createPasskeyHandlers( + buildDeps({ + getAppConfig: async () => ({ + config: {}, + fileStrategy: FileSources.local, + imageOutputType: 'png', + passkeys: { perUserMax: 2 }, + }), + }), + ); + const user = await createUser(); + await Promise.all([createStoredPasskey(user, 'cap-0'), createStoredPasskey(user, 'cap-1')]); + const res = buildRes(); + + await handlers.registerPasskeyOptions(authedReq(user, { password: PASSWORD }), res); + + expect(res.status).toHaveBeenCalledWith(409); + expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' }); + }); + + it('awaits an asynchronous cap resolver on the verify path', async () => { + const handlers = createPasskeyHandlers( + buildDeps({ + getAppConfig: async () => ({ + config: {}, + fileStrategy: FileSources.local, + imageOutputType: 'png', + passkeys: { perUserMax: 1 }, + }), + }), + ); + const user = await createUser(); + await createStoredPasskey(user, 'cap-verify-0'); + const res = buildRes(); + + await handlers.registerPasskeyVerify( + authedReq(user, { + credential: attestation, + name: 'Third key', + password: PASSWORD, + }), + res, + ); + + expect(res.status).toHaveBeenCalledWith(409); + expect(res.json).toHaveBeenCalledWith({ message: 'Passkey limit reached' }); + }); + + it('resolves the authenticated principal once before writing a credential', async () => { + const getAppConfig = jest + .fn< + ReturnType>, + Parameters> + >() + .mockResolvedValueOnce({ + config: {}, + fileStrategy: FileSources.local, + imageOutputType: 'png', + passkeys: { perUserMax: 1 }, + }) + .mockRejectedValue(new Error('Config unavailable after enrollment')); + const handlers = createPasskeyHandlers(buildDeps({ getAppConfig })); + const user = await createUser(); + const req = authedReq(user, { credential: attestation, password: PASSWORD }); + req.user.role = 'USER'; + req.user.idOnTheSource = 'source-user'; + const res = buildRes(); + + await handlers.registerPasskeyVerify(req, res); + + expect(res.status).toHaveBeenCalledWith(201); + expect(getAppConfig).toHaveBeenCalledTimes(1); + expect(getAppConfig).toHaveBeenCalledWith({ + userId: user._id.toString(), + role: 'USER', + idOnTheSource: 'source-user', + tenantId: undefined, + failClosed: true, + }); + expect(await methods.countPasskeysByUser(user._id.toString())).toBe(1); + }); + + it('reuses configuration already loaded for the request', async () => { + const getAppConfig = jest.fn().mockRejectedValue(new Error('Unnecessary config read')); + const handlers = createPasskeyHandlers(buildDeps({ getAppConfig })); + const user = await createUser(); + await createStoredPasskey(user); + const req = authedReq(user, { password: PASSWORD }); + req.config = { + config: {}, + fileStrategy: FileSources.local, + imageOutputType: 'png', + passkeys: { perUserMax: 1 }, + }; + const res = buildRes(); + + await handlers.registerPasskeyOptions(req, res); + + expect(res.status).toHaveBeenCalledWith(409); + expect(getAppConfig).not.toHaveBeenCalled(); + }); + + it('does not enroll a credential when effective configuration cannot be loaded', async () => { + const getAppConfig = jest.fn().mockRejectedValue(new Error('Config unavailable')); + const handlers = createPasskeyHandlers(buildDeps({ getAppConfig })); + const user = await createUser(); + const res = buildRes(); + + await handlers.registerPasskeyVerify( + authedReq(user, { credential: attestation, password: PASSWORD }), + res, + ); + + expect(res.status).toHaveBeenCalledWith(500); + expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0); + expect(mockVerifyRegistration).not.toHaveBeenCalled(); + }); + + it('removes the inserted credential if the post-write count fails', async () => { + const countPasskeysByUser = jest + .fn(methods.countPasskeysByUser) + .mockResolvedValueOnce(0) + .mockRejectedValueOnce(new Error('Count unavailable')); + const handlers = createPasskeyHandlers(buildDeps({ countPasskeysByUser })); + const user = await createUser(); + const res = buildRes(); + + await handlers.registerPasskeyVerify( + authedReq(user, { credential: attestation, password: PASSWORD }), + res, + ); + + expect(res.status).toHaveBeenCalledWith(500); + expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0); + }); + + it('rolls back a credential that wins the enrollment race past the cap', async () => { + /** Both verifies observe the pre-enrollment count, as two concurrent + * ceremonies for the same account do, so both pass the early check. */ + const racedCount = jest + .fn() + .mockImplementationOnce(async () => 0) + .mockImplementationOnce(async () => 0) + .mockImplementation(methods.countPasskeysByUser); + const handlers = createPasskeyHandlers( + buildDeps({ + getAppConfig: async () => ({ + config: {}, + fileStrategy: FileSources.local, + imageOutputType: 'png', + passkeys: { perUserMax: 1 }, + }), + countPasskeysByUser: racedCount, + }), + ); + let ceremony = 0; + mockVerifyRegistration.mockImplementation(async () => + verifiedRegistration(`raced-cred-${++ceremony}`), + ); + const user = await createUser(); + const results = await Promise.allSettled( + [1, 2].map((index) => + handlers.registerPasskeyVerify( + authedReq(user, { + credential: { id: `raced-cred-${index}` } as RegistrationResponseJSON, + name: `Raced ${index}`, + password: PASSWORD, + }), + buildRes(), + ), + ), + ); + + expect( + results.every( + (result) => + result.status === 'fulfilled' || + result.reason === undefined /** handlers return rather than throw */, + ), + ).toBe(true); + expect(await methods.countPasskeysByUser(user._id.toString())).toBeLessThanOrEqual(1); + }); + it('stores the credential when the account is local', async () => { const handlers = createPasskeyHandlers(buildDeps()); const user = await createUser(); diff --git a/packages/api/src/auth/passkey/handlers.ts b/packages/api/src/auth/passkey/handlers.ts index a03619660c..e1d57a7ed9 100644 --- a/packages/api/src/auth/passkey/handlers.ts +++ b/packages/api/src/auth/passkey/handlers.ts @@ -1,9 +1,9 @@ import { logger } from '@librechat/data-schemas'; -import { MAX_PASSKEYS_PER_USER } from 'librechat-data-provider'; import type { AuthenticationResponseJSON, RegistrationResponseJSON } from '@simplewebauthn/server'; -import type { PasskeyCreateData, PasskeyRecord } from '@librechat/data-schemas'; +import type { PasskeyCreateData, PasskeyRecord, AppConfig } from '@librechat/data-schemas'; import type { TPasskey } from 'librechat-data-provider'; import type { Request, Response } from 'express'; +import type { AppConfigUserLike, GetAppConfigOptions } from '~/app/service'; import type { PasskeyConfig, PasskeyChallengeStore } from '~/auth/passkey'; import type { ComparePasswordDeps } from '~/auth/password'; import type { UserDocumentId } from '~/auth/verification'; @@ -11,12 +11,14 @@ import { getPasskeyConfig, isPasskeyEnabled, defaultPasskeyName, + resolveMaxPasskeysPerUser, verifyPasskeyRegistration, verifyPasskeyAuthentication, createPasskeyRegistrationOptions, createPasskeyAuthenticationOptions, } from '~/auth/passkey'; import { grandfatherLegacyEmailVerification } from '~/auth/verification'; +import { resolveStrictAppConfig } from '~/app/service'; import { comparePassword } from '~/auth/password'; import { isEnabled } from '~/utils'; @@ -53,7 +55,7 @@ interface AuthenticationBody { * handoff to `loginController` and legacy-verification grandfathering, not by * the route handlers themselves. */ -export interface PasskeyAccount { +export interface PasskeyAccount extends AppConfigUserLike { id?: string; _id?: UserDocumentId; email?: string; @@ -74,6 +76,7 @@ export type PasskeyRequest = Request< > & { user?: PasskeyAccount; banned?: boolean; + config?: AppConfig; }; /** Every management route sits behind `requireJwtAuth`, so `req.user` is always populated. */ @@ -115,6 +118,8 @@ export interface PasskeyHandlersDeps { findPasskeyByCredentialId: (credentialId: string) => Promise; /** Resolves the cache backing pending WebAuthn ceremonies. */ getChallengeCache: () => PasskeyChallengeStore; + /** Resolves effective configuration for the authenticated principal. */ + getAppConfig?: (options: GetAppConfigOptions) => Promise; compare: ComparePasswordDeps['compare']; /** The login ban middleware; reports an internal failure through `next(err)`. */ checkBan: ( @@ -242,6 +247,7 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler recordPasskeyUse, getChallengeCache, findPasskeysByUser, + getAppConfig, countPasskeysByUser, findPasskeyByCredentialId, } = deps; @@ -249,6 +255,14 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler const getChallengeStore = (): PasskeyChallengeStore => createPasskeyChallengeStore(getChallengeCache()); + /** Resolved per request, so a config reload changes the cap without a restart. */ + const resolveMaxPasskeys = async (req: AuthenticatedPasskeyRequest): Promise => { + const appConfig = + req.config ?? + (getAppConfig ? await resolveStrictAppConfig(getAppConfig, req.user) : undefined); + return resolveMaxPasskeysPerUser(appConfig?.passkeys); + }; + /** * Step-up gate shared by the passkey endpoints that add or remove a login factor. * A passkey is a durable single-factor login that outlives session revocation, so @@ -336,8 +350,11 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler } try { - const existingCredentials = await findPasskeysByUser(req.user.id); - if (existingCredentials.length >= MAX_PASSKEYS_PER_USER) { + const [existingCredentials, maxPasskeys] = await Promise.all([ + findPasskeysByUser(req.user.id), + resolveMaxPasskeys(req), + ]); + if (existingCredentials.length >= maxPasskeys) { return res.status(409).json({ message: 'Passkey limit reached' }); } @@ -387,7 +404,11 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler return res.status(400).json({ message: 'Missing credential' }); } - if ((await countPasskeysByUser(req.user.id)) >= MAX_PASSKEYS_PER_USER) { + const [count, maxPasskeys] = await Promise.all([ + countPasskeysByUser(req.user.id), + resolveMaxPasskeys(req), + ]); + if (count >= maxPasskeys) { return res.status(409).json({ message: 'Passkey limit reached' }); } @@ -419,6 +440,24 @@ export function createPasskeyHandlers(deps: PasskeyHandlersDeps): PasskeyHandler trimmedName.slice(0, MAX_PASSKEY_NAME_LENGTH) || defaultPasskeyName(verified.transports), }); + /** + * The early count check races a concurrent ceremony for the same account: + * both can observe a below-cap count and both insert. Re-counting after + * the write and rolling this credential back keeps the stored set within + * the cap without a transaction, at the cost of rejecting the whole race. + */ + let countAfterWrite: number; + try { + countAfterWrite = await countPasskeysByUser(req.user.id); + } catch (error) { + await deletePasskey(passkey.id, req.user.id); + throw error; + } + if (countAfterWrite > maxPasskeys) { + await deletePasskey(passkey.id, req.user.id); + return res.status(409).json({ message: 'Passkey limit reached' }); + } + return res.status(201).json({ passkey: serializePasskey(passkey) }); } catch (err) { if (isDuplicateKeyError(err as MongoWriteError)) { diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.ts index 223e45d1ce..acb55cec5a 100644 --- a/packages/data-provider/src/config.spec.ts +++ b/packages/data-provider/src/config.spec.ts @@ -175,6 +175,22 @@ describe('ask user retained answers', () => { }); }); +describe('passkey enrollment config', () => { + it('ships a per-account cap a deployment can raise or lower', () => { + expect(configSchema.parse({ version: '1.0' }).passkeys).toEqual({}); + expect( + configSchema.parse({ version: '1.0', passkeys: { perUserMax: 5 } }).passkeys.perUserMax, + ).toBe(5); + /** A cap below one would brick enrollment; a fraction of a credential is nonsense. */ + expect(configSchema.safeParse({ version: '1.0', passkeys: { perUserMax: 0 } }).success).toBe( + false, + ); + expect(configSchema.safeParse({ version: '1.0', passkeys: { perUserMax: 1.5 } }).success).toBe( + false, + ); + }); +}); + describe('retained tool-count ceiling', () => { it('ships the exact-count budget a deployment can raise or lower', () => { /** The save path tokenizes a stopped turn's retained tool results to add an diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts index 8b66fdf554..18ddfbb798 100644 --- a/packages/data-provider/src/config.ts +++ b/packages/data-provider/src/config.ts @@ -2748,6 +2748,8 @@ export type TStartupConfig = { appleLoginEnabled: boolean; samlLoginEnabled: boolean; passkeyLoginEnabled: boolean; + /** Per-account passkey enrollment cap, from `passkeys.perUserMax`; post-login only. */ + maxPasskeysPerUser?: number; openidLabel: string; openidImageUrl: string; openidAutoRedirect: boolean; @@ -3521,6 +3523,14 @@ export const configSchema = z.object({ tokenTTLSeconds: z.number().int().min(60).max(86_400).optional(), }) .optional(), + /** WebAuthn passkey enrollment. An unset field falls back to its env var, then the + * documented default, so an existing deployment keeps the behavior it has today. */ + passkeys: z + .object({ + /** `MAX_PASSKEYS_PER_USER` when unset; the documented default when neither is given. */ + perUserMax: z.number().int().min(1).max(100).optional(), + }) + .default({}), balance: balanceSchema.optional(), transactions: transactionsSchema.optional(), speech: z diff --git a/packages/data-schemas/src/app/service.ts b/packages/data-schemas/src/app/service.ts index 78016b670b..2a40be0fee 100644 --- a/packages/data-schemas/src/app/service.ts +++ b/packages/data-schemas/src/app/service.ts @@ -187,6 +187,7 @@ export const AppService = async (params?: { fileStrategy, registration, emailChange, + passkeys: config.passkeys, transactions, filteredTools, includedTools, diff --git a/packages/data-schemas/src/types/app.ts b/packages/data-schemas/src/types/app.ts index 7d6d673ab1..1a0b3a5d9f 100644 --- a/packages/data-schemas/src/types/app.ts +++ b/packages/data-schemas/src/types/app.ts @@ -82,6 +82,8 @@ export interface AppConfig { registration?: TCustomConfig['registration']; /** Changing the registered email address */ emailChange?: TCustomConfig['emailChange']; + /** Passkey enrollment configuration */ + passkeys?: TCustomConfig['passkeys']; /** Actions configurations */ actions?: TCustomConfig['actions']; /** Admin-filtered tools */