Skip to main content

Nx CVE-2026-104854

| EUVDEUVD-2026-91762 HIGH
Improper Privilege Management (CWE-269)
2026-10-02 security-advisories@github.com GHSA-w3vv-58gj-gw77
8.5
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain unprivileged local account on shared host
  2. Delivery
    Enumerate Nx sockets in shared temp dir
  3. Exploit
    Connect to unauthenticated daemon/worker socket
  4. Execution
    Send PROCESS_IN_BACKGROUND with attacker-controlled module path
  5. Impact
    Nx invokes default export, executing code as victim account

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V8 - Authorization Least privilege enforcement
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires (1) a Unix-like host (macOS/Linux - the advisory notes Windows named pipes are not filesystem objects and this does not apply), (2) a vulnerable Nx version (14.6.0 up to but not including 22.7.9, or 23.1.x before 23.1.2), (3) a running Nx daemon OR isolated plugin-worker process creating sockets in a shared temp location such as /tmp/.nx (default when owner-only 0700 directory/socket permissions are absent), and critically (4) a SECOND unprivileged local account on the same shared build server, developer host, or multi-user container controlled by the attacker. Key limiting factors: single-user machines with no other local account are NOT exposed; the attacker must already possess local access as a distinct user (PR:L) and be able to write a module file readable by the socket handler. Note the partial mitigation trap: disabling the daemon (NX_DAEMON=false) does NOT remove the still-vulnerable plugin-worker sockets, so only upgrading or enforcing owner-only socket/directory permissions fully closes the exposure.

Impact

This is a local privilege-escalation/code-execution flaw (CWE-269) in Nx, scored CVSS 4.0 8.5 by the GitHub-issued advisory (AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H). The vector is unambiguously local and requires an existing low-privileged account (PR:L), so despite the high score this is NOT a remotely exploitable, internet-facing issue - it is gated behind the attacker already having a foothold as a separate unprivileged user on the SAME host. No EPSS score, CISA KEV listing, or public POC is present in the supplied data, so there is no public exploit identified at time of analysis and no evidence of active exploitation. The real-world priority is therefore scenario-dependent: it is a genuine and serious risk on multi-tenant/shared build servers, CI runners, and multi-user containers (where lateral movement between user accounts is the goal), but the vendor explicitly notes single-user machines with no other local account are not exposed, which sharply narrows the realistic attack surface. Treat as high priority for shared/CI infrastructure and low priority for single-developer workstations. Note the daemon-disable mitigation is incomplete - plugin-worker sockets remain vulnerable - so configuration-based mitigation should not be relied upon in place of upgrading.

Exploit ScenarioDerived

On a shared build server or multi-user CI container, a low-privileged attacker with their own local account discovers another user's running Nx daemon or plugin-worker Unix socket in a world-reachable temp directory (e.g. under /tmp/.nx). Because the transport performs no authentication, the attacker connects and sends a PROCESS_IN_BACKGROUND request pointing at a module file they control, causing its default export to be invoked and executing arbitrary code as the victim account running Nx. No public exploit was identified in the supplied data, but the attack is straightforward given a low-privilege foothold.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 02, 2026

Local privilege escalation leading to code execution in Nx (Nrwl Nx) affects versions 14.6.0 through 22.7.8 and 23.1.x before 23.1.2 on macOS and Linux, where daemon and isolated plugin-worker Unix domain sockets are created in shared temporary locations such as /tmp/.nx without owner-only 0700 directory or socket permissions. Because the socket transport performs no authentication and relies entirely on filesystem containment, a second unprivileged local account on the same shared build server, developer host, or multi-user container can connect and invoke handlers - notably PROCESS_IN_BACKGROUND, which accepts a module path and invokes its default export as the account running Nx - and can also read workspace file contents, project graphs, and task hashes. The flaw is rated CVSS 4.0 8.5 (AV:L/AC:L/PR:L, CWE-269); no public exploit code was identified at time of analysis, single-user machines with no other local account are not exposed, and disabling the daemon alone does not remove the still-vulnerable plugin-worker sockets - only upgrading to 22.7.9 or 23.1.2, or enforcing owner-only socket and directory permissions, closes the exposure.

RemediationAI

Upgrade to a fixed release: Nx 22.7.9 or later for the 22.x line, or 23.1.2 or later for the 23.1.x line (vendor-released patch: 22.7.9 and 23.1.2; see https://github.com/nrwl/nx/releases/tag/22.7.9, https://github.com/nrwl/nx/releases/tag/23.1.2, and advisory https://github.com/nrwl/nx/security/advisories/GHSA-w3vv-58gj-gw77). Where immediate upgrading is not possible, treat the socket root as the control point: ensure /tmp/.nx and every per-user subdirectory and socket beneath it (and ~/.nx/sockets and <workspaceRoot>/.nx/workspace-data/d as fallbacks) are owned exclusively by the running user and mode 0700, since the vulnerability is precisely the absence of those owner-only permissions; alternatively set NX_SOCKET_DIR to a directory only your account can traverse. Be aware of the trade-offs: NX_SOCKET_DIR replaces rather than augments the default search list, an unusable configured directory causes Nx to warn and fall back to the workspace path, and deeply nested workspace fallback paths can exceed the conservative 95-character socket path limit Nx enforces. Disabling the daemon with NX_DAEMON=false or useDaemonProcess:false is NOT a sufficient mitigation because isolated plugin-worker sockets remain vulnerable; that option only removes the daemon attack surface while leaving code-execution paths through plugin workers, so combine it with strict socket-directory permissions or an upgrade. On shared build servers and multi-user containers, additionally restrict local account creation and audit for unexpected users who could connect to /tmp/.nx sockets until patched.

Affected VersionsENISA

NX 23.0.0, < 23.1.2
NX 14.6.0, < 22.7.9

Affected Packages

npm nx fix: 22.7.9, 23.1.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in npm

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The vulnerability is a CWE-269 improper privilege management issue rooted in how Nx establishes inter-process communication over Unix domain sockets. From version 14.6.0 onward, the Nx daemon, forked task processes, and isolated plugin workers create filesystem-backed sockets beneath a shared temporary root (by default /tmp/.nx/<uid>/sockets, with ~/.nx/sockets and <workspaceRoot>/.nx/workspace-data/d as fallbacks). The transport performs no authentication, so access control depends entirely on filesystem permissions - specifically on the socket directories and socket files being owned by the running user and mode 0700. In vulnerable versions those owner-only permissions were not correctly applied, leaving the sockets discoverable and connectable by any other unprivileged local account. Once connected, an attacker can issue requests to the daemon's JSON-RPC-style handlers; PROCESS_IN_BACKGROUND accepts a module path and executes its default export in the Nx process context, yielding code execution as the account running Nx, while other handlers leak workspace file contents, project graphs, and task hashes. The advisory notes that Windows is unaffected because named pipes are not filesystem objects and carry no per-user directory segment. The fix, shipped in 22.7.9 and 23.1.2 via PR #36370 and commits 3298fd8/63e1abb/71c2253, creates each socket directory and then verifies ownership and 0700 mode afterward rather than checking before use (closing a check-then-use race in which the path could be swapped).

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (github) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Attacker needs a separate local unprivileged account (AV:L, PR:L); unauthenticated socket makes exploitation straightforward (AC:L, UI:N); arbitrary code execution as the victim user yields full C/I/A:H.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Red Hat 7.8 HIGH

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 02, 2026 - 18:02 EUVD
CVE Published
Oct 02, 2026 - 17:17 cve.org
HIGH 8.5

DescriptionCVE.org

Nx is a monorepo solution for TypeScript and polyglot codebases. From 14.6.0 until 22.7.9 and 23.1.2, Nx creates Unix domain sockets for its daemon and isolated plugin workers in shared temporary locations without owner-only directory and socket permissions. Another unprivileged local account on a shared build server, developer host, or multi-user container can discover and connect to a running socket because the transport performs no authentication and relies on filesystem containment. The daemon's PROCESS_IN_BACKGROUND request accepts a module path and invokes its default export, allowing a caller that controls a file to execute code as the account running Nx; other handlers can expose workspace file contents, project graphs, and task hashes. Disabling the daemon alone does not remove the vulnerable plugin-worker sockets, while single-user machines without another local account are not exposed. This issue is fixed in versions 22.7.9 and 23.1.2.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 23 npm packages depend on nx (8 direct, 15 indirect)

Ecosystem-wide dependent count for version 14.6.0.

Technical POC Analysis

Class: CWE-269 (Improper Privilege Management), with the advisory also listing CWE-732 (Incorrect Permission Assignment for Critical Resource).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

Nx, the widely used monorepo build and task-running tool, exposes shared macOS and Linux build servers, developer workstations, and multi-user containers to local privilege escalation: a second unprivileged account on the same host can take control of the identity that runs Nx builds. Because build hosts typically hold deployment credentials, package registry tokens, and broad source and artifact access, this can turn a low-privilege local foothold into compromise of the software supply chain itself. Any organization running Nx 14.6.0 through 22.7.8 or 23.1.x before 23.1.2 on a host with more than one local account should consider itself in scope, and no vendor-released patch was identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: enforce owner-only 0700 permissions on the /tmp/.nx directory and its sockets, with ownership limited to the Nx build account; run Nx only on single-user ephemeral CI runners or isolated containers with private /tmp namespaces rather than shared build servers, developer hosts, or multi-user containers; remove or tightly control additional local accounts on Nx hosts; run builds under dedicated least-privilege service accounts with no access to production credentials; and monitor for anomalous connections to Nx daemon and plugin-worker sockets. Note that disabling the Nx daemon alone does not remove the exposure.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
High
Nx is a very widely used monorepo build tool across the JS/TS ecosystem
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy