Skip to main content

Deno CVE-2025-61786

LOW
Improper Privilege Management (CWE-269)
2025-10-08 security-advisories@github.com
3.3
CVSS 3.1 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Run malicious script under Deno with --deny-read/--allow-write
  2. Exploit
    Open target file write-only via Deno.open
  3. Execution
    Call FsFile.stat()/statSync() bypassing read check
  4. Impact
    Exfiltrate 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.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 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

cargo deno fix: 2.5.3

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

Vendor (github) PRIMARY 3.3 LOW
AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N
vuln.today AI 3.3 LOW

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.

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

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
None

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

EPSS Score
0.2%
Top 92% exploitable
Prevalence
Medium
popular JS/TS/WASM runtime but far smaller production footprint than Node.js
Exploit
POC
Public exploit code exists
Data Quality
4 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 LOW
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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· derived
Defer
Exploitation· derived
Poc
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Low

Priority Score

36
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +16
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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

cpe:2.3:a:deno:deno:*:*:*:*:*:*:*:*
cpe:2.3:a:deno:deno:*:*:*:*:*:*:*:*

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