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.phpendpoint 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.phpwith 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.phpthat 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.

