Summary
WWBN AVideo's Live plugin, when used in standalone mode, contains a server-side request forgery (SSRF) flaw in saveDVR.json.php where a user-controlled URL is fetched directly by the server.
An unauthenticated attacker can abuse this behavior to make the AVideo server initiate arbitrary outbound HTTP requests, potentially reaching internal services or metadata endpoints that are not directly exposed to the internet.
Affected context
This vulnerability appears in AVideo deployments that:
- Have the Live plugin enabled in standalone mode, and
- Expose
plugin/Live/standAloneFiles/saveDVR.json.phpto untrusted clients, and - Allow the server to make outbound HTTP/HTTPS requests.
In this configuration, the webSiteRootURL request parameter is treated as a trusted URL and used to construct a target that the server then fetches via file_get_contents() without authentication or validation.
Exploit preconditions
- Attack surface: HTTP(S) endpoint
plugin/Live/standAloneFiles/saveDVR.json.phpreachable from the attacker. - Required access: None; the endpoint can be invoked without authentication in the affected configuration.
- Trigger point: Supplying a crafted
webSiteRootURLparameter that points to an attacker-chosen URL (including internal IPs/hosts). - Why exploitation is possible: The server directly interpolates the user-supplied
webSiteRootURLinto a URL string and passes it tofile_get_contents()without origin checks, allowlisting, or scheme restrictions, effectively turning the application into a blind HTTP client for the attacker.
Why this happens
The underlying issue is a trust violation in how user input is used to build server-side HTTP requests.
The webSiteRootURL request parameter is assumed to be safe and is concatenated into a URL that is passed to file_get_contents(), which performs an outbound HTTP request on behalf of the server.
Because there is no validation of the destination (e.g., IP ranges, schemes, hostnames) and no authentication barrier, external clients can route the server to arbitrary network locations.
This aligns with CWE-918: Server-Side Request Forgery (SSRF), where an application allows an attacker to induce the server to initiate requests to unintended internal or external endpoints.
Potential impact
- Access to internal HTTP services that are not exposed publicly (e.g., admin panels, internal APIs, monitoring endpoints).
- Interaction with cloud instance metadata services (where present), which may lead to credential exposure or configuration leakage.
- Network scanning of internal IP ranges using response behavior as an oracle.
- Abuse of the AVideo server as a proxy to bypass IP allowlists or firewalls.
- Potential pivoting into further vulnerabilities on internal services reachable only from the server's network.
General mitigation guidance
Effective mitigation typically focuses on reducing the trust placed in user-controlled URLs and constraining server-initiated requests:
- Introduce strict allowlists or patterns for permitted outbound destinations instead of accepting arbitrary URLs from clients.
- Normalize and validate the scheme, host, and port of any URL derived from external input, rejecting private or loopback address ranges and non-HTTP(S) schemes.
- Avoid passing raw user input into generic URL-fetching functions; instead, bind server-side requests to preconfigured, server-controlled endpoints.
- Enforce authentication and authorization around DVR or live-stream management endpoints so that only trusted parties can trigger server-side network activity.
- Where feasible, apply network egress controls (firewall rules, proxy policies) to restrict which hosts the application server can contact.
How teams detect issues like this
Organizations can detect SSRF patterns and instances through multiple layers of review and monitoring:
- Static analysis: Flag uses of functions like
file_get_contents(), cURL, or HTTP client libraries where the URL parameter is constructed from$_GET,$_POST,$_REQUEST, or other untrusted sources without validation. - Code review: Look for endpoints that accept full URLs or hostnames from clients, especially in features related to callbacks, webhooks, or DVR/live streaming, and confirm the presence of origin checks and allowlists.
- Security testing: Perform targeted SSRF tests against endpoints that trigger server-side calls, observing network traffic or application behavior for signs of internal resource access.
- Runtime monitoring: Use network-level logging and egress controls to detect unusual outbound requests from the application, particularly to internal IP ranges or metadata service addresses.

