/

CVE-2026-40089

Severity:

CRITICAL RISK

(9.9)

SSRF in Sonicverse Radio Dashboard API Client

CVE-2026-40089

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Access to Internal/Protected Resources

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

The Sonicverse Radio Audio Streaming Stack dashboard contains a Server-Side Request Forgery (SSRF) weakness in its server-side API client that allows user-controlled URLs to be requested by the backend.

In deployments created using the provided install scripts, an authenticated operator can abuse this behavior to send arbitrary HTTP requests from the dashboard backend to internal or external systems, potentially reaching otherwise non-exposed services.

Affected context

This vulnerability affects Sonicverse deployments where the dashboard backend exposes an API that accepts a URL parameter and forwards it to a server-side HTTP client without robust validation or restriction.

It is particularly relevant for installations created via the official install.sh / one‑liner setup, where the dashboard runs with network access to other services in the Docker Compose stack and possibly the surrounding infrastructure.

The issue manifests when authenticated dashboard operators can influence which remote resource the backend fetches, turning a convenience feature into a capability to reach internal HTTP endpoints, metadata services, or other sensitive network targets.

Exploit preconditions

  • Attack surface: Sonicverse dashboard HTTP interface and its backend API.
  • Required access: Valid authenticated operator access to the dashboard (no direct shell or container access required).
  • Trigger point: Any dashboard feature that accepts a user-provided URL and forwards it to the backend API client in apps/dashboard/lib/api.ts.
  • Why exploitation is possible: The backend trusts the URL supplied by the user and passes it directly to a server-side HTTP client without sufficient validation, filtering, or network egress restrictions. As a result, the backend can be coerced into issuing HTTP requests to arbitrary internal or external hosts reachable from its network context.

Why this happens

The underlying flaw is a classic Server-Side Request Forgery pattern: a server-side component makes outbound HTTP requests to URLs that are directly or indirectly controlled by a user.

In this case, the dashboard API client (apps/dashboard/lib/api.ts) uses a generic HTTP library to fetch resources based on user-supplied URLs, but does not implement strong controls such as allowlists, denylisted address ranges, scheme restrictions, or hostname validation.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where an attacker leverages a trusted server to initiate network connections into zones they cannot reach directly, abusing the server's position, credentials, or network topology.

Potential impact

  • May enable access to internal HTTP services within the Docker Compose network or adjacent infrastructure that are not directly exposed to the internet.
  • Could allow interaction with cloud instance metadata services or similar control-plane endpoints, potentially leading to credential exposure.
  • Can be used to enumerate internal network hosts, ports, and services reachable by the dashboard backend.
  • Might facilitate chaining with other vulnerabilities (e.g., hitting internal admin panels or debug endpoints) to escalate privileges or gain remote code execution.
  • Could allow an attacker to bypass firewalls or IP-based access controls by proxying traffic through the Sonicverse backend.

General mitigation guidance

Effective mitigation focuses on constraining how and where the backend is allowed to send HTTP requests and reducing trust in user-supplied URLs.

Common defensive patterns include:

  • Introducing strict allowlists of permitted outbound destinations or hostnames, especially for any feature that fetches remote resources.
  • Enforcing scheme and port restrictions (e.g., only https on standard ports) and rejecting URLs targeting private, loopback, link-local, or metadata IP ranges.
  • Normalizing and validating URLs server-side before use, including resolving hostnames and checking final IPs against approved network ranges.
  • Decoupling user input from direct HTTP calls by mapping user choices to predefined, server-controlled endpoints rather than arbitrary URLs.
  • Applying network-level egress controls (e.g., container firewalling, restrictive Docker network policies) so that the dashboard backend cannot freely reach sensitive internal services.
  • Following the principle of least privilege for the dashboard's runtime environment, including limiting credentials or tokens that might be exposed if internal endpoints are reached.

How teams detect issues like this

Detecting and managing SSRF risks typically involves a combination of code-level review and runtime monitoring:

  • Static analysis: Create rules or queries to flag server-side HTTP calls where the URL or target host is derived from request parameters, headers, or other user-influenced inputs without validation or normalization.
  • Code review signals: During manual review, pay attention to API endpoints that accept URLs, domains, or paths and then invoke HTTP clients, especially in shared utility modules like apps/dashboard/lib/api.ts.
  • Security testing: Use internal penetration testing or dynamic analysis to probe URL-handling endpoints with targets in private or loopback ranges and verify whether the backend follows these requests.
  • Policy enforcement: Adopt engineering guidelines that disallow arbitrary outbound HTTP from user-facing services and mandate allowlists or service discovery mechanisms instead of free-form URLs.
  • Monitoring and logging: Log outbound requests from sensitive services, including destination host/IP and caller context, and alert on unusual internal destinations or patterns.

Sources

SourceLink
github.comgithub.com/sonicverse-eu/audiostreaming-stack/security/advisories/GHSA-8vvj-7f7r-7v48

Frequently asked

questions

It is exploitable through the Sonicverse dashboard interface by anyone who has authenticated operator access. The attacker does not need direct network access to internal services; instead, they abuse the dashboard backend as a proxy to reach those services.

The issue requires authenticated access to the Sonicverse dashboard with the ability to interact with features that accept URLs. No direct system shell or container-level access is needed, but the operator role must be able to supply or influence URLs processed by the backend.

The most robust fix is to eliminate or tightly constrain user-driven outbound requests: replace arbitrary URL fetching with a curated set of allowed endpoints, enforce strict validation and network restrictions, and ensure the backend cannot contact private or sensitive network ranges based solely on user input.

Integrate SSRF-aware design guidelines and security checks into the development lifecycle: treat any feature that makes outbound HTTP calls as sensitive, enforce allowlists and IP range validation by default, apply container/network egress controls, and use automated code scanning and peer review to catch new instances where user input influences outbound request targets.

Find out what's already
exploitable in your codebase.