Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify Windows Deno app that shells out with user input
-
DeliverySubmit argument with shell-specific metacharacters
-
ExploitWrong-grammar escaping fails to neutralize input
-
ExecutionShell reinterprets injected OS commands
-
ImpactArbitrary command execution as Deno process
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 all of: (1) the Windows platform - the flaw does not affect Unix-like systems; (2) a Deno version in 2.7.0 through 2.9.7; (3) application code that invokes node:child_process (spawn/exec family) with the |
| Impact | Signals are moderate, not top-tier. The vendor CVSS 4.0 base score of 9.2 (AV:N/AC:H/AT:P/PR:N/UI:N with full VC/VI/VA:H) looks critical, but three qualifiers pull real-world risk down: it is Windows-ONLY (the 'AV:N' reachability depends on untrusted data reaching a Deno server process), exploitation requires the application to opt into the |
| Exploit ScenarioDerived | A Windows-hosted Deno web service builds a command from user-supplied input and runs it via child_process with the |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 30, 2026
Command injection in Deno 2.7.0 through 2.9.7 on Windows allows an attacker who controls arguments passed to node:child_process spawn/exec calls with the shell option enabled to execute arbitrary OS commands with the privileges of the Deno process. The root cause is that Deno applied cmd.exe quoting rules to every shell, so arguments escaped for cmd.exe are reinterpreted as syntax by PowerShell/pwsh, a custom bash.exe, or another POSIX-style shell running on Windows. Exploitation requires a specific, non-default developer-chosen pattern - untrusted arguments plus the shell option on a Windows host, which is why the assessed vector carries AC:H/AT:P - and no public exploit has been identified at time of analysis, although the vendor has published an upstream fix in PR 36772.
RemediationAI
Upgrade Deno to a build that includes the upstream fix; the vendor patch is tracked by GitHub PR 36772 (https://github.com/denoland/deno/pull/36772), and patch availability is confirmed by the vendor, but a specific patched release version beyond the affected 2.7.0-2.9.7 range is not independently confirmed from the supplied data - validate against Deno's release notes before pinning a version. Until then, the highest-value compensating control is to stop using the shell option: call spawn/execFile with an explicit executable and an argument array (shell: false) so no shell parses the arguments at all; the trade-off is that shell features such as pipes, redirection, globbing, and environment-variable expansion must be reimplemented by the caller or dropped, and Windows paths containing spaces or .cmd/.bat shims may need explicit handling. If a shell must be used, restrict it to cmd.exe on Windows and avoid PowerShell/pwsh or custom bash.exe, since the flawed escaping is specifically wrong for those grammars - this narrows functionality for scripts that depend on PowerShell. Also enforce strict allow-listing or validation of any argument derived from user input before it reaches node:child_process, and run the Deno process under a least-privilege Windows account or container so successful injection yields minimal privileges. Monitoring guidance: no public exploit code has been identified at time of analysis, so detection should focus on anomalous child-process creation from Deno hosts (unexpected cmd.exe/powershell.exe/bash.exe children, especially with -c) rather than known exploit signatures.
Affected VersionsENISA
Affected Packages
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
The vulnerability lives in Deno's Node.js compatibility layer, specifically ext/node/polyfills/internal/child_process.ts, which implements the node:child_process API surface (spawn/exec family) for Deno. In normalizeSpawnArguments, the pre-patch code selected quoting behavior purely from process.platform: on Windows it assumed cmd.exe semantics and produced double-quoted, backslash-escaped arguments; everywhere else it used POSIX single-quote escaping. That model breaks whenever options.shell names a different interpreter - a custom PowerShell/pwsh executable, or bash.exe/sh.exe - because the string handed to -c is then parsed by a shell with an entirely different grammar, so cmd.exe-style escaping no longer neutralizes metacharacters and injected commands are executed. This is CWE-78 (Improper Neutralization of Special Elements used in an OS Command), i.e. classic OS command injection through incorrect/incomplete escaping for the actual parser. The upstream fix (GitHub PR 36772) introduces shellGrammarFor(shellFile), which resolves the shell before escaping and classifies it as cmd, powershell, or posix; adds regexes such as powerShellRe, cmdUnrepresentableRe, and psSpecialCharsRe; adds a PowerShell call operator (&) when a quoted program path is used in command position; and, for cmd.exe, throws ERR_INVALID_ARG_VALUE for arguments containing double quotes, CR, or LF rather than emitting an approximation cmd.exe would reparse as extra commands. The affected component carries CPE cpe:2.3:a:denoland:deno:*:*:*:*:*:*:*:*, and the referenced source lines (child_process.ts#L1339 and #L1499) correspond to the vulnerable argument-normalization and escaping routines.
Know when Deno 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
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
AV:N as untrusted args typically arrive via the hosting app; AC:H because it needs Windows plus a shell-enabled spawn with a non-cmd grammar; PR:N/UI:N; full CIA from arbitrary command execution.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Deno versions 2.7.0 through 2.9.7 on Windows contain a command injection vulnerability in node:child_process where shell arguments are escaped for the wrong shell type. Attackers can inject OS commands by passing untrusted arguments with the shell option, allowing arbitrary command execution with Deno process privileges.
Articles & Coverage 2
Executive ViewAI
Deno versions 2.7.0 through 2.9.7 on Windows contain a critical command injection vulnerability that could allow an attacker to execute arbitrary commands with the privileges of the Deno process, potentially compromising developer workstations or CI/CD pipelines. No public exploit identified at time of analysis, but patch available per vendor advisory (upstream fix PR 36772). Organizations using Deno on Windows should prioritize patching to prevent potential unauthorized access or data loss.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Deno Standard Modules before 0.107.0 allows Code Injection via an untrusted YAML file in certain configurations. Rated c
Deno versions 2.2.0 through 2.2.4 contain an authorization bypass vulnerability in SQLite database handling that allows
Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.8), this vulnerability is low att
Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.8), this vulnerability is low att
Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Rated high
Command injection on Windows in the Deno JavaScript/TypeScript runtime (versions prior to 2.5.3 and 2.2.15) allows attac
Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.3), this vulnerability is remotel
Command injection in Deno versions prior to 2.6.8 allows unauthenticated remote attackers to execute arbitrary commands
Arbitrary code execution in Deno runtime versions before 2.5.6 allows unauthenticated attackers to bypass shell script e
Deno versions up to 2.6.0 contains a vulnerability that allows attackers to have infinite encryptions (CVSS 7.5).
Versions of the package deno before 1.31.0 are vulnerable to Regular Expression Denial of Service (ReDoS) due to the upg
Deno is a runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Rated high severity (CVSS 7.5), this
EUVD-2026-90204
GHSA-m6mv-f8h2-2w86
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB