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.phpendpoint 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
Locationheader are fetched byfakeBrowser()without re-runningisSSRFSafeURL(), 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.

