/

CVE-2026-33351

Severity:

CRITICAL RISK

(9.1)

SSRF in WWBN AVideo Live Standalone DVR Endpoint

CVE-2026-33351

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Arbitrary Server-Side Network Access

Severity:

CRITICAL RISK

(9.1)

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

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.php to 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.php reachable from the attacker.
  • Required access: None; the endpoint can be invoked without authentication in the affected configuration.
  • Trigger point: Supplying a crafted webSiteRootURL parameter that points to an attacker-chosen URL (including internal IPs/hosts).
  • Why exploitation is possible: The server directly interpolates the user-supplied webSiteRootURL into a URL string and passes it to file_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.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/d0c54960389eeb85e76caed5a257ae90e6a739f2
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-5f7v-4f6g-74rj

Frequently asked

questions

Yes. When the standalone Live plugin endpoint is exposed, an unauthenticated remote attacker can trigger server-side requests by supplying crafted webSiteRootURL values.

In the vulnerable configuration, no authentication is required. The affected endpoint processes the webSiteRootURL parameter without verifying the caller's identity or enforcing access control.

The most robust pattern is to avoid accepting arbitrary URLs from clients for server-side fetches. Instead, restrict requests to predefined, server-owned destinations and enforce strong validation and allowlisting on any remaining dynamic URLs.

Treat all client-supplied URLs and host-related parameters as untrusted, forbid direct use of them in HTTP clients, implement consistent URL validation and allowlisting utilities, and integrate SSRF-focused checks into code review and static analysis pipelines.

Find out what's already
exploitable in your codebase.