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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import mongoose from 'mongoose';
import { createHash } from 'node:crypto';
import { MongoMemoryServer } from 'mongodb-memory-server';
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';
import type { Response } from 'express';
import type {
PasskeyAccount,
PasskeyHandlersDeps,
PasskeyRequest,
AuthenticatedPasskeyRequest,
} from './handlers';
import type { PasskeyChallengeStore } from '~/auth/passkey';
import {
verifyPasskeyRegistration,
verifyPasskeyAuthentication,
createPasskeyRegistrationOptions,
} from '~/auth/passkey';
import { createPasskeyHandlers, createPasskeyChallengeStore } from './handlers';
/**
* The WebAuthn ceremonies need a real authenticator to produce a signature, so only
* they are replaced. Config resolution, naming and everything behind them stay real.
*/
jest.mock('~/auth/passkey', () => ({
...jest.requireActual('~/auth/passkey'),
createPasskeyRegistrationOptions: jest.fn(),
verifyPasskeyRegistration: jest.fn(),
verifyPasskeyAuthentication: jest.fn(),
}));
const mockRegistrationOptions = jest.mocked(createPasskeyRegistrationOptions);
const mockVerifyRegistration = jest.mocked(verifyPasskeyRegistration);
const mockVerifyAuthentication = jest.mocked(verifyPasskeyAuthentication);
const PASSWORD = 'correct horse battery staple';
/** Stands in for the caller's hash function: the gate only needs a real comparison to run. */
const hash = (value: string): string => createHash('sha256').update(value).digest('hex');
const compare = async (candidate: string, stored: string): Promise<boolean> =>
hash(candidate) === stored;
const PASSWORD_HASH = hash(PASSWORD);
const attestation = { id: 'cred-1' } as RegistrationResponseJSON;
const REQUEST_IP = '203.0.113.10';
const ENV_KEYS = [
'ALLOW_PASSKEY_LOGIN',
'ALLOW_UNVERIFIED_EMAIL_LOGIN',
'EMAIL_SERVICE',
'EMAIL_FROM',
'MAX_PASSKEYS_PER_USER',
] as const;
type MockResponse = Response & { status: jest.Mock; json: jest.Mock };
type BanCheck = PasskeyHandlersDeps['checkBan'];
let mongoServer: MongoMemoryServer;
let methods: ReturnType<typeof createMethods>;
let checkBan: jest.MockedFunction<BanCheck>;
let savedEnv: Partial<Record<(typeof ENV_KEYS)[number], string>>;
function buildRes(): MockResponse {
const res = { headersSent: false } as MockResponse;
res.status = jest.fn().mockReturnValue(res);
res.json = jest.fn().mockReturnValue(res);
return res;
}
function memoryCache(): PasskeyChallengeStore {
const entries = new Map<string, string>();
return {
get: async (key) => entries.get(key),
set: async (key, value) => entries.set(key, value),
delete: async (key) => entries.delete(key),
};
}
function buildDeps(overrides: Partial<PasskeyHandlersDeps> = {}): PasskeyHandlersDeps {
return {
checkBan,
compare,
getChallengeCache: memoryCache,
getUserById: methods.getUserById,
updateUser: (userId, update) => methods.updateUser(userId.toString(), update as Partial<IUser>),
createPasskey: methods.createPasskey,
deletePasskey: methods.deletePasskey,
renamePasskey: methods.renamePasskey,
recordPasskeyUse: methods.recordPasskeyUse,
findPasskeysByUser: methods.findPasskeysByUser,
countPasskeysByUser: methods.countPasskeysByUser,
findPasskeyByCredentialId: methods.findPasskeyByCredentialId,
...overrides,
};
}
async function createUser(fields: Partial<IUser> = {}): Promise<IUser> {
const doc = await mongoose.models.User.create({
email: `user-${new mongoose.Types.ObjectId().toString()}@example.com`,
provider: 'local',
password: PASSWORD_HASH,
emailVerified: true,
...fields,
});
return doc.toObject({ virtuals: true }) as IUser;
}
async function createStoredPasskey(user: IUser, credentialId = 'cred-1') {
return methods.createPasskey({
user: user._id.toString(),
credentialId,
publicKey: Buffer.from('public-key'),
counter: 0,
transports: ['internal'],
deviceType: 'singleDevice',
backedUp: false,
name: 'Laptop',
});
}
function authedReq<TBody>(
user: IUser,
body?: TBody,
params: { passkeyId: string } = { passkeyId: '' },
): AuthenticatedPasskeyRequest<TBody> {
return {
user: { id: user._id.toString(), provider: user.provider, email: user.email },
ip: REQUEST_IP,
body,
params,
} as AuthenticatedPasskeyRequest<TBody>;
}
const verifiedRegistration = (credentialId = 'cred-1') => ({
credentialId,
publicKey: Buffer.from('public-key'),
counter: 0,
transports: ['internal'],
deviceType: 'singleDevice' as const,
backedUp: false,
});
beforeAll(async () => {
mongoServer = await MongoMemoryServer.create();
await mongoose.connect(mongoServer.getUri());
createModels(mongoose);
methods = createMethods(mongoose);
await mongoose.models.Passkey.syncIndexes();
});
afterAll(async () => {
await mongoose.disconnect();
await mongoServer.stop();
});
beforeEach(async () => {
savedEnv = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
for (const key of ENV_KEYS) {
delete process.env[key];
}
process.env.ALLOW_PASSKEY_LOGIN = 'true';
/** Email configured by default, so the legacy grandfather path stays out of the way. */
process.env.EMAIL_SERVICE = 'smtp';
process.env.EMAIL_FROM = '[email protected]';
jest.clearAllMocks();
jest.spyOn(logger, 'warn').mockImplementation(() => logger);
jest.spyOn(logger, 'error').mockImplementation(() => logger);
checkBan = jest.fn<ReturnType<BanCheck>, Parameters<BanCheck>>(async () => undefined);
mockRegistrationOptions.mockResolvedValue({ challenge: 'chal' } as Awaited<
ReturnType<typeof createPasskeyRegistrationOptions>
>);
mockVerifyRegistration.mockResolvedValue(verifiedRegistration());
mockVerifyAuthentication.mockResolvedValue({ newCounter: 1, backedUp: false });
await mongoose.models.User.deleteMany({});
await mongoose.models.Passkey.deleteMany({});
});
afterEach(() => {
for (const key of ENV_KEYS) {
if (savedEnv[key] === undefined) {
delete process.env[key];
} else {
process.env[key] = savedEnv[key];
}
}
jest.restoreAllMocks();
});
describe('feature gate', () => {
it('answers 404 on every route while passkeys are disabled', async () => {
process.env.ALLOW_PASSKEY_LOGIN = 'false';
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.listPasskeys(authedReq(user), res);
expect(res.status).toHaveBeenCalledWith(404);
expect(res.json).toHaveBeenCalledWith({ message: 'Passkey authentication is not enabled' });
});
});
describe('passkey registration provider enforcement', () => {
it('issues registration options for a local account', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyOptions(authedReq(user, { password: PASSWORD }), res);
expect(res.status).toHaveBeenCalledWith(200);
expect(res.json).toHaveBeenCalledWith({ challenge: 'chal' });
});
it.each(['openid', 'google', 'ldap', 'saml', undefined])(
'rejects registration options for provider %s',
async (provider) => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const req = authedReq(user, { password: PASSWORD });
req.user.provider = provider as string;
const res = buildRes();
await handlers.registerPasskeyOptions(req, res);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.json).toHaveBeenCalledWith({
message: 'Passkeys are only available for local accounts',
});
expect(mockRegistrationOptions).not.toHaveBeenCalled();
},
);
it('does not read the account password when the provider check already failed', async () => {
const getUserById = jest.fn(methods.getUserById);
const handlers = createPasskeyHandlers(buildDeps({ getUserById }));
const user = await createUser({ provider: 'openid' });
const res = buildRes();
await handlers.registerPasskeyOptions(authedReq(user, { password: PASSWORD }), res);
expect(res.status).toHaveBeenCalledWith(403);
expect(getUserById).not.toHaveBeenCalled();
});
it('refuses a new challenge once the account holds the maximum number of passkeys', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await Promise.all(
Array.from({ length: MAX_PASSKEYS_PER_USER }, (_, i) =>
createStoredPasskey(user, `cred-${i}`),
),
);
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('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<NonNullable<PasskeyHandlersDeps['getAppConfig']>>,
Parameters<NonNullable<PasskeyHandlersDeps['getAppConfig']>>
>()
.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('audits a credential that survives a failed rollback', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const countPasskeysByUser = jest
.fn(methods.countPasskeysByUser)
.mockResolvedValueOnce(0)
.mockRejectedValueOnce(new Error('Count unavailable'));
const deletePasskey = jest.fn().mockRejectedValue(new Error('Delete unavailable'));
const handlers = createPasskeyHandlers(
buildDeps({ countPasskeysByUser, deletePasskey, recordAuditEntry }),
);
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(500);
expect(recordAuditEntry).toHaveBeenCalledWith(
expect.objectContaining({
action: 'passkey.registered',
metadata: expect.objectContaining({ rollback: 'failed' }),
}),
);
});
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();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, {
credential: attestation,
name: ' Work laptop ',
password: PASSWORD,
}),
res,
);
expect(res.status).toHaveBeenCalledWith(201);
const stored = await methods.findPasskeysByUser(user._id.toString());
expect(stored).toHaveLength(1);
expect(res.json).toHaveBeenCalledWith({
passkey: {
id: stored[0].id,
name: 'Work laptop',
deviceType: 'singleDevice',
backedUp: false,
transports: ['internal'],
createdAt: expect.any(Date),
lastUsedAt: null,
},
});
});
it('records passkey.registered with the user as actor', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const handlers = createPasskeyHandlers(buildDeps({ recordAuditEntry }));
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, name: 'Work laptop', password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(201);
const [stored] = await methods.findPasskeysByUser(user._id.toString());
expect(recordAuditEntry).toHaveBeenCalledTimes(1);
expect(recordAuditEntry).toHaveBeenCalledWith(
expect.objectContaining({
action: 'passkey.registered',
actor: expect.objectContaining({ type: 'user', id: user._id.toString() }),
target: { type: 'passkey', id: stored.id, name: 'Work laptop' },
metadata: { deviceType: 'singleDevice', backedUp: false },
}),
);
});
it('does not record passkey.registered when registration is rejected', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const handlers = createPasskeyHandlers(buildDeps({ recordAuditEntry }));
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, name: 'Key', password: 'wrong' }),
res,
);
expect(res.status).toHaveBeenCalledWith(403);
expect(recordAuditEntry).not.toHaveBeenCalled();
});
it('names an unnamed credential after its transports', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
buildRes(),
);
const [stored] = await methods.findPasskeysByUser(user._id.toString());
expect(stored.name).toBeTruthy();
});
it('rejects registration verification for a non-local account', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ provider: 'openid' });
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(403);
expect(mockVerifyRegistration).not.toHaveBeenCalled();
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
});
it('answers 400 when the credential is missing', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(authedReq(user, { password: PASSWORD }), res);
expect(res.status).toHaveBeenCalledWith(400);
expect(res.json).toHaveBeenCalledWith({ message: 'Missing credential' });
});
it('answers 400 when the attestation does not verify', async () => {
mockVerifyRegistration.mockResolvedValue(null);
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(400);
expect(res.json).toHaveBeenCalledWith({
message: 'Passkey registration could not be verified',
});
});
it('returns 409 for a credential that is already registered', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(409);
expect(res.json).toHaveBeenCalledWith({ message: 'This passkey is already registered' });
});
it('returns 409 when create races on a duplicate credentialId', async () => {
const handlers = createPasskeyHandlers(
buildDeps({ findPasskeyByCredentialId: async () => null }),
);
const user = await createUser();
await createStoredPasskey(user);
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(409);
expect(res.json).toHaveBeenCalledWith({ message: 'This passkey is already registered' });
});
it('still lists passkeys for a non-local account so a stale credential can be removed', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ provider: 'openid' });
const res = buildRes();
await handlers.listPasskeys(authedReq(user), res);
expect(res.status).toHaveBeenCalledWith(200);
expect(res.json).toHaveBeenCalledWith({ passkeys: [] });
});
});
describe('passkey registration password confirmation (step-up)', () => {
const rejections: Array<[string, object | undefined]> = [
['a missing password', undefined],
['a missing password field', {}],
['an empty password', { password: '' }],
['a non-string password', { password: 12345 }],
['an object password', { password: { $ne: null } }],
['a wrong password', { password: 'not the password' }],
];
it.each(rejections)('rejects registration options for %s', async (_label, body) => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyOptions(authedReq(user, body), res);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.json).toHaveBeenCalledWith({ message: 'Incorrect password' });
expect(mockRegistrationOptions).not.toHaveBeenCalled();
});
it.each(rejections)('rejects registration verification for %s', async (_label, body) => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, name: 'Laptop', ...body }),
res,
);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.json).toHaveBeenCalledWith({ message: 'Incorrect password' });
expect(mockVerifyRegistration).not.toHaveBeenCalled();
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
});
it('rejects an account that has no usable password hash', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ password: undefined });
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.json).toHaveBeenCalledWith({ message: 'Incorrect password' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
});
it('answers 500 when the account lookup fails, without minting a credential', async () => {
const handlers = createPasskeyHandlers(
buildDeps({ getUserById: jest.fn().mockRejectedValue(new Error('mongo down')) }),
);
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: PASSWORD }),
res,
);
expect(res.status).toHaveBeenCalledWith(500);
expect(res.json).toHaveBeenCalledWith({ message: 'Something went wrong' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
});
it('never answers 401, which the client would turn into a sign-out', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.registerPasskeyOptions(authedReq(user, { password: 'wrong' }), res);
expect(res.status).not.toHaveBeenCalledWith(401);
});
it('logs a warning naming the user and request IP on a failed step-up', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await handlers.registerPasskeyOptions(authedReq(user, { password: 'wrong' }), buildRes());
await handlers.registerPasskeyVerify(
authedReq(user, { credential: attestation, password: 'wrong' }),
buildRes(),
);
const expected = `[Passkey] [Registration step-up failed] [User: ${user._id.toString()}] [Request-IP: ${REQUEST_IP}]`;
expect(logger.warn).toHaveBeenNthCalledWith(1, expected);
expect(logger.warn).toHaveBeenNthCalledWith(2, expected);
});
it('reads the password field explicitly, which the schema hides by default', async () => {
const getUserById = jest.fn(methods.getUserById);
const handlers = createPasskeyHandlers(buildDeps({ getUserById }));
const user = await createUser();
await handlers.registerPasskeyOptions(authedReq(user, { password: PASSWORD }), buildRes());
expect(getUserById).toHaveBeenCalledWith(user._id.toString(), '+password');
expect(logger.warn).not.toHaveBeenCalled();
});
});
describe('passkey rename', () => {
it('leaves rename ungated: it grants nothing and removes no login factor', async () => {
const getUserById = jest.fn(methods.getUserById);
const handlers = createPasskeyHandlers(buildDeps({ getUserById }));
const user = await createUser();
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.updatePasskey(
authedReq(user, { name: ` ${'x'.repeat(80)} ` }, { passkeyId: passkey.id }),
res,
);
expect(res.status).toHaveBeenCalledWith(200);
expect(getUserById).not.toHaveBeenCalled();
expect(res.json.mock.calls[0][0].passkey.name).toBe('x'.repeat(60));
});
it('requires a non-blank name', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const res = buildRes();
await handlers.updatePasskey(authedReq(user, { name: ' ' }, { passkeyId: 'p1' }), res);
expect(res.status).toHaveBeenCalledWith(400);
expect(res.json).toHaveBeenCalledWith({ message: 'Name is required' });
});
it('records passkey.removed only when a credential was deleted', async () => {
const recordAuditEntry = jest.fn().mockResolvedValue(undefined);
const handlers = createPasskeyHandlers(buildDeps({ recordAuditEntry }));
const owner = await createUser();
const other = await createUser();
const passkey = await createStoredPasskey(owner);
await handlers.removePasskey(
authedReq(other, { password: PASSWORD }, { passkeyId: passkey.id }),
buildRes(),
);
expect(recordAuditEntry).not.toHaveBeenCalled();
await handlers.removePasskey(
authedReq(owner, { password: PASSWORD }, { passkeyId: passkey.id }),
buildRes(),
);
expect(recordAuditEntry).toHaveBeenCalledTimes(1);
expect(recordAuditEntry).toHaveBeenCalledWith(
expect.objectContaining({
action: 'passkey.removed',
actor: expect.objectContaining({ type: 'user', id: owner._id.toString() }),
target: { type: 'passkey', id: passkey.id },
}),
);
});
it('answers 404 for a credential the caller does not own', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const owner = await createUser();
const other = await createUser();
const passkey = await createStoredPasskey(owner);
const res = buildRes();
await handlers.updatePasskey(
authedReq(other, { name: 'Mine now' }, { passkeyId: passkey.id }),
res,
);
expect(res.status).toHaveBeenCalledWith(404);
expect(res.json).toHaveBeenCalledWith({ message: 'Passkey not found' });
});
});
describe('passkey removal password confirmation (step-up)', () => {
const rejections: Array<[string, object | undefined]> = [
['a missing body', undefined],
['a missing password field', {}],
['an empty password', { password: '' }],
['a non-string password', { password: 12345 }],
['an object password', { password: { $ne: null } }],
['a wrong password', { password: 'not the password' }],
];
it.each(rejections)('refuses removal for %s', async (_label, body) => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.removePasskey(authedReq(user, body, { passkeyId: passkey.id }), res);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.status).not.toHaveBeenCalledWith(401);
expect(res.json).toHaveBeenCalledWith({ message: 'Incorrect password' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(1);
});
it('logs a warning naming the user and request IP on a failed step-up', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await handlers.removePasskey(
authedReq(user, { password: 'wrong' }, { passkeyId: 'p1' }),
buildRes(),
);
expect(logger.warn).toHaveBeenCalledWith(
`[Passkey] [Deletion step-up failed] [User: ${user._id.toString()}] [Request-IP: ${REQUEST_IP}]`,
);
});
it('answers 500 when the account lookup fails, without deleting', async () => {
const handlers = createPasskeyHandlers(
buildDeps({ getUserById: jest.fn().mockRejectedValue(new Error('mongo down')) }),
);
const user = await createUser();
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.removePasskey(
authedReq(user, { password: PASSWORD }, { passkeyId: passkey.id }),
res,
);
expect(res.status).toHaveBeenCalledWith(500);
expect(res.json).toHaveBeenCalledWith({ message: 'Something went wrong' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(1);
});
it('removes the credential once the password matches', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.removePasskey(
authedReq(user, { password: PASSWORD }, { passkeyId: passkey.id }),
res,
);
expect(res.status).toHaveBeenCalledWith(200);
expect(res.json).toHaveBeenCalledWith({ message: 'Passkey deleted' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
expect(logger.warn).not.toHaveBeenCalled();
});
it('answers 404 for a credential the caller does not own', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const owner = await createUser();
const other = await createUser();
const passkey = await createStoredPasskey(owner);
const res = buildRes();
await handlers.removePasskey(
authedReq(other, { password: PASSWORD }, { passkeyId: passkey.id }),
res,
);
expect(res.status).toHaveBeenCalledWith(404);
expect(res.json).toHaveBeenCalledWith({ message: 'Passkey not found' });
expect(await methods.countPasskeysByUser(owner._id.toString())).toBe(1);
});
it('removes a stranded credential from an account with no password hash', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ provider: 'openid', password: undefined });
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.removePasskey(authedReq(user, undefined, { passkeyId: passkey.id }), res);
expect(res.status).toHaveBeenCalledWith(200);
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(0);
expect(logger.warn).not.toHaveBeenCalled();
});
it('gates on the password hash and not on the provider', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ provider: 'openid' });
const passkey = await createStoredPasskey(user);
const res = buildRes();
await handlers.removePasskey(authedReq(user, undefined, { passkeyId: passkey.id }), res);
expect(res.status).toHaveBeenCalledWith(403);
expect(res.json).toHaveBeenCalledWith({ message: 'Incorrect password' });
expect(await methods.countPasskeysByUser(user._id.toString())).toBe(1);
});
});
describe('passkey sign-in', () => {
const loginReq = (credentialId = 'cred-1', userHandle?: string) =>
({
body: { credential: { id: credentialId, response: { userHandle } }, sessionId: 'sess-1' },
}) as PasskeyRequest<{
credential: { id: string; response: { userHandle?: string } };
sessionId: string;
}> as Parameters<ReturnType<typeof createPasskeyHandlers>['authenticatePasskey']>[0];
it('issues an anonymous challenge that lists no credentials', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
await handlers.loginPasskeyOptions({} as PasskeyRequest, res);
expect(res.status).toHaveBeenCalledWith(200);
const body = res.json.mock.calls[0][0];
expect(typeof body.sessionId).toBe('string');
expect(body.options.allowCredentials ?? []).toEqual([]);
});
it('answers 400 without a session id', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
const req = loginReq();
delete (req.body as { sessionId?: string }).sessionId;
await handlers.authenticatePasskey(req, res, jest.fn());
expect(res.status).toHaveBeenCalledWith(400);
expect(res.json).toHaveBeenCalledWith({ message: 'Missing credential' });
});
it('signs in a credential owned by a verified local account and advances the counter', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
const req = loginReq();
const next = jest.fn();
await handlers.authenticatePasskey(req, buildRes(), next);
expect(next).toHaveBeenCalledTimes(1);
expect(req.user?._id?.toString()).toBe(user._id.toString());
const stored = await methods.findPasskeyByCredentialId('cred-1');
expect(stored?.counter).toBe(1);
expect(stored?.lastUsedAt).toBeInstanceOf(Date);
});
it('refuses an unknown credential', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
await handlers.authenticatePasskey(loginReq('missing'), res, jest.fn());
expect(res.status).toHaveBeenCalledWith(401);
expect(res.json).toHaveBeenCalledWith({ message: 'Passkey authentication failed' });
});
it('refuses a user handle that does not match the credential owner', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
const res = buildRes();
const handle = Buffer.from('someone-else').toString('base64url');
await handlers.authenticatePasskey(loginReq('cred-1', handle), res, jest.fn());
expect(res.status).toHaveBeenCalledWith(401);
expect(mockVerifyAuthentication).not.toHaveBeenCalled();
expect(logger.warn).toHaveBeenCalledWith(
'[authenticatePasskey] User handle does not match the credential owner',
);
});
it('refuses an assertion that does not verify', async () => {
mockVerifyAuthentication.mockResolvedValue(null);
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
const res = buildRes();
await handlers.authenticatePasskey(
loginReq('cred-1', Buffer.from(user._id.toString()).toString('base64url')),
res,
jest.fn(),
);
expect(res.status).toHaveBeenCalledWith(401);
});
it('refuses a credential owned by an SSO-provisioned account', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ provider: 'openid' });
await createStoredPasskey(user);
const res = buildRes();
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), res, next);
expect(next).not.toHaveBeenCalled();
expect(res.status).toHaveBeenCalledWith(401);
expect((await methods.findPasskeyByCredentialId('cred-1'))?.counter).toBe(0);
});
it('rejects an unverified local account when ALLOW_UNVERIFIED_EMAIL_LOGIN is false', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ emailVerified: false });
await createStoredPasskey(user);
const res = buildRes();
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), res, next);
expect(next).not.toHaveBeenCalled();
expect(res.status).toHaveBeenCalledWith(401);
expect(logger.warn).toHaveBeenCalledWith(
'[authenticatePasskey] Rejected unverified email login',
);
expect((await methods.findPasskeyByCredentialId('cred-1'))?.counter).toBe(0);
});
it('allows an unverified local account when ALLOW_UNVERIFIED_EMAIL_LOGIN is true', async () => {
process.env.ALLOW_UNVERIFIED_EMAIL_LOGIN = 'true';
const updateUser = jest.fn(buildDeps().updateUser);
const handlers = createPasskeyHandlers(buildDeps({ updateUser }));
const expiresAt = new Date(Date.now() + 60_000);
const user = await createUser({ emailVerified: false, expiresAt });
await createStoredPasskey(user);
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), buildRes(), next);
expect(next).toHaveBeenCalledTimes(1);
expect(updateUser).toHaveBeenCalledWith(user._id, {});
});
/**
* Matches `localStrategy`: an account predating mandatory verification, on a
* deployment with no email configured, is verified as it signs in. Diverging here
* would let the password factor in and lock the passkey factor out.
*/
it('grandfathers a legacy unverified account the way the password flow does', async () => {
delete process.env.EMAIL_SERVICE;
delete process.env.EMAIL_FROM;
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser({ emailVerified: false });
await mongoose.models.User.collection.updateOne(
{ _id: user._id },
{ $set: { createdAt: new Date('2024-01-01T00:00:00.000Z') } },
);
await createStoredPasskey(user);
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), buildRes(), next);
expect(next).toHaveBeenCalledTimes(1);
const reloaded = await methods.getUserById(user._id.toString());
expect(reloaded?.emailVerified).toBe(true);
});
it('rejects an assertion that loses the signature counter transition', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
await methods.recordPasskeyUse('cred-1', 5);
mockVerifyAuthentication.mockResolvedValue({ newCounter: 3, backedUp: false });
const req = loginReq();
const res = buildRes();
const next = jest.fn();
await handlers.authenticatePasskey(req, res, next);
expect(next).not.toHaveBeenCalled();
expect(req.user).toBeUndefined();
expect(res.status).toHaveBeenCalledWith(401);
});
it('persists the backup state the authenticator reports on sign-in', async () => {
const handlers = createPasskeyHandlers(buildDeps());
const user = await createUser();
await createStoredPasskey(user);
mockVerifyAuthentication.mockResolvedValue({ newCounter: 1, backedUp: true });
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), buildRes(), next);
expect(next).toHaveBeenCalledTimes(1);
const stored = await methods.findPasskeyByCredentialId('cred-1');
expect(stored?.backedUp).toBe(true);
});
it('answers 500 when a lookup throws', async () => {
const handlers = createPasskeyHandlers(
buildDeps({ findPasskeyByCredentialId: jest.fn().mockRejectedValue(new Error('down')) }),
);
const res = buildRes();
await handlers.authenticatePasskey(loginReq(), res, jest.fn());
expect(res.status).toHaveBeenCalledWith(500);
expect(res.json).toHaveBeenCalledWith({ message: 'Something went wrong' });
});
});
describe('passkey sign-in ban enforcement', () => {
const loginReq = () =>
({
body: { credential: { id: 'cred-1', response: {} }, sessionId: 'sess-1' },
}) as Parameters<ReturnType<typeof createPasskeyHandlers>['authenticatePasskey']>[0];
let user: IUser;
beforeEach(async () => {
user = await createUser();
await createStoredPasskey(user);
});
it('re-checks the ban with the resolved user before handing off', async () => {
let userAtCheck: PasskeyAccount | undefined;
checkBan.mockImplementation(async (req) => {
userAtCheck = req.user;
});
const handlers = createPasskeyHandlers(buildDeps());
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), buildRes(), next);
expect(checkBan).toHaveBeenCalledTimes(1);
expect(userAtCheck?._id?.toString()).toBe(user._id.toString());
expect(next).toHaveBeenCalledTimes(1);
});
it('does not issue tokens for a banned user', async () => {
checkBan.mockImplementation(async (req, res) => {
req.banned = true;
return res.status(403).json({ message: 'banned' });
});
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), res, next);
expect(next).not.toHaveBeenCalled();
expect(res.status).toHaveBeenCalledWith(403);
expect(res.status).toHaveBeenCalledTimes(1);
});
/**
* `checkBan` swallows its own errors into a no-op `next`, so a failed check leaves
* `req.banned` unset. Falling through there would issue tokens to an account the
* ban list was never able to answer for.
*/
it('refuses when the ban check cannot complete', async () => {
checkBan.mockImplementation(async (_req, _res, next) => next(new Error('ban store down')));
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
const next = jest.fn();
await handlers.authenticatePasskey(loginReq(), res, next);
expect(next).not.toHaveBeenCalled();
expect(res.status).toHaveBeenCalledWith(401);
});
it('does not answer twice when the failed ban check already responded', async () => {
checkBan.mockImplementation(async (_req, res, next) => {
res.headersSent = true;
next(new Error('ban store down'));
});
const handlers = createPasskeyHandlers(buildDeps());
const res = buildRes();
await handlers.authenticatePasskey(loginReq(), res, jest.fn());
expect(res.status).not.toHaveBeenCalled();
});
});
describe('createPasskeyChallengeStore', () => {
it('leaves arbitration to delete when the cache has no native getDel', async () => {
const store = createPasskeyChallengeStore(memoryCache());
await store.set('k', 'challenge');
expect(store.getDel).toBeUndefined();
await expect(store.get('k')).resolves.toBe('challenge');
await expect(Promise.all([store.delete('k'), store.delete('k')])).resolves.toEqual([
true,
false,
]);
});
it('prefers the cache getDel when the adapter exposes one', async () => {
const getDel = jest.fn(async () => 'atomic');
const store = createPasskeyChallengeStore({ ...memoryCache(), getDel });
await expect(store.getDel?.('k')).resolves.toBe('atomic');
expect(getDel).toHaveBeenCalledWith('k');
});
});