/

CVE-2026-33039

Severity:

HIGH RISK

(8.6)

SSRF in WWBN AVideo LiveLinks Proxy

CVE-2026-33039

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network 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 LiveLinks proxy endpoint inadequately validates redirects, allowing attacker-controlled URLs to bypass SSRF protections after an initial safety check.

By abusing HTTP redirects from an allowed external URL, an attacker can cause the server to access internal or private network resources, including cloud metadata endpoints and RFC1918 addresses.

Affected context

This vulnerability occurs in WWBN AVideo deployments that expose the plugin/LiveLinks/proxy.php endpoint and rely on isSSRFSafeURL() to restrict outbound HTTP requests.

The issue appears when user-supplied URLs are only validated before the initial request, but subsequent redirects are followed by fakeBrowser() without additional safety checks.

Any environment where the AVideo server can reach internal services, management interfaces, or cloud provider metadata endpoints is at elevated risk.

Exploit preconditions

  • Attack surface: The plugin/LiveLinks/proxy.php endpoint accessible over HTTP/HTTPS.
  • Required access: Ability to submit or control a URL parameter to the LiveLinks proxy (typically unauthenticated or low-privilege web access, depending on deployment).
  • Trigger point: Supplying a URL that:
  • Passes the isSSRFSafeURL() validation, and
  • Responds with an HTTP redirect (e.g., 301/302) to an internal/private target.
  • Why exploitation is possible: The SSRF filter validates only the original URL. Redirect locations returned in the Location header are fetched by fakeBrowser() without re-running isSSRFSafeURL(), enabling traversal from a "safe" origin to an unsafe internal destination.

Why this happens

The underlying bug is an incomplete implementation of SSRF protections that fails to consider HTTP redirect chains.

isSSRFSafeURL() enforces network and hostname restrictions only on the initial URL, while fakeBrowser() automatically follows redirects without subjecting the new target to the same validation.

This creates a classic CWE-918: Server-Side Request Forgery condition where the application acts as an HTTP client on behalf of the attacker, bridging otherwise inaccessible internal networks.

Conceptually, the design trusts the redirect behavior of external resources instead of consistently enforcing outbound access control on every hop in the request flow.

Potential impact

  • Access to internal HTTP services that are not directly exposed to the internet.
  • Retrieval of sensitive data from cloud metadata endpoints (e.g., IAM credentials, tokens, configuration).
  • Interaction with services bound to localhost or RFC1918/private address space.
  • Enumeration of internal network structure and reachable hosts via HTTP-based probes.
  • Potential pivoting into further attacks if internal services expose administrative or debugging interfaces.

General mitigation guidance

Effective mitigation focuses on enforcing consistent, context-aware outbound request validation and reducing the server's ability to reach sensitive network locations.

Recommended defensive patterns include:

  • Applying the same SSRF safety checks to every redirect target and each step in a redirect chain, not just the initial URL.
  • Restricting outbound connections from the application server to a minimal, explicit allowlist of domains or endpoints.
  • Disallowing or tightly limiting redirects in proxy-style endpoints; for many use cases, redirects can be rejected or resolved server-side against strict policies.
  • Normalizing and validating final resolved URLs (including scheme, host, port, and IP) before issuing any outbound request.
  • Segmenting the application server from highly sensitive internal services and cloud metadata endpoints at the network level (firewalls, VPC controls).
  • Running the application with least-privilege network access so that even if SSRF occurs, reachable targets are minimized.

How teams detect issues like this

Detection strategies generally revolve around code-level analysis and runtime monitoring:

  • Static analysis rules that flag:
  • Proxy or "URL fetcher" functions that follow redirects without re-validating targets.
  • Custom SSRF validation helpers (like isSSRFSafeURL()) that are only applied once in a multi-step request flow.
  • Direct outbound HTTP calls that accept user-controlled URLs or redirect locations.
  • Code review checklists that explicitly ask:
  • Is every externally-controlled URL validated before each request and after redirect resolution?
  • Are IP-based checks (e.g., blocking private ranges and link-local addresses) applied after DNS resolution?
  • Dynamic testing and security scanning that:
  • Sends benign SSRF probes using allowed external URLs that redirect to internal-style targets.
  • Monitors application logs, outbound proxy logs, or egress firewall logs for unexpected requests to RFC1918 ranges or metadata services.
  • Use of automated SAST/DAST tools configured with SSRF-specific rules to surface risky URL handling patterns during CI.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/0e56382921fc71e64829cd1ec35f04e338c70917
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-9x67-f2v7-63rw

Frequently asked

questions

Yes, if the plugin/LiveLinks/proxy.php endpoint is reachable from the internet and accepts user-supplied URLs, an external attacker can typically exploit this issue by hosting a redirecting URL.

The attacker only needs the ability to provide or influence the URL parameter consumed by the LiveLinks proxy. No direct access to internal services is required; the application server performs the requests on the attacker's behalf.

Apply strict SSRF validation to every outbound request destination, including all redirect targets, and prefer an allowlist of approved hosts or domains. Where practical, disable following redirects or resolve them under strict policy rather than blindly trusting Location headers.

Centralize outbound HTTP requests through a hardened client or gateway that enforces network policies; avoid passing raw user-controlled URLs directly to HTTP libraries; apply IP and hostname checks after DNS resolution; and combine these controls with network-layer egress restrictions so that high-value internal services are not reachable even in the presence of application bugs.

Find out what's already
exploitable in your codebase.