Deno
CVE-2025-61785
LOW
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessExecute untrusted script under --deny-write=./
-
ExploitOpen target file read-only via Deno.open
-
ExecutionCall FsFile.utime()/utimeSync()
-
ImpactBypass 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N
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.
Primary rating from NVD.
CVSS VectorNVD
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
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Affected Products (CPE)NVD
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