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: SSRF-Guard Speech (STT/TTS) and OCR Outbound Requests at Connect Time (#14560)
Dustin Healy96404bfc739c
diff --git a/api/server/services/Files/Audio/STTService.js b/api/server/services/Files/Audio/STTService.jsindex c5124ea7cf..bf7b3cc004 100644--- a/api/server/services/Files/Audio/STTService.js+++ b/api/server/services/Files/Audio/STTService.js@@ -8,6 +8,7 @@ const {logAxiosError,applyAxiosProxyConfig,resolveConfigSecret,+ applySSRFSafeAgentIfDirect,} = require('@librechat/api');const { extractEnvVariable, STTProviders } = require('librechat-data-provider');const { getAppConfig } = require('~/server/services/Config');@@ -138,7 +139,7 @@ class STTService {/*** Retrieves the configured STT provider and its schema.* @param {ServerRequest} req - The request object.- * @returns {Promise<[string, Object]>} A promise that resolves to an array containing the provider name and its schema.+ * @returns {Promise<[string, Object, (string[]|undefined)]>} A promise that resolves to the provider name, its schema, and the section-level allowedAddresses exemption list.* @throws {Error} If no STT schema is set, multiple providers are set, or no provider is set.*/async getProviderSchema(req) {@@ -169,7 +170,7 @@ class STTService {}const [provider, schema] = providers[0];- return [provider, schema];+ return [provider, schema, sttSchema.allowedAddresses];}/**@@ -283,10 +284,11 @@ class STTService {* @param {Buffer} requestData.audioBuffer - The audio data to be transcribed.* @param {Object} requestData.audioFile - The audio file object containing originalname, mimetype, and size.* @param {string} requestData.language - The language code for the transcription.+ * @param {string[]} [allowedAddresses] - Section-level SSRF exemption list of host:port pairs.* @returns {Promise<string>} A promise that resolves to the transcribed text.* @throws {Error} If the provider is invalid, the response status is not 200, or the response data is missing.*/- async sttRequest(provider, sttSchema, { audioBuffer, audioFile, language }) {+ async sttRequest(provider, sttSchema, { audioBuffer, audioFile, language }, allowedAddresses) {const strategy = this.providerStrategies[provider];if (!strategy) {throw new Error('Invalid provider');@@ -308,6 +310,7 @@ class STTService {const options = { headers };applyAxiosProxyConfig(options, url);+ applySSRFSafeAgentIfDirect(options, url, allowedAddresses);try {const response = await axios.post(url, data, options);@@ -347,9 +350,14 @@ class STTService {};try {- const [provider, sttSchema] = await this.getProviderSchema(req);+ const [provider, sttSchema, allowedAddresses] = await this.getProviderSchema(req);const language = req.body?.language || '';- const text = await this.sttRequest(provider, sttSchema, { audioBuffer, audioFile, language });+ const text = await this.sttRequest(+ provider,+ sttSchema,+ { audioBuffer, audioFile, language },+ allowedAddresses,+ );res.json({ text });} catch (error) {logAxiosError({ message: 'An error occurred while processing the audio:', error });diff --git a/api/server/services/Files/Audio/TTSService.js b/api/server/services/Files/Audio/TTSService.jsindex 58ac157db5..bace395504 100644--- a/api/server/services/Files/Audio/TTSService.js+++ b/api/server/services/Files/Audio/TTSService.js@@ -5,6 +5,7 @@ const {logAxiosError,applyAxiosProxyConfig,resolveConfigSecret,+ applySSRFSafeAgentIfDirect,} = require('@librechat/api');const { extractEnvVariable, TTSProviders } = require('librechat-data-provider');const { getRandomVoiceId, createChunkProcessor, splitTextIntoChunks } = require('./streamAudio');@@ -255,10 +256,11 @@ class TTSService {* @param {string} options.input - The input text.* @param {string} options.voice - The voice to use.* @param {boolean} [options.stream=true] - Whether to use streaming.+ * @param {string[]} [allowedAddresses] - Section-level SSRF exemption list of host:port pairs.* @returns {Promise<Object>} The axios response object.* @throws {Error} If the provider is invalid or the request fails.*/- async ttsRequest(provider, ttsSchema, { input, voice, stream = true }) {+ async ttsRequest(provider, ttsSchema, { input, voice, stream = true }, allowedAddresses) {const strategy = this.providerStrategies[provider];if (!strategy) {throw new Error('Invalid provider');@@ -271,6 +273,7 @@ class TTSService {const options = { headers, responseType: stream ? 'stream' : 'arraybuffer' };applyAxiosProxyConfig(options, url);+ applySSRFSafeAgentIfDirect(options, url, allowedAddresses);try {return await axios.post(url, data, options);@@ -305,10 +308,16 @@ class TTSService {res.setHeader('Content-Type', 'audio/mpeg');const provider = this.getProvider(appConfig);const ttsSchema = appConfig?.speech?.tts?.[provider];+ const allowedAddresses = appConfig?.speech?.tts?.allowedAddresses;const voice = await this.getVoice(ttsSchema, requestVoice);if (input.length < 4096) {- const response = await this.ttsRequest(provider, ttsSchema, { input, voice });+ const response = await this.ttsRequest(+ provider,+ ttsSchema,+ { input, voice },+ allowedAddresses,+ );response.data.pipe(res);return;}@@ -317,11 +326,16 @@ class TTSService {for (const chunk of textChunks) {try {- const response = await this.ttsRequest(provider, ttsSchema, {- voice,- input: chunk.text,- stream: true,- });+ const response = await this.ttsRequest(+ provider,+ ttsSchema,+ {+ voice,+ input: chunk.text,+ stream: true,+ },+ allowedAddresses,+ );logger.debug(`[textToSpeech] user: ${req?.user?.id} | writing audio stream`);await new Promise((resolve) => {@@ -373,6 +387,7 @@ class TTSService {}));const provider = this.getProvider(appConfig);const ttsSchema = appConfig?.speech?.tts?.[provider];+ const allowedAddresses = appConfig?.speech?.tts?.allowedAddresses;const voice = await this.getVoice(ttsSchema, req.body.voice);let shouldContinue = true;@@ -399,11 +414,16 @@ class TTSService {for (const update of updates) {try {- const response = await this.ttsRequest(provider, ttsSchema, {- voice,- input: update.text,- stream: true,- });+ const response = await this.ttsRequest(+ provider,+ ttsSchema,+ {+ voice,+ input: update.text,+ stream: true,+ },+ allowedAddresses,+ );if (!shouldContinue) {break;diff --git a/api/server/services/Files/Audio/speechSSRF.spec.js b/api/server/services/Files/Audio/speechSSRF.spec.jsnew file mode 100644index 0000000000..3279dc69bf--- /dev/null+++ b/api/server/services/Files/Audio/speechSSRF.spec.js@@ -0,0 +1,91 @@+jest.mock('axios');+jest.mock('@librechat/data-schemas', () => ({+ logger: { warn: jest.fn(), error: jest.fn(), debug: jest.fn() },+}));+jest.mock('~/server/services/Config', () => ({ getAppConfig: jest.fn() }));+jest.mock('./streamAudio', () => ({+ getRandomVoiceId: jest.fn(),+ createChunkProcessor: jest.fn(),+ splitTextIntoChunks: jest.fn(),+}));++const axios = require('axios');+const { STTService } = require('./STTService');+const { textToSpeech } = require('./TTSService');++afterEach(() => {+ jest.restoreAllMocks();+ axios.post.mockReset();+});++describe('STT sttRequest SSRF guard (real agent)', () => {+ const audioFile = { originalname: 'a.wav', mimetype: 'audio/wav', size: 1 };+ const audioBuffer = Buffer.from('audio');+ const provider = { url: 'http://10.0.0.5:8080', apiKey: 'sk', model: 'whisper-1' };++ it('blocks a private-IP provider url with ESSRF before any request goes out', async () => {+ const service = new STTService();+ await expect(+ service.sttRequest('openai', provider, { audioBuffer, audioFile, language: '' }),+ ).rejects.toMatchObject({ code: 'ESSRF' });+ expect(axios.post).not.toHaveBeenCalled();+ });++ it('exempts a host:port in the section allowedAddresses and sets maxRedirects 0 with agents', async () => {+ axios.post.mockResolvedValue({ status: 200, data: { text: 'ok' } });+ const service = new STTService();++ await service.sttRequest('openai', provider, { audioBuffer, audioFile, language: '' }, [+ '10.0.0.5:8080',+ ]);++ const options = axios.post.mock.calls[0][2];+ expect(options.maxRedirects).toBe(0);+ expect(options.httpAgent).toBeDefined();+ expect(options.httpsAgent).toBeDefined();+ });+});++describe('TTS textToSpeech SSRF guard (real agent)', () => {+ function buildReqRes(allowedAddresses) {+ const req = {+ body: { input: 'hi', voice: 'v1' },+ user: { id: 'u1' },+ config: {+ speech: {+ tts: {+ ...(allowedAddresses ? { allowedAddresses } : {}),+ localai: { url: 'http://10.0.0.5:8080', apiKey: 'sk', voices: ['v1'] },+ },+ },+ },+ };+ const res = {+ setHeader: jest.fn(),+ headersSent: false,+ status: jest.fn(() => ({ end: jest.fn(), send: jest.fn() })),+ end: jest.fn(),+ };+ return { req, res };+ }++ it('blocks a private-IP provider url and never issues the outbound request', async () => {+ const { req, res } = buildReqRes();++ await textToSpeech(req, res);++ expect(axios.post).not.toHaveBeenCalled();+ });++ it('exempts a host:port in the section allowedAddresses and sets maxRedirects 0 with agents', async () => {+ axios.post.mockResolvedValue({ status: 200, data: { pipe: jest.fn(), on: jest.fn() } });+ const { req, res } = buildReqRes(['10.0.0.5:8080']);++ await textToSpeech(req, res);++ const options = axios.post.mock.calls[0][2];+ expect(options.maxRedirects).toBe(0);+ expect(options.httpAgent).toBeDefined();+ expect(options.httpsAgent).toBeDefined();+ });+});diff --git a/librechat.example.yaml b/librechat.example.yamlindex 60e5c952c2..b8f6ce4bbb 100644--- a/librechat.example.yaml+++ b/librechat.example.yaml@@ -257,6 +257,20 @@ registration:# Note: If balance.enabled is true, transactions will always be enabled# regardless of this setting to ensure balance tracking works correctly+# Speech (STT/TTS) outbound requests to operator-provided target URLs are SSRF-guarded+# at connect time: private, loopback, link-local, and cloud-metadata targets are blocked+# by default. To point STT/TTS at a private or self-hosted service (LocalAI, a self-hosted+# Whisper server), add its host:port to `allowedAddresses` on the `stt` / `tts` section.+# SECURITY: `allowedAddresses` entries are trusted before the private-IP check. A listed+# host:port is permitted even when it resolves to a private IP, so list only hosts you fully+# control and that cannot be repointed by an attacker. Do not list attacker-controllable or+# DNS-rebindable hostnames, because doing so re-opens the private-address path this guard+# closes. Prefer a private IP literal over a hostname when exempting a private target. Entries+# must include a port (`host:port`, `private.ip:port`, or `[ipv6]:port`); do not use URLs, paths,+# CIDR ranges, bare hosts/IPs, or public IP literals.+# When a forward proxy is configured (PROXY / HTTP(S)_PROXY), it performs DNS and egress in its+# own network context, so these requests are delegated to it and it must be SSRF-enforcing; the+# connect-time guard only covers direct, non-proxied connections.# speech:# tts:# openai:@@ -264,13 +278,32 @@ registration:# apiKey: '${TTS_API_KEY}'# model: ''# voices: ['']-+# allowedAddresses:+# - 'localhost:8020'+# - '127.0.0.1:8020'## stt:# openai:# url: ''# apiKey: '${STT_API_KEY}'# model: ''+# allowedAddresses:+# - 'localhost:8000'+# - '127.0.0.1:8000'++# OCR (Mistral / Mistral-compatible) outbound requests to `ocr.baseURL` are SSRF-guarded at+# connect time with the same default-deny for private targets. To point OCR at a private or+# self-hosted Mistral-compatible service, add its host:port to `allowedAddresses`. The same+# trust caveat as speech applies: a listed host:port is trusted before the private-IP check,+# so list only hosts you fully control and that cannot be repointed by an attacker. Entries+# must include a port and must not be URLs, paths, CIDR ranges, bare hosts/IPs, or public IP+# literals.+# ocr:+# baseURL: '${OCR_BASEURL}'+# apiKey: '${OCR_API_KEY}'+# allowedAddresses:+# - 'localhost:8080'+# - '127.0.0.1:8080'# rateLimits:# fileUploads:diff --git a/packages/api/src/auth/agent.spec.ts b/packages/api/src/auth/agent.spec.tsindex f74542c6c8..e9a081767d 100644--- a/packages/api/src/auth/agent.spec.ts+++ b/packages/api/src/auth/agent.spec.ts@@ -8,8 +8,13 @@ jest.mock('node:dns', () => {import dns from 'node:dns';import http from 'node:http';+import type { AxiosRequestConfig } from 'axios';import type { LookupFunction } from 'node:net';-import { createSSRFSafeAgents, createSSRFSafeUndiciConnect } from './agent';+import {+ createSSRFSafeAgents,+ createSSRFSafeUndiciConnect,+ applySSRFSafeAgentIfDirect,+} from './agent';type LookupCallback = (err: NodeJS.ErrnoException | null,@@ -330,3 +335,163 @@ describe('SSRF agents — allowedAddresses exemption', () => {expect(result.err!.code).toBe('ESSRF');});});++describe('applySSRFSafeAgentIfDirect', () => {+ afterEach(() => {+ jest.restoreAllMocks();+ jest.clearAllMocks();+ });++ function spyLookup(hostname: string, port: number) {+ const captured: { err: NodeJS.ErrnoException | null; address: string } = {+ err: null,+ address: '',+ };+ jest.spyOn(httpAgentPrototype, 'createConnection').mockImplementation(((+ options: Record<string, unknown>,+ ) => {+ (options.lookup as LookupFunction)(hostname, {}, (err, address) => {+ captured.err = err;+ captured.address = address as string;+ });+ return {};+ }) as never);+ return {+ drive(agent: unknown) {+ (agent as { createConnection: (o: Record<string, unknown>) => unknown }).createConnection({+ host: hostname,+ port,+ });+ return captured;+ },+ };+ }++ it('attaches both agents and disables redirects for a direct http(s) request', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'https://api.example.com/v1');+ expect(config.httpAgent).toBeDefined();+ expect(config.httpsAgent).toBeDefined();+ expect(config.maxRedirects).toBe(0);+ });++ it('rejects a target resolving to a private IP with ESSRF through the real lookup', () => {+ mockDnsResult('10.0.0.5', 4);+ const probe = spyLookup('internal.example.com', 80);+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://internal.example.com');+ const result = probe.drive(config.httpAgent);+ expect(result.err).toBeTruthy();+ expect(result.err!.code).toBe('ESSRF');+ });++ it('exempts a host:port present in allowedAddresses through the real lookup', () => {+ mockDnsResult('10.0.0.5', 4);+ const probe = spyLookup('ollama.internal', 11434);+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://ollama.internal:11434', ['ollama.internal:11434']);+ const result = probe.drive(config.httpAgent);+ expect(result.err).toBeNull();+ expect(result.address).toBe('10.0.0.5');+ });++ it('throws on a non-http(s) scheme', () => {+ expect(() => applySSRFSafeAgentIfDirect({}, 'file:///etc/passwd')).toThrow();+ expect(() => applySSRFSafeAgentIfDirect({}, 'gopher://example.com')).toThrow();+ });++ it('throws on a malformed url', () => {+ expect(() => applySSRFSafeAgentIfDirect({}, 'not a url')).toThrow();+ });++ it('preserves an existing proxy and still disables redirects', () => {+ const config: AxiosRequestConfig = { proxy: { host: '127.0.0.1', port: 8080 } };+ applySSRFSafeAgentIfDirect(config, 'https://api.example.com');+ expect(config.httpAgent).toBeUndefined();+ expect(config.httpsAgent).toBeUndefined();+ expect(config.maxRedirects).toBe(0);+ });++ it('preserves a pre-set agent and still disables redirects', () => {+ const preset = new http.Agent();+ const config: AxiosRequestConfig = { httpAgent: preset };+ applySSRFSafeAgentIfDirect(config, 'https://api.example.com');+ expect(config.httpAgent).toBe(preset);+ expect(config.httpsAgent).toBeUndefined();+ expect(config.maxRedirects).toBe(0);+ });++ it('blocks a literal private IPv4 host that skips the agent DNS lookup', () => {+ let code: string | undefined;+ try {+ applySSRFSafeAgentIfDirect({}, 'http://127.0.0.1:9000');+ } catch (err) {+ code = (err as NodeJS.ErrnoException).code;+ }+ expect(code).toBe('ESSRF');+ });++ it('blocks a literal private IPv6 host', () => {+ let code: string | undefined;+ try {+ applySSRFSafeAgentIfDirect({}, 'http://[::1]:9000');+ } catch (err) {+ code = (err as NodeJS.ErrnoException).code;+ }+ expect(code).toBe('ESSRF');+ });++ it('exempts a literal private IP present in allowedAddresses', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://127.0.0.1:9000', ['127.0.0.1:9000']);+ expect(config.httpAgent).toBeDefined();+ expect(config.maxRedirects).toBe(0);+ });++ it('allows a public literal IP', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://8.8.8.8:80');+ expect(config.httpAgent).toBeDefined();+ });++ it('exempts a literal private IP on the default http port when the URL omits it', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://127.0.0.1', ['127.0.0.1:80']);+ expect(config.httpAgent).toBeDefined();+ });++ it('exempts a literal private IP on the default https port when the URL omits it', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'https://127.0.0.1', ['127.0.0.1:443']);+ expect(config.httpsAgent).toBeDefined();+ });++ it('blocks a literal private IP even when a proxy is already configured', () => {+ let code: string | undefined;+ try {+ applySSRFSafeAgentIfDirect(+ { proxy: { host: '127.0.0.1', port: 8080 } },+ 'http://169.254.169.254',+ );+ } catch (err) {+ code = (err as NodeJS.ErrnoException).code;+ }+ expect(code).toBe('ESSRF');+ });++ it('exempts an IPv4-mapped IPv6 literal listed in allowedAddresses', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://[::ffff:127.0.0.1]:8080', [+ '[::ffff:127.0.0.1]:8080',+ ]);+ expect(config.httpAgent).toBeDefined();+ });++ it('exempts a fully expanded ULA literal listed in allowedAddresses', () => {+ const config: AxiosRequestConfig = {};+ applySSRFSafeAgentIfDirect(config, 'http://[fd00:0:0:0:0:0:0:1]:8080', [+ '[fd00:0:0:0:0:0:0:1]:8080',+ ]);+ expect(config.httpAgent).toBeDefined();+ });+});diff --git a/packages/api/src/auth/agent.ts b/packages/api/src/auth/agent.tsindex 7222d8de64..2ef15be693 100644--- a/packages/api/src/auth/agent.ts+++ b/packages/api/src/auth/agent.ts@@ -1,6 +1,8 @@import dns from 'node:dns';import http from 'node:http';import https from 'node:https';+import { isIP } from 'node:net';+import type { AxiosRequestConfig } from 'axios';import type { LookupFunction } from 'node:net';import {normalizePort,@@ -142,3 +144,55 @@ export function createSSRFSafeUndiciConnect(: ssrfSafeLookup;return { lookup };}++/**+ * Attaches SSRF-safe HTTP(S) agents to an axios config for a direct request.+ * Rejects non-http(s) (and unparseable) target urls, since the agents validate+ * the resolved IP at connect time but never inspect the scheme. Sets+ * `maxRedirects: 0` unconditionally so a redirect cannot bypass that check, and+ * leaves the agents untouched when a proxy or agent is already set.+ *+ * @param config - The axios request config to mutate.+ * @param url - The request target URL (http/https only).+ * @param allowedAddresses - Optional admin exemption list of host:port pairs.+ */+export function applySSRFSafeAgentIfDirect(+ config: AxiosRequestConfig,+ url: string,+ allowedAddresses?: string[] | null,+): AxiosRequestConfig {+ const { protocol, hostname, port } = new URL(url);+ if (protocol !== 'http:' && protocol !== 'https:') {+ throw new Error(`Unsupported URL scheme for SSRF-guarded request: ${protocol}`);+ }++ config.maxRedirects = 0;++ // Node skips the agent's custom DNS lookup for IP-literal hosts, and a configured proxy+ // connects on our behalf without running that check, so a literal private IP (e.g.+ // http://169.254.169.254) must be rejected before any proxy or agent early return.+ const literalHost = hostname.replace(/^\[|\]$/g, '');+ if (isIP(literalHost)) {+ const exemptSet = normalizeAllowedAddressesSet(allowedAddresses);+ const normalizedPort = normalizePort(port || (protocol === 'https:' ? '443' : '80'));+ const hostnameAllowed = isAddressInAllowedSet(literalHost, exemptSet, normalizedPort);+ const blockedAddress = getBlockedLookupAddress(+ literalHost,+ hostnameAllowed,+ exemptSet,+ normalizedPort,+ );+ if (blockedAddress) {+ throw createSSRFLookupError(literalHost, blockedAddress);+ }+ }++ if (config.httpsAgent || config.httpAgent || config.proxy) {+ return config;+ }++ const { httpAgent, httpsAgent } = createSSRFSafeAgents(allowedAddresses);+ config.httpAgent = httpAgent;+ config.httpsAgent = httpsAgent;+ return config;+}diff --git a/packages/api/src/auth/allowedAddresses.ts b/packages/api/src/auth/allowedAddresses.tsindex 01b8ff0e4b..2b701ac44b 100644--- a/packages/api/src/auth/allowedAddresses.ts+++ b/packages/api/src/auth/allowedAddresses.ts@@ -16,6 +16,7 @@* status. Hostnames pass through; their resolved IP is checked* separately by callers (e.g. `resolveHostnameSSRF`).*/+import { isIP } from 'node:net';import { isPrivateIP } from './ip';const ADDRESS_PORT_SEPARATOR = '\0';@@ -58,13 +59,32 @@ function addressPortKey(address: string, port: string): string {return `${address}${ADDRESS_PORT_SEPARATOR}${port}`;}+/**+ * Canonicalizes an IP literal to WHATWG-URL form so allowlist entries and targets (which pass+ * through `new URL`) compare identically, covering IPv4-mapped and expanded/ULA IPv6 forms.+ */+function canonicalizeIPLiteral(value: string): string {+ const family = isIP(value);+ if (family === 0) return value;+ try {+ const host = family === 6 ? `[${value}]` : value;+ return new URL(`http://${host}`).hostname.replace(/^\[|\]$/g, '');+ } catch {+ return value;+ }+}+function normalizeAddressCandidate(candidate: string): string {const normalized = candidate.toLowerCase().trim().replace(/^\[|\]$/g, '');if (!normalized) return '';- if (isIPLiteral(normalized) && !isPrivateIP(normalized)) return '';+ if (isIPLiteral(normalized)) {+ const canonical = canonicalizeIPLiteral(normalized);+ if (!isPrivateIP(canonical)) return '';+ return canonical;+ }return normalized;}diff --git a/packages/api/src/files/audio.spec.ts b/packages/api/src/files/audio.spec.tsnew file mode 100644index 0000000000..93b044047f--- /dev/null+++ b/packages/api/src/files/audio.spec.ts@@ -0,0 +1,34 @@+import fs from 'fs';+import type { STTService, ServerRequest, FileObject } from '../types';+import { processAudioFile } from './audio';++jest.mock('fs', () => {+ const actual = jest.requireActual('fs');+ return { ...actual, promises: { ...actual.promises, readFile: jest.fn() } };+});++describe('processAudioFile', () => {+ it('threads the section-level allowedAddresses from getProviderSchema into sttRequest', async () => {+ (fs.promises.readFile as jest.Mock).mockResolvedValue(Buffer.from('audio'));+ const sttRequest = jest.fn().mockResolvedValue('transcribed');+ const schema = { url: 'http://stt.internal:8020' };+ const sttService: STTService = {+ getInstance: jest.fn(),+ getProviderSchema: jest.fn().mockResolvedValue(['openai', schema, ['stt.internal:8020']]),+ sttRequest,+ };+ const file: FileObject = {+ path: '/tmp/a.wav',+ originalname: 'a.wav',+ mimetype: 'audio/wav',+ size: 5,+ };++ const result = await processAudioFile({ req: {} as ServerRequest, file, sttService });++ expect(result.text).toBe('transcribed');+ expect(sttRequest).toHaveBeenCalledWith('openai', schema, expect.any(Object), [+ 'stt.internal:8020',+ ]);+ });+});diff --git a/packages/api/src/files/audio.ts b/packages/api/src/files/audio.tsindex a2d93c1002..01d5de6714 100644--- a/packages/api/src/files/audio.ts+++ b/packages/api/src/files/audio.ts@@ -29,8 +29,13 @@ export async function processAudioFile({size: file.size,};- const [provider, sttSchema] = await sttService.getProviderSchema(req);- const text = await sttService.sttRequest(provider, sttSchema, { audioBuffer, audioFile });+ const [provider, sttSchema, allowedAddresses] = await sttService.getProviderSchema(req);+ const text = await sttService.sttRequest(+ provider,+ sttSchema,+ { audioBuffer, audioFile },+ allowedAddresses,+ );return {text,diff --git a/packages/api/src/files/mistral/crud.spec.ts b/packages/api/src/files/mistral/crud.spec.tsindex ecac188091..33b2f9b3d1 100644--- a/packages/api/src/files/mistral/crud.spec.ts+++ b/packages/api/src/files/mistral/crud.spec.ts@@ -139,6 +139,18 @@ describe('MistralOCR Service', () => {(jest.mocked(fs).createReadStream as jest.Mock).mockReturnValue(mockReadStream);});+ it('destroys the upload stream when the request fails (async SSRF block)', async () => {+ const err = Object.assign(new Error('SSRF protection'), { code: 'ESSRF' });+ mockAxios.post!.mockRejectedValueOnce(err);++ await expect(+ uploadDocumentToMistral({ filePath: '/path/to/test.pdf', apiKey: 'k' }),+ ).rejects.toBe(err);++ const stream = (jest.mocked(fs).createReadStream as jest.Mock).mock.results[0].value;+ expect(stream.destroy).toHaveBeenCalled();+ });+it('should upload a document to Mistral API using file streaming', async () => {const mockResponse: { data: MistralFileUploadResponse } = {data: {@@ -172,6 +184,9 @@ describe('MistralOCR Service', () => {}),maxBodyLength: Infinity,maxContentLength: Infinity,+ maxRedirects: 0,+ httpAgent: expect.anything(),+ httpsAgent: expect.anything(),}),);expect(result).toEqual(mockResponse.data);@@ -212,11 +227,14 @@ describe('MistralOCR Service', () => {expect(mockAxios.get).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-123/url?expiry=24',- {+ expect.objectContaining({headers: {Authorization: 'Bearer test-api-key',},- },+ maxRedirects: 0,+ httpAgent: expect.anything(),+ httpsAgent: expect.anything(),+ }),);expect(result).toEqual(mockResponse.data);});@@ -246,11 +264,17 @@ describe('MistralOCR Service', () => {baseURL: 'https://api.mistral.ai/v1',});- expect(mockAxios.delete).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-123', {- headers: {- Authorization: 'Bearer test-api-key',- },- });+ expect(mockAxios.delete).toHaveBeenCalledWith(+ 'https://api.mistral.ai/v1/files/file-123',+ expect.objectContaining({+ headers: {+ Authorization: 'Bearer test-api-key',+ },+ maxRedirects: 0,+ httpAgent: expect.anything(),+ httpsAgent: expect.anything(),+ }),+ );});it('should use default baseURL when not provided', async () => {@@ -261,11 +285,14 @@ describe('MistralOCR Service', () => {apiKey: 'test-api-key',});- expect(mockAxios.delete).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-456', {- headers: {- Authorization: 'Bearer test-api-key',- },- });+ expect(mockAxios.delete).toHaveBeenCalledWith(+ 'https://api.mistral.ai/v1/files/file-456',+ expect.objectContaining({+ headers: {+ Authorization: 'Bearer test-api-key',+ },+ }),+ );});it('should not throw when deletion fails', async () => {@@ -332,12 +359,15 @@ describe('MistralOCR Service', () => {document_url: 'https://document-url.com',},},- {+ expect.objectContaining({headers: {'Content-Type': 'application/json',Authorization: 'Bearer test-api-key',},- },+ maxRedirects: 0,+ httpAgent: expect.anything(),+ httpsAgent: expect.anything(),+ }),);expect(result).toEqual(mockResponse.data);});@@ -381,12 +411,12 @@ describe('MistralOCR Service', () => {image_url: 'https://image-url.com/image.png',},},- {+ expect.objectContaining({headers: {'Content-Type': 'application/json',Authorization: 'Bearer test-api-key',},- },+ }),);expect(result).toEqual(mockResponse.data);});@@ -858,8 +888,8 @@ describe('MistralOCR Service', () => {user: { id: 'user123' },config: {ocr: {- apiKey: 'OCR_API_KEY',- baseURL: 'OCR_BASEURL',+ apiKey: '${OCR_API_KEY}',+ baseURL: '${OCR_BASEURL}',},},} as unknown as ServerRequest;@@ -942,8 +972,8 @@ describe('MistralOCR Service', () => {user: { id: 'user123' },config: {ocr: {- apiKey: 'OCR_API_KEY',- baseURL: 'OCR_BASEURL',+ apiKey: '${OCR_API_KEY}',+ baseURL: '${OCR_BASEURL}',mistralModel: 'mistral-ocr-latest',},},@@ -1603,11 +1633,11 @@ describe('MistralOCR Service', () => {// Verify delete was called with correct parametersexpect(mockAxios.delete).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-cleanup-123',- {+ expect.objectContaining({headers: {Authorization: 'Bearer test-api-key',},- },+ }),);expect(mockAxios.delete).toHaveBeenCalledTimes(1);});@@ -1672,11 +1702,11 @@ describe('MistralOCR Service', () => {// Verify delete was still called despite the errorexpect(mockAxios.delete).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-cleanup-456',- {+ expect.objectContaining({headers: {Authorization: 'Bearer test-api-key',},- },+ }),);expect(mockAxios.delete).toHaveBeenCalledTimes(1);});@@ -1765,11 +1795,11 @@ describe('MistralOCR Service', () => {// Verify delete was attemptedexpect(mockAxios.delete).toHaveBeenCalledWith('https://api.mistral.ai/v1/files/file-cleanup-789',- {+ expect.objectContaining({headers: {Authorization: 'Bearer test-api-key',},- },+ }),);// Verify error was logged@@ -2015,13 +2045,13 @@ describe('MistralOCR Service', () => {apiKey: 'test-api-key',});- expect(mockAxios.post).toHaveBeenCalledWith(- 'https://api.mistral.ai/v1/files',- expect.anything(),- expect.not.objectContaining({- httpsAgent: expect.anything(),- }),- );+ const config = mockAxios.post!.mock.calls[0][2] as {+ maxRedirects?: number;+ httpsAgent?: { proxyUrl?: string };+ };+ expect(config.maxRedirects).toBe(0);+ expect(config.httpsAgent).toBeDefined();+ expect(config.httpsAgent?.proxyUrl).toBeUndefined();});});@@ -2459,4 +2489,69 @@ describe('MistralOCR Service', () => {});});});++ describe('SSRF connect-time guard', () => {+ afterEach(() => {+ jest.restoreAllMocks();+ delete process.env.PROXY;+ });++ it('blocks a literal private-IP baseURL with ESSRF', async () => {+ await expect(+ performOCR({+ apiKey: 'k',+ url: 'https://document-url.com',+ baseURL: 'http://10.0.0.5:8080',+ }),+ ).rejects.toMatchObject({ code: 'ESSRF' });+ });++ it('exempts a literal private IP present in ocr.allowedAddresses', async () => {+ mockAxios.post!.mockResolvedValueOnce({ data: { pages: [] } });+ await performOCR({+ apiKey: 'k',+ url: 'https://document-url.com',+ baseURL: 'http://10.0.0.5:8080',+ allowedAddresses: ['10.0.0.5:8080'],+ });++ const config = mockAxios.post!.mock.calls[0][2] as {+ httpAgent?: unknown;+ maxRedirects?: number;+ };+ expect(config.httpAgent).toBeDefined();+ expect(config.maxRedirects).toBe(0);+ });++ it('does not open the upload file stream when the OCR target is a blocked literal private IP', async () => {+ (jest.mocked(fs).createReadStream as jest.Mock).mockClear();+ await expect(+ uploadDocumentToMistral({+ apiKey: 'k',+ filePath: '/tmp/doc.pdf',+ baseURL: 'http://10.0.0.5:8080',+ }),+ ).rejects.toMatchObject({ code: 'ESSRF' });+ expect(jest.mocked(fs).createReadStream).not.toHaveBeenCalled();+ });++ it('preserves proxy precedence and still disables redirects', async () => {+ process.env.PROXY = 'http://proxy.example.com:8080';+ mockAxios.post!.mockResolvedValueOnce({ data: { pages: [] } });+ await performOCR({+ apiKey: 'k',+ url: 'https://document-url.com',+ baseURL: 'https://api.mistral.ai/v1',+ });++ const config = mockAxios.post!.mock.calls[0][2] as {+ maxRedirects?: number;+ httpsAgent?: { proxyUrl?: string };+ httpAgent?: unknown;+ };+ expect(config.maxRedirects).toBe(0);+ expect(config.httpsAgent?.proxyUrl).toBe('http://proxy.example.com:8080');+ expect(config.httpAgent).toBeUndefined();+ });+ });});diff --git a/packages/api/src/files/mistral/crud.ts b/packages/api/src/files/mistral/crud.tsindex 5af1ef90a9..463faa4d51 100644--- a/packages/api/src/files/mistral/crud.ts+++ b/packages/api/src/files/mistral/crud.ts@@ -22,6 +22,7 @@ import type {} from '~/types';import { decryptConfigSecret, isEncryptedSecretPayload } from '~/admin/secrets';import { logAxiosError, createAxiosInstance } from '~/utils/axios';+import { applySSRFSafeAgentIfDirect } from '~/auth/agent';import { applyAxiosProxyConfig } from '~/utils/proxy';import { readFileAsBuffer } from '~/utils/files';import { loadServiceKey } from '~/utils/key';@@ -68,17 +69,17 @@ export async function uploadDocumentToMistral({filePath,baseURL = DEFAULT_MISTRAL_BASE_URL,fileName = '',+ allowedAddresses,}: {apiKey: string;filePath: string;baseURL?: string;fileName?: string;+ allowedAddresses?: string[] | null;}): Promise<MistralFileUploadResponse> {const form = new FormData();form.append('purpose', 'ocr');const actualFileName = fileName || path.basename(filePath);- const fileStream = fs.createReadStream(filePath);- form.append('file', fileStream, { filename: actualFileName });const config: AxiosRequestConfig = {headers: {@@ -90,13 +91,17 @@ export async function uploadDocumentToMistral({};applyAxiosProxyConfig(config, `${baseURL}/files`);+ applySSRFSafeAgentIfDirect(config, `${baseURL}/files`, allowedAddresses);- return axios- .post(`${baseURL}/files`, form, config)- .then((res) => res.data)- .catch((error) => {- throw error;- });+ const fileStream = fs.createReadStream(filePath);+ form.append('file', fileStream, { filename: actualFileName });++ try {+ const response = await axios.post(`${baseURL}/files`, form, config);+ return response.data;+ } finally {+ fileStream.destroy();+ }}export async function getSignedUrl({@@ -104,11 +109,13 @@ export async function getSignedUrl({fileId,expiry = 24,baseURL = DEFAULT_MISTRAL_BASE_URL,+ allowedAddresses,}: {apiKey: string;fileId: string;expiry?: number;baseURL?: string;+ allowedAddresses?: string[] | null;}): Promise<MistralSignedUrlResponse> {const config: AxiosRequestConfig = {headers: {@@ -116,7 +123,9 @@ export async function getSignedUrl({},};- applyAxiosProxyConfig(config, `${baseURL}/files/${fileId}/url?expiry=${expiry}`);+ const signedUrlTarget = `${baseURL}/files/${fileId}/url?expiry=${expiry}`;+ applyAxiosProxyConfig(config, signedUrlTarget);+ applySSRFSafeAgentIfDirect(config, signedUrlTarget, allowedAddresses);return axios.get(`${baseURL}/files/${fileId}/url?expiry=${expiry}`, config)@@ -142,12 +151,14 @@ export async function performOCR({model = DEFAULT_MISTRAL_MODEL,baseURL = DEFAULT_MISTRAL_BASE_URL,documentType = 'document_url',+ allowedAddresses,}: {url: string;apiKey: string;model?: string;baseURL?: string;documentType?: 'document_url' | 'image_url';+ allowedAddresses?: string[] | null;}): Promise<OCRResult> {const documentKey = documentType === 'image_url' ? 'image_url' : 'document_url';@@ -160,6 +171,7 @@ export async function performOCR({const ocrURL = baseURL.endsWith('/ocr') ? baseURL : `${baseURL}/ocr`;applyAxiosProxyConfig(config, ocrURL);+ applySSRFSafeAgentIfDirect(config, ocrURL, allowedAddresses);return axios.post(@@ -194,10 +206,12 @@ export async function deleteMistralFile({fileId,apiKey,baseURL = DEFAULT_MISTRAL_BASE_URL,+ allowedAddresses,}: {fileId: string;apiKey: string;baseURL?: string;+ allowedAddresses?: string[] | null;}): Promise<void> {const config: AxiosRequestConfig = {headers: {@@ -206,6 +220,7 @@ export async function deleteMistralFile({};applyAxiosProxyConfig(config, `${baseURL}/files/${fileId}`);+ applySSRFSafeAgentIfDirect(config, `${baseURL}/files/${fileId}`, allowedAddresses);try {const result = await axios.delete(`${baseURL}/files/${fileId}`, config);@@ -386,6 +401,8 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRUlet apiKey: string | undefined;let baseURL: string | undefined;+ const allowedAddresses = context.req.config?.ocr?.allowedAddresses;+try {const authConfig = await loadAuthConfig(context);apiKey = authConfig.apiKey;@@ -397,6 +414,7 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRUfileName: context.file.originalname,apiKey,baseURL,+ allowedAddresses,});mistralFileId = mistralFile.id;@@ -405,6 +423,7 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRUapiKey,baseURL,fileId: mistralFile.id,+ allowedAddresses,});const documentType = getDocumentType(context.file);@@ -414,6 +433,7 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRUbaseURL,apiKey,model,+ allowedAddresses,});if (!ocrResult || !ocrResult.pages || ocrResult.pages.length === 0) {@@ -424,7 +444,7 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRUconst { text, images } = processOCRResult(ocrResult);if (mistralFileId && apiKey && baseURL) {- await deleteMistralFile({ fileId: mistralFileId, apiKey, baseURL });+ await deleteMistralFile({ fileId: mistralFileId, apiKey, baseURL, allowedAddresses });}return {@@ -436,7 +456,7 @@ export const uploadMistralOCR = async (context: OCRContext): Promise<MistralOCRU};} catch (error) {if (mistralFileId && apiKey && baseURL) {- await deleteMistralFile({ fileId: mistralFileId, apiKey, baseURL });+ await deleteMistralFile({ fileId: mistralFileId, apiKey, baseURL, allowedAddresses });}throw createOCRError(error, 'Error uploading document to Mistral OCR API:');}@@ -461,6 +481,7 @@ export const uploadAzureMistralOCR = async (try {const { apiKey, baseURL } = await loadAuthConfig(context);const model = getModelConfig(context.req.config?.ocr);+ const allowedAddresses = context.req.config?.ocr?.allowedAddresses;const { content: buffer } = await readFileAsBuffer(context.file.path, {fileSize: context.file.size,@@ -476,6 +497,7 @@ export const uploadAzureMistralOCR = async (model,url: `${base64Prefix}${base64}`,documentType,+ allowedAddresses,});if (!ocrResult || !ocrResult.pages || ocrResult.pages.length === 0) {diff --git a/packages/api/src/types/files.ts b/packages/api/src/types/files.tsindex 203c500eeb..fa708d7c35 100644--- a/packages/api/src/types/files.ts+++ b/packages/api/src/types/files.ts@@ -1,15 +1,16 @@import type { BedrockDocumentFormat } from 'librechat-data-provider';import type { IMongoFile } from '@librechat/data-schemas';import type { Readable } from 'stream';-import type { ServerRequest } from './http';import type { DownloadURLParams } from '~/storage/types';+import type { ServerRequest } from './http';export interface STTService {getInstance(): Promise<STTService>;- getProviderSchema(req: ServerRequest): Promise<[string, object]>;+ getProviderSchema(req: ServerRequest): Promise<[string, object, string[] | undefined]>;sttRequest(provider: string,schema: object,params: { audioBuffer: Buffer; audioFile: AudioFileInfo },+ allowedAddresses?: string[],): Promise<string>;}