Details
Why this bypass works
- The Library's Logic:
compressingusespath.resolveon entry names and compares them string-wise with the destination directory. - The Gap: Because
path.resolvedoes not check if intermediate directories are symlinks on disk, it treatsconfig_file(the symlink) as a normal path inside the allowed directory. - The Result: The underlying
fs.writeFilefollows the existing symlink to the protected target (/tmp/fake_root/etc/passwd), bypassing all string-based security checks.
<img width="733" height="126" alt="01_malicious_symlink_proof" src="https://github.com/user-attachments/assets/a24b5844-8efd-4f5c-8ee6-9cbbffee6ceb" />
<img width="780" height="111" alt="02_malicious_payload_content" src="https://github.com/user-attachments/assets/a20ef72b-35c9-4355-8583-08a3e9467d4a" />
<img width="888" height="111" alt="03_vulnerable_version_proof" src="https://github.com/user-attachments/assets/5e6864ce-fe48-4327-be2f-1bea8e8ba800" />
<img width="921" height="294" alt="04_exploit_success_verification" src="https://github.com/user-attachments/assets/3b4bc21e-55de-42b2-b819-8d7c0e90b055" />
4. Impact Assessment
What kind of vulnerability is it?
This is an Arbitrary File Overwrite vulnerability caused by a Symlink Path Traversal bypass. Specifically, it is a "Partial Fix" bypass where a security patch meant to prevent directory traversal only validates path strings but ignores the filesystem state (symlinks).
Who is impacted?
1. Developers & Organizations: Any user of the compressing library (up to v2.1.0) who extracts untrusted archives into a working directory.
2. Supply Chain via Git Clone (Primary Vector): Git natively restores symlinks during git clone. An attacker who controls or compromises any upstream repository can embed malicious symlinks. The victim's only required action is standard developer workflow clone and run. No social engineering or extra steps needed beyond trusting a repository.
3. Privileged Environments: Systems where the extraction process runs as a high-privilege user (root/admin), as it allows for the overwriting of sensitive system files like /etc/passwd or /etc/shadow.
Impact Details
- Privilege Escalation: Gaining root access by overwriting system configuration files.
- Remote Code Execution (RCE): Overwriting executable binaries or startup scripts (.bashrc, .profile) to run malicious code upon the next boot or login.
- Data Corruption: Permanent loss or modification of application data and database files.
- Reputational Damage to Library: Loss of trust in the compressing library's security architecture due to an incomplete patch for a known CVE.
5. Technical Remediation & Proposed Fix
To completely fix this vulnerability, the library must transition from String-based validation to State-aware validation.
1. The Vulnerable Code (Current Incomplete Patch)
The current logic in lib/utils.js only checks the path string:
// [VULNERABLE] Does not check if disk segments are symlinks
function isPathWithinParent(childPath, parentPath) {
const normalizedChild = path.resolve(childPath);
const normalizedParent = path.resolve(parentPath);
// ... (omitted startsWith check)
return normalizedChild.startsWith(parentWithSep);
}
2. The Proposed Fix (Complete Mitigation)
The library must recursively check every component of the path on the disk using fs.lstatSync to ensure no component is a symbolic link that redirects to a location outside the root.
const fs = require('fs');
const path = require('path');
/**
* SECURE VALIDATION: Checks every segment of the path on disk
* to prevent symlink-based directory poisoning.
*/
function secureIsPathWithinParent(childPath, parentPath) {
const absoluteDest = path.resolve(parentPath);
const absoluteChild = path.resolve(childPath);
// Basic string check first
if (!absoluteChild.startsWith(absoluteDest + path.sep) &&
absoluteChild !== absoluteDest) {
return false;
}
// RECURSIVE DISK CHECK
// Iteratively check every directory segment from the root to the file
let currentPath = absoluteDest;
const relativeParts = path.relative(absoluteDest, absoluteChild).split(path.sep);
for (const part of relativeParts) {
if (!part || part === '.') continue;
currentPath = path.join(currentPath, part);
try {
const stats = fs.lstatSync(currentPath);
// IF ANY COMPONENT IS A SYMLINK, REJECT IT
if (stats.isSymbolicLink()) {
throw new Error(`Security Exception: Symlink detected at ${currentPath}`);
}
} catch (err) {
if (err.code === 'ENOENT') break; // Path doesn't exist yet, which is fine
throw err;
}
}
return true;
}
3. Why and How it works:
- Filesystem Awareness: Unlike the previous fix, this code uses
fs.lstatSync. It doesn't trust the string; it asks the Operating System, "What is actually at this location?". - Segmented Verification: By splitting the path and checking each part (
config, thenconfig/file), it catches the "Poisoned Directory" (config -> /etc) before the final write happens. - Bypass Prevention: Even if the string check passes, the loop will detect the symlink at the
configsegment and throw a security exception, stopping thefs.writeFilebefore it can follow the link to/etc/passwd. - Atomic Security: This implementation ensures that the logical path and the physical path are identical, leaving no room for "Divergence" exploits.
> Note: For production, it is recommended to use the asynchronous fs.promises.lstat to prevent blocking the Node.js event loop during recursive checks.