Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain ability to supply CASL rule conditions
-
DeliveryInject dotted key e.g. 'toString.call'
-
ExploitrulesToFields expands path onto inherited builtin
-
ExecutionShared Object.prototype function corrupted process-wide
-
ImpactNode.js process denial of service
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Prototype pollution prevention
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the application (1) uses @casl/ability between 6.7.5 and 7.0.2, (2) calls rulesToFields() on an ability, and (3) allows an attacker to control the keys of a rule's conditions object so that a dotted key such as 'toString.call', 'hasOwnProperty', or 'valueOf' can be supplied. The dotted path is then expanded via the internal setByPath helper and reaches an inherited builtin, mutating Object.prototype members shared across the whole process. Limiting factors: the attacker must have write influence over rule-condition construction (PR:L - typically a server-side or privileged operation, not raw external input), the CVSS 4.0 vector marks High attack complexity and a Present attack requirement (AC:H/AT:P), and the impact is confined to availability (process DoS) with no confidentiality or integrity consequence. Applications that never expose rule-condition keys to untrusted data, or that do not use rulesToFields(), are not exploitable. |
| Impact | This is a moderate-severity, availability-only issue, not an urgent priority. The supplied CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:L/UI:N) scores 6.0 and limits impact to availability (VA:H) with no confidentiality or integrity effect (VC:N/VI:N) - consistent with a prototype-pollution bug that corrupts shared Node.js builtins to crash the process rather than achieve RCE or data theft. Exploitation is gated by High attack complexity (AC:H), a Present attack requirement (AT:P), and Low privileges (PR:L), meaning the attacker must already be able to supply CASL rule conditions, which in most deployments is a privileged/server-side operation rather than arbitrary external input. No EPSS score, KEV listing, or POC indicator is present in the input, so there is no signal of active or widespread exploitation - the disclosure comes from VulnCheck research with a vendor patch. Net assessment: a real but conditional DoS affecting applications that feed attacker-influenceable conditions into rulesToFields(); treat as a dependency-hygiene patch rather than an emergency. NOTE: the real-world PR level depends entirely on whether the host application exposes rule-condition construction to untrusted actors - verify in your own code path. |
| Exploit ScenarioDerived | An attacker who can influence the condition objects of CASL rules (for example an application that builds authorization rules from user-supplied filter/query input) submits a dotted key such as 'toString.call' with a value. When the application calls rulesToFields() to derive field defaults, the dotted key walks into and overwrites a shared builtin function on Object.prototype process-wide, corrupting it for all code and crashing or destabilizing the Node.js process. No public exploit identified at time of analysis, and the network-reachable path still carries high attack complexity (AC:H). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Denial of service in the @casl/ability npm package (6.7.5 through 7.0.1) stems from prototype pollution in the rulesToFields() helper, which expands attacker-influenced dotted condition keys through an internal setByPath utility and can overwrite inherited builtins such as Function.prototype.call, corrupting shared objects process-wide and crashing the Node.js process. Only applications that call rulesToFields() on rule conditions whose keys are under an attacker's write influence are affected, and the required access is authenticated (PR:L) with high attack complexity, so exposure is conditional rather than broad. The impact is availability only (no confidentiality or integrity loss), no public exploit code has been identified at time of analysis, and the flaw is not listed in CISA KEV, making this a moderate-severity issue rather than an urgent one.
RemediationAI
Upgrade @casl/ability to 7.0.2 or later - the vendor-released patch that fixes this issue; the fix is visible in the upstream references at https://github.com/stalniy/casl/commit/58242cb3c7911c8a89bacfb7d732701d81bc1324 and https://github.com/stalniy/casl/pull/1305, with additional detail at https://www.vulncheck.com/advisories/casl-ability-6.7.5-before-7.0.2-prototype-pollution-via-rulestofields-setbypath. If an immediate upgrade is not possible, the highest-value compensating control is to stop feeding attacker-influenced condition keys into rulesToFields(): validate and reject condition keys containing dots, as well as '__proto__', 'constructor', and 'prototype', at the boundary where rules are built (side effect: legitimate nested-condition keys must be restructured into explicit nested objects instead of dotted strings, which can require application changes). Because the assessed prerequisite is authenticated write influence over rule-condition construction (PR:L), restricting rule authoring to trusted server-side code or privileged roles measurably reduces exposure. Defensively freezing or null-prototyping Object.prototype/Function.prototype is not recommended as a general workaround: freezing Object.prototype must occur before any pollution and has process-wide side effects that frequently break third-party libraries, while per-call sanitization of condition keys carries no such risk.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
CASL is a JavaScript/TypeScript authorization library in which an Ability is composed of rules, each carrying action, subject, and an optional conditions object. The rulesToFields() utility (part of the @casl/ability package, sourced from packages/casl-ability/src/utils.ts) converts those conditions into a flat field map, and dotted condition keys are expanded into nested objects by an internal setByPath helper that walks the path segment by segment. Because the traversal writes into whatever object it reaches rather than into a guaranteed own, prototype-free object, a key such as 'toString.call', 'hasOwnProperty.call', or 'valueOf' can resolve to an inherited builtin function on Object.prototype/Function.prototype and mutate it for the entire process. This is CWE-1321 (improperly controlled modification of object prototype attributes, i.e. prototype pollution); the practical consequence is that a polluted builtin throws or misbehaves for all code in the process, producing a denial of service. The vendor fix (commit 58242cb3c7911c8a89bacfb7d732701d81bc1324, PR #1305) is corroborated by new tests showing null-prototype result objects (Object.getPrototypeOf(object) === null), skipping of '__proto__', 'constructor', and 'prototype' as final properties, replacement of non-object/array intermediate values when expanding dotted paths, and dotted-path merging that produces own properties instead of touching builtins. CPE data identifies the affected artifact as cpe:2.3:a:stalniy:@casl/ability; because the code is an npm library, exploitation depends entirely on how the consuming application uses it.
Know when Prototype Pollution 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
CVSS:4.0/AV:N/AC:H/AT:P/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Attacker must control rule conditions (PR:L) and overcome non-trivial path/key constraints (AC:H); impact is process-wide DoS only, so C:N/I:N/A:H with no scope change.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
@casl/ability 6.7.5 before 7.0.2 contains a prototype pollution vulnerability in rulesToFields() that allows attackers to modify inherited builtins via dotted condition keys. Attackers controlling rule conditions can supply keys like 'toString.call' to alter shared builtin functions process-wide, causing denial of service for the Node.js process.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Prototype Pollution
View allPrototype pollution in Adobe Acrobat Reader versions 24.001.30356, 26.001.21367 and earlier enables arbitrary code execu
All versions of package dojo are vulnerable to Prototype Pollution via the setObject function. Rated critical severity (
Prototype pollution in the farinspace Partners WordPress plugin (versions up to and including 0.2.0) enables remote unau
The package handlebars before 4.7.7 are vulnerable to Prototype Pollution when selecting certain compiling options to co
This affects the package ini before 1.3.6. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitabl
Prototype pollution vulnerability in 'deephas' versions 1.0.0 through 1.0.5 allows attacker to cause a denial of service
A Prototype Pollution issue in Cronvel Tree-kit v.0.7.4 and before allows a remote attacker to execute arbitrary code vi
A Prototype Pollution issue in Aliconnect /sdk v.0.0.6 allows an attacker to execute arbitrary code via the aim function
All versions of the package safe-eval are vulnerable to Prototype Pollution via the safeEval function, due to improper s
This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr
Prototype Pollution in chargeover redoc v2.0.9-rc.69 allows attackers to execute arbitrary code or cause a Denial of Ser
alizeait unflatto <= 1.0.2 was discovered to contain a prototype pollution via the method exports.unflatto at /dist/inde
EUVD-2026-102299
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB