/

CVE-2026-33502

Severity:

CRITICAL RISK

(9.3)

SSRF in WWBN AVideo Live Test Endpoint

CVE-2026-33502

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Internal Service Access via SSRF

Severity:

CRITICAL RISK

(9.3)

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 versions up to and including 26.0 contain an unauthenticated server-side request forgery (SSRF) vulnerability in plugin/Live/test.php that lets remote users instruct the server to send HTTP requests to arbitrary URLs.

When an attacker can control these outbound requests, they may probe internal networks, access otherwise unreachable HTTP services, or query cloud metadata endpoints exposed only to the AVideo host.

Affected context

The vulnerability exists in WWBN AVideo deployments that expose the plugin/Live/test.php endpoint over the network without strong access control.

In this context, user-supplied URL parameters are used by the server to make outbound HTTP requests, and the endpoint does not adequately restrict which addresses or hostnames can be contacted.

Installations running on infrastructure where the AVideo server can reach internal services, management interfaces, or cloud provider metadata endpoints are particularly exposed.

Exploit preconditions

  • Attack surface: Publicly reachable plugin/Live/test.php endpoint on the AVideo web server.
  • Required access: None; the issue is explicitly described as unauthenticated, so any remote user who can reach the endpoint can attempt exploitation.
  • Trigger point: Sending crafted HTTP requests to plugin/Live/test.php with attacker-controlled URL input that the server then uses to initiate outbound HTTP connections.
  • Why exploitation is possible: The server trusts and forwards user-controlled URLs without sufficient validation or restriction, allowing attackers to leverage the server's network position to reach arbitrary HTTP endpoints, including those on localhost or private networks.

Why this happens

This vulnerability stems from a classic server-side request forgery pattern: the application takes a user-provided URL and uses it directly in a server-side HTTP request without constraining the destination.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where an attacker can cause the server to initiate outbound connections to locations of the attacker's choosing.

Because the server operates from within a more privileged network environment than the attacker, the HTTP client code in plugin/Live/test.php effectively becomes a proxy into internal or otherwise non-public resources.

Potential impact

  • Attackers can probe and enumerate internal HTTP services (e.g., on 127.0.0.1, RFC1918 addresses, or service mesh networks).
  • Attackers can access cloud instance metadata endpoints (such as those exposing credentials or configuration), when reachable from the AVideo server.
  • Attackers can interact with administrative panels or management APIs that are bound only to localhost or private interfaces.
  • Attackers can potentially chain discovered services and credentials into broader compromise of the hosting environment or adjacent applications.
  • Attackers may exfiltrate sensitive configuration data exposed by internal web applications reachable from the server.

General mitigation guidance

Addressing SSRF in this context generally involves constraining outbound requests and reducing trust in user-supplied URLs.

Useful mitigation patterns include:

  • Introducing strict allowlists for outbound HTTP requests (e.g., only permitting specific domains or paths that the feature legitimately needs).
  • Rejecting or blocking URLs that resolve to loopback, link-local, or private IP ranges, and preventing requests to raw IP addresses when not needed.
  • Normalizing and validating user-provided URLs before use, including DNS resolution checks and consistent handling of redirects to avoid bypasses.
  • Decoupling user input from direct network calls by using server-side configuration or indirect identifiers instead of raw URLs.
  • Running the application in network-segmented environments where web servers cannot directly access sensitive internal services or cloud metadata endpoints.
  • Applying least-privilege to the runtime environment so that any accessible internal services expose minimal data and capabilities.

How teams detect issues like this

Detecting SSRF issues typically combines static inspection of code paths and runtime monitoring:

  • Static analysis / code review: Look for server-side HTTP client usage (e.g., curl, HTTP libraries, stream wrappers) where the destination URL is derived from request parameters or other user input without comprehensive validation.
  • Configuration review: Examine endpoints like plugin/Live/test.php that appear to "test" or "debug" remote connectivity and confirm they enforce strong access controls and destination restrictions.
  • Network monitoring: Use egress filtering and logging at the firewall or proxy layer to detect unusual outbound HTTP requests from web servers to internal IP ranges or metadata endpoints.
  • Automated scanning: Employ security testing tools configured to probe for SSRF by supplying URLs pointing to controlled endpoints and verifying whether the server attempts outbound connections.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/1e6cf03e93b5a5318204b010ea28440b0d9a5ab3
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-3fpm-8rjr-v5mc

Frequently asked

questions

Yes. The affected endpoint is described as unauthenticated, so any remote user who can reach plugin/Live/test.php can attempt to exploit the SSRF behavior.

Only network access to the AVideo server's HTTP interface is required; no valid user account or prior compromise is necessary.

Restrict where server-side HTTP clients can connect by implementing domain or service allowlists, block access to local and private address ranges, and avoid using raw user-provided URLs as direct inputs to outbound requests.

Design features so that users select from predefined, server-controlled targets rather than submitting arbitrary URLs, enforce strong URL validation and network egress controls, and include SSRF-specific checks in code review and automated testing processes.

Find out what's already
exploitable in your codebase.