CVE-2026-106071 in Node.js
Summary
by MITRE • 10/23/2026
A flaw in Node.js Permission Model filesystem enforcement can grant access to paths that do not match a wildcard `--allow-fs-read` or `--allow-fs-write` rule.
When the requested path is shorter than the prefix of a wildcard grant, the radix tree lookup stops comparing early and treats the path as a match. For example, `--allow-fs-read=/etc/passwd.*` also allows reading `/etc/passwd`. This requires the wildcard grant to sit directly under the root of the permission tree, for example when it is the only grant for that scope. This is a different root cause from CVE-2026-58043.
This vulnerability affects Node.js **26.x**.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 10/23/2026
The identified flaw resides within the core filesystem permission enforcement mechanism of Node.js version 26, specifically affecting the handling of wildcard grants for read and write operations via command-line flags such as --allow-fs-read and --allow-fs-write. The vulnerability stems from an incorrect implementation of path validation logic when utilizing a radix tree data structure to manage access control rules. In this specific architecture, permissions are organized in a hierarchical manner where prefixes determine scope. When the runtime evaluates whether a requested file path is permitted under a wildcard grant rule, it performs a comparison against the prefix defined in that rule. The critical technical error occurs during this comparison process: if the length of the requested absolute path is shorter than the length of the wildcard grant's prefix string, the radix tree lookup algorithm prematurely terminates its character-by-character evaluation. Instead of recognizing that the paths do not match due to insufficient depth or structural mismatch, the system incorrectly interprets this early termination as a successful match. This logic error effectively bypasses the intended security boundary, granting access to files and directories that were explicitly excluded by the wildcard pattern's design intent.
The operational impact of this vulnerability is significant for applications relying on Node.js sandboxing features to restrict filesystem access. An attacker who can influence or predict file paths accessed by a restricted process could exploit this flaw to read sensitive configuration files, environment variables stored in system directories, or other critical data that should remain inaccessible under the current permission policy. For instance, if an application is configured with --allow-fs-read=/etc/passwd.*, intending to allow reading only files starting with /etc/passwd followed by additional characters (such as backups like /etc/passwd.bak), this flaw allows direct access to /etc/passwd itself because its path length is shorter than the prefix. This behavior contradicts standard security expectations where wildcard patterns are generally interpreted to match specific extensions or suffixes rather than their base names unless explicitly configured otherwise. The vulnerability requires that the problematic wildcard grant be situated directly under the root of the permission tree, typically occurring when it is the sole grant for a given scope, which limits the attack surface slightly but does not eliminate the risk in common deployment scenarios where broad filesystem access is restricted to specific subdirectories or file types.
This issue represents a classic case of improper input validation and boundary checking within security-critical code paths. From an industry standard perspective, this aligns with CWE-20 Improper Input Validation, as the system fails to correctly validate that the requested resource fully conforms to the allowed pattern constraints before granting access. Furthermore, it relates to CWE-732 Incorrect Permission Assignment for Critical Resource, since the permission model assigns broader access rights than intended due to a logical error in rule evaluation. In terms of adversarial tactics, this vulnerability facilitates lateral movement and data exfiltration within a compromised environment by allowing an attacker to bypass application-level sandboxing controls that are supposed to limit file system interactions. It is distinct from CVE-2026-58043, indicating a separate root cause in the permission model's implementation details rather than a systemic failure of the entire security architecture.
Mitigation strategies for this vulnerability primarily involve upgrading Node.js to patched versions where the radix tree lookup logic has been corrected to ensure that path comparisons account for length differences and structural mismatches appropriately. Until an upgrade is feasible, developers should avoid using wildcard patterns in --allow-fs-read or --allow-fs-write flags when precise control over file access is required. Instead of relying on broad wildcards like /path/to/files.*, it is safer to explicitly list allowed files if the number is manageable, or to use more restrictive prefixes that do not create ambiguity regarding shorter path matches. Additionally, implementing defense-in-depth measures such as operating system-level mandatory access controls can provide an additional layer of protection against unauthorized file access resulting from this application-layer flaw. Security teams should audit their Node.js configurations for any wildcard filesystem permissions and assess whether the potential for unintended access to parent or base paths poses a risk to sensitive data assets within their specific deployment context.