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
deleteDumpparameter 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
deleteDumpvalue into a filesystem path and callsunlink()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.

