
CVE-2026-8712: Unauthenticated SSRF / Backend URI Override in Wyoming HTTP API via uri Query Parameter
uri Query ParameterSeverity: High, CVSS 3.1 8.3
Vector (v3.1): CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:L/I:L/A:L
Vector (v4.0): CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:L/SI:L/SA:L (6.9, Medium)
Affected: wyoming < 1.10.2 (confirmed on 1.9.0; the same vulnerable pattern is present in 1.8.0)
Fixed in: 1.10.2
CWE: CWE-918 (Server-Side Request Forgery)
Component: wyoming/http/shared.py → AsyncClient.from_uri() (wyoming/client.py)
Vendor / Product: OHF-Voice / Wyoming
Reported by: Rahul Karne
CNA: VulnCheck
The Wyoming HTTP API lets an unauthenticated HTTP client supply a uri query parameter. That value is passed directly to AsyncClient.from_uri() and used as the backend Wyoming service address.
As a result, an attacker can override the server's configured backend URI and force the HTTP server to connect to attacker-chosen tcp:// or unix:// targets. This enables server-side request forgery, backend redirection, interaction with internal services, and retrieval of responses from an attacker-selected Wyoming service through the HTTP API.
The server operator configures a backend once, at startup, with --uri. The bug is that this configured value is not treated as a trust boundary: any request can replace it, per request, with ?uri=....
An unauthenticated attacker with network access to the Wyoming HTTP server can control the backend URI used by the server for individual requests.
This allows the attacker to:
Because the forged connection originates from the server, it can reach hosts and ports the attacker cannot reach directly — for example services bound to loopback or to an internal network segment — which is the defining characteristic of SSRF.
wyoming is the voice protocol used across the open-source voice-assistant ecosystem, including Home Assistant's Assist / voice pipeline and the Rhasspy project, and is the transport spoken by Wyoming ASR, TTS, wake-word, and intent services.
The affected population is any deployment that exposes the Wyoming HTTP API to a network an attacker can reach.
In wyoming/http/shared.py, the backend URI is taken from the request query string, falling back to the configured value:
uri = request.args.get("uri", args.uri)
and then handed straight to the client factory:
async with AsyncClient.from_uri(uri) as client:
...
In wyoming/client.py, AsyncClient.from_uri() accepts attacker-controlled URI schemes:
if result.scheme == "unix":
return AsyncUnixClient(result.path)
if result.scheme == "tcp":
return AsyncTcpClient(result.hostname, result.port)
if result.scheme == "stdio":
return AsyncStdioClient()
There is no allowlist, no authentication check, and no restriction on the host, port, or scheme of the supplied URI before the connection is made.
The request-controlled uri is honored on the endpoints that proxy to a Wyoming backend, including:
/api/info
/api/speech-to-text
/api/text-to-speech
/api/recognize-intent
/api/detect-wake-word
The HTTP layer treats a client-supplied value as the address of a trusted internal service. request.args.get("uri", args.uri) makes the request parameter take precedence over the operator's --uri, so the startup configuration is only a default, not an enforced boundary.
AsyncClient.from_uri() is a general-purpose factory that will connect to whatever tcp://, unix://, or stdio:// target it is given. It is safe when the URI comes from a trusted operator and unsafe when the URI comes from an unauthenticated request. The HTTP API supplies it with the latter without any validation.
The server operator configures a backend URI at startup:
--uri tcp://127.0.0.1:1
Any unauthenticated HTTP client can override it per request:
?uri=tcp://127.0.0.1:9999
The configured backend is therefore not enforced as a trust boundary. Whatever isolation the operator believed the fixed backend provided does not exist.
The dangerous input is the uri query parameter on an ordinary, unauthenticated HTTP request. No special client, no user interaction, and no prior access to the backend are required.
Any of the following exposure patterns is sufficient:
Once a request reaches the endpoint, the attacker chooses the backend the server connects to.
Successful exploitation requires:
wyoming.http.asr_server, tts_server, etc.).That is the entire precondition set. There is no version-of-Python dependency, no memory-corruption primitive, and no victim interaction.
poc_wyoming.py drives the real Wyoming HTTP server and the real Wyoming client factory.
The demonstration is intentionally harmless and fully local:
wyoming.http.asr_server with an intentionally unreachable configured backend (tcp://127.0.0.1:1).wyoming library) and only logs what it receives.127.0.0.1.AsyncClient.from_uri().--uri tcp://127.0.0.1:1)./api/info and observes it fail (the configured backend is unreachable)./api/info?uri=tcp://127.0.0.1:<fake-port> and observes it succeed, with the fake backend recording the inbound Wyoming describe request.Install the affected package with the HTTP extra:
pip install "wyoming==1.9.0"
# the HTTP servers require the http extra in some distributions:
# pip install "wyoming[http]==1.9.0"
The issue has been confirmed against:
wyoming 1.9.0
and the same pattern is present in 1.8.0. It is fixed in 1.10.2.
Run the self-contained demonstration:
python poc_wyoming.py --no-pause
Optional flags: