/

CVE-2026-33293

Severity:

HIGH RISK

(8.1)

Path Traversal / Arbitrary File Deletion in WWBN AVideo

CVE-2026-33293

Analyzed

Vulnerability type

Category:

Path Traversal / Arbitrary File Deletion

CWE:

CWE-22

Impact:

Arbitrary File Deletion leading to Denial of Service and Security Control Bypass

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

WWBN AVideo's CloneSite plugin previously passed the deleteDump parameter directly into unlink() without sanitizing the path, allowing crafted input to traverse directories and delete unintended files.

An authenticated attacker with valid clone credentials could leverage this to remove arbitrary files on the server, potentially breaking the application, deleting configuration, or weakening security controls.

Affected context

The vulnerability occurs in deployments of WWBN AVideo that have the CloneSite plugin enabled and expose the plugin/CloneSite/cloneServer.json.php endpoint.

It becomes relevant when the application accepts the deleteDump parameter from a user who has valid clone credentials and then uses that value directly as a filesystem path for unlink(), without enforcing a fixed base directory or validating that the path stays within an expected location.

In such contexts, directory traversal sequences like ../ can escape the intended directory and target sensitive files elsewhere on the server.

Exploit preconditions

  • Attack surface: HTTP(S) interface to plugin/CloneSite/cloneServer.json.php within the AVideo application.
  • Required access: Valid clone credentials or equivalent authenticated access required to invoke the CloneSite functionality.
  • Trigger point: Supplying a crafted deleteDump parameter containing path traversal sequences (e.g., ../../configuration.php) in a request that triggers file deletion.
  • Why exploitation is possible: The server-side code passes the unvalidated deleteDump value directly to unlink() without canonicalization, normalization, or restriction to an allowed directory, allowing deletion of files outside the intended dump location.

Why this happens

The issue stems from improper restriction of filesystem paths derived from user-controlled input.

Instead of constraining deleteDump to a specific directory or validating that the requested path remains within a safe base path, the implementation passes the parameter directly into PHP's unlink() function.

This maps to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), where attacker-controlled path elements such as ../ are honored, enabling access to files outside the intended directory.

Conceptually, this reflects an insecure pattern where authorization is tied to an operation (delete a dump file) but not bound to a narrow set of allowable resources, leading to general-purpose file deletion.

Potential impact

  • Deletion of critical application files such as configuration.php, causing application downtime or complete denial of service.
  • Removal of security-relevant files (e.g., access control lists, key material, or logging configurations), potentially weakening defenses.
  • Disruption of backup or clone processes by removing essential data or scripts.
  • Facilitation of chained attacks, where deletion of configuration or integrity checks enables easier exploitation of other weaknesses.
  • Potential data loss if user-generated content or database dumps are targeted.

General mitigation guidance

Mitigation usually focuses on strictly controlling which paths can be deleted and separating user intent from raw filesystem operations.

Common defensive patterns include:

  • Restricting deletions to a known, hard-coded base directory and resolving the requested filename against that directory before performing unlink().
  • Normalizing and canonicalizing paths, then verifying that the resulting absolute path starts with the expected base directory.
  • Using whitelists or identifiers instead of direct filesystem paths (e.g., mapping a logical dump ID to a stored path on the server side).
  • Applying least privilege to the web server and application user so that even if deletion is abused, access to highly sensitive files is constrained.
  • Centralizing file deletion logic in a well-reviewed utility that enforces these rules, rather than calling unlink() directly with user-controlled data.

How teams detect issues like this

Detection can combine code-centric analysis with operational monitoring:

  • Static analysis rules that flag direct use of filesystem functions (e.g., unlink, rm, fopen) with tainted or request-derived parameters, especially where no base directory enforcement is evident.
  • Code review checklists that include validation of all user-influenced filesystem paths, looking for proper normalization and boundary checks around directory traversal.
  • Application security tests (DAST) designed to send directory traversal payloads in parameters like deleteDump and verify unexpected deletion or error patterns.
  • Runtime monitoring or file integrity tools that alert on unexpected deletion of configuration or application files in directories that should rarely change.
  • Integration of automated scanning tools into CI/CD to detect path traversal patterns before deployment.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/941decd6d19e2e694acb75e86317d10fbb560284
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-xmjm-86qv-g226

Frequently asked

questions

It can be, if the AVideo instance and its CloneSite endpoint are exposed and an attacker can obtain or abuse valid clone credentials. The attack is carried out via HTTP(S) requests but is gated by authentication.

The attacker must have valid clone credentials or equivalent authenticated access to the CloneSite functionality. Unauthenticated users typically cannot trigger this specific file deletion behavior.

The robust fix is to decouple user input from raw filesystem paths: constrain deletions to a predefined directory, map user-supplied identifiers to server-side paths, normalize and validate paths before deletion, and centralize file operation logic behind strict checks.

Adopt secure coding guidelines that prohibit passing request-derived paths directly into filesystem APIs, enforce code review rules for all file operations, use automated static analysis to detect path traversal patterns, and design APIs around resource identifiers rather than direct paths.

Find out what's already
exploitable in your codebase.