Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach endpoint deserializing JSON:API via yayson
-
DeliverySend document with type "__proto__"
-
ExploitStore writes attacker key onto Object.prototype
-
ExecutionPollution persists process-wide
-
ImpactDoS/logic corruption, gadget-dependent authz bypass or RCE
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 | Requires that the target application deserializes attacker-influenced JSON:API documents through yayson's Store or LegacyStore (Store.sync or equivalent) at version <= 4.2.0. The attacker must be able to set the document |
| Impact | The provided CVSS 3.1 vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H describes network-reachable, unauthenticated, low-complexity exploitation with no confidentiality impact but high integrity and availability impact - the advisory's own suggested severity is 8.1, while the summary score field lists 9.1; the 8.1 figure is the more defensible number given C:N. No CISA KEV listing and no EPSS score are provided, but a working proof-of-concept is published in the advisory, so exploit code exists even though there is no confirmation of exploitation in the wild. Real-world risk hinges on the consuming application: prototype pollution here reliably yields process-wide DoS or logic corruption, and any operator or deployment team running an internet-facing service that deserializes untrusted JSON:API through yayson should treat this as urgent, but escalation to authorization bypass or remote code execution is not guaranteed by yayson itself and requires exploitable gadgets in the surrounding code. The bar to trigger the base pollution is low, so priority should be driven by whether yayson processes attacker-supplied documents. |
| Exploit ScenarioDerived | An attacker sends a crafted JSON:API document (for example a POST body or an |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 11, 2026
Prototype pollution in the yayson npm JSON:API library (<= 4.2.0) lets a remote attacker corrupt Object.prototype by submitting a document whose resource type is "__proto__". Store/LegacyStore use the attacker-supplied type, id, and relationship names as plain-object keys in internal lookup tables, so a crafted JSON:API payload writes attacker-controlled key/value pairs onto every object in the Node.js process for its lifetime. Proof-of-concept code is published in the GitHub Security Advisory; there is no evidence of active exploitation. The guaranteed impact is process-wide denial of service and logic corruption, with escalation to authorization bypass or RCE dependent on gadgets in the consuming application.
RemediationAI
Vendor-released patch: upgrade to yayson 4.3.0, which uses null-prototype lookup tables, rejects __proto__/constructor/prototype as document-derived member names, iterates with Object.keys(), and normalizes caller-supplied caches to null-prototype (per GHSA-325j-mg25-8q58). If an immediate upgrade is not possible, reject any incoming JSON:API document whose type or relationship names equal __proto__, constructor, or prototype before passing it to Store/LegacyStore - note this must cover included resources, not just data.type, or an allow-list can be bypassed. As a process-level defense you can run Node with --disable-proto=throw, which turns __proto__ writes into thrown errors, but this changes global runtime behavior and may break other dependencies that rely on __proto__, so validate compatibility first. Advisory: https://github.com/confetti/yayson/security/advisories/GHSA-325j-mg25-8q58.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
yayson is a Node.js library (pkg:npm/yayson) that serializes and deserializes JSON:API documents. The flaw is a classic prototype pollution (CWE-1321): the deserializer builds nested plain-object caches keyed by document-derived strings, e.g. if (!models[type]) models[type] = {} followed by models[type][id] = model. Because type is a string value passed through untouched by JSON.parse, a value of __proto__ resolves models["__proto__"] to the existing Object.prototype rather than creating a new key, so the subsequent [id] = model assignment writes the attacker-controlled id (with the model built from attributes) directly onto Object.prototype. The malicious type can be delivered not only via data.type but also through an included resource referenced by a relationship, which bypasses any allow-list applied only to data.type. LegacyStore is additionally reachable when a configured types mapping resolves to __proto__.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H
Remote, low-complexity, unauthenticated deserialization of untrusted documents; guaranteed integrity/availability impact via prototype pollution but no direct confidentiality loss, matching the advisory's 8.1.
Primary rating from Vendor (https://github.com/confetti/yayson).
CVSS VectorVendor: https://github.com/confetti/yayson
DescriptionCVE.org
Summary
Store/LegacyStore key internal lookup tables by the type, id, and relationship names from a JSON:API document. Because these were plain objects, a document with type: "__proto__" writes onto Object.prototype, polluting every object in the process.
Severity
Suggested CVSS v3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H (8.1). The guaranteed impact is process-wide DoS / logic corruption; escalation to authorization bypass or RCE is dependent on gadgets in the consuming application.
Affected / Patched
- Affected:
<= 4.2.0(verified in3.0.0and4.2.0; all 3.x and 4.x). - Patched:
4.3.0.
Details
type is a string *value*, untouched by JSON.parse, and is used directly as an object key:
if (!models[type]) models[type] = {} // models["__proto__"] is Object.prototype → skipped
if (!models[type][id]) models[type][id] = model // → Object.prototype[id] = modelThe attacker controls the polluted key (id) and value (the model, populated from attributes). Pollution persists for the process lifetime. The malicious type can also arrive via an included resource referenced by a relationship, bypassing any data.type allow-list. LegacyStore is additionally reachable when a configured types mapping resolves to "__proto__".
Proof of concept
const { Store } = require('yayson')()
new Store().sync({ data: { type: '__proto__', id: 'polluted', attributes: { x: 1 } } })
console.log(({}).polluted) // { x: 1, id: 'polluted' } ← Object.prototype pollutedWorkarounds
Reject documents whose type or relationship names are __proto__, constructor, or prototype, or run Node with --disable-proto=throw.
Fix
Null-prototype lookup tables, rejection of __proto__/constructor/prototype as document-derived member names, Object.keys() iteration, and null-prototype normalization of caller-supplied caches.
Articles & Coverage 1
Technical POC Analysis
CWE-1321: Improperly Controlled Modification of Object Prototype Attributes.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
yayson JSON:API library versions 4.2.0 and earlier contain a prototype pollution vulnerability (CWE-1321) that allows remote attackers to corrupt the Object.prototype chain globally across the Node.js process. Publicly available exploit code exists. Organizations using yayson face process-wide denial of service, logic corruption, authorization bypass, and potential remote code execution from a single malicious JSON:API request.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Strict input validation rejecting '__proto__' and special object keys in JSON:API payloads at the application boundary; (2) Web application firewall rules blocking suspicious JSON:API resource type patterns; (3) Process isolation via containerized Node.js instances with restricted memory access; (4) Runtime monitoring of Object.prototype mutations to detect exploitation attempts; (5) Security review of all consuming applications for gadget-chain escalation paths to RCE.
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.
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-77579
GHSA-325j-mg25-8q58
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB