/

CVE-2026-33480

Severity:

HIGH RISK

(8.6)

SSRF in WWBN AVideo LiveLinks Proxy URL Validation

CVE-2026-33480

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Access to internal and cloud-only resources via SSRF

Severity:

HIGH RISK

(8.6)

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 URL validation in isSSRFSafeURL() can be bypassed using IPv4-mapped IPv6 addresses, allowing attackers to trick the server into making unintended HTTP requests.

Through the unauthenticated plugin/LiveLinks/proxy.php endpoint, an attacker can cause the server to access internal services such as cloud metadata endpoints, internal network hosts, or localhost-only applications.

Affected context

The vulnerability appears in WWBN AVideo deployments that expose the plugin/LiveLinks/proxy.php endpoint and rely on isSSRFSafeURL() to validate outbound URLs.

The function attempts to block access to sensitive destinations (e.g., localhost, private IP ranges, metadata services) but fails to properly handle IPv4-mapped IPv6 addresses (::ffff:x.x.x.x).

When this address form is used, it passes the existing checks, enabling requests from the AVideo server to internal or protected network locations that would normally be unreachable from the internet.

Exploit preconditions

  • Attack surface: Publicly exposed plugin/LiveLinks/proxy.php endpoint that performs server-side URL fetching.
  • Required access: No authentication required; an attacker can send crafted HTTP requests directly to the endpoint.
  • Trigger point: Supplying a URL parameter encoded as an IPv4-mapped IPv6 address (e.g., http://[::ffff:169.254.169.254]/) to the proxy endpoint.
  • Why exploitation is possible: The SSRF safety check function isSSRFSafeURL() does not correctly interpret and filter IPv4-mapped IPv6 addresses, so IP-based blocking logic for localhost, internal ranges, and special addresses is bypassed.

Why this happens

This issue is a classic SSRF input validation flaw where network address validation is incomplete and fails to account for all equivalent representations of restricted targets.

The isSSRFSafeURL() routine checks URLs against disallowed hosts and IP ranges but relies on parsing logic that assumes conventional IPv4 or IPv6 notation. IPv4-mapped IPv6 addresses (::ffff:x.x.x.x) are treated as safe even when they resolve to blocked IPv4 ranges such as 127.0.0.1 or 169.254.169.254.

Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF): untrusted user input controls the target of a server-initiated HTTP request, and incomplete canonicalization/normalization of network addresses allows attackers to reach internal or privileged services.

Potential impact

  • Access to cloud provider metadata services, which may expose instance credentials or configuration.
  • Interaction with internal network services not directly exposed to the internet (e.g., databases, admin panels, internal APIs).
  • Interaction with services bound to localhost only, potentially reading status pages or management endpoints.
  • Use of the AVideo server as a pivot point for reconnaissance within the internal network.
  • Potential elevation of privileges or further compromise if internal services trust the AVideo server's network location.

General mitigation guidance

Mitigation strategies typically focus on hardening how outbound URLs are validated and minimizing where the server can connect:

  • Normalize and canonicalize all host and IP representations before applying allow/deny checks, including IPv4, IPv6, IPv4-mapped IPv6, and DNS names.
  • Prefer positive security models (explicit allowlists of domains or services) for server-side HTTP clients rather than attempting to block "bad" destinations.
  • Enforce network-layer egress restrictions so web application servers cannot directly access metadata services, management networks, or other sensitive internal segments.
  • Avoid exposing generic open proxy-style endpoints; constrain proxy features to specific, well-defined upstream targets.
  • Apply least-privilege principles to the runtime environment, ensuring that even if SSRF occurs, reachable services are minimized and strongly authenticated.

How teams detect issues like this

Effective detection generally combines code-centric and operational approaches:

  • Static analysis / code review:
  • Flag application endpoints that accept user-controlled URLs and then use server-side HTTP clients (e.g., curl, file_get_contents).
  • Look for custom IP/host validation logic and verify that it normalizes addresses and handles IPv4-mapped IPv6 and other alternate encodings.
  • Identify patterns where URL validation and URL usage are separated or inconsistently applied.
  • Configuration and policy checks:
  • Enforce policies that prohibit unrestricted HTTP proxy endpoints or require explicit allowlists for outbound connections.
  • Use infrastructure-as-code scanning to detect servers with unfettered network egress to sensitive internal services or metadata addresses.
  • Runtime monitoring:
  • Monitor outbound HTTP traffic from application servers for connections to known sensitive targets (e.g., 169.254.169.254, RFC1918 ranges, localhost).
  • Alert on unusual bursts of outbound requests originating from web-accessible endpoints.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/75ce8a579a58c9d4c7aafe453fbced002cb8f373
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-p3gr-g84w-g8hh

Frequently asked

questions

Yes. As described, the plugin/LiveLinks/proxy.php endpoint is unauthenticated, so any remote attacker who can reach the AVideo instance over the network can attempt to trigger SSRF using crafted URLs.

The attacker only needs network access to the vulnerable endpoint; no valid user account or special permissions are required. Control over the URL parameter is sufficient to influence where the server sends HTTP requests.

The most robust pattern is to avoid generic proxy behavior and instead restrict outbound requests to a tightly controlled allowlist of domains or services. All hostnames and IP addresses should be fully normalized and resolved before applying policy, with explicit handling of IPv4, IPv6, and IPv4-mapped IPv6 formats.

Treat any user-controlled URL as untrusted input, normalize and validate it rigorously, and design architectures where web application servers have very limited egress capabilities. During design and code review, flag features that proxy or fetch arbitrary URLs and require strong justification and allowlist-based controls before deployment.

Find out what's already
exploitable in your codebase.