Description

A prototype pollution vulnerability in Software Mansion React Native Worklets before 0.12.2 allows an attacker-controlled object containing a __proto__ property to modify the prototype of an object created during serialization in clonePlainJSObject in packages/react-native-worklets/src/memory/serializable.native.ts. When affected data is subsequently processed by React Native Worklets, the malformed serialized object can cause the React Native application to crash. This can result in a remotely triggered denial of service in applications that pass attacker-controlled data through the affected serialization path. In applications where the attacker-controlled data is persisted, the denial of service may persist across application restarts or repeated attempts to access the affected content.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "4.3",
  "pubDate": "2026-09-25T03:16:59.327Z",
  "pubdate": "2026-09-25T03:16:59.327Z",
  "executiveSummary": "A prototype pollution vulnerability exists in Software Mansion React Native Worklets versions prior to 0.12.2, stemming from insecure object serialization practices.\nThe vulnerability occurs within the clonePlainJSObject function, where insufficient validation of object keys allows the injection of a __proto__ property. This enables an attacker to modify the prototype of objects created during the serialization process.\nSuccessful exploitation results in a remotely triggered denial of service (DoS). By injecting a malformed serialized object, an attacker can crash the React Native application. If the malicious data is persisted, the DoS condition can persist across application restarts, significantly impacting availability.\nThis vulnerability is particularly dangerous in applications that process external, attacker-controlled data through the affected serialization path. No specific authentication or high-privilege access is required to initiate the attack, provided the attacker can influence the input processed by the vulnerable component.",
  "technicalDetails": "The root cause of this vulnerability is improper handling of object keys within the clonePlainJSObject function located in packages/react-native-worklets/src/memory/serializable.native.ts. During the cloning process, the logic fails to sanitize or validate input objects for special properties that manipulate the JavaScript prototype chain.\nSpecifically, when an attacker provides an object containing a __proto__ key, the function processes this key during serialization. Because the implementation does not explicitly block or sanitize this property, it allows the attacker to pollute the base Object prototype. This effectively grants the attacker the ability to modify the prototype of all objects created throughout the application runtime after the pollution event.\nThe attack flow begins when an application passes unsanitized, attacker-controlled data into the serialization path. The affected routine recursively processes this data. When the parser encounters the __proto__ property, the prototype chain of the targeted object is altered, injecting malicious properties into the object's prototype. Subsequent execution of React Native Worklets logic relies on the integrity of these objects; when the application attempts to access or process the polluted object, the unexpected state transition or prototype override triggers an unhandled exception.\nThis unhandled exception leads to an application-level crash, resulting in a denial of service. The impact is exacerbated when the application persists the received data, such as saving it to local storage, a database, or cache. In such scenarios, the application will attempt to re-process the corrupted object upon initialization or subsequent access, leading to a persistent crash loop that prevents the user from interacting with the application.\nThe vulnerability affects all versions of Software Mansion React Native Worklets prior to 0.12.2. Exploitation requires only the ability to inject malicious data into the serialization routine, which is typical in scenarios involving user-supplied JSON or object-based message passing. The attack does not require specific user authentication or administrative privileges, making it a viable vector for remote attackers capable of influencing the data stream processed by the React Native bridge or related Worklets interfaces."
}