Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
Tools/GitHubGitHub/rahulreddykarne/cve-2026-8712-wyoming
Vulnerability AnalysisExploitationWeb SecurityLearning & EducationAPI Security
GitHubrahulreddykarne/cve-2026-8712-wyoming

CVE-2026-8712-Wyoming

CVE-2026-8712: Unauthenticated SSRF / Backend URI Override in Wyoming HTTP API via uri Query Parameter

View Repository
161 month agoNot yet reviewed

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    936
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    555
  • 3

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    353
  • 4

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    348
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT platform that ingests Shadowserver reports into MongoDB and replays them as interactive maps, analysis, findings, advisories and executive dashboards.

    336
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    288

Explore all tools

Browse our collection of tools

View all tools →
Share

CVE-2026-8712: Unauthenticated SSRF / Backend URI Override in Wyoming HTTP API via uri Query Parameter

Severity: 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


Summary

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=....


Impact

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:

  • Force outbound TCP connections from the server to attacker-chosen hosts and ports.
  • Redirect the HTTP API to attacker-controlled or internal Wyoming backend services.
  • Retrieve backend responses through the HTTP API.
  • Interact with internal-only Wyoming services that are not directly reachable by the attacker.
  • Cause availability impact by redirecting requests to dead, slow, or malicious backends.

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.


Reach

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.

  • Downloads, all-time: 1.22M
  • Downloads, last 30 days: ~101K
  • Downloads, last 24 hours: ~2.7K
  • Deployment context: self-hosted voice assistants and home/edge automation, frequently on internal networks alongside other internal-only services — precisely the environment where SSRF is most useful.

The affected population is any deployment that exposes the Wyoming HTTP API to a network an attacker can reach.


Technical Detail

Affected Code

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.

Affected HTTP Endpoints

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

Root Cause

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.


Security Boundary Violation

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.


Delivery Over the Network

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:

  • The Wyoming HTTP API is bound to a routable interface.
  • It is reachable through a reverse proxy, port forward, or container port mapping.
  • It sits on an internal network that the attacker has any foothold on.

Once a request reaches the endpoint, the attacker chooses the backend the server connects to.


Exploitation Preconditions

Successful exploitation requires:

  1. The Wyoming HTTP server is running (for example wyoming.http.asr_server, tts_server, etc.).
  2. The attacker can send HTTP requests to it.
  3. No authentication or authorization is required for the affected endpoints.

That is the entire precondition set. There is no version-of-Python dependency, no memory-corruption primitive, and no victim interaction.


Proof of Concept

poc_wyoming.py drives the real Wyoming HTTP server and the real Wyoming client factory.

The demonstration is intentionally harmless and fully local:

  • It starts the real wyoming.http.asr_server with an intentionally unreachable configured backend (tcp://127.0.0.1:1).
  • It starts a local "fake backend" that speaks the real Wyoming protocol (using the installed wyoming library) and only logs what it receives.
  • It sends two unauthenticated HTTP requests and compares the results.
  • It touches no real system files, credentials, or cloud services, and connects only to 127.0.0.1.

What the PoC Does

  1. Prints the environment and the vulnerable source lines for the HTTP handler and AsyncClient.from_uri().
  2. Starts a harmless local Wyoming backend on a loopback port that an attacker "controls," which records every connection and the first event it receives.
  3. Starts the real Wyoming HTTP server pointed at a dead backend (--uri tcp://127.0.0.1:1).
  4. Sends a baseline request to /api/info and observes it fail (the configured backend is unreachable).
  5. Sends /api/info?uri=tcp://127.0.0.1:<fake-port> and observes it succeed, with the fake backend recording the inbound Wyoming describe request.
  6. Concludes SSRF: the unauthenticated request chose the backend the server connected to.

Setup

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

Run the self-contained demonstration:

python poc_wyoming.py --no-pause

Optional flags:

Download Tool