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: Block Unsafe MCP OAuth Redirects and Private IPs (#16514)

lia-by-librechat[bot]4d33d8c2c71a
diff --git a/packages/api/src/mcp/oauth/hardenedFetch.behavior.test.ts b/packages/api/src/mcp/oauth/hardenedFetch.behavior.test.ts
index 206616fdd0..24c42c662e 100644
--- a/packages/api/src/mcp/oauth/hardenedFetch.behavior.test.ts
+++ b/packages/api/src/mcp/oauth/hardenedFetch.behavior.test.ts
@@ -8,11 +8,19 @@ type TestServer = {
close: () => Promise<void>;
};
-async function createLocalServer(): Promise<TestServer> {
+async function createLocalServer(
+ hostname = 'localhost',
+ redirect?: { status: 302 | 307; target: string },
+): Promise<TestServer> {
let requestCount = 0;
const sockets = new Set<Socket>();
const server = http.createServer((_req, res) => {
requestCount += 1;
+ if (redirect) {
+ res.writeHead(redirect.status, { Location: redirect.target });
+ res.end();
+ return;
+ }
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({ ok: true }));
});
@@ -22,7 +30,7 @@ async function createLocalServer(): Promise<TestServer> {
socket.once('close', () => sockets.delete(socket));
});
- await new Promise<void>((resolve) => server.listen(0, 'localhost', resolve));
+ await new Promise<void>((resolve) => server.listen(0, hostname, resolve));
const address = server.address() as AddressInfo;
return {
@@ -63,6 +71,31 @@ describe('createHardenedOAuthFetch request policy', () => {
expect(server.requestCount()).toBe(0);
});
+ it('blocks private IP literals even when the DNS lookup is bypassed', async () => {
+ const target = await createLocalServer('127.0.0.1');
+ try {
+ await expect(
+ createHardenedOAuthFetch()(`http://127.0.0.1:${target.port}/token`),
+ ).rejects.toThrow('OAuth endpoint targets a blocked address');
+ expect(target.requestCount()).toBe(0);
+ } finally {
+ await target.close();
+ }
+ });
+
+ it('permits an explicitly exempted private IP and port', async () => {
+ const target = await createLocalServer('127.0.0.1');
+ try {
+ const response = await createHardenedOAuthFetch({
+ allowedAddresses: [`127.0.0.1:${target.port}`],
+ })(`http://127.0.0.1:${target.port}/token`);
+ await expect(response.json()).resolves.toEqual({ ok: true });
+ expect(target.requestCount()).toBe(1);
+ } finally {
+ await target.close();
+ }
+ });
+
it('allows explicitly trusted local OAuth endpoints', async () => {
const oauthFetch = createHardenedOAuthFetch({ allowedDomains: ['localhost'] });
@@ -74,6 +107,30 @@ describe('createHardenedOAuthFetch request policy', () => {
expect(server.requestCount()).toBe(1);
});
+ it.each([302, 307] as const)(
+ 'does not follow a %i from an allowlisted OAuth endpoint to a private IP',
+ async (status) => {
+ const target = await createLocalServer('127.0.0.1');
+ const redirector = await createLocalServer('localhost', {
+ status,
+ target: `http://127.0.0.1:${target.port}/internal`,
+ });
+ try {
+ await expect(
+ createHardenedOAuthFetch({ allowedDomains: ['localhost'] })(
+ `http://localhost:${redirector.port}/token`,
+ { method: 'POST', body: 'grant_type=refresh_token', redirect: 'follow' },
+ ),
+ ).rejects.toThrow();
+ expect(redirector.requestCount()).toBe(1);
+ expect(target.requestCount()).toBe(0);
+ } finally {
+ await redirector.close();
+ await target.close();
+ }
+ },
+ );
+
it('does not use address exemptions when domain policy is active but unmatched', async () => {
const oauthFetch = createHardenedOAuthFetch({
allowedDomains: ['trusted.example.com'],
diff --git a/packages/api/src/mcp/oauth/hardenedFetch.test.ts b/packages/api/src/mcp/oauth/hardenedFetch.test.ts
index 5e9f5bb082..b0570ad46e 100644
--- a/packages/api/src/mcp/oauth/hardenedFetch.test.ts
+++ b/packages/api/src/mcp/oauth/hardenedFetch.test.ts
@@ -1,15 +1,17 @@
-import { createSSRFSafeUndiciConnect, isOAuthUrlAllowed } from '~/auth';
import { createHardenedOAuthFetch, resetHardenedOAuthFetchDispatchers } from './hardenedFetch';
+import { createSSRFSafeUndiciConnect, isOAuthUrlAllowed, isSSRFTarget } from '~/auth';
jest.mock('~/auth', () => ({
createSSRFSafeUndiciConnect: jest.fn(() => ({ lookup: jest.fn() })),
isOAuthUrlAllowed: jest.fn(() => false),
+ isSSRFTarget: jest.fn(() => false),
}));
const mockCreateSSRFSafeUndiciConnect = createSSRFSafeUndiciConnect as jest.MockedFunction<
typeof createSSRFSafeUndiciConnect
>;
const mockIsOAuthUrlAllowed = isOAuthUrlAllowed as jest.MockedFunction<typeof isOAuthUrlAllowed>;
+const mockIsSSRFTarget = isSSRFTarget as jest.MockedFunction<typeof isSSRFTarget>;
describe('createHardenedOAuthFetch', () => {
const originalFetch = global.fetch;
@@ -20,6 +22,7 @@ describe('createHardenedOAuthFetch', () => {
global.fetch = mockFetch;
mockFetch.mockResolvedValue({ ok: true } as Response);
mockIsOAuthUrlAllowed.mockReturnValue(false);
+ mockIsSSRFTarget.mockReturnValue(false);
});
afterEach(() => {
@@ -41,6 +44,7 @@ describe('createHardenedOAuthFetch', () => {
expect.objectContaining({
method: 'POST',
dispatcher: expect.any(Object),
+ redirect: 'error',
}),
);
});
@@ -66,6 +70,53 @@ describe('createHardenedOAuthFetch', () => {
expect(mockCreateSSRFSafeUndiciConnect).not.toHaveBeenCalled();
expect(mockFetch.mock.calls[0][1]).not.toHaveProperty('dispatcher');
+ expect(mockFetch.mock.calls[0][1]).toEqual(expect.objectContaining({ redirect: 'error' }));
+ });
+
+ it('rejects an IPv6 literal before the Undici lookup can be bypassed', async () => {
+ mockIsSSRFTarget.mockReturnValueOnce(true);
+
+ await expect(createHardenedOAuthFetch()('http://[::1]:9443/token')).rejects.toThrow();
+
+ expect(mockIsSSRFTarget).toHaveBeenCalledWith('::1', undefined, '9443');
+ expect(mockFetch).not.toHaveBeenCalled();
+ });
+
+ it('checks private IPs before reusing a dispatcher cached for the same port', async () => {
+ await createHardenedOAuthFetch()('https://auth.example.com:9443/token');
+ mockIsSSRFTarget.mockReturnValueOnce(true);
+
+ await expect(createHardenedOAuthFetch()('http://127.0.0.1:9443/token')).rejects.toThrow(
+ 'OAuth endpoint targets a blocked address',
+ );
+
+ expect(mockIsSSRFTarget).toHaveBeenCalledWith('127.0.0.1', undefined, '9443');
+ expect(mockFetch).toHaveBeenCalledTimes(1);
+ });
+
+ it('normalizes alternate IPv4 spellings before checking the literal', async () => {
+ mockIsSSRFTarget.mockReturnValueOnce(true);
+
+ await expect(createHardenedOAuthFetch()('http://0x7f000001:9443/token')).rejects.toThrow(
+ 'OAuth endpoint targets a blocked address',
+ );
+
+ expect(mockIsSSRFTarget).toHaveBeenCalledWith('127.0.0.1', undefined, '9443');
+ expect(mockFetch).not.toHaveBeenCalled();
+ });
+
+ it('does not apply address exemptions to an IP when domain policy is active but unmatched', async () => {
+ mockIsSSRFTarget.mockReturnValueOnce(true);
+
+ await expect(
+ createHardenedOAuthFetch({
+ allowedDomains: ['trusted.example.com'],
+ allowedAddresses: ['127.0.0.1:9443'],
+ })('http://127.0.0.1:9443/token'),
+ ).rejects.toThrow();
+
+ expect(mockIsSSRFTarget).toHaveBeenCalledWith('127.0.0.1', null, '9443');
+ expect(mockFetch).not.toHaveBeenCalled();
});
it('normalizes allowedAddresses before caching dispatchers', async () => {
diff --git a/packages/api/src/mcp/oauth/hardenedFetch.ts b/packages/api/src/mcp/oauth/hardenedFetch.ts
index 18988af0c7..8cd317547d 100644
--- a/packages/api/src/mcp/oauth/hardenedFetch.ts
+++ b/packages/api/src/mcp/oauth/hardenedFetch.ts
@@ -1,7 +1,8 @@
import { Agent } from 'undici';
-import type { Dispatcher } from 'undici';
+import { isIP } from 'node:net';
import type { FetchLike } from '@modelcontextprotocol/sdk/shared/transport';
-import { createSSRFSafeUndiciConnect, isOAuthUrlAllowed } from '~/auth';
+import type { Dispatcher } from 'undici';
+import { createSSRFSafeUndiciConnect, isOAuthUrlAllowed, isSSRFTarget } from '~/auth';
import { getOAuthUrlPort } from './url';
type FetchInitWithDispatcher = RequestInit & {
@@ -50,6 +51,10 @@ function getOAuthDispatcher(
const port = getOAuthUrlPort(parsedUrl);
const effectiveAddresses =
Array.isArray(allowedDomains) && allowedDomains.length > 0 ? null : allowedAddresses;
+ const literalHost = parsedUrl.hostname.replace(/^\[|\]$/g, '');
+ if (isIP(literalHost) && isSSRFTarget(literalHost, effectiveAddresses, port)) {
+ throw new Error('OAuth endpoint targets a blocked address');
+ }
const cacheKey = getDispatcherCacheKey(port, effectiveAddresses);
const cached = oauthDispatchers.get(cacheKey);
if (cached) {
@@ -79,7 +84,9 @@ export function createHardenedOAuthFetch({
return async (url: string | URL, init?: RequestInit): Promise<Response> => {
const dispatcher = getOAuthDispatcher(url, allowedDomains, allowedAddresses);
const fetchInit: FetchInitWithDispatcher =
- dispatcher != null ? { ...init, dispatcher } : { ...init };
+ dispatcher != null
+ ? { ...init, dispatcher, redirect: 'error' }
+ : { ...init, redirect: 'error' };
return fetch(url, fetchInit);
};
}