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
🔏 fix: Encrypt Provider Keys With v3, Reject Plaintext in decryptV2 and Default to Strong Backup Codes (#17051)
Marco Beretta1994a4949d04
diff --git a/.env.example b/.env.exampleindex 4146dc3e5a..96c2c2cb38 100644--- a/.env.example+++ b/.env.example@@ -937,14 +937,12 @@ ALLOW_UNVERIFIED_EMAIL_LOGIN=true# existing pre-authentication login limits, because they apply before request/tenant config is available.ENFORCE_TWO_FACTOR_AUTHENTICATION=false-# Strong recovery codes require matching backend and client versions. This process-wide-# issuance gate defaults to legacy when unset, so upgrades do not strand older replicas/clients.-# During a rolling upgrade, leave this unset or set legacy on every replica. After every-# backend is upgraded and users reload the updated client, set strong on every replica.-# Replacements issued in legacy mode retain the previous 32-bit strength. Switching to-# strong does not rewrite existing codes; users must regenerate them. Do not roll back-# to an older backend after strong codes have been issued without replacing those codes.-TWO_FACTOR_BACKUP_CODE_FORMAT=strong+# Recovery codes are issued in the strong format (128-bit, salted) unless this is set to legacy.+# Set legacy only during a rolling upgrade, on every replica, while older backends or clients+# that cannot read strong codes are still running; legacy codes are 32-bit and unsalted.+# Existing legacy codes keep working until the user regenerates them. Do not roll back to an+# older backend after strong codes have been issued without replacing those codes.+# TWO_FACTOR_BACKUP_CODE_FORMAT=strongSESSION_EXPIRY=1000 * 60 * 15REFRESH_TOKEN_EXPIRY=(1000 * 60 * 60 * 24) * 7diff --git a/api/server/routes/__tests__/keys.spec.js b/api/server/routes/__tests__/keys.spec.jsindex 0c96dd3bcb..b0f95e6d10 100644--- a/api/server/routes/__tests__/keys.spec.js+++ b/api/server/routes/__tests__/keys.spec.js@@ -9,8 +9,14 @@ jest.mock('~/models', () => ({jest.mock('~/server/middleware/requireJwtAuth', () => (req, res, next) => next());+let mockCredentialsConfig;+jest.mock('~/server/middleware', () => ({requireJwtAuth: (req, res, next) => next(),+ configMiddleware: (req, res, next) => {+ req.config = { credentials: mockCredentialsConfig };+ next();+ },}));describe('Keys Routes', () => {@@ -33,6 +39,7 @@ describe('Keys Routes', () => {beforeEach(() => {jest.clearAllMocks();+ mockCredentialsConfig = undefined;});describe('PUT /', () => {@@ -53,6 +60,18 @@ describe('Keys Routes', () => {expect(updateUserKey).toHaveBeenCalledTimes(1);});+ it('passes the configured credentials write format from the loaded request config', async () => {+ updateUserKey.mockResolvedValue({});+ mockCredentialsConfig = { writeFormat: 'legacy' };++ const response = await request(app).put('/api/keys').send({ name: 'openAI', value: 'sk-1' });++ expect(response.status).toBe(201);+ expect(updateUserKey).toHaveBeenCalledWith(+ expect.objectContaining({ writeFormat: 'legacy' }),+ );+ });+it('should not allow userId override via request body (IDOR prevention)', async () => {updateUserKey.mockResolvedValue({});diff --git a/api/server/routes/keys.js b/api/server/routes/keys.jsindex dfd68f69c4..7622f5a275 100644--- a/api/server/routes/keys.js+++ b/api/server/routes/keys.js@@ -1,15 +1,21 @@const express = require('express');const { updateUserKey, deleteUserKey, getUserKeyExpiry } = require('~/models');-const { requireJwtAuth } = require('~/server/middleware');+const { configMiddleware, requireJwtAuth } = require('~/server/middleware');const router = express.Router();-router.put('/', requireJwtAuth, async (req, res) => {+router.put('/', requireJwtAuth, configMiddleware, async (req, res) => {if (req.body == null || typeof req.body !== 'object') {return res.status(400).send({ error: 'Invalid request body.' });}const { name, value, expiresAt } = req.body;- await updateUserKey({ userId: req.user.id, name, value, expiresAt });+ await updateUserKey({+ userId: req.user.id,+ name,+ value,+ expiresAt,+ writeFormat: req.config?.credentials?.writeFormat,+ });res.status(201).send();});diff --git a/api/server/services/ActionService.spec.js b/api/server/services/ActionService.spec.jsindex 08260b99bd..1ada3184d7 100644--- a/api/server/services/ActionService.spec.js+++ b/api/server/services/ActionService.spec.js@@ -561,10 +561,10 @@ describe('createActionTool OAuth abort identity', () => {const { requestBuilder, preparedExecutor } = oauthToolFixture();/** No access token but a live refresh token: the branch that waits on the* shared refresh flow rather than opening a login. */+ const refreshToken = await dataSchemas.encryptV2('refresh-token');mockFindToken.mockImplementation(async ({ type }) =>- type === 'oauth_refresh' ? { token: 'encrypted-refresh-token' } : null,+ type === 'oauth_refresh' ? { token: refreshToken } : null,);- jest.spyOn(dataSchemas, 'decryptV2').mockResolvedValue('refresh-token');/** The refresh never settles; the run stops while it is pending. */mockActionFlowManager.createFlowWithHandler.mockImplementation(() => new Promise(() => {}));diff --git a/e2e/specs/mock/scenarios/credential-encryption.spec.ts b/e2e/specs/mock/scenarios/credential-encryption.spec.tsindex 2138b04d5e..ea9c4f2008 100644--- a/e2e/specs/mock/scenarios/credential-encryption.spec.ts+++ b/e2e/specs/mock/scenarios/credential-encryption.spec.ts@@ -1,5 +1,5 @@+import { createCipheriv, randomUUID } from 'crypto';import { ObjectId } from 'mongodb';-import { randomUUID } from 'crypto';import { expect, test } from '@playwright/test';import type { APIRequestContext } from '@playwright/test';import type { User } from '../../../types';@@ -90,32 +90,17 @@ async function readStoredAuths(userId: string, pluginKey: string): Promise<Store}/**- * Produces a value in the legacy fixed-IV format by letting the server encrypt it on a- * path that still writes that format (user endpoint keys), then removes the key record.+ * Produces a value in the legacy fixed-IV format with the server's credential key and IV,+ * which the mock config exports to the test runner. No current write path emits this+ * format by default, so a legacy record has to be built the way an old install stored it.*/-async function legacyCiphertext(- request: APIRequestContext,- token: string,- userId: string,- plaintext: string,-): Promise<string> {- const name = `e2e-legacy-${randomUUID()}`;- const response = await request.put('/api/keys', {- headers: { Authorization: `Bearer ${token}` },- data: { name, value: plaintext },- });- expect(response.status()).toBe(201);- return withMongo(async (db) => {- const doc = await db- .collection('keys')- .findOneAndDelete({ userId: new ObjectId(userId), name });- const value = (doc as { value?: unknown } | null)?.value;- if (typeof value !== 'string') {- throw new Error('Expected the legacy key record to carry an encrypted value');- }- expect(value).toMatch(LEGACY_FORMAT);- return value;- });+function legacyCiphertext(plaintext: string): string {+ const key = Buffer.from(process.env.CREDS_KEY ?? '', 'hex');+ const iv = Buffer.from(process.env.CREDS_IV ?? '', 'hex');+ const cipher = createCipheriv('aes-256-cbc', key, iv);+ const value = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]).toString('hex');+ expect(value).toMatch(LEGACY_FORMAT);+ return value;}async function seedStoredAuth(userId: string, auth: StoredAuth): Promise<void> {@@ -231,7 +216,7 @@ test.describe('stored credential encryption', () => {const seeded: StoredAuth[] = [];for (const authField of Object.values(WEB_SEARCH_FIELDS)) {- const value = await legacyCiphertext(request, token, userId, `e2e-legacy-${authField}`);+ const value = legacyCiphertext(`e2e-legacy-${authField}`);const auth = { authField, value, pluginKey: WEB_SEARCH };await seedStoredAuth(userId, auth);seeded.push(auth);@@ -259,7 +244,7 @@ test.describe('stored credential encryption', () => {firecrawlApiKey: secret,jinaApiKey: secret,});- const legacy = await legacyCiphertext(request, token, userId, secret);+ const legacy = legacyCiphertext(secret);await seedStoredAuth(userId, {authField: WEB_SEARCH_FIELDS.serperApiKey,value: legacy,@@ -311,7 +296,7 @@ test.describe('stored credential encryption', () => {const user = newUser('mcp-legacy');try {const { token, userId } = await registerAndLogin(request, user);- const value = await legacyCiphertext(request, token, userId, MCP_TOKEN);+ const value = legacyCiphertext(MCP_TOKEN);await seedStoredAuth(userId, { authField: MCP_VAR, value, pluginKey: MCP_PLUGIN_KEY });expect(await mcpVarIsSet(request, token)).toBe(true);@@ -366,6 +351,21 @@ test.describe('stored credential encryption', () => {expect(stored[0].value).not.toContain(MCP_TOKEN);expect(await mcpVarIsSet(request, token)).toBe(true);await expectMcpConnects(request, token);++ /** The user provider key route reads the same override. */+ const keyName = `e2e-legacy-key-${randomUUID()}`;+ const keyPut = await request.put('/api/keys', {+ headers: { Authorization: `Bearer ${token}` },+ data: { name: keyName, value: 'e2e-provider-key' },+ });+ expect(keyPut.status()).toBe(201);+ const keyValue = await withMongo(async (db) => {+ const doc = await db+ .collection('keys')+ .findOne({ userId: new ObjectId(userId), name: keyName });+ return (doc as { value?: string } | null)?.value ?? '';+ });+ expect(keyValue).toMatch(LEGACY_FORMAT);} finally {if (userId) {const del = await request.delete(`/api/admin/config/user/${userId}`, {diff --git a/packages/api/src/admin/config.handler.spec.ts b/packages/api/src/admin/config.handler.spec.tsindex b2168470b7..88cbcd0cbe 100644--- a/packages/api/src/admin/config.handler.spec.ts+++ b/packages/api/src/admin/config.handler.spec.ts@@ -110,7 +110,7 @@ describe('createAdminConfigHandlers', () => {}>;expect(configs[0].overrides.langfuse).toEqual({publicKey: 'pk-lf-1',- secretKeyPreview: 'sk-lf-...cret',+ secretKeyPreview: '*************',});});});@@ -664,14 +664,14 @@ describe('createAdminConfigHandlers', () => {const savedOverrides = deps.upsertConfig.mock.calls[0][3];const [saved, envRef] = savedOverrides.endpoints.custom as Array<Record<string, string>>;expect(saved.apiKey).toBe('v3:test:sk-or-secret-key');- expect(saved.apiKeyPreview).toBe('sk-or-...-key');+ expect(saved.apiKeyPreview).toBe('...-key');expect(envRef.apiKey).toBe('${OPENROUTER_KEY}');expect(envRef.apiKeyPreview).toBeUndefined();const responseConfig = res.body!.config as {overrides: { endpoints: { custom: Array<Record<string, string>> } };};expect(responseConfig.overrides.endpoints.custom[0].apiKey).toBeUndefined();- expect(responseConfig.overrides.endpoints.custom[0].apiKeyPreview).toBe('sk-or-...-key');+ expect(responseConfig.overrides.endpoints.custom[0].apiKeyPreview).toBe('...-key');expect(responseConfig.overrides.endpoints.custom[1].apiKey).toBe('${OPENROUTER_KEY}');});@@ -2392,11 +2392,11 @@ describe('createAdminConfigHandlers', () => {};expect(responseConfig.langfuse).toEqual({publicKey: 'pk-lf-1',- secretKeyPreview: 'sk-lf-...cret',+ secretKeyPreview: '*************',});expect(responseConfig.config.langfuse).toEqual({publicKey: 'pk-lf-1',- secretKeyPreview: 'sk-lf-...cret',+ secretKeyPreview: '*************',});});diff --git a/packages/api/src/admin/langfuse.handler.spec.ts b/packages/api/src/admin/langfuse.handler.spec.tsindex 5db211dbd2..f74df7907b 100644--- a/packages/api/src/admin/langfuse.handler.spec.ts+++ b/packages/api/src/admin/langfuse.handler.spec.ts@@ -526,7 +526,7 @@ describe('createAdminLangfuseHandlers', () => {const fields = deps.patchConfigFields.mock.calls[0][3];expect(fields['langfuse.secretKey']).toMatch(/^v3:/);expect(fields['langfuse.secretKey']).not.toContain('sk-lf-secret');- expect(fields['langfuse.secretKeyPreview']).toBe('sk-lf-...cret');+ expect(fields['langfuse.secretKeyPreview']).toBe('************');expect(fields['langfuse.enabled']).toBe(true);expect(fields['langfuse.destination']).toBe('eu');expect(fields['langfuse.publicKey']).toBe('pk-lf-1');diff --git a/packages/api/src/admin/secrets.integration.spec.ts b/packages/api/src/admin/secrets.integration.spec.tsindex b1297bb187..0580855699 100644--- a/packages/api/src/admin/secrets.integration.spec.ts+++ b/packages/api/src/admin/secrets.integration.spec.ts@@ -734,7 +734,7 @@ describe('config secret registry — real handlers against a real Config collectexpect(getAtPath(config, 'speech.tts.openai.model')).toBe('tts-1');expect(getAtPath(config, 'speech.tts.openai.apiKey')).toBeUndefined();expect(getAtPath(config, 'speech.tts.openai.apiKeyPreview')).toBe(getSecretPreview(SECRET));- expect(getAtPath(config, 'langfuse.secretKeyPreview')).toBe('sk-...ret');+ expect(getAtPath(config, 'langfuse.secretKeyPreview')).toBe('*********');expect(getAtPath(config, 'config.speech.tts.openai.apiKey')).toBeUndefined();});});diff --git a/packages/api/src/admin/secrets.spec.ts b/packages/api/src/admin/secrets.spec.tsindex d076bc069f..6d2064ba23 100644--- a/packages/api/src/admin/secrets.spec.ts+++ b/packages/api/src/admin/secrets.spec.ts@@ -46,7 +46,7 @@ describe('Langfuse config secrets', () => {expect(out['langfuse.secretKey']).toMatch(/^v3:/);expect(decryptV3(out['langfuse.secretKey'] as string)).toBe('sk-lf-secret');- expect(out['langfuse.secretKeyPreview']).toBe('sk-lf-...cret');+ expect(out['langfuse.secretKeyPreview']).toBe('************');expect(out['langfuse.publicKey']).toBe('pk-lf-1');});@@ -61,7 +61,7 @@ describe('Langfuse config secrets', () => {expect(out.langfuse.secretKey).toMatch(/^v3:/);expect(decryptV3(out.langfuse.secretKey)).toBe('sk-lf-secret');- expect(out.langfuse.secretKeyPreview).toBe('sk-lf-...cret');+ expect(out.langfuse.secretKeyPreview).toBe('************');expect(out.langfuse.publicKey).toBe('pk-lf-1');});@@ -204,7 +204,7 @@ describe('Langfuse config secrets', () => {enabled: true,destination: 'eu',publicKey: 'pk-lf-1',- secretKeyPreview: 'sk-lf-...cret',+ secretKeyPreview: '*************',});});@@ -244,7 +244,7 @@ describe('Langfuse config secrets', () => {const redacted = redactConfigSecrets({langfuse: { publicKey: 'pk-lf-1', secretKey: 'v3:abc:def', displaySecretKey: 'sk-lf-...old' },});- expect(redacted.langfuse).toEqual({ publicKey: 'pk-lf-1', secretKeyPreview: 'sk-lf-...old' });+ expect(redacted.langfuse).toEqual({ publicKey: 'pk-lf-1', secretKeyPreview: '************' });const alreadyMigrated = redactConfigSecrets({langfuse: {@@ -253,13 +253,13 @@ describe('Langfuse config secrets', () => {displaySecretKey: 'sk-lf-...old',},});- expect(alreadyMigrated.langfuse).toEqual({ secretKeyPreview: 'sk-lf-...new' });+ expect(alreadyMigrated.langfuse).toEqual({ secretKeyPreview: '************' });const encrypted = encryptConfigSecrets({langfuse: { secretKey: 'sk-lf-new-secret', displaySecretKey: 'sk-lf-...old' },}).langfuse as Record<string, string>;expect(encrypted.displaySecretKey).toBeUndefined();- expect(encrypted.secretKeyPreview).toBe('sk-lf-...cret');+ expect(encrypted.secretKeyPreview).toBe('...cret');const existing = {langfuse: {@@ -271,7 +271,7 @@ describe('Langfuse config secrets', () => {const preserved = preserveConfigSecrets({ langfuse: { publicKey: 'pk-new' } }, existing);const preservedLangfuse = preserved.langfuse as Record<string, string>;expect(decryptV3(preservedLangfuse.secretKey)).toBe('sk-lf-old-secret');- expect(preservedLangfuse.secretKeyPreview).toBe('sk-lf-...cret');+ expect(preservedLangfuse.secretKeyPreview).toBe('*************');expect(preservedLangfuse.displaySecretKey).toBeUndefined();expect(getConfigSecretInputError('langfuse.displaySecretKey', 'spoofed')).toContain(@@ -387,7 +387,13 @@ describe('Config secret registry fields', () => {it('masks short credentials fully instead of disclosing them via the preview companion', () => {expect(getSecretPreview('short12')).toBe('*******');expect(getSecretPreview('0123456789')).toBe('**********');- expect(getSecretPreview('sk-longer-secret-value')).toBe('sk-lon...alue');+ expect(getSecretPreview('0123456789abcde')).toBe('***************');+ });++ it('reveals only the last four characters of a long secret, never a prefix', () => {+ const preview = getSecretPreview('sk-longer-secret-value');+ expect(preview).toBe('...alue');+ expect(preview).not.toContain('sk-');});it('encrypts dotted patch writes and sets a masked preview companion for every field', () => {@@ -502,7 +508,7 @@ describe('Config secret registry fields', () => {model: 'tts-1',});expect(redacted.speech.stt.openai).toEqual({- apiKeyPreview: 'sk-old...-old',+ apiKeyPreview: '*************',model: 'whisper-1',});expect(redacted.ocr).toEqual({@@ -510,7 +516,7 @@ describe('Config secret registry fields', () => {mistralModel: 'mistral-ocr-latest',});expect(redacted.webSearch).toEqual({- serperApiKeyPreview: 'sk-lite...eral',+ serperApiKeyPreview: '**************',searchProvider: 'serper',});});@@ -696,7 +702,7 @@ describe('Custom endpoint config secrets', () => {expect(entry.apiKey).toMatch(/^v3:/);expect(decryptV3(entry.apiKey)).toBe('sk-or-super-secret');- expect(entry.apiKeyPreview).toBe('sk-or-...cret');+ expect(entry.apiKeyPreview).toBe('...cret');expect(entry.baseURL).toBe('https://openrouter.ai');});@@ -715,6 +721,25 @@ describe('Custom endpoint config secrets', () => {expect(b.apiKeyPreview).toBeUndefined();});+ it('fully masks previews stored under the old prefix policy on read and preserve', () => {+ const stored = {+ langfuse: { secretKey: 'v3:abc:def', secretKeyPreview: 'sk-lf-...cret' },+ endpoints: {+ custom: [{ name: 'A', apiKey: 'v3:abc:def', apiKeyPreview: 'sk-or-...cret' }],+ },+ };+ const redacted = redactConfigSecrets(structuredClone(stored)) as typeof stored;+ expect(redacted.langfuse.secretKeyPreview).toBe('*************');+ expect(redacted.endpoints.custom[0].apiKeyPreview).toBe('*************');++ const preserved = preserveConfigSecrets(+ { langfuse: { publicKey: 'pk' }, endpoints: { custom: [{ name: 'A' }] } },+ structuredClone(stored),+ ) as unknown as typeof stored;+ expect(preserved.langfuse.secretKeyPreview).toBe('*************');+ expect(preserved.endpoints.custom[0].apiKeyPreview).toBe('*************');+ });+it('encrypts section and array patched values from field maps', () => {const viaSection = encryptConfigSecretFields({endpoints: { custom: [{ name: 'A', apiKey: 'sk-section-key' }] },@@ -722,14 +747,14 @@ describe('Custom endpoint config secrets', () => {const sectionEntry = (viaSection.endpoints as { custom: Array<Record<string, string>> }).custom[0];expect(decryptV3(sectionEntry.apiKey)).toBe('sk-section-key');- expect(sectionEntry.apiKeyPreview).toBe('sk-sec...-key');+ expect(sectionEntry.apiKeyPreview).toBe('**************');const viaArray = encryptConfigSecretFields({'endpoints.custom': [{ name: 'A', apiKey: 'sk-array-key0' }],});const arrayEntry = (viaArray['endpoints.custom'] as Array<Record<string, string>>)[0];expect(decryptV3(arrayEntry.apiKey)).toBe('sk-array-key0');- expect(arrayEntry.apiKeyPreview).toBe('sk-arr...key0');+ expect(arrayEntry.apiKeyPreview).toBe('*************');});it('clears empty, non-string, or pre-encrypted API key submissions', () => {@@ -848,7 +873,7 @@ describe('Custom endpoint config secrets', () => {const [openRouter, brandNew] = preserved.endpoints.custom as Array<Record<string, string>>;expect(decryptV3(openRouter.apiKey)).toBe('sk-or-old-secret');- expect(openRouter.apiKeyPreview).toBe('sk-or-...cret');+ expect(openRouter.apiKeyPreview).toBe('...cret');expect(brandNew.apiKey).toBeUndefined();});@@ -869,7 +894,7 @@ describe('Custom endpoint config secrets', () => {expect(legacy.apiKey).toMatch(/^v3:/);expect(decryptV3(legacy.apiKey)).toBe('sk-legacy-plaintext');- expect(legacy.apiKeyPreview).toBe('sk-leg...text');+ expect(legacy.apiKeyPreview).toBe('...text');expect(envRef.apiKey).toBeUndefined();});@@ -940,7 +965,7 @@ describe('Custom endpoint config secrets', () => {const [a, b, c, d, e] = redacted.endpoints.custom as Array<Record<string, string>>;expect(a.apiKey).toBeUndefined();- expect(a.apiKeyPreview).toBe('sk-a...key');+ expect(a.apiKeyPreview).toBe('**********');expect(b.apiKey).toBeUndefined();expect(c.apiKey).toBe('user_provided');expect(d.apiKey).toBe('${OPENROUTER_KEY}');diff --git a/packages/api/src/admin/secrets.ts b/packages/api/src/admin/secrets.tsindex 8064dd6735..547600c52e 100644--- a/packages/api/src/admin/secrets.ts+++ b/packages/api/src/admin/secrets.ts@@ -109,11 +109,33 @@ const SECRET_SECTIONS: readonly string[] = []),];+/** Shortest secret that earns a hint; below this, even four characters reveal too much. */+const PREVIEW_MIN_LENGTH = 16;+const PREVIEW_VISIBLE = 4;++/** Masked hint for admin display: only the last four characters of a long secret, never a prefix. */export function getSecretPreview(secret: string): string {- if (secret.length <= 10) {+ if (secret.length < PREVIEW_MIN_LENGTH) {return '*'.repeat(secret.length);}- return secret.slice(0, 6) + '...' + secret.slice(-4);+ return '...' + secret.slice(-PREVIEW_VISIBLE);+}++/**+ * Re-derives a stored preview under the current policy. Previews persisted by+ * earlier releases carry a fixed-width leading prefix (`sk-lf-...cret`) whatever+ * the secret length, so the original length cannot be established and they are+ * fully masked until the secret is next written. Anything unrecognised is also+ * fully masked.+ */+export function normalizeStoredPreview(preview: string): string {+ if (preview === '' || /^\*+$/.test(preview)) {+ return preview;+ }+ if (preview.startsWith('...') && preview.length <= 3 + PREVIEW_VISIBLE) {+ return preview;+ }+ return '*'.repeat(preview.length);}/** Top-level config sections containing registered secret fields. */@@ -443,7 +465,9 @@ function preserveArraySecrets(result: unknown, existing: unknown, basePath: striif (isEncryptedConfigSecret(existingSecret)) {entry[field.secretKey] = existingSecret;if (typeof existingEntry[field.previewKey] === 'string') {- entry[field.previewKey] = existingEntry[field.previewKey];+ entry[field.previewKey] = normalizeStoredPreview(+ existingEntry[field.previewKey] as string,+ );}continue;}@@ -770,7 +794,7 @@ export function preserveConfigSecrets<T>(next: T, existing?: unknown, basePath =const legacyPreview = legacyPath ? existingSection[lastSegment(legacyPath)] : undefined;const existingPreview = existingSection[previewKey] ?? legacyPreview;if (typeof existingPreview === 'string') {- section[previewKey] = existingPreview;+ section[previewKey] = normalizeStoredPreview(existingPreview);} else if (!isAlreadyEncrypted && !isPlaceholder) {section[previewKey] = getSecretPreview(existingSecret);}@@ -869,6 +893,10 @@ export function redactConfigSecrets<T>(root: T): T {continue;}migrateLegacyPreviewKey(section, field);+ const previewKey = lastSegment(field.previewPath);+ if (typeof section[previewKey] === 'string') {+ section[previewKey] = normalizeStoredPreview(section[previewKey]);+ }const key = segments[segments.length - 1];if (!(key in section)) {continue;@@ -887,6 +915,9 @@ export function redactConfigSecrets<T>(root: T): T {}for (const item of entries) {const entry = getPlainRecord(item);+ if (entry && typeof entry[field.previewKey] === 'string') {+ entry[field.previewKey] = normalizeStoredPreview(entry[field.previewKey] as string);+ }if (entry && shouldRedactArraySecretValue(entry[field.secretKey], field)) {delete entry[field.secretKey];}diff --git a/packages/api/src/auth/recovery.spec.ts b/packages/api/src/auth/recovery.spec.tsindex 23e100eab2..8c2ab2d182 100644--- a/packages/api/src/auth/recovery.spec.ts+++ b/packages/api/src/auth/recovery.spec.ts@@ -8,22 +8,23 @@ import {} from './recovery';describe('two-factor credential generation', () => {- it.each([undefined, 'legacy', 'invalid'])(- 'keeps issuance compatible before activation: %s',+ it.each(['legacy'])('issues legacy codes only on explicit opt-out: %s', async (format) => {+ const { plainCodes, codeObjects } = await createBackupCodeGenerator(format)(2);+ plainCodes.forEach((code, index) => {+ expect(code).toMatch(/^[a-f0-9]{8}$/);+ expect(codeObjects[index].codeHash).toBe(createHash('sha256').update(code).digest('hex'));+ });+ });++ it.each([undefined, 'strong', 'invalid'])(+ 'issues strong codes by default: %s',async (format) => {- const { plainCodes, codeObjects } = await createBackupCodeGenerator(format)(2);- plainCodes.forEach((code, index) => {- expect(code).toMatch(/^[a-f0-9]{8}$/);- expect(codeObjects[index].codeHash).toBe(createHash('sha256').update(code).digest('hex'));- });+ const { plainCodes, codeObjects } = await createBackupCodeGenerator(format)(1);+ expect(plainCodes[0]).toHaveLength(32);+ expect(codeObjects[0].codeHash).toMatch(/^sha256:[a-f0-9]{32}:[a-f0-9]{64}$/);+ expect(matchesBackupCode(plainCodes[0], codeObjects[0].codeHash)).toBe(true);},);-- it('activates strong issuance only when explicitly configured', async () => {- const { plainCodes, codeObjects } = await createBackupCodeGenerator('strong')(1);- expect(plainCodes[0]).toHaveLength(32);- expect(matchesBackupCode(plainCodes[0], codeObjects[0].codeHash)).toBe(true);- });it('generates a 160-bit Base32 TOTP secret', () => {expect(generateTOTPSecret()).toMatch(/^[A-Z2-7]{32}$/);expect(generateTOTPSecret()).not.toBe(generateTOTPSecret());diff --git a/packages/api/src/auth/recovery.ts b/packages/api/src/auth/recovery.tsindex 9bde9c0e6a..48bd0bb9e1 100644--- a/packages/api/src/auth/recovery.ts+++ b/packages/api/src/auth/recovery.ts@@ -56,9 +56,9 @@ export async function generateBackupCodes(return { plainCodes, codeObjects };}-/** Keep issuance compatible until the operator completes the backend/client rollout. */+/** Strong issuance is the default; `legacy` is the explicit opt-out for mixed-version rollouts. */export function createBackupCodeGenerator(format?: string): typeof generateBackupCodes {- return (count = 10) => generateBackupCodes(count, format !== 'strong');+ return (count = 10) => generateBackupCodes(count, format === 'legacy');}/** Accept legacy digests until the user regenerates their recovery codes. */diff --git a/packages/data-schemas/src/crypto/index.spec.ts b/packages/data-schemas/src/crypto/index.spec.tsnew file mode 100644index 0000000000..c015a9cbcf--- /dev/null+++ b/packages/data-schemas/src/crypto/index.spec.ts@@ -0,0 +1,29 @@+const CREDS_KEY: string = 'a'.repeat(64);+const CREDS_IV: string = 'b'.repeat(32);++let credCrypto: typeof import('./index');++beforeAll(async () => {+ process.env.CREDS_KEY = CREDS_KEY;+ process.env.CREDS_IV = CREDS_IV;+ credCrypto = await import('./index');+});++describe('decryptV2', () => {+ it('round-trips a value encrypted with encryptV2', async () => {+ const encrypted = await credCrypto.encryptV2('secret-token');+ expect(encrypted).toContain(':');+ await expect(credCrypto.decryptV2(encrypted)).resolves.toBe('secret-token');+ });++ it('rejects undelimited input instead of returning it as plaintext', async () => {+ await expect(credCrypto.decryptV2('plain-token')).rejects.toThrow('Invalid encrypted value');+ await expect(credCrypto.decryptV2('')).rejects.toThrow('Invalid encrypted value');+ });+});++describe('encryptV3', () => {+ it('uses a fresh IV per value', () => {+ expect(credCrypto.encryptV3('same')).not.toBe(credCrypto.encryptV3('same'));+ });+});diff --git a/packages/data-schemas/src/crypto/index.ts b/packages/data-schemas/src/crypto/index.tsindex 474fa75ecb..b030ec96be 100644--- a/packages/data-schemas/src/crypto/index.ts+++ b/packages/data-schemas/src/crypto/index.ts@@ -90,11 +90,13 @@ export async function encryptV2(value: string): Promise<string> {* Decrypts an encrypted value using AES-CBC with random IV* @param encryptedValue - The encrypted string in iv:ciphertext format* @returns The decrypted plaintext+ * @throws If the value has no `iv:ciphertext` delimiter. Undelimited input is never returned+ * as plaintext; callers holding legacy plaintext rows must detect and handle them explicitly.*/export async function decryptV2(encryptedValue: string): Promise<string> {const parts = encryptedValue.split(':');if (parts.length === 1) {- return parts[0];+ throw new Error('Invalid encrypted value: expected iv:ciphertext format');}const gen_iv = Buffer.from(parts.shift() ?? '', 'hex');const encrypted = parts.join(':');diff --git a/packages/data-schemas/src/methods/key.spec.ts b/packages/data-schemas/src/methods/key.spec.tsnew file mode 100644index 0000000000..7d0b498e9a--- /dev/null+++ b/packages/data-schemas/src/methods/key.spec.ts@@ -0,0 +1,69 @@+import mongoose from 'mongoose';+import { MongoMemoryServer } from 'mongodb-memory-server';+import type { createKeyMethods as CreateKeyMethods } from './key';+import type * as Crypto from '~/crypto';++process.env.CREDS_KEY = 'a'.repeat(64);+process.env.CREDS_IV = 'b'.repeat(32);++let mongoServer: MongoMemoryServer;+let methods: ReturnType<typeof CreateKeyMethods>;+let crypto: typeof Crypto;+const userId = new mongoose.Types.ObjectId().toString();++beforeAll(async () => {+ crypto = await import('~/crypto');+ const { createKeyMethods } = await import('./key');+ const { createModels } = await import('../models');+ mongoServer = await MongoMemoryServer.create();+ await mongoose.connect(mongoServer.getUri());+ createModels(mongoose);+ methods = createKeyMethods(mongoose);+});++afterAll(async () => {+ await mongoose.disconnect();+ await mongoServer.stop();+});++beforeEach(async () => {+ await mongoose.models.Key.deleteMany({});+});++const stored = async (name: string) =>+ (await mongoose.models.Key.findOne({ userId, name }).lean()) as unknown as { value: string };++describe('user provider keys', () => {+ it('writes the random-IV v3 format by default and reads it back', async () => {+ await methods.updateUserKey({ userId, name: 'openAI', value: 'sk-test' });+ await methods.updateUserKey({ userId, name: 'anthropic', value: 'sk-test' });+ const first = await stored('openAI');+ const second = await stored('anthropic');+ expect(first.value).toMatch(/^v3:[0-9a-f]{32}:[0-9a-f]+$/);+ expect(first.value).not.toBe(second.value);+ await expect(methods.getUserKey({ userId, name: 'openAI' })).resolves.toBe('sk-test');+ });++ it('writes the fixed-IV format only when writeFormat is legacy', async () => {+ await methods.updateUserKey({+ userId,+ name: 'openAI',+ value: 'sk-test',+ writeFormat: 'legacy',+ });+ const row = await stored('openAI');+ expect(row.value).toMatch(/^[0-9a-f]+$/);+ await expect(methods.getUserKey({ userId, name: 'openAI' })).resolves.toBe('sk-test');+ });++ it('still reads legacy values written by earlier releases', async () => {+ await mongoose.models.Key.create({+ userId,+ name: 'google',+ value: await crypto.encrypt(JSON.stringify({ apiKey: 'legacy-key' })),+ });+ await expect(methods.getUserKeyValues({ userId, name: 'google' })).resolves.toEqual({+ apiKey: 'legacy-key',+ });+ });+});diff --git a/packages/data-schemas/src/methods/key.ts b/packages/data-schemas/src/methods/key.tsindex 8a7c8a337a..b2d78f855b 100644--- a/packages/data-schemas/src/methods/key.ts+++ b/packages/data-schemas/src/methods/key.ts@@ -1,8 +1,16 @@import { ErrorTypes } from 'librechat-data-provider';+import type { TCredentialsConfig } from 'librechat-data-provider';// Note: checkUserKeyExpiry moved to @librechat/api (utils/key.ts) as it's a pure validation utility-import { encrypt, decrypt } from '~/crypto';+import { encrypt, decrypt, encryptV3, decryptV3 } from '~/crypto';import logger from '~/config/winston';+const V3_PREFIX = 'v3:';++/** Values written by earlier releases are bare hex (fixed IV); `v3:` values carry a random IV. */+function decryptStoredKey(value: string): Promise<string> | string {+ return value.startsWith(V3_PREFIX) ? decryptV3(value) : decrypt(value);+}+/** Factory function that takes mongoose instance and returns the key methods */export function createKeyMethods(mongoose: typeof import('mongoose')): {getUserKey: (params: { userId: string; name: string }) => Promise<string>;@@ -11,6 +19,7 @@ export function createKeyMethods(mongoose: typeof import('mongoose')): {name: string;value: string;expiresAt?: Date | null;+ writeFormat?: TCredentialsConfig['writeFormat'];}) => Promise<unknown>;deleteUserKey: (params: { userId: string; name?: string; all?: boolean }) => Promise<unknown>;getUserKeyValues: (params: { userId: string; name: string }) => Promise<Record<string, string>>;@@ -43,7 +52,7 @@ export function createKeyMethods(mongoose: typeof import('mongoose')): {}),);}- return await decrypt(keyValue.value);+ return await decryptStoredKey(keyValue.value);}/**@@ -106,6 +115,8 @@ export function createKeyMethods(mongoose: typeof import('mongoose')): {* @param params.name - The name associated with the key* @param params.value - The value to be encrypted and stored as the key's value* @param params.expiresAt - The expiry date for the key [optional]+ * @param params.writeFormat - `v3` (default) writes a random IV per value; `legacy` writes the+ * fixed-IV format that releases predating `v3` can read (rolling upgrades)* @returns The updated or newly inserted key document* @description This function either updates an existing user key or inserts a new one into the database,* after encrypting the provided value. It sets the provided expiry date for the key (or unsets for no expiry).@@ -115,10 +126,11 @@ export function createKeyMethods(mongoose: typeof import('mongoose')): {name: string;value: string;expiresAt?: Date | null;+ writeFormat?: TCredentialsConfig['writeFormat'];}): Promise<unknown> {- const { userId, name, value, expiresAt = null } = params;+ const { userId, name, value, expiresAt = null, writeFormat = 'v3' } = params;const Key = mongoose.models.Key;- const encryptedValue = await encrypt(value);+ const encryptedValue = writeFormat === 'legacy' ? await encrypt(value) : encryptV3(value);const updateObject: { userId: string; name: string; value: string; expiresAt?: Date } = {userId,name,