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.

