/

CVE-2026-41058

Severity:

HIGH RISK

(8.1)

Path Traversal in WWBN AVideo CloneSite deleteDump Parameter

CVE-2026-41058

Analyzed

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Arbitrary File Deletion

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 versions 29.0 and below contain a path traversal vulnerability in the CloneSite feature's deleteDump parameter, where user input is used to construct file paths without proper filtering.

An attacker can supply ../../ sequences via a GET request to trigger unlink() on arbitrary files that the web server can access, potentially leading to loss of critical application or system data.

Affected context

The vulnerability exists in WWBN AVideo deployments running version 29.0 or earlier that expose the CloneSite functionality over HTTP.

The deleteDump GET parameter is used to decide which dump file to remove, but path traversal filtering is incomplete, so crafted relative paths can escape the intended directory.

Impact is constrained by the file system permissions of the AVideo process; only files writable by that account can be deleted.

Exploit preconditions

  • Attack surface: HTTP endpoint handling CloneSite operations, reachable over the network.
  • Required access: Ability to send crafted GET requests to the vulnerable endpoint; further authentication requirements depend on how CloneSite is exposed in the deployment.
  • Trigger point: Supplying a deleteDump parameter containing ../ sequences (e.g., ../../) so that the resulting path points outside the expected dump directory.
  • Why exploitation is possible: The server-side code concatenates the user-supplied deleteDump value into a filesystem path and calls unlink() without robust normalization or validation, allowing directory traversal.

Why this happens

This issue is a classic path traversal problem where user-controlled input is incorporated into a filesystem path without adequate validation or normalization.

The incomplete prior fix for the CloneSite deleteDump parameter failed to block ../ sequences or otherwise constrain file operations to a specific directory, enabling an attacker to escape the intended path sandbox.

This behavior maps directly to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal'), where the application trusts path components supplied by clients when performing filesystem operations.

Potential impact

  • Deletion of arbitrary application files that the web server user can write to.
  • Removal of configuration or log files, which could disrupt monitoring and forensics.
  • Deletion of uploaded media assets, causing data loss and service disruption.
  • Targeted deletion of security-related files (e.g., access controls, temporary auth artifacts) that may facilitate further compromise depending on environment configuration.

General mitigation guidance

Effective mitigation focuses on tightening how file paths are derived from user input and narrowing the set of files the application is allowed to manipulate.

Recommended defensive patterns include:

  • Directory whitelisting: Resolve the requested filename against a fixed, application-controlled base directory and reject paths that resolve outside that directory after canonicalization.
  • Strict input validation: Accept only known-safe identifiers (e.g., IDs, tokens, or filenames matching a strict pattern) instead of arbitrary path fragments; avoid honoring ../ or absolute paths entirely.
  • Indirect file references: Map user-facing identifiers to internal paths using a lookup table or metadata store, rather than constructing paths directly from user input.
  • Least-privilege filesystem permissions: Run the web application under an account that has write access only to directories that are intended to be modified (e.g., a specific dump or uploads folder).
  • Secure-by-default error handling: Fail closed when validation fails—refuse to perform file operations if the requested file cannot be safely resolved and verified.

How teams detect issues like this

Detection typically blends code-level analysis with runtime monitoring:

  • Static analysis: Scan for filesystem operations (unlink, delete, fopen, etc.) that use request parameters or other untrusted data in path construction without canonicalization and directory checks.
  • Code review cues: Flag any occurrence where paths are formed via string concatenation with GET/POST parameters, especially where ../ filtering is implemented manually or partially.
  • Security testing: Use dynamic application security testing (DAST) to probe file-handling endpoints with ../ sequences and observe whether unexpected files are affected.
  • Runtime monitoring: Log and alert on file deletions outside expected directories made by the web server process, particularly when correlated with suspicious HTTP requests.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/3c729717c26f160014a5c86b0b6accdbd613e7b2
github.comgithub.com/WWBN/AVideo/commit/941decd6d19e2e694acb75e86317d10fbb560284
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-5879-4fmr-xwf2
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-xmjm-86qv-g226

Frequently asked

questions

Yes. As long as an attacker can reach the CloneSite endpoint that processes the deleteDump parameter over the network, they can attempt to exploit the vulnerability by sending crafted HTTP requests.

It depends on how the instance is configured. If the CloneSite feature is accessible only to authenticated or administrative users, an attacker would first need those privileges. If it is exposed more broadly, exploitation may be possible without authentication.

The safest approach is to stop using raw user input as part of filesystem paths. Instead, use validated identifiers mapped to known-good paths and ensure that any resolved path is constrained to a specific directory after canonicalization. Reject any request that leads outside the permitted directory or does not match a strict whitelist.

Adopt a defensive design that treats all path components from clients as untrusted. Use centralized helper functions for filesystem access that enforce directory constraints, integrate static analysis rules for path traversal patterns, and require security review for any code that performs file operations based on HTTP parameters.

Find out what's already
exploitable in your codebase.