CVE-2026-92779 in sdk-angular
Summary
by MITRE • 09/16/2026
Builder.io Gen2 SDKs through versions 5.2.11 and 0.25.13 contain a prototype pollution vulnerability in the deep-set helper function that processes content block bindings without validation. Attackers can craft content blocks with binding keys containing __proto__, prototype, or constructor paths to pollute Object.prototype during rendering, affecting all subsequent objects created in the process including other tenants' renders.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 09/16/2026
The vulnerability identified within Builder.io Gen2 SDKs, specifically affecting versions through 5.2.11 and 0.25.13, represents a critical prototype pollution flaw rooted in the deep-set helper function responsible for processing content block bindings. This component is designed to traverse nested object structures and assign values based on provided key paths without implementing sufficient validation or sanitization checks. The core technical failure lies in the lack of boundary checking when handling user-supplied input that defines these binding keys, allowing attackers to inject malicious property names into the JavaScript prototype chain rather than standard data fields.
By crafting content blocks with binding keys containing specific strings such as _proto_, prototype, or constructor paths, an attacker can manipulate the internal state of the runtime environment during the rendering process. When the deep-set function processes these inputs, it inadvertently assigns properties to Object.prototype instead of creating new properties on the target object instance. This action effectively pollutes the global prototype chain, causing all subsequently created objects in the current execution context to inherit the maliciously injected properties or methods.
The operational impact of this vulnerability is severe due to its potential for cross-tenant data leakage and denial of service. Since JavaScript prototypes are shared across instances within a single event loop or process, polluting Object.prototype affects not only the immediate rendering operation but also all other objects created thereafter in that context. In multi-tenant environments typical of SaaS platforms like Builder.io, this can lead to information disclosure where sensitive data from one tenant's session becomes accessible to another tenant's render operations. Additionally, attackers may leverage prototype pollution to execute arbitrary code if they can inject methods that are later invoked by legitimate application logic, leading to remote code execution scenarios.
This vulnerability aligns with CWE-1325, which covers improper check for unusual or exceptional conditions in the deep-set function, and more broadly with CWE-915 regarding Improper Modification of Objects with Incorrectly Controlled Dynamically-Mapped Attributes. From a tactical perspective, this exploitation technique maps to MITRE ATT&CK techniques such as Taint: Shared Components (T1428) where an attacker modifies shared resources like prototypes to affect other components or users within the same environment. It also relates to Command Injection via Prototype Pollution if the polluted properties lead to unintended function calls.
To mitigate this risk, developers must immediately upgrade to patched versions of the Builder.io Gen2 SDKs that address the validation gaps in the deep-set helper function. Implementing strict input validation is essential, specifically ensuring that binding keys do not contain reserved JavaScript prototype property names such as _proto_, constructor, or prototype before they are processed by object manipulation utilities. Utilizing libraries like lodash.set with safe defaults or implementing custom sanitization logic that blocks these specific key paths can prevent the injection of malicious properties into the global prototype chain. Furthermore, adopting a security-first approach to content block parsing involves validating all user-supplied data against an allowlist of expected keys and rejecting any input that attempts to traverse or modify internal object structures outside of defined boundaries.