Skip to main content

Deno CVE-2025-61785

LOW
Incorrect Privilege Assignment (CWE-266)
2025-10-08 security-advisories@github.com
3.3
CVSS 3.1 · NVD
View

Attack ChainAIDerived

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

  1. Access
    Execute untrusted script under --deny-write=./
  2. Exploit
    Open target file read-only via Deno.open
  3. Execution
    Call FsFile.utime()/utimeSync()
  4. Impact
    Bypass permission check, alter atime/mtime timestamps

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V8 - Authorization Privilege assignment review
Exploitation Conditions

Exploitation requires attacker-controlled script code executing inside the Deno runtime with read permission (e.g. --allow-read=./) on the target file, even while --deny-write=./ is set and the file is opened with {read: true, write: false}. The exact trigger is calling Deno.FsFile.prototype.utime() or utimeSync() on the resulting file handle, which (unlike Deno.utime/utimeSync) skipped the write-permission check. Limiting factors: the attacker must already be running JavaScript/TypeScript within the Deno sandbox; impact is confined to modifying a file's atime/mtime (no content write, read, or deletion); the file must be openable for reading; and affected versions are only those prior to 2.5.3 and 2.2.15. There is no remote, network-facing, or unauthenticated path.

Impact

This is a genuinely low-priority issue, and all available signals agree. The CVSS 3.1 base score is 3.3 (Low) with vector AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N - local attack vector, low complexity, some privilege required, and only a Low integrity impact with no confidentiality or availability effect. EPSS reinforces this: 0.20% probability at the 9th percentile indicates negligible likelihood of broad exploitation. The vulnerability is NOT in CISA KEV (no active-exploitation signal), though publicly available exploit code exists in the form of the working PoC embedded in the GHSA-vg2r-rmgp-cgqj advisory. No SSVC decision data was provided in the input. The signals are consistent rather than conflicting: a published PoC exists but EPSS and the absence of KEV listing both point to this being a security-hardening fix rather than a weaponizable threat. The real-world impact is narrow - it permits altering a file's access/modification timestamps (atime/mtime) despite a --deny-write policy, i.e. a sandbox permission-model bypass (CWE-266, incorrect privilege assignment), not code execution or data disclosure. Note that CVSS PR:L reflects that exploitation presupposes the attacker is already executing script code inside the Deno runtime with read permission, which materially limits severity.

Exploit ScenarioDerived

An operator runs an untrusted or semi-trusted Deno script under a hardened policy (--allow-read=./ --deny-write=./), expecting the deny-write flag to block all filesystem mutations. The script opens a file read-only via Deno.open and then calls file.utime()/utimeSync() to silently rewrite the file's atime and mtime, bypassing the permission model. A working PoC demonstrating exactly this is published in the vendor's GHSA advisory.

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

Deno 2.x runtimes prior to 2.5.3 and 2.2.15 fail to apply the write-permission check to Deno.FsFile.prototype.utime() and utimeSync(), so a script running with read-only file access under --deny-write=./ can still change a file's access (atime) and modification (mtime) timestamps. The attacker must already be executing JavaScript/TypeScript inside the Deno sandbox with read permission on the target file and must open it as a read-only file handle; no remote or unauthenticated path exists, and impact is limited to metadata (timestamps) with no content write, read, or deletion. Publicly available proof-of-concept code is included in the GitHub security advisory, but EPSS is very low (0.20%, 9th percentile) and there is no confirmed active exploitation (CISA KEV); this is a low-severity, local sandbox-hardening issue.

RemediationAI

Upgrade to Deno 2.5.3 (current line) or 2.2.15 (2.2.x line), the versions that fix the issue; the upstream fix is the commit https://github.com/denoland/deno/commit/992e998dfe436cdc9325232759af8be92f11739b and PR https://github.com/denoland/deno/pull/30872, with releases published at the v2.5.3 and v2.2.15 tags. No patch is needed for the API itself beyond upgrading, since the correction simply restores the missing write-permission check. If immediate upgrading is not possible, the effective compensating control is to avoid granting read permission to sensitive files when running untrusted Deno code - the bug only matters when --allow-read exposes a file that a malicious script should not be able to modify in any way, so tightening --allow-read scopes, running untrusted scripts inside an OS-level sandbox or read-only mount, or serving the data through a controlled interface instead of direct file handles removes the exposure; note that --deny-write alone is not sufficient on vulnerable versions and these mitigations trade some script functionality for containment. Adopting the fixed release is strongly preferred because it is the only change that makes the permission model consistent across the utime APIs.

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 enforces a capability-based permission model (allow-read, allow-write, deny-write, etc.) at the runtime level, and the CWE-266 (Incorrect Privilege Assignment) root cause here is that two internal ops backing the file-handle timestamp APIs - op_fs_futime_sync and op_fs_futime_async in ext/fs/ops.rs - never called the FsPermissions::check_open() routine with OpenAccessKind::WriteNoFollow, unlike the path-based Deno.utime/Deno.utimeSync APIs, which correctly require write permission. The fix in commit 992e998 (PR #30872) threads a maybe_path() accessor through the file-resource abstractions (StdFileResourceInner in ext/io/lib.rs, FileBackedVfsFile in cli/rt/file_system.rs, and the trait in ext/io/fs.rs) so that a real filesystem handle opened from a path retains it, and then the futime ops perform the missing check. VFS-backed handles deliberately return None for maybe_path() because they are never written to, and stdio pipes pass None. Affected CPEs (cpe:2.3:a:deno:deno) confirm the Deno runtime itself, not an ecosystem package, is the vulnerable component.

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

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

Attacker must run code in the local runtime with read permission, so AV:L and PR:L; only timestamp integrity is affected, giving I:L with C:N and A:N.

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

Primary rating from NVD.

CVSS VectorNVD

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

DescriptionNVD

Deno is a JavaScript, TypeScript, and WebAssembly runtime. In versions prior to 2.5.3 and 2.2.15, Deno.FsFile.prototype.utime and Deno.FsFile.prototype.utimeSync are not limited by the permission model check --deny-write=./. It's possible to change to change the access (atime) and modification (mtime) times on the file stream resource even when the file is opened with read only permission (and write: false) and file write operations are not allowed (the script is executed with --deny-write=./). Similar APIs like Deno.utime and Deno.utimeSync require allow-write permission, however, when a file is opened, even with read only flags and deny-write permission, it's still possible to change the access (atime) and modification (mtime) times, 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 91% exploitable
Prevalence
Medium
popular but not ubiquitous JavaScript/TypeScript runtime, far smaller 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

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

Affected Products (CPE)NVD

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