Summary
A server-side request forgery (SSRF) vulnerability in AVideo's aVideoEncoder.json.php endpoint allows authenticated users to make the server perform HTTP requests to arbitrary URLs via the downloadURL parameter.
When an attacker can control this parameter, they may interact with internal network services or metadata endpoints that are not directly exposed to the internet, potentially leading to data exposure or further compromise depending on the environment.
Affected context
This vulnerability occurs in AVideo deployments where the aVideoEncoder.json.php endpoint is exposed to authenticated users and the backend server has network-level access to internal resources or cloud metadata services.
It is most impactful when the AVideo server resides in a network segment that can reach internal HTTP services, administrative APIs, or instance metadata endpoints that are not otherwise reachable from the public internet.
Exploit preconditions
- Attack surface: The
aVideoEncoder.json.phpAPI endpoint accessible to authenticated users. - Required access: Valid authenticated account with permission to call the encoder API and supply a
downloadURLparameter. - Trigger point: Supplying a crafted
downloadURLvalue that points to an internal or otherwise sensitive HTTP(S) endpoint. - Why exploitation is possible: The server performs outbound HTTP(S) requests based directly on user-controlled input without enforcing an allow-list, proper URL validation, or network egress restrictions, enabling SSRF to arbitrary targets reachable by the server.
Why this happens
The root cause is untrusted user input being used directly to construct server-side HTTP requests, without adequate validation or restriction on destination hosts or schemes.
This maps to CWE-918: Server-Side Request Forgery (SSRF), where the application acts as a proxy, allowing attackers to pivot through the server to reach internal or otherwise restricted resources.
The downloadURL parameter operates as a fully trusted URL, and the backend logic fails to:
- Enforce a strict allow-list of permitted domains or paths,
- Reject non-HTTP schemes or loopback/internal IP ranges,
- Separate user-controlled URLs from sensitive network zones.
Potential impact
- Access to internal HTTP(S) services that are not exposed externally
- Retrieval of sensitive configuration data, internal API responses, or service metadata
- Interaction with cloud metadata endpoints, which can lead to credential theft or token exposure
- Use of the server as a pivot point for further reconnaissance within the internal network
- Potential modification of internal services depending on their exposed endpoints and permissions
General mitigation guidance
Effective mitigation focuses on constraining server-side outbound requests and reducing trust in user-supplied URLs:
- Apply a strict allow-list of permitted domains, IPs, or URL patterns for any server-side fetch functionality.
- Block or carefully scrutinize requests to private IP ranges, loopback addresses, link-local addresses, and cloud metadata endpoints.
- Normalize and parse URLs using robust libraries before evaluation, avoiding string-based checks that can be bypassed.
- Enforce scheme restrictions (e.g., only
https://to known domains) and reject ambiguous or non-HTTP schemes. - Segregate services so that web-facing components have limited network access to internal management or data planes.
- Follow least-privilege principles for network routing and firewall rules to limit where the application server can connect.
How teams detect issues like this
Detection typically involves a combination of code-level analysis and runtime monitoring:
- Static analysis: Flag patterns where user-controlled parameters feed into HTTP client libraries or URL constructors without prior validation or allow-list checks.
- Code review: Look for endpoints that accept URL/host parameters, particularly ones named like
url,callback,redirect,target, ordownloadURL, and verify they enforce strong destination constraints. - Policy enforcement: Implement development policies requiring allow-lists or fixed endpoints for server-side HTTP calls, backed by automated checks in CI.
- Runtime monitoring: Use logging and security analytics to detect unusual outbound requests to internal or unexpected destinations initiated by web application processes.

