By vendor

Deno vulnerabilities

Known CVEs affecting Deno products, prioritized by severity, with SEC.co remediation and detection guidance.

10 published vulnerabilities

• CVE-2026-49402HIGH 8.1

  Deno's implementation of Node.js child process spawning on Windows contains a command injection vulnerability in its shell argument escaping logic. When developers use the shell:true option with spawn, spawnSync, exec, or related functions, Deno fails to properly quote and escape arguments containing Windows cmd.exe metacharacters, particularly the percent sign (%). An attacker who can control any part of an argument passed to these functions can inject and execute arbitrary additional commands within the spawned cmd.exe process. This affects Deno versions before 2.7.10 and is resolved in that release.

• CVE-2026-44726HIGH 7.4

  Deno versions 2.0.0 through 2.7.7 contain a flaw in how they handle TLS connections when automatic address-family fallback is enabled. If an initial connection attempt fails (such as dropping IPv6 traffic), Deno may reuse stale TLS upgrade logic when establishing a replacement connection, resulting in the new TCP connection never being encrypted. An attacker who can reliably trigger the first connection attempt to fail—for example, by blocking IPv6 on a dual-stack network—could force application data to be transmitted in plaintext, allowing them to intercept or modify traffic the application believed was secure.

• CVE-2026-49440HIGH 7.4

  Deno's prime number validation function contains a critical flaw that allows composite numbers to be incorrectly identified as prime. When developers use the default settings, the checkPrime() and checkPrimeSync() functions skip cryptographic validation rounds entirely, relying only on a basic divisibility check against small primes. This means a number that is actually the product of two larger primes can be falsely reported as prime, potentially compromising cryptographic operations that depend on genuine prime generation.

• CVE-2026-49401HIGH 7.3

  Deno's permission system on macOS can be bypassed using Unicode character variations that represent the same filename. When you tell Deno to block access to a file using `--deny-read`, `--deny-write`, `--deny-run`, or `--deny-ffi`, the runtime compares the requested path against your deny rule at the byte level. However, APFS (Apple's filesystem) treats different Unicode representations of the same character as identical files. An attacker can exploit this mismatch by requesting a file using an alternate Unicode spelling, circumventing the intended permission restriction. This is fixed in Deno 2.7.14.

• CVE-2026-49411MEDIUM 6.5

  Deno, a JavaScript/TypeScript/WebAssembly runtime, had a permission-checking flaw in its Node.js compatibility layer for TCP connections. When code attempted to connect to a host that was supposed to be denied, Deno only checked permissions against the hostname as originally provided—not after that hostname resolved to an IP address. An attacker could bypass restrictions by using numeric representations of IP addresses (like decimal 2130706433 or hexadecimal 0x7f000001, both resolving to localhost) in node:net.connect() or node:http.request() calls, reaching destinations that should have been blocked. This was fixed in Deno 2.8.0.

• CVE-2026-49406MEDIUM 5.5

  Deno, a modern JavaScript and TypeScript runtime, has a path traversal vulnerability in its module resolver when operating in BYONM (Bring Your Own Node Modules) mode. A malicious package can craft a package.json file with directory traversal sequences (..) in its main field, causing Deno to load files from arbitrary locations on disk rather than from within the package's intended directory. Critically, this circumvents Deno's permission system—files that would normally be blocked by --allow-read restrictions can be read anyway if accessed through a require() call. The issue affects Deno versions prior to 2.7.12 and is resolved in that release.

• CVE-2026-49859MEDIUM 5.2

  Deno, a modern JavaScript and TypeScript runtime, contains a network access control bypass in versions before 2.8.1. When a script uses fetch() to make network requests, Deno's security model allows administrators to block connections to specific IP addresses or networks using the --deny-net flag. However, the vulnerability exists because Deno only checked the hostname against the deny list but failed to verify the actual IP addresses that hostname resolved to. An attacker could craft a malicious domain name that appears to pass the hostname restrictions yet resolves to a blocked IP address, allowing unauthorized network access. This was patched in version 2.8.1.

• CVE-2026-49860MEDIUM 5.2

  Deno versions before 2.8.1 contain a network access control bypass vulnerability in WebSocket connections. When a script attempts to open a WebSocket, Deno validates the destination hostname against deny-net security rules, but fails to re-validate the IP address that hostname resolves to. An attacker can craft a domain name that passes the hostname check but resolves to a blocked IP address, allowing network communication to restricted destinations. This affects local scripts with network privileges, potentially allowing unauthorized outbound connections despite active network restrictions.

• CVE-2026-49983MEDIUM 5.2

  Deno is a modern JavaScript/TypeScript runtime that includes permission controls to restrict what programs can access. One of these controls is the env permission, which blocks access to environment variables. You can use --deny-env to prevent this entirely, or --allow-env=FOO,BAR to restrict access to specific variables. However, in versions before 2.8.1, a built-in function called process.loadEnvFile() bypasses this protection. This function loads environment variables from a .env file, but it only checks whether the program can read the file—it ignores whether env access is allowed. This means an attacker who can control or create a .env file on the system, combined with read access (--allow-read), can inject environment variables into a sandboxed program that was supposed to have no env access. The vulnerability is patched in version 2.8.1.

• CVE-2026-55517MEDIUM 4.3

  Deno, a modern JavaScript/TypeScript runtime, has a flaw in how it processes WebSocket connection responses. When a remote server sends back specially crafted response headers containing non-ASCII bytes, Deno crashes entirely rather than handling the malformed data gracefully. An attacker controlling a WebSocket server could exploit this to deny service to any Deno client that connects to it. The issue affects Deno versions before 2.7.5 and is resolved in that release.