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: Redeem Admin OAuth Codes Only Once (#16513)

lia-by-librechat[bot]d7e70646928b
diff --git a/packages/api/src/auth/exchange.spec.ts b/packages/api/src/auth/exchange.spec.ts
index d929d05e61..be05b356fd 100644
--- a/packages/api/src/auth/exchange.spec.ts
+++ b/packages/api/src/auth/exchange.spec.ts
@@ -1,5 +1,7 @@
import crypto from 'crypto';
import { Keyv } from 'keyv';
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const KeyvRedis = require('@keyv/redis').default as typeof import('@keyv/redis').default;
import type { IUser } from '@librechat/data-schemas';
jest.mock(
@@ -30,11 +32,7 @@ describe('admin OAuth code exchange', () => {
provider: 'openid',
} as unknown as IUser;
- const createCache = () => {
- const cache = new Keyv();
- const deleteSpy = jest.spyOn(cache, 'delete');
- return { cache, deleteSpy };
- };
+ const createCache = () => ({ cache: new Keyv() });
describe('origin binding', () => {
it('exchanges code when request origin matches generated origin', async () => {
@@ -56,7 +54,7 @@ describe('admin OAuth code exchange', () => {
});
it('rejects code exchange when request origin does not match generated origin', async () => {
- const { cache, deleteSpy } = createCache();
+ const { cache } = createCache();
const exchangeCode = await generateAdminExchangeCode(
cache,
user,
@@ -68,7 +66,6 @@ describe('admin OAuth code exchange', () => {
const result = await exchangeAdminCode(cache, exchangeCode, 'https://evil.example.com');
expect(result).toBeNull();
- expect(deleteSpy).toHaveBeenCalledWith(exchangeCode);
await expect(cache.get(exchangeCode)).resolves.toBeUndefined();
});
@@ -123,6 +120,84 @@ describe('admin OAuth code exchange', () => {
expect(secondAttempt).toBeNull();
});
+
+ it('allows only one simultaneous exchange with the in-memory cache', async () => {
+ const { cache } = createCache();
+ const code = await generateAdminExchangeCode(cache, user, 'jwt-token');
+
+ const results = await Promise.all([
+ exchangeAdminCode(cache, code),
+ exchangeAdminCode(cache, code),
+ ]);
+
+ expect(results.filter((result) => result?.token === 'jwt-token')).toHaveLength(1);
+ expect(results.filter((result) => result === null)).toHaveLength(1);
+ });
+
+ it('rejects an entry whose Keyv TTL has expired before redemption', async () => {
+ const cache = new Keyv({ ttl: 50 });
+ const code = await generateAdminExchangeCode(cache, user, 'jwt-token');
+ const now = Date.now();
+ const clock = jest.spyOn(Date, 'now').mockReturnValue(now + 100);
+ try {
+ await expect(exchangeAdminCode(cache, code)).resolves.toBeNull();
+ } finally {
+ clock.mockRestore();
+ }
+ await expect(cache.get(code)).resolves.toBeUndefined();
+ });
+
+ const createRedisCache = () => {
+ const values = new Map<string, string>();
+ const client = {
+ set: jest.fn(async (key: string, value: string) => {
+ values.set(key, value);
+ return 'OK';
+ }),
+ getDel: jest.fn(async (key: string) => {
+ const value = values.get(key) ?? null;
+ values.delete(key);
+ return value;
+ }),
+ };
+ const store = new KeyvRedis();
+ Object.defineProperty(store, 'getClient', { value: async () => client });
+ const cache = new Keyv(store, { namespace: 'ADMIN_OAUTH_EXCHANGE', ttl: 30_000 });
+ store.namespace = 'deployment';
+ store.keyPrefixSeparator = '::';
+ const onError = jest.fn();
+ cache.on('error', onError);
+ return { cache, client, values, onError };
+ };
+
+ it('uses one prefixed GETDEL per attempt so concurrent Redis exchanges cannot replay', async () => {
+ const { cache, client, values } = createRedisCache();
+ const code = await generateAdminExchangeCode(cache, user, 'jwt-token');
+
+ const results = await Promise.all([
+ exchangeAdminCode(cache, code),
+ exchangeAdminCode(cache, code),
+ ]);
+
+ expect(results.filter((result) => result?.token === 'jwt-token')).toHaveLength(1);
+ expect(results.filter((result) => result === null)).toHaveLength(1);
+ expect(client.getDel).toHaveBeenCalledTimes(2);
+ expect(client.getDel).toHaveBeenCalledWith(`deployment::ADMIN_OAUTH_EXCHANGE:${code}`);
+ expect(values.size).toBe(0);
+ });
+
+ it('fails closed when Redis cannot consume the code, allowing a later retry', async () => {
+ const { cache, client, onError } = createRedisCache();
+ const code = await generateAdminExchangeCode(cache, user, 'jwt-token');
+ client.getDel.mockRejectedValueOnce(new Error('Redis unavailable'));
+
+ await expect(exchangeAdminCode(cache, code)).rejects.toThrow('Redis unavailable');
+ expect(onError).toHaveBeenCalledWith(
+ expect.objectContaining({ message: 'Redis unavailable' }),
+ );
+ await expect(exchangeAdminCode(cache, code)).resolves.toMatchObject({ token: 'jwt-token' });
+ await expect(exchangeAdminCode(cache, code)).resolves.toBeNull();
+ });
});
describe('PKCE verification', () => {
diff --git a/packages/api/src/auth/exchange.ts b/packages/api/src/auth/exchange.ts
index bf7fa163d6..9dd53ae293 100644
--- a/packages/api/src/auth/exchange.ts
+++ b/packages/api/src/auth/exchange.ts
@@ -2,6 +2,7 @@ import crypto from 'crypto';
import { Keyv } from 'keyv';
import { logger } from '@librechat/data-schemas';
import type { IUser } from '@librechat/data-schemas';
+import { consumeCacheEntry } from '../cache/consume';
/** Default admin panel URL for local development */
const DEFAULT_ADMIN_PANEL_URL = 'http://localhost:3000';
@@ -138,7 +139,7 @@ export async function generateAdminExchangeCode(
/**
* Exchanges an authorization code for tokens and user data.
- * The code is deleted immediately after retrieval (one-time use).
+ * The code is atomically removed before validation (one-time use).
* @param cache - The Keyv cache instance for retrieving exchange data
* @param code - The authorization code to exchange
* @param requestOrigin - The origin of the requesting client for origin binding
@@ -151,10 +152,7 @@ export async function exchangeAdminCode(
requestOrigin?: string,
codeVerifier?: string,
): Promise<AdminExchangeResponse | null> {
- const data = (await cache.get(code)) as AdminExchangeData | undefined;
-
- /** Delete before validation — ensures one-time use even if subsequent checks throw */
- await cache.delete(code);
+ const data = await consumeCacheEntry<AdminExchangeData>(cache, code);
if (!data) {
logger.warn('[adminExchange] Invalid or expired authorization code');
diff --git a/packages/api/src/cache/consume.ts b/packages/api/src/cache/consume.ts
new file mode 100644
index 0000000000..196dd4bfa0
--- /dev/null
+++ b/packages/api/src/cache/consume.ts
@@ -0,0 +1,43 @@
+/**
+ * @keyv/redis's CommonJS default export requires the same interop as cacheFactory.
+ */
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const KeyvRedis = require('@keyv/redis').default as typeof import('@keyv/redis').default;
+import type { Keyv, DeserializedData } from 'keyv';
+import { observeRedisOperation } from './redisTelemetry';
+
+/** Removes a Keyv entry atomically, including its serialized expiry. */
+export async function consumeCacheEntry<T>(cache: Keyv, key: string): Promise<T | undefined> {
+ const prefixedKey =
+ cache.useKeyPrefix && cache.namespace && !key.startsWith(`${cache.namespace}:`)
+ ? `${cache.namespace}:${key}`
+ : key;
+ const store = cache.store;
+ let raw: string | DeserializedData<T> | null | undefined;
+
+ if (store instanceof Map) {
+ raw = store.get(prefixedKey);
+ store.delete(prefixedKey);
+ } else if (store instanceof KeyvRedis) {
+ const client = await store.getClient();
+ try {
+ raw = await observeRedisOperation('keyv', cache.namespace ?? '', 'getDel', () =>
+ client.getDel(store.createKeyPrefix(prefixedKey, store.namespace)),
+ );
+ } catch (error) {
+ cache.emit('error', error);
+ throw error;
+ }
+ } else {
+ throw new Error('Atomic cache consumption requires an in-memory or Redis store');
+ }
+
+ if (raw == null) {
+ return undefined;
+ }
+ const entry = typeof raw === 'string' ? await cache.deserializeData<T>(raw) : raw;
+ if (!entry || (typeof entry.expires === 'number' && Date.now() > entry.expires)) {
+ return undefined;
+ }
+ return entry.value;
+}