CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-72R4-9C5J-MJ57

GHSA-72R4-9C5J-MJ57: Arbitrary File Deletion via Path Traversal in pnpm patch-remove

Alon Barad
Alon Barad
Software Engineer

Jun 27, 2026·5 min read·43 visits

Executive Summary (TL;DR)

The pnpm package manager failed to validate file paths in its 'patch-remove' routine. A malicious actor could exploit this by embedding directory traversal sequences in the project's configuration, leading to arbitrary file deletion when a user or CI/CD runner executed the command.

A path traversal vulnerability in the pnpm package manager's 'patch-remove' command allows an attacker to delete arbitrary files outside the patches directory. By manipulating configuration files like package.json, an attacker can specify a traversal path that the application deletes recursively without validating the path's containment.

Vulnerability Overview

The pnpm package manager is an alternative to npm and yarn designed for performance and efficient disk utilization through hard links and a content-addressable store. To support custom dependency modification, pnpm offers a native patching framework. This subsystem exposes an attack surface when processing localized configuration assets such as package.json files or workspace lockfiles.

Historically, the 'patch-remove' command enabled developers to reverse local dependency patches and clean up corresponding patch files. However, the mechanism lacked security boundaries between the local project folder and the host filesystem. This design flaw introduced a path-traversal vulnerability that allows arbitrary file deletion.

Classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory), the underlying issue stems from a lack of boundary validation during path resolution. An attacker who can influence configuration inputs can force the tool to clean up assets outside the designated directory structure, compromising filesystem integrity and causing denial-of-service conditions on vulnerable workstations and build runners.

Root Cause Analysis

The vulnerability is located in the core execution logic of the 'pnpm patch-remove' command. This utility is responsible for cleaning up local overrides configured within the 'patchedDependencies' block of the configuration. When executed, the command parses the workspace metadata to locate the patch files to delete. Prior to remediation, the application trusted the path strings provided in the configuration map directly without sanitization.

A typical 'patchedDependencies' configuration maps a target package to its localized patch file. Because the resolution routine accepted arbitrary string values, it did not verify that the resolved path remained inside the boundaries of the workspace's designated 'patches' folder. An attacker could introduce relative traversal sequences or absolute paths to target sensitive resources.

The system then executed a highly privilege-insensitive deletion routine using Node's 'fs.rm' with recursive and force options enabled. This API call resolved the user-controlled path relative to the workspace directory and deleted the target asset. Because no validation occurred, the utility deleted any host-accessible file or directory, bypassing structural folder boundaries.

Code-Level Analysis

The original vulnerable implementation resolved the target path and immediately invoked destructive file operations. To mitigate this, a subdirectory containment validation utility named 'isSubdirectory' was introduced to verify parent-child directory structures.

export function isSubdirectory (parentDir: string, childPath: string, pathUtils: PathUtils = path): boolean {
  const relativePath = pathUtils.relative(parentDir, childPath)
 
  return relativePath === '' || (
    relativePath !== '..' &&
    !relativePath.startsWith(`..${pathUtils.sep}`) &&
    !pathUtils.isAbsolute(relativePath)
  )
}

The utility uses relative path calculations to guarantee that the child path resides within the parent directory. The 'patch-remove' routine was also updated to validate the target's physical location against symbolic link attacks. By utilizing 'fs.realpath' to canonicalize paths, the system ensures that symbolic links cannot be abused to point outside the workspace.

const targetPath = path.resolve(ctx.lockfileDir, patchFile)
if (
  targetPath === ctx.patchesDir ||
  !isSubdirectory(ctx.patchesDir, targetPath)
) {
  throw new PnpmError('PATCH_FILE_OUTSIDE_PATCHES_DIR', `Patch file "${patchFile}" is outside the configured patches directory`)
}

Additionally, the recursive file deletion API was replaced with 'fs.unlink'. This prevents directory erasure if a target resolves to a folder structure, limiting the tool to deleting individual files and symbolic links.

Exploitation Methodology

Exploitation requires the manipulation of the workspace configuration. This is typically achieved by submitting a malicious pull request to a public repository or distributing a compromised configuration inside an open-source archive. The attacker injects a path traversal sequence into the 'patchedDependencies' structure within 'package.json'.

{
  "pnpm": {
    "patchedDependencies": {
      "target-package": "../../../../etc/passwd"
    }
  }
}

When a developer or an automated CI/CD pipeline runs the 'pnpm patch-remove target-package' command, the execution flow proceeds as follows:

  1. The command parses 'package.json' and reads the entry for 'target-package'.
  2. The system resolves the path '../../../../etc/passwd' relative to the workspace directory.
  3. The cleanup routine executes the file deletion against the resolved target.
  4. The target file is deleted, resulting in system modification or configuration destruction.

In automation environments, this primitive can be used to destroy credentials, configurations, or critical software dependencies to disrupt operations.

Threat Model and Impact Assessment

The primary impact of this vulnerability is arbitrary file deletion on the system hosting the pnpm process. The severity depends on the privileges of the user executing the 'pnpm' command. On local development workstations, this can lead to the loss of source code, configuration files, and authentication keys.

In continuous integration and continuous deployment (CI/CD) environments, the impact is significant. Automated pipelines often run with elevated permissions. If an attacker can trigger the vulnerability inside a build runner, they can destroy pipeline configurations, build assets, or deployment credentials. This results in pipeline denial of service or configuration tampering.

Because the vulnerability does not directly expose read capabilities, it represents a threat to data integrity and availability rather than confidentiality. However, deleting critical security controls can weaken a system's overall security posture.

Remediation and Defense-in-Depth

To address the vulnerability, users must update pnpm to a version containing the path verification patch. The fix was integrated into the main branch and backported to the version 10 release line.

For environments where immediate patching is not possible, the following defense-in-depth measures are recommended:

  1. Review all pull requests that modify configuration files, including 'package.json' and 'pnpm-lock.yaml', before running command-line utilities.
  2. Execute build tasks within isolated containers that restrict filesystem access, limiting the scope of any potential file deletion.
  3. Run development and CI/CD tools with the minimum necessary filesystem permissions to prevent access to sensitive directories.

Official Patches

pnpmPrimary containment fix commit
pnpmBackport commit for release/10

Fix Analysis (2)

Technical Appendix

CVSS Score
7.1/ 10

Affected Systems

pnpm command-line interface@pnpm/plugin-commands-patching node module@pnpm/patching.commands node module

Affected Versions Detail

Product
Affected Versions
Fixed Version
pnpm
pnpm
< 10.0.0 (and versions without the containment patch)v10.x (patched releases)
@pnpm/plugin-commands-patching
pnpm
< 10.0.0-
AttributeDetail
CWE IDCWE-22 (Improper Limitation of a Pathname to a Restricted Directory)
Attack VectorLocal / Context-dependent execution of malicious workspace files
CVSS Severity7.1 (High Severity Recommendation)
Exploit StatusConcept-proven (PoC verified in test cases)
Impact TypeArbitrary File and Folder Deletion
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1485Data Destruction
Impact
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

The product uses external input to construct a pathname that should be within a restricted directory, but it does not properly neutralize sequences such as '..' that can resolve to a location outside of the directory.

Vulnerability Timeline

Initial fix commit published to main development branch
2026-06-12
Containment fix backported to release/10 branch
2026-06-18

References & Sources

  • [1]GitHub Security Advisory GHSA-72R4-9C5J-MJ57

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
5 views•10 min read
•1 day ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
11 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
11 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
14 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read