Jun 27, 2026·5 min read·42 visits
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.
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.
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.
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 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:
In automation environments, this primitive can be used to destroy credentials, configurations, or critical software dependencies to disrupt operations.
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.
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:
| 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 | - |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-22 (Improper Limitation of a Pathname to a Restricted Directory) |
| Attack Vector | Local / Context-dependent execution of malicious workspace files |
| CVSS Severity | 7.1 (High Severity Recommendation) |
| Exploit Status | Concept-proven (PoC verified in test cases) |
| Impact Type | Arbitrary File and Folder Deletion |
| KEV Status | Not Listed |
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.
CVE-2026-16454 is an object-level authorization bypass vulnerability (CWE-284, CWE-862) in Eclipse hawkBit versions 1.0.3 and prior. The flaw exists within the Direct Device Integration (DDI) REST controller (hawkbit-ddi-resource), where endpoints responsible for enumerating software module metadata and serving firmware binaries fail to verify whether the requested software module is assigned to the authenticated device. Consequently, any device with valid credentials (such as a TargetToken or GatewayToken) can enumerate software module identifiers and download arbitrary firmware artifacts across the entire tenant namespace.
CVE-2026-62284 (GHSA-5w5g-j6hw-6p8f) is a code injection and server-side request forgery vulnerability in the console-proxy component of the OSAC Operator. The RemoteConfigResolver parses Kubernetes Secrets containing kubeconfig files via clientcmd.RESTConfigFromKubeConfig without sanitizing execution-related fields. An attacker with RBAC permissions to create or modify labeled Secrets in monitored namespaces can supply a malicious exec credential plugin, resulting in arbitrary command execution within the console-proxy pod.
CVE-2026-62361 (GHSA-xgjr-7j9q-2h4r) is an authenticated SQL injection and authorization bypass vulnerability in listmonk, an open-source, self-hosted newsletter and mailing list manager written in Go. In versions prior to 6.2.0, the subscriber export endpoint (GET /api/subscribers/export) directly interpolates user-supplied SQL filter expressions into a PostgreSQL query without invoking the table allowlist validation function (validateQueryTables). Consequently, authenticated users possessing the subscribers:sql_query and subscribers:get_all permissions can bypass relational access controls, execute arbitrary subqueries against restricted tables such as users and settings, and modify database state via writable Common Table Expressions (CTEs).
CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.
Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.
CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.