/

CVE-2026-27732

Severity:

HIGH RISK

(8.1)

SSRF in AVideo aVideoEncoder.json.php API

CVE-2026-27732

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and sensitive data exposure via SSRF

Severity:

HIGH RISK

(8.1)

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

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.php API endpoint accessible to authenticated users.
  • Required access: Valid authenticated account with permission to call the encoder API and supply a downloadURL parameter.
  • Trigger point: Supplying a crafted downloadURL value 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, or downloadURL, 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.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/384ef2548093f4cbb1bfac00f1f429fe57fab853
github.comgithub.com/WWBN/AVideo/releases/tag/22.0
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-h39h-7cvg-q7j6

Frequently asked

questions

Yes, but it requires an authenticated user account. An attacker who can log in and reach the aVideoEncoder.json.php endpoint can exploit the SSRF from a remote location.

The attacker needs valid authentication to the AVideo platform with permissions to invoke the encoder API and control the downloadURL parameter. No direct access to the internal network is required; the application server acts as the proxy.

The safest pattern is to strictly limit where the server can send outbound requests by:

  • Enforcing an allow-list of approved domains or fixed endpoints,
  • Rejecting requests to private or sensitive address ranges and metadata services,
  • Removing or redesigning functionality that allows arbitrary user-provided URLs to be fetched server-side.

Treat any user-supplied URL or host as untrusted by default and:

  • Require explicit design review for features that make server-side network calls based on user input,
  • Implement reusable URL validation and allow-list utilities,
  • Combine application-level checks with network-layer controls (firewalls, security groups) to restrict egress,
  • Incorporate SSRF-focused checks into static analysis, code review guidelines, and security testing.
Find out what's already
exploitable in your codebase.