/

CVE-2026-33493

Severity:

HIGH RISK

(7.1)

Path Traversal in WWBN AVideo import.json.php File Import

CVE-2026-33493

Analyzed

Vulnerability type

Category:

Path Traversal / Directory Traversal

CWE:

CWE-22

Impact:

Unauthorized File Access and Deletion

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 up to and including 26.0 contain a path traversal issue in the objects/import.json.php endpoint, where a user-controlled fileURI is only checked to end with .mp4 and is not confined to the intended videos/ directory.

An authenticated user with upload permission can leverage this to read or import other users' private video files, access certain adjacent text/HTML files, and delete .mp4 and nearby text files accessible to the web server.

Affected context

The vulnerability occurs in WWBN AVideo deployments where the objects/import.json.php endpoint is exposed to authenticated users who have permission to upload or import files.

The endpoint accepts a fileURI parameter and only validates that it ends in .mp4, without restricting the resolved path to the videos/ directory or another safe location.

This contrasts with objects/listFiles.json.php, which performs a realpath() plus directory prefix check; the lack of equivalent checks in import.json.php allows access to files elsewhere on the file system that the web server can read or modify.

Exploit preconditions

  • Attack surface: HTTP POST requests to objects/import.json.php within the AVideo web application.
  • Required access: Valid authenticated AVideo account with sufficient permission to upload/import videos.
  • Trigger point: Supplying a crafted fileURI value that points to a targeted .mp4 file or a path that causes adjacent .txt/.html/.htm files to be processed.
  • Why exploitation is possible: The fileURI parameter is only checked via a regex to ensure it ends with .mp4 and is not normalized or constrained via realpath() or a strict directory prefix check. As a result, users can reference arbitrary .mp4 files and adjacent text/HTML files accessible to the web server, enabling unauthorized read/import and deletion operations.

Why this happens

The core issue is a classic path traversal (CWE-22) caused by failure to enforce strict directory constraints on user-supplied file paths.

The code path for objects/import.json.php relies solely on a regex check to ensure fileURI ends in .mp4, but does not:

  • Normalize the path with realpath(), and
  • Verify that the resolved path is inside the intended videos/ directory (or another controlled storage root).

This mismatch with the hardened behavior in objects/listFiles.json.php creates an insecure pattern where logically sensitive file operations (read/import/delete) are performed based on partially validated input, allowing users to target arbitrary files that satisfy the superficial extension check and are accessible under the web server's file permissions.

Potential impact

  • An authenticated user may import other users' private video files into their own account, bypassing access controls.
  • Attackers could read .txt, .html, or .htm files located adjacent to any targeted .mp4 file on the filesystem, potentially exposing configuration fragments, metadata, or other sensitive information.
  • .mp4 files and adjacent text/HTML files writable by the web server can be deleted, leading to data loss or service disruption.
  • Partial content disclosure may assist with further attacks (e.g., discovering file structures, gaining insight into deployment paths).

General mitigation guidance

Effective mitigation centers on treating any path-like input as untrusted and strictly constraining it to controlled storage locations.

Recommended defensive patterns include:

  • Applying canonicalization (realpath() or equivalent) to the user-supplied fileURI and enforcing that the resolved path has a required directory prefix (e.g., the videos/ directory).
  • Avoiding the direct use of user-controlled file paths; instead, map user inputs to internal identifiers that the application translates to safe, pre-validated paths.
  • Enforcing whitelists of permissible directories and disallowing any relative path segments (.., symlinks, or absolute paths) that would escape those directories.
  • Aligning all file-handling endpoints (import, list, delete) to use a shared, hardened file resolution routine rather than bespoke checks.
  • Ensuring the web server process runs with least-privilege filesystem permissions so that even if path validation fails, the set of files exposed is minimized.

How teams detect issues like this

To detect this class of issue, organizations can:

  • Use static analysis to flag any use of user-controlled parameters in file operations (e.g., fopen, file_get_contents, unlink, copy) that are not routed through a common normalization and directory-check function.
  • Include security-focused code review checklists that explicitly ask reviewers to identify path traversal risks and verify that all file paths derived from HTTP parameters are sanitized and constrained.
  • Implement application-level logging for file import and deletion operations, including the resolved file paths and calling user, and periodically review logs for abnormal access patterns (e.g., imports from unexpected directories).
  • Employ web application scanners configured to probe file-handling endpoints with traversal-like input patterns to highlight cases where directory constraints are missing or ineffective.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/e110ff542acdd7e3b81bdd02b8402b9f6a61ad78
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-83xq-8jxj-4rxm

Frequently asked

questions

Exploitation is limited to authenticated users who have permission to upload/import videos, but within that scope those users can access and manipulate files they should not be able to reach.

No. The issue can be triggered by any authenticated account with upload/import rights; administrative privileges are not required, although higher-privileged accounts may have broader visibility into which files exist.

Centralize file path resolution through a function that canonicalizes paths (e.g., with realpath()), verifies they reside within a designated storage root (such as the videos/ directory), and rejects or logs any request that attempts to escape that root, then ensure all file-handling endpoints use this routine.

Treat all path components from user input as untrusted, avoid exposing raw filesystem paths, enforce strict directory whitelists, add automated checks (static analysis, tests) for path traversal patterns, and ensure code reviews specifically verify that any new file operations respect these constraints.

Find out what's already
exploitable in your codebase.