Skip to content

CVE-2026-121936: easyVoice AI Voice & TTS API Server-Side Request Forgery via openaiBaseUrl

Density:
C-Level Executive Briefing CVE-2026-121936 CRITICAL SCORE 84/100

On November 5, 2026, VulnCheck cataloged as weaponized a high-impact Server-Side Request Forgery (SSRF) vulnerability affecting easyVoice text-to-speech (TTS) services prior to version 0.0.23. Widely integrated into autonomous voice agents and conversational AI platforms to synthesize real-time speech, easyVoice accepts an arbitrary openaiBaseUrl parameter when handling TTS requests with useLLM enabled. Because backend URL sanitization was incomplete in packages/backend/src/utils/ssrf.ts, unauthenticated remote attackers can coerce the Node.js server into dispatching arbitrary POST requests to internal VPC endpoints, loopback interfaces (127.0.0.1), private LLM inference clusters (vLLM, Ollama), and cloud instance metadata services (169.254.169.254). Crucially, failed connection errors and HTTP response status banners are reflected directly to the caller via the custom x-generate-tts-warning HTTP response header, creating an interactive port-scanning and asset-discovery oracle. Hermes assigns an Agentic Security Score (HASS) of 86 and an overall HTS of 84.

HYBRID

HERMES THREAT SCORE & AUTONOMOUS AI AGENT AUDIO SSRF INTEGRITY EVALUATION

Target: easyVoice TTS API Controller & SSRF Sanitizer (/api/v1/tts)
Confidence: 97%
84 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 17 / 20
Weaponization 19 / 20
Exposure 18 / 20
Prevalence 14 / 20
Impact 18 / 20
Exploit Maturity 19 / 20
Attack Chain Potential 18 / 20
โš–๏ธ Divergence & Operational Rationale

[object Object]

In modern enterprise generative AI systems, conversational voice agents rely on multi-stage pipeline architectures. When an autonomous agent interacts with users over WebSockets or telephony gateways, text generated by large language models (LLMs) is dispatched to text-to-speech (TTS) synthesis microservices. easyVoice is an open-source voice generation engine designed to bridge natural language generation with dynamic voice cloning, phonetic timing, and audio synthesis.

To allow voice agents to enhance, rephrase, or translate text prompts before generating audio, easyVoice includes an optional LLM integration feature (useLLM). When enabled, the caller can specify an alternative OpenAI-compatible API base URL (openaiBaseUrl) to route pre-processing queries to customized model endpoints (such as local vLLM instances, self-hosted Ollama servers, or fine-tuned language models).

+---------------------------------------+
| Adversary (Unauthenticated Internet) |
+---------------------------------------+
|
| 1. POST /api/v1/tts
| openaiBaseUrl: "http://169.254.169.254"
v
+----------------------------+
| easyVoice Microservice |
| (VPC Private Container) |
+----------------------------+
/ \
2. SSRF Query (IAM Metadata) / \ 3. SSRF Query (Local AI)
v v
+-----------------------+ +-------------------------------+
| AWS / GCP IMDSv2 | | Unauthenticated Internal LLM |
| (169.254.169.254) | | (vLLM / Ollama: 10.0.1.50) |
+-----------------------+ +-------------------------------+
\ /
\ /
v v
4. Leaked Connection Errors & Tokens
x-generate-tts-warning: "..."

CVE-2026-121936 represents a critical architectural failure in how easyVoice processes openaiBaseUrl. In versions prior to 0.0.23, the application failed to validate whether the supplied URL targeted external, publicly routable IP addresses. Consequently, unauthenticated remote attackers can abuse public-facing easyVoice endpoints to force the server into performing arbitrary HTTP requests against internal cloud infrastructure, container networks, and private API microservices. Furthermore, easyVoice reflects internal connection errors in the x-generate-tts-warning response header, turning the service into a high-speed reconnaissance and exploitation scanner.


The vulnerability stems from defective URL validation logic located in packages/backend/src/utils/ssrf.ts and invoked by the main text-to-speech handler in packages/backend/src/controllers/tts.controller.ts.

// packages/backend/src/controllers/tts.controller.ts (Vulnerable Implementation)
export async function generateTTS(req: Request, res: Response) {
const { text, voice, useLLM, openaiBaseUrl, openaiApiKey } = req.body;
let processedText = text;
if (useLLM) {
try {
// INSECURE: Target URL accepted directly from unauthenticated user input
const targetUrl = openaiBaseUrl || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
// Flawed pre-check: only checks for protocol presence, no IP resolution or private range blocking
if (!isValidProtocol(targetUrl)) {
throw new Error('Invalid URL protocol');
}
const client = new OpenAI({
baseURL: targetUrl,
apiKey: openaiApiKey || process.env.OPENAI_API_KEY,
});
const completion = await client.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: `Format text for TTS: ${text}` }],
});
processedText = completion.choices[0].message.content;
} catch (error: any) {
// INFORMATION LEAKAGE: Internal error strings reflected directly in response headers
res.setHeader('x-generate-tts-warning', `LLM Preprocessing Failed: ${error.message}`);
}
}
// Proceeds to audio generation...
const audioBuffer = await synthesizeSpeech(processedText, voice);
return res.type('audio/mpeg').send(audioBuffer);
}
  1. Missing DNS Resolution & CIDR Filtering: The validation routine only checked whether the URL began with http:// or https://. It performed no DNS lookup prior to connecting and failed to inspect whether resolved IP addresses fell within private, link-local, loopback, or reserved blocks:

    • 127.0.0.0/8 (Loopback)
    • 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 (RFC 1918 Private Networks)
    • 169.254.169.254 (RFC 3927 Cloud Instance Metadata)
    • ::1, fe80::/10 (IPv6 Loopback and Link-Local)
  2. Full Reflection in Response Headers: When the OpenAI SDK attempts to establish a TCP handshake with an internal host (e.g., http://10.0.0.12:8000/v1), network timeouts, refused connections, or HTTP status codes (e.g., 401 Unauthorized, 404 Not Found) are captured in the catch block. Instead of logging the error privately, the controller attaches the raw string to x-generate-tts-warning. This completely bypasses traditional โ€œblindโ€ SSRF constraints, giving attackers immediate feedback on open ports and active internal services.

In version 0.0.23, the developers refactored packages/backend/src/utils/ssrf.ts to implement strict hostname resolution and socket-level IP pinning:

// packages/backend/src/utils/ssrf.ts (Patched Implementation)
import dns from 'node:dns/promises';
import ipaddr from 'ipaddr.js';
export async function validateSafeUrl(rawUrl: string): Promise<URL> {
const parsed = new URL(rawUrl);
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
throw new Error('Restricted protocol: Only HTTP and HTTPS are permitted');
}
// Resolve hostname to all associated IP addresses
const addresses = await dns.lookup(parsed.hostname, { all: true });
for (const { address } of addresses) {
const addr = ipaddr.parse(address);
const range = addr.range();
// Block private, loopback, link-local, and cloud metadata ranges
if (
range === 'loopback' ||
range === 'private' ||
range === 'linkLocal' ||
range === 'uniqueLocal' ||
address === '169.254.169.254'
) {
throw new Error(`SSRF Prevention: Access to private network target ${address} is forbidden`);
}
}
return parsed;
}

Adversaries weaponize CVE-2026-121936 to perform internal network reconnaissance and cloud credential exfiltration:

  1. Host & Port Enumeration via Header Reflection: The attacker scripts automated POST requests to /api/v1/tts, cycling through internal IP addresses (e.g. http://10.0.0.1:22, http://10.0.0.1:80, http://10.0.0.1:6379).

    • If port 6379 (Redis) is open, the header returns: x-generate-tts-warning: LLM Preprocessing Failed: Expected JSON, received -ERR unknown command.
    • If the port is closed: x-generate-tts-warning: LLM Preprocessing Failed: connect ECONNREFUSED 10.0.0.1:6379.
    • If the host is inactive: x-generate-tts-warning: LLM Preprocessing Failed: connect ETIMEDOUT 10.0.0.1:6379.
  2. Cloud Metadata Target Hijacking: On AWS Elastic Container Service (ECS) or EC2 environments running IMDSv1 or misconfigured IMDSv2, the attacker points openaiBaseUrl to http://169.254.169.254/latest/meta-data/iam/security-credentials/.

  3. Autonomous Agent Knowledge Injection & Prompt Poisoning: If internal LLM inference engines (such as Ollama on port 11434 or vLLM on port 8000) are deployed without authentication on the container network, the attacker crafts malicious completion prompts through the text parameter, inducing the internal model to execute unauthorized tool invocations or poisoned context summaries.


Security teams can detect exploit attempts through reverse proxy access logs, web application firewall (WAF) inspect rules, and container egress traffic monitoring.

title: easyVoice TTS API SSRF Exploitation Attempt via openaiBaseUrl
id: c48a1290-9f1e-4c7b-b389-cve2026121936-sigma
status: production
description: Detects unauthenticated POST requests targeting easyVoice TTS API containing private IPs, loopback, or cloud metadata indicators in the openaiBaseUrl field.
author: Hermes Codex Cyber Risk Intelligence
date: 2026-11-05
references:
- https://vulncheck.com/advisories/easyvoice-before-0.0.23-ssrf-via-openaibaseurl-in-tts-api
- https://github.com/cosin2077/easyVoice/pull/88
logsource:
category: webserver
product: easyvoice
detection:
selection_endpoint:
cs-method: 'POST'
cs-uri-stem|endswith: '/api/v1/tts'
selection_payload:
cs-body|contains:
- '169.254.169.254'
- '127.0.0.1'
- 'localhost'
- '10.'
- '172.16.'
- '172.17.'
- '172.18.'
- '172.19.'
- '172.20.'
- '172.31.'
- '192.168.'
- 'metadata.google.internal'
condition: selection_endpoint and selection_payload
fields:
- c-ip
- cs-method
- cs-uri-stem
- cs-body
- sc-status
falsepositives:
- Legitimate self-hosted internal LLMs explicitly configured in non-production development environments
level: critical
tags:
- attack.initial_access
- attack.t1090
- attack.t1552
- cve.2026.121936
// Detect easyVoice SSRF payloads targeting private or metadata IPs
W3CIISLog
| where csMethod =~ "POST" and csUriStem has "/api/v1/tts"
| where csBody has_any ("169.254.169.254", "localhost", "127.0.0.1", "metadata.google", "10.", "192.168.")
| project TimeGenerated, cIP, csMethod, csUriStem, csBody, scStatus, scSubStatus
| order by TimeGenerated desc

To remediate CVE-2026-121936 across containerized and cloud environments:

Update the backend package to version 0.0.23 or later:

Terminal window
npm install easyvoice@latest
# or if using docker
docker pull cosin2077/easyvoice:0.0.23

Confirm that validateSafeUrl in packages/backend/src/utils/ssrf.ts is actively enforced on all incoming openaiBaseUrl parameters.

Enforce strict IMDSv2 hop limits to prevent containers from querying instance metadata:

Terminal window
# AWS CLI: Enforce IMDSv2 with maximum hop limit of 1
aws ec2 modify-instance-metadata-options \
--instance-id <instance-id> \
--http-tokens required \
--http-put-response-hop-limit 1 \
--http-endpoint enabled

Deploy Kubernetes NetworkPolicies or Docker bridge firewall rules disallowing easyVoice containers from communicating directly with internal RFC 1918 subnets unless explicitly whitelisted:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: easyvoice-egress-lockdown
spec:
podSelector:
matchLabels:
app: easyvoice
policyTypes:
- Egress
egress:
# Allow external DNS
- to:
- namespaceSelector: {}
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- protocol: UDP
port: 53
# Allow outbound HTTPS only to legitimate public AI providers
- to:
- ipBlock:
cidr: 0.0.0.0/0
except:
- 10.0.0.0/8
- 172.16.0.0/12
- 192.168.0.0/16
- 169.254.169.254/32
ports:
- protocol: TCP
port: 443