Skip to main content

@zuke/core EUVDEUVD-2026-114133

| CVE-2026-119288 HIGH
OS Command Injection (CWE-78)
2026-10-30 GitHub_M
7.0
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Embed unquoted &, |, or ^ in branch name or filename
  2. Delivery
    Windows build forwards text to node_modules/.bin wrapper
  3. Exploit
    cmd /c makes cmd.exe reparse the line
  4. Execution
    Injected command executes in build context
  5. Impact
    Steal build credentials and secrets

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

Exploitation requires all of: the build runs on Windows (POSIX platforms are never affected); the build resolves a tool from node_modules/.bin that exists as a .cmd or .bat shim (covers JavaScript-ecosystem wrappers); and the build passes attacker-influenced text - a branch name, a filename, or a parameter taken from repository content - as an argument to that wrapper. The injected text must contain an unquoted &, |, or ^ metacharacter with no surrounding space, since C-runtime quoting only quotes on spaces/tabs. Limiting factors that reduce real-world risk below the raw score: Windows-only, a build must actually be triggered (UI:R), a local batch shim must exist, the attacker must get crafted text into a wrapper argument, and only @zuke/core versions < 1.51.0 are vulnerable. The only complete fix is upgrading to 1.51.0; stated workarounds are not interpolating untrusted text into wrapper arguments on Windows runners, or pinning the tool to a non-batch executable with .toolPath(...).

Impact

Signals point to a genuine but bounded risk rather than a drop-everything emergency. The CVSS base score is 7.0 (High) with vector AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H: full confidentiality, integrity and availability impact (arbitrary command execution in the build context), but gated by local attack vector, high attack complexity, and required user interaction (a build must actually run). The vuln.today decision label is 'this_week', consistent with a serious-but-not-immediate priority. No CISA KEV listing is present, so there is no confirmed active exploitation, and no EPSS score was supplied, so widespread-exploitation probability cannot be quantified from the input. The supplied references are all patch/advisory artifacts (GHSA, PR #542, fix commit, release tag) - no public exploit or PoC reference is present - so this is 'no public exploit identified at time of analysis'. One nuance worth flagging: CVSS rates this AV:L, yet the attacker-influenced text (branch name, filename, repository-derived parameter) is frequently delivered via a remote source such as a pull request processed on a Windows CI runner, so the practical exposure of CI/CD pipelines may exceed what AV:L alone suggests - verify against your own runner topology. A data-quality issue also affects triage: the 'Microsoft' tag mislabels the vendor (Windows is only the affected platform; the product is the independent open-source zuke-build/zuke).

Exploit ScenarioDerived

An attacker opens a pull request whose branch name or filename embeds a shell metacharacter with no surrounding space (for example &calc). When a Windows CI runner executes a Zuke build that forwards that attacker-influenced text as an argument to a tool resolved from node_modules/.bin (a .cmd/.bat shim), cmd.exe reparses the command line and runs the attacker's chosen command with the build's credentials. No public exploit code is identified; the attack requires Windows, a resolved batch shim, and a build that passes attacker-controlled text to a wrapper.

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

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

Alert me

AnalysisAIv1 – Oct 30, 2026

Argument injection in Zuke's @zuke/core package (all versions before 1.51.0) on Windows lets attacker-influenced text passed to a resolved node_modules/.bin .cmd or .bat shim escape the argument boundary and be executed by cmd.exe as an additional attacker-chosen command, running in the build's own context with access to whatever credentials that build holds. Only Windows builds that resolve a batch shim and interpolate untrusted text - a branch name, a filename, or a parameter taken from repository content - into a wrapper argument are on the affected path; POSIX platforms were never affected and the CVSS vector records local attack, high attack complexity, no privileges required and user interaction required. The issue is fixed in 1.51.0, and no public exploit code was identified at time of analysis; the advisory notes the flawed launch path was the primary route for every wrapper resolving its tool from node_modules on Windows, not a rarely-taken fallback.

RemediationAI

Upgrade @zuke/core to 1.51.0, the vendor-released patch, which spawns resolved shims as themselves and launches batch shims through the command processor with quoting hardened so each argument remains exactly one argument; see https://github.com/zuke-build/zuke/releases/tag/core-v1.51.0 and the advisory at https://github.com/zuke-build/zuke/security/advisories/GHSA-7h34-cmvx-hg95. Upgrading is the only complete fix. If upgrading is not immediately possible, the advisory states two workarounds: on Windows runners, do not interpolate untrusted text into wrapper arguments - the trade-off is that any wrapper whose argument legitimately derives from a branch name, filename or repository-derived parameter must be reworked or fed sanitized values, and this depends on every call site being audited; or pin the tool to a non-batch executable with .toolPath(...), which avoids the cmd.exe reparse entirely but requires the tool to ship a non-.cmd/.bat executable and fixes the path explicitly. Note that the deprecated helper functions for building the wrapped argument vector are still exported and their documentation states the hazard, so code using them should be migrated.

Affected VersionsENISA

zuke < 1.51.0

Affected Packages

euvd zuke fix: 1.51.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

Zuke is a code-first, strongly typed build automation system for Deno, and @zuke/core is the runtime that launches external tools. The design property the tooling layer rests on is that commands are built as discrete argument vectors, never as shell strings. On Windows, when a wrapper resolved its tool to a .cmd or .bat shim inside node_modules/.bin, the pre-1.51.0 code prepended cmd /c to the argument vector, making cmd.exe the direct child process. Windows builds a child process's command line with C-runtime quoting rules, which quote on spaces and tabs but leave &, | and ^ untouched; cmd.exe then re-parsed that line, so an argument containing one of those metacharacters and no space - nothing quotes it - was treated as a further command. This is the classic CWE-78 OS command injection class, here manifesting as argument injection through a batch shim rather than a directly concatenated shell string. The fix spawns a resolved shim as itself, resolving a bare name through the platform's executable-extension list (PATHEXT) and launching a batch shim through the command processor with quoting hardened so an argument stays exactly one argument. The two helper functions that built the wrapped argument vector remain exported but are deprecated, with documentation stating the hazard.

Know when Zuke 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.0 HIGH
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

A local Windows build must run and process crafted unquoted metacharacters (UI:R, AC:H), no privileges are needed (PR:N), and the result is full command execution (C/I/A:H).

3.1 AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:N/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
High
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 30, 2026 - 17:02 EUVD
CVE Published
Oct 30, 2026 - 15:47 cve.org
HIGH 7.0

DescriptionCVE.org

Zuke is a code-first, strongly typed build automation system for Deno. Prior to 1.51.0, @zuke/core launches resolved Windows .cmd and .bat shims by prepending cmd /c, causing cmd.exe to reparse a command line assembled with C-runtime quoting rules. A build running on Windows that resolves a tool from node_modules/.bin and passes attacker-influenced text containing an unquoted &, |, or ^ metacharacter can execute an additional attacker-chosen command in the build's context with access to its credentials. POSIX platforms are not affected. This issue is fixed in version 1.51.0.

Technical POC Analysis

CWE-78 (improper neutralization of special elements used in an OS command).

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

CVE-2026-119288 is a high-severity argument injection vulnerability in Zuke's @zuke/core package (versions before 1.51.0) affecting Windows build environments. It allows attacker-influenced text, such as branch names or filenames from repository content, to escape argument boundaries and execute arbitrary commands with the build's credentials. This poses a significant risk to organizations using Zuke on Windows, as compromised builds could lead to unauthorized access to sensitive systems and data.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Low
niche code-first build tool for the minority Deno runtime
Data Quality
5 sources
Confidence: Medium

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.2%
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

35
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +35
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