/

CVE-2026-39370

Severity:

HIGH RISK

(7.1)

SSRF in WWBN AVideo Upload-by-URL Flow

CVE-2026-39370

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and data exfiltration via SSRF

Severity:

HIGH RISK

(7.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

WWBN AVideo versions 26.0 and prior contain a server-side request forgery (SSRF) flaw in objects/aVideoEncoder.json.php that allows attacker-controlled downloadURL values with certain media and archive extensions to bypass validation.

An authenticated uploader can abuse the upload-by-URL feature to make the server fetch arbitrary internal resources and store the responses as media content, enabling reliable SSRF-based response exfiltration in some environments.

Affected context

This vulnerability arises in WWBN AVideo deployments that expose the upload-by-URL capability through objects/aVideoEncoder.json.php and rely on extension-based filtering to restrict outbound fetches.

When an authenticated user supplies a downloadURL ending in allowed extensions such as .mp4, .mp3, .zip, .jpg, .png, .gif, or .webm, the application may still perform the outbound request even if the target is an internal or otherwise sensitive endpoint.

The issue persists where the prior fix for similar behavior was incomplete and did not fully constrain the destinations or semantics of the requested URLs.

Exploit preconditions

  • Attack surface: The HTTP endpoint handling upload-by-URL (objects/aVideoEncoder.json.php).
  • Required access: Valid authenticated uploader (or any role allowed to initiate upload-by-URL operations).
  • Trigger point: Supplying a crafted downloadURL value that points to internal or protected services while using an allowed file extension.
  • Why exploitation is possible: URL validation focuses on extensions and incomplete checks rather than robustly constraining destination hosts, IP ranges, or protocols. As a result, the backend behaves as an HTTP proxy capable of reaching internal resources and storing their responses as media, enabling inspection or exfiltration of those responses.

Why this happens

The underlying issue is a classic Server-Side Request Forgery (CWE-918) where server-side logic makes outbound HTTP requests based on user-controlled URLs without adequately restricting possible targets.

In this case, validation relies primarily on file extensions and a partial patch for a prior CVE, leaving gaps that allow URLs with approved extensions to still point at internal or sensitive network locations.

The design implicitly trusts that URLs resembling media or archive files are safe to fetch, rather than applying strict network-level and scheme-level allowlists or rejecting access to non-public address spaces.

Potential impact

  • Access to internal HTTP services that are not exposed externally
  • Exfiltration of sensitive information from internal endpoints when responses are stored or made viewable as media
  • Interaction with cloud metadata services, potentially exposing credentials or configuration data
  • Pivoting within the infrastructure by probing internal ports or services reachable from the AVideo server
  • Assisting further attacks such as enumeration of internal APIs or discovery of additional misconfigurations

General mitigation guidance

Effective mitigation focuses on constraining outbound requests from server-side URL fetch features and reducing the trust boundary around user-supplied URLs:

  • Enforce strict allowlists of destination domains or IP ranges that the upload-by-URL feature may contact, avoiding generic outbound access.
  • Block requests to private, loopback, link-local, and metadata address ranges at the application level and, where possible, at the network layer.
  • Validate schemes (e.g., only allow https/http) and reject URLs with embedded credentials, unusual ports, or redirection chains to unapproved addresses.
  • Treat responses as untrusted data; avoid exposing raw responses directly to users without normalization or filtering.
  • Consider isolating URL-fetching components in a network segment with minimal privileges and no access to sensitive internal services.

How teams detect issues like this

Identifying and monitoring this class of vulnerability typically involves:

  • Static analysis or code review rules that flag server-side HTTP clients invoked with user-controlled URLs and lacking clear host/IP allowlists.
  • Reviewing input validation logic around downloadURL and similar parameters, looking for extension-only checks or incomplete network restrictions.
  • Logging outbound HTTP requests made by the application and analyzing for patterns such as access to internal IP ranges, metadata addresses, or unusual ports.
  • Implementing security controls (e.g., egress firewalls, service mesh policies) that log and optionally block unexpected internal destinations from web-facing services.
  • Incorporating automated security testing (SAST/DAST) specifically targeting SSRF patterns in upload-by-URL or webhook-style features.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-cmcr-q4jf-p6q9

Frequently asked

questions

It is exploitable by any authenticated user who has permission to use the upload-by-URL functionality; it does not typically allow unauthenticated exploitation unless that feature is exposed without login.

The attacker must be able to authenticate as a user role that can submit downloadURL values to the encoder endpoint. No direct shell or server-level access is required—only the ability to trigger the server to fetch external URLs.

The most robust fix is to strictly control where the server is allowed to connect: introduce domain/IP allowlists, block access to non-public address ranges, validate schemes and ports, and avoid relying solely on file extensions to decide if a URL is safe.

Treat all user-supplied URLs as untrusted, design outbound HTTP features with network-aware restrictions, codify SSRF-safe patterns in code review and security guidelines, and enforce egress controls so that web-facing services cannot freely reach internal or metadata endpoints.

Find out what's already
exploitable in your codebase.