CVE-2026-33228: flatted: Prototype Pollution via parse()
flatted is a circular JSON parser. Prior to version 3.4.2, the parse() function in flatted can use attacker-controlled string values from the parsed JSON as direct array index keys, without validating that they are numeric. Since the internal input buffer is a JavaScript Array, accessing it with the key "__proto__" returns Array.prototype via the inherited getter. This object is then treated as a legitimate parsed value and assigned as a property of the output object, effectively leaking a live reference to Array.prototype to the consumer. Any code that subsequently writes to that property will pollute the global prototype. This issue has been patched in version 3.4.2.
Security readout for executives and security teams
Plain-English summary
A flaw in flatted can turn specially crafted serialized data into a live reference to a shared JavaScript prototype. If application code later modifies that returned property, behavior across the process may be corrupted, potentially affecting data integrity, confidentiality, or availability. Exposure depends on whether untrusted data reaches flatted.parse() and how the result is used.
Executive priority
Prioritize rapid inventory and upgrade for internet-facing or multi-tenant services processing untrusted flatted data. Treat confirmed reachable instances as urgent. Do not assume every installation is exploitable; validate the input path and downstream writes while remediation proceeds.
Technical view
Before 3.4.2, flatted.parse() accepts attacker-controlled string values as Array index keys without ensuring they are numeric. The key "__proto__" can resolve through inheritance to Array.prototype, which is returned as parsed data. A subsequent write through that property can cause global prototype pollution. Version 3.4.2 patches the issue.
Likely exposure
Potentially exposed systems use flatted below 3.4.2, directly or transitively, and parse attacker-controlled serialized input. Risk is lower where inputs are trusted or parsed results are never subsequently written through the affected property, but dependency presence alone does not establish exploitability.
Exploitation context
The supplied data reports CVSS 3.1 score 9.8 and no KEV listing. No provided source confirms active exploitation. Successful impact requires malicious input reaching parse() and later consumer behavior that writes through the leaked prototype reference; the resulting effect depends on the application.
Researcher notes
The primitive is indirect: parsing exposes Array.prototype as a legitimate value, while later consumer writes produce pollution. Assessment should distinguish package presence, attacker-controlled parse reachability, and a usable write path. The provided evidence establishes the vulnerable logic and patched release, but not observed exploitation or a universal application-level impact.
Mitigation direction
Upgrade flatted to version 3.4.2 or later.
Update lockfiles and rebuild deployments so the corrected version is actually resolved.
Identify and update parent packages that introduce vulnerable transitive versions.
Until upgraded, prevent untrusted serialized data from reaching flatted.parse().
Review applicable Red Hat advisories for vendor-packaged deployments.
Validation and detection
Search manifests, lockfiles, SBOMs, and deployed artifacts for flatted versions below 3.4.2.
Confirm the production runtime resolves flatted 3.4.2 or later.
Trace whether external input can reach flatted.parse().
Review downstream code for writes to properties obtained from parsed data.
Use isolated regression tests to confirm rejected nonnumeric references and unchanged global prototypes.
Generated from the cited source records. This long-tail analysis has not been individually reviewed by a named human.
Potential ATT&CK relevance
Conservative CVE-to-ATT&CK context
These mappings and lookup hints may be relevant to the vulnerability behavior, CWE, affected product, or exposure path. Glexia-inferred context is not an official MITRE, ATT&CK, CWE, or CVE Program mapping.
ATT&CK lookup starting points
Use these exact CWE pages and searches to review the Glexia ATT&CK library from this CVE's weakness and description context.
cwe · low confidence lookup
CWE-1321: Exact CWE lookup
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
Use the exact CWE identifier as the starting point before reviewing related ATT&CK behavior. Open the exact CWE lookup page first, then review the ATT&CK searches from that MITRE weakness context. This is a Glexia lookup hint, not an official ATT&CK mapping.
These fields come from the CVE record and ADP containers, not from Glexia's Take. They preserve time-varying source decisions such as CISA SSVC, KEV status, CVSS metrics, and provider references.
2CVSS vectors
5Timeline events
2ADP providers
10Source links
SSVC decision data
CISA-ADPCISA Coordinator
Timestamp
Version
2.0.3
Exploitation: pocAutomatable: yesTechnical Impact: total
CVSS vector scores
2 official scores
We collect every scored CVSS vector available in the official CNA and ADP containers. When more than one version is present, the table keeps the source vectors side by side instead of collapsing them into the highest score.
CWE links open Glexia weakness intelligence pages with official CWE context, developer remediation guidance, and related CVE mappings.
CWE-1321 · source CWE mapping
Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution') represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.
Improperly Controlled Modification of Dynamically-Determined Object Attributes
Improperly Controlled Modification of Dynamically-Determined Object Attributes represents a recurring weakness pattern that can create exploitable paths when design, validation, or implementation controls are missing.