Deno
CVE-2025-61786
LOW
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessRun malicious script under Deno with --deny-read/--allow-write
-
ExploitOpen target file write-only via Deno.open
-
ExecutionCall FsFile.stat()/statSync() bypassing read check
-
ImpactExfiltrate file metadata outside permission boundary
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V8 - Authorization Least privilege enforcement
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires executing code inside the Deno runtime (versions < 2.5.3 on the 2.5.x line or < 2.2.15 on the 2.2.x line) under a permission configuration that denies read but grants write - specifically a file opened via Deno.open/openSync with write:true and read:false while --deny-read (or absence of --allow-read) is in effect; the stat bypass works through Deno.FsFile.prototype.stat and statSync (note Deno.stat/statSync are NOT affected, as they correctly enforce allow-read). Limiting factors that reduce real-world risk: the attacker must already have local code execution within the sandbox (AV:L) with at least write permission (PR:L), the leak is confined to file metadata/stats rather than file contents (C:L, I:N, A:N), and it only matters where Deno's --deny-read permission model is relied on as a boundary against untrusted code. |
| Impact | This is a genuinely low-severity issue despite being a security advisory, and the multiple signals agree rather than conflict. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N = 3.3 Low) describes a local, low-privilege flaw with only limited confidentiality impact and no integrity or availability impact - consistent with the GHSA description of a metadata-only permission bypass. EPSS reinforces low real-world urgency at 0.19% (8th percentile), and the vulnerability is NOT on the CISA KEV list, so there is no evidence of active exploitation. A public PoC does exist (published in the GHSA advisory itself), but PoC availability is not the same as exploitation in the wild and should not be conflated with it. The attack vector is local (AV:L): exploitation requires already running code inside the Deno runtime, so this is a sandbox/permission-model weakness exploitable only by code the operator chose to execute under a specific restrictive permission set, not a remotely reachable flaw. Net assessment: low priority for most defenders - it matters chiefly to those who rely on Deno's --deny-read permission model as a hard security boundary for untrusted code, where even file-metadata leakage is a trust-boundary violation worth patching. |
| Exploit ScenarioDerived | An operator runs untrusted or semi-trusted third-party code under Deno with write access but read explicitly denied (e.g. --deny-read=./ --allow-write=./), expecting the script cannot learn anything about files it may not read. The malicious script opens a target file for write-only via Deno.open and then calls file.stat()/file.statSync(), retrieving metadata (existence, size, timestamps, file type) despite the deny-read policy. A public PoC demonstrating exactly this is included in the GitHub Security Advisory GHSA-qq26-84mh-26j9. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 08, 2026
File-metadata disclosure in the Deno runtime allows code running under the permission model to retrieve stats for files it is explicitly denied read access to: Deno.FsFile.prototype.stat and Deno.FsFile.prototype.statSync skip the --deny-read check when a file handle has been opened with write-only flags (read:false, write:true), leaking file type, size and timestamps even though the analogous Deno.stat/Deno.statSync correctly enforce allow-read. Affected are Deno releases before 2.5.3 on the 2.5.x line and before 2.2.15 on the 2.2.x line (local code execution with write permission, per the PR:L vector). Severity is genuinely low and the signals agree: CVSS 3.3, EPSS 0.19% (8th percentile), a publicly available proof-of-concept in the vendor advisory, and confirmed fixes shipped by the vendor in 2.5.3 and 2.2.15 - no active exploitation is indicated.
RemediationAI
Vendor-released patches are available: upgrade Deno to 2.5.3 (for the 2.5.x line) or 2.2.15 (for the 2.2.x line), as published at https://github.com/denoland/deno/releases/tag/v2.5.3 and https://github.com/denoland/deno/releases/tag/v2.2.15; the fix is the upstream PR https://github.com/denoland/deno/pull/30876 / commit https://github.com/denoland/deno/commit/1ab2268c0bcbf9b0468e0e36963f77f8c31c73ec, which adds a read-permission check to the FsFile stat ops. Where upgrading is not immediately possible, note that the bypass only manifests when a write-capable handle to the target path exists, so the most effective compensating control is to stop granting write permission over directories that also require read confidentiality - i.e., avoid --allow-write (or --deny-write) on the same paths you protect with --deny-read; the trade-off is that scripts legitimately writing to those directories will break unless refactored to use a narrower, dedicated path. A secondary option is to treat --deny-read as non-binding for untrusted code and instead run Deno inside an OS-level sandbox (container, separate UID, read-only bind mounts of sensitive trees) so metadata is not reachable regardless of runtime permission quirks; this adds operational overhead and is unaffected by the low (3.3) severity. Disabling or shimming Deno.FsFile.prototype.stat/statSync in application bootstrap code is possible but brittle, since it relies on the very permission model that the flaw undermines.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Deno is a Rust-based JavaScript/TypeScript/WebAssembly runtime that ships its own capability-style permission model, where filesystem access is gated by --allow-read/--allow-write and the inverse --deny-read/--deny-write flags. Internally, filesystem operations are exposed to JavaScript through deno_core ops; the affected ops were op_fs_file_stat_sync and op_fs_file_stat_async in ext/fs/ops.rs, which back Deno.FsFile.prototype.statSync() and stat(). These ops previously performed no permission check at all on the underlying file handle, so once a handle was obtained via Deno.open/openSync with write:true and read:false, the stat calls returned metadata without consulting the read-permission policy - while the top-level Deno.stat/Deno.statSync entry points did perform the check. The root cause is classified as CWE-269 (Improper Privilege Management): an operation that logically requires read capability was not routed through the capability-checking layer, creating a permission-model bypass confined to file metadata (not file contents). The upstream fix (commit 1ab2268c and PR 30876) makes the two ops generic over FsPermissions and, when the handle exposes a path via maybe_path(), calls check_open with OpenAccessKind::Read, raising Deno.errors.NotCapable - exactly the behavior asserted by the new unit tests added in tests/unit/stat_test.ts.
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
AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N
Exploited by code running locally in the Deno sandbox (AV:L) holding write permission (PR:L); reliably leaks only file metadata, so C:L with no integrity or availability impact.
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
Deno is a JavaScript, TypeScript, and WebAssembly runtime. In versions prior to 2.5.3 and 2.2.15, Deno.FsFile.prototype.stat and Deno.FsFile.prototype.statSync are not limited by the permission model check --deny-read=./. It's possible to retrieve stats from files that the user do not have explicit read access to (the script is executed with --deny-read=./). Similar APIs like Deno.stat and Deno.statSync require allow-read permission, however, when a file is opened, even with file-write only flags and deny-read permission, it's still possible to retrieve file stats, and thus bypass the permission model. Versions 2.5.3 and 2.2.15 fix the issue.
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
Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.
Affected Products (CPE)CVE.org
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
NVD
CVE.org
EPSS
GitHub
Exploit-DB