Skip to main content

yayson CVE-2026-61534

| EUVDEUVD-2026-77579 CRITICAL
Improperly Controlled Modification of Object Prototype Attributes (Prototype Pollution) (CWE-1321)
2026-09-11 https://github.com/confetti/yayson GHSA-325j-mg25-8q58
9.1
CVSS 3.1 · Vendor: https://github.com/confetti/yayson
View

Attack ChainAIDerived

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

  1. Access
    Reach endpoint deserializing JSON:API via yayson
  2. Delivery
    Send document with type "__proto__"
  3. Exploit
    Store writes attacker key onto Object.prototype
  4. Execution
    Pollution persists process-wide
  5. Impact
    DoS/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 type to __proto__ in data or, notably, in an included resource referenced by a relationship - the latter bypasses allow-lists applied only to data.type. LegacyStore is additionally reachable when a configured types mapping resolves to __proto__. No authentication or user interaction is required by yayson itself (PR:N/UI:N). Limiting factors: the base impact is DoS/logic corruption only; escalation to authz bypass or RCE requires exploitable gadgets in the consuming application, and hardened runtimes (Node --disable-proto=throw) or input validation neutralize the primitive.

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 included resource) with type: "__proto__" and a chosen id and attributes to an endpoint that deserializes input via yayson's Store. yayson writes the attacker's key/value onto Object.prototype, corrupting every object in the process and causing DoS or logic corruption, and potentially authorization bypass or RCE if a suitable gadget exists downstream. A working proof-of-concept is included in the published advisory.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
Patch available 0.8% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

yayson < 4.3.0

Affected Packages

npm yayson fix: 4.3.0

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

Vendor (https://github.com/confetti/yayson) PRIMARY 9.1 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H
vuln.today AI 9.1 CRITICAL

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.

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

Primary rating from Vendor (https://github.com/confetti/yayson).

CVSS VectorVendor: https://github.com/confetti/yayson

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

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 in 3.0.0 and 4.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:

js
if (!models[type]) models[type] = {}          // models["__proto__"] is Object.prototype → skipped
if (!models[type][id]) models[type][id] = model // → Object.prototype[id] = model

The 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

js
const { Store } = require('yayson')()
new Store().sync({ data: { type: '__proto__', id: 'polluted', attributes: { x: 1 } } })
console.log(({}).polluted) // { x: 1, id: 'polluted' }  ← Object.prototype polluted

Workarounds

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.

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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

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

EPSS Score
0.8%
Top 46% exploitable
Prevalence
Low
niche npm JSON:API serialization library, modest adoption
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Social Media
3
Sightings
Data Quality
6 sources
Confidence: High

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 CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.8%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Partial

Priority Score

67
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +46
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.

CVE-2026-34621 HIGH POC
8.6 Apr 11

Prototype pollution in Adobe Acrobat Reader versions 24.001.30356, 26.001.21367 and earlier enables arbitrary code execu

CVE-2021-23450 CRITICAL POC
9.8 Dec 17

All versions of package dojo are vulnerable to Prototype Pollution via the setObject function. Rated critical severity (

CVE-2024-56059 CRITICAL
9.8 Dec 18

Prototype pollution in the farinspace Partners WordPress plugin (versions up to and including 0.2.0) enables remote unau

CVE-2021-23383 CRITICAL POC
9.8 May 04

The package handlebars before 4.7.7 are vulnerable to Prototype Pollution when selecting certain compiling options to co

CVE-2020-7788 CRITICAL POC
9.8 Dec 11

This affects the package ini before 1.3.6. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitabl

CVE-2020-28271 CRITICAL POC
9.8 Nov 12

Prototype pollution vulnerability in 'deephas' versions 1.0.0 through 1.0.5 allows attacker to cause a denial of service

CVE-2023-38894 CRITICAL POC
9.8 Aug 16

A Prototype Pollution issue in Cronvel Tree-kit v.0.7.4 and before allows a remote attacker to execute arbitrary code vi

CVE-2024-24292 CRITICAL POC
9.8 Mar 28

A Prototype Pollution issue in Aliconnect /sdk v.0.0.6 allows an attacker to execute arbitrary code via the aim function

CVE-2023-26121 CRITICAL POC
10.0 Apr 11

All versions of the package safe-eval are vulnerable to Prototype Pollution via the safeEval function, due to improper s

CVE-2021-23449 CRITICAL POC
10.0 Oct 18

This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr

CVE-2024-39011 CRITICAL POC
9.8 Jul 30

Prototype Pollution in chargeover redoc v2.0.9-rc.69 allows attackers to execute arbitrary code or cause a Denial of Ser

CVE-2024-38988 CRITICAL POC
9.8 Mar 28

alizeait unflatto <= 1.0.2 was discovered to contain a prototype pollution via the method exports.unflatto at /dist/inde

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy