Skip to content

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

🔏 fix: 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.example
index 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=strong
SESSION_EXPIRY=1000 * 60 * 15
REFRESH_TOKEN_EXPIRY=(1000 * 60 * 60 * 24) * 7
diff --git a/api/server/routes/__tests__/keys.spec.js b/api/server/routes/__tests__/keys.spec.js
index 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.js
index 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.js
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 collect
expect(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.ts
index 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.ts
index 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: stri
if (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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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,