CVE-2026-104183 in stream-json
Summary
by MITRE • 10/02/2026
stream-json is a micro-library of stream components for processing JSON and JSONC with a minimal memory footprint. Prior to 3.6.0, Assembler materializes object properties with plain assignment, so an input key named __proto__ invokes the inherited setter and causes parsed object prototype replacement instead of creating an own data property. Applications that make authorization or feature decisions from inherited values can therefore consume attacker-controlled properties, and a null prototype can disrupt code that expects Object.prototype methods. The researcher treats parsing untrusted JSON as part of the project contract, while the maintainer states that documented inputs are locally owned dumps, exports, or logs and characterizes the attack vector as local. The global Object.prototype is not polluted. This issue is fixed in version 3.6.0.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 10/02/2026
The stream-json library serves as a specialized tool for processing JSON and JSONC data streams with an emphasis on minimal memory consumption, making it suitable for high-throughput or resource-constrained environments. However, prior to version 3.6.0, the Assembler component contained a critical implementation flaw related to how object properties are materialized during parsing. Specifically, the library utilized plain JavaScript assignment operators when constructing objects from parsed JSON keys. This approach failed to distinguish between standard data properties and special inherited property descriptors defined on Object.prototype, such as _proto_. When an input stream contains a key named _proto_, the Assembler inadvertently triggers the inherited setter associated with that name rather than creating a new own property on the target object.
This behavior results in prototype pollution, where the internal [[Prototype]] of the parsed object is replaced by the value provided in the JSON payload instead of treating it as regular data. While this does not pollute the global Object.prototype itself, it compromises the integrity of individual objects created during parsing operations. The security implications are significant for applications that rely on inherited values to make authorization decisions or feature toggles. An attacker controlling the input stream can inject malicious _proto_ entries to manipulate object inheritance chains, potentially bypassing access controls or causing unexpected behavior in code paths that assume standard prototype structures. Furthermore, setting a null prototype via this mechanism can disrupt functionality for any downstream code expecting the presence of Object.prototype methods like toString or hasOwnProperty on parsed objects.
The classification of this vulnerability involves considerations from both CWE and MITRE ATT&CK frameworks. It aligns with CWE-1321: Improperly Controlled Modification of Object Prototype Attributes, as it allows an attacker to modify the prototype chain through untrusted input. In terms of attack vectors, while some researchers view parsing any JSON as a potential trust boundary requiring strict validation, maintainers often characterize such inputs as local dumps or logs where external manipulation is less likely. Consequently, this issue may be classified under ATT&CK technique T1559: Inter-Process Communication if the input source is considered internal, though it retains characteristics of injection-based attacks due to the modification of object structure via data content rather than code execution.
Mitigation for this vulnerability requires an immediate upgrade to version 3.6.0 or later, where the Assembler has been patched to handle _proto_ keys safely by creating own properties instead of invoking inherited setters. For applications unable to update immediately, developers should implement input validation layers that sanitize JSON payloads before they reach the stream-json parser, specifically filtering out keys named _proto_, constructor, and prototype. Additionally, using Object.create(null) for base objects in custom parsing logic can provide an additional layer of defense against prototype pollution attacks by ensuring parsed objects do not inherit from Object.prototype by default.