/

CVE-2026-58192

Severity:

HIGH RISK

(8.6)

Path Traversal (CWE-22) in Appium Storage Plugin

CVE-2026-58192

Undergoing Analysis

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22, CWE-73

Impact:

Arbitrary File and Directory Deletion

Severity:

HIGH RISK

(8.6)

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

A path traversal flaw in the Appium storage plugin's delete endpoint allows user-supplied file names to be used directly in filesystem operations without sanitization.

An unauthenticated remote client can exploit this by using ../ sequences to escape the storage root and recursively delete arbitrary writable files or directories on the host where Appium runs.

Affected context

This vulnerability arises in Appium deployments that enable the storage plugin and expose its HTTP API, particularly the POST /storage/delete endpoint.

It is relevant when the Appium server has filesystem access to directories beyond the intended storage root and runs with permissions that allow deletion of local files.

The risk is higher in environments where Appium is co-located with shared resources, CI infrastructure, or critical test artifacts, and where network access to the Appium server is not tightly restricted.

Exploit preconditions

  • Attack surface: Exposed Appium storage plugin HTTP API (POST /storage/delete).
  • Required access: Network reachability to the Appium server; no authentication required on the vulnerable endpoint.
  • Trigger point: Sending a crafted DELETE request that includes path traversal sequences (e.g., "../") in the name parameter.
  • Why exploitation is possible: The handler uses the supplied name directly in path.join(storageRoot, name) and passes it to recursive deletion (fs.rimraf()), without validating or normalizing the resulting path to keep it within the designated storage root.

Why this happens

The underlying issue is improper restriction of file paths constructed from user input, corresponding to CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') and related file handling weaknesses in CWE-73.

The application trusts a client-provided name value and concatenates it with a storage base path, then performs destructive filesystem operations.

Without strict checks to ensure the final path remains inside the intended directory, attackers can embed directory traversal tokens such as "../" to escape the storage root and target arbitrary locations.

This insecure pattern reflects a broader class of path-based authorization flaws where file operations are not constrained by a canonical, validated path policy.

Potential impact

  • Remote clients may delete test artifacts, logs, and stored application data managed by Appium.
  • Attackers could remove configuration files or local resources, causing denial of service for the Appium server or associated tooling.
  • CI or automation environments can experience job failures or data loss if shared directories are deleted.
  • In permissive runtimes, attackers might delete application binaries or scripts, disrupting broader services on the same host.

General mitigation guidance

Effective mitigation focuses on enforcing strict path confinement and reducing trust in user-supplied file identifiers.

Common defensive patterns include:

  • Normalizing and validating user-provided path segments, rejecting any input containing traversal sequences or absolute paths.
  • Resolving the target path to its canonical form and verifying that it remains within an allowed base directory before performing filesystem operations.
  • Using whitelisted identifiers or opaque IDs that map to server-known file paths instead of accepting raw filenames from clients.
  • Applying least-privilege principles to the Appium process so it can only modify files in a dedicated, constrained directory tree.
  • Restricting network exposure of the storage plugin endpoint and applying authentication/authorization checks to sensitive file operations.

How teams detect issues like this

Organizations can detect similar vulnerabilities by:

  • Applying static analysis rules that flag direct use of user input in filesystem APIs, particularly delete or recursive operations.
  • Reviewing code for patterns where request parameters are concatenated into paths without canonicalization or boundary checks.
  • Enforcing secure coding policies that require path validation utilities around join/resolve calls before file operations.
  • Monitoring application logs and host telemetry for suspicious deletion patterns, such as unexpected removal of non-storage directories initiated via application APIs.
  • Using automated security testing tools to fuzz file-related endpoints with path traversal payloads and verify access controls.

Sources

SourceLink
github.comgithub.com/appium/appium/commit/5fee01752f2782e96fbe64fd13520b433d4a7535
github.comgithub.com/appium/appium/pull/22362
github.comgithub.com/appium/appium/releases/tag/%40appium/storage-plugin%401.1.6
github.comgithub.com/appium/appium/security/advisories/GHSA-jwgx-mp9m-jwcr

Frequently asked

questions

Exploitation is as broad as network access to the Appium storage plugin's HTTP interface; any remote client that can reach the POST /storage/delete endpoint can attempt traversal-based deletion.

No. The described issue affects an unauthenticated endpoint, so exploitation does not require valid credentials or prior account access, only network reachability.

The safest approach is to avoid direct use of client-supplied file paths, instead mapping opaque identifiers to server-managed locations and enforcing canonical path checks that ensure every file operation stays within a designated base directory.

Prevention involves adopting secure file-handling patterns: normalize and validate every path, centralize path-confinement logic, restrict process filesystem privileges, and incorporate security-focused code review and automated testing for endpoints that manipulate files or directories.

Find out what's already
exploitable in your codebase.