Skip to main content

Deno EUVDEUVD-2026-90204

| CVE-2026-103473 CRITICAL
OS Command Injection (CWE-78)
2026-09-30 VulnCheck GHSA-m6mv-f8h2-2w86
9.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Identify Windows Deno app that shells out with user input
  2. Delivery
    Submit argument with shell-specific metacharacters
  3. Exploit
    Wrong-grammar escaping fails to neutralize input
  4. Execution
    Shell reinterprets injected OS commands
  5. Impact
    Arbitrary 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 shell option enabled, particularly with a shell whose quoting grammar differs from cmd.exe (e.g. PowerShell/pwsh or a custom bash.exe), since Deno wrongly applied cmd.exe escaping to all shells; and (4) attacker influence over the arguments passed to that call. Limiting factors: exploitation depends entirely on a non-default, developer-chosen code pattern (untrusted args + shell option), the target must run on Windows, and the vendor's AC:H/AT:P rating reflects the specific conditions needed - it is not exploitable against a default Deno install that does not shell out with untrusted data.

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 shell option of node:child_process AND pass attacker-controlled arguments, and the AC:H/AT:P metrics already encode that this is not a point-and-click path. EPSS is not provided, KEV=NO (not in CISA KEV - no evidence of active exploitation), and no public PoC is identified, so exploitation status is: no public exploit identified at time of analysis. The flaw is genuine (a real CWE-78 argument-escaping error confirmed by the PR#36772 diff, which rebuilds quoting per resolved shell grammar via shellGrammarFor), but it is a developer-dependent 'sharp edge' rather than a wormable remote hole. Net: real and patch-worthy for Windows Deno deployments that shell out with untrusted input, but a targeted/conditional issue, not a widespread emergency. Note a data conflict to verify: CVSS marks AV:N while the vulnerable path is local process spawning - 'network' here means the untrusted argument may originate remotely through the hosting app, so treat AV:N as application-context-dependent.

Exploit ScenarioDerived

A Windows-hosted Deno web service builds a command from user-supplied input and runs it via child_process with the shell option set (e.g. a non-cmd.exe shell such as PowerShell or bash.exe). Because Deno escapes the argument for cmd.exe syntax rather than the shell that actually parses it, an attacker submits a crafted argument containing shell metacharacters that survive escaping and are reinterpreted as additional commands, yielding arbitrary OS command execution with the Deno process's privileges. No public PoC is known, and the attack requires the Windows platform plus a vulnerable shell-enabled spawn pattern (AC:H/AT:P).

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 2.7% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

deno 2.7.0 ≤2.9.7

Affected Packages

euvd deno no fix

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

Vendor (VulnCheck) PRIMARY 9.2 CRITICAL
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
vuln.today AI 8.1 HIGH

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
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

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.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
2.7%
Top 15% exploitable
Prevalence
Medium
Deno is a popular JS/TS runtime but far less deployed than Node.js
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 CRITICAL
CISA KEV No
Public POC No
EPSS 2.7%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

49
Low Medium High Critical
KEV: 0
EPSS: +3
CVSS: +46
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.

More in Deno

View all
CVE-2021-42139 CRITICAL POC
9.8 Oct 11

Deno Standard Modules before 0.107.0 allows Code Injection via an untrusted YAML file in certain configurations. Rated c

CVE-2025-48935 CRITICAL POC
9.1 Jun 04

Deno versions 2.2.0 through 2.2.4 contain an authorization bypass vulnerability in SQLite database handling that allows

CVE-2024-27934 HIGH POC
8.8 Mar 21

Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.8), this vulnerability is low att

CVE-2024-27933 HIGH POC
8.8 Mar 21

Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.8), this vulnerability is low att

CVE-2023-28446 HIGH POC
8.8 Mar 24

Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Rated high

CVE-2025-61787 HIGH POC
8.1 Oct 08

Command injection on Windows in the Deno JavaScript/TypeScript runtime (versions prior to 2.5.3 and 2.2.15) allows attac

CVE-2024-27935 HIGH POC
8.3 Mar 21

Deno is a JavaScript, TypeScript, and WebAssembly runtime. Rated high severity (CVSS 8.3), this vulnerability is remotel

CVE-2026-27190 HIGH POC
8.1 Feb 20

Command injection in Deno versions prior to 2.6.8 allows unauthenticated remote attackers to execute arbitrary commands

CVE-2026-22864 HIGH POC
8.1 Jan 15

Arbitrary code execution in Deno runtime versions before 2.5.6 allows unauthenticated attackers to bypass shell script e

CVE-2026-22863 HIGH POC
7.5 Jan 15

Deno versions up to 2.6.0 contains a vulnerability that allows attackers to have infinite encryptions (CVSS 7.5).

CVE-2023-26103 HIGH POC
7.5 Feb 25

Versions of the package deno before 1.31.0 are vulnerable to Regular Expression Denial of Service (ReDoS) due to the upg

CVE-2023-22499 HIGH POC
7.5 Jan 17

Deno is a runtime for JavaScript and TypeScript that uses V8 and is built in Rust. Rated high severity (CVSS 7.5), this

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