CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-77413

CVE-2026-77413: Remote Code Execution via Prototype Chain Bypass in JSONata Evaluator

Alon Barad
Alon Barad
Software Engineer

Aug 22, 2026·6 min read·43 visits

Executive Summary (TL;DR)

Unauthenticated remote code execution vulnerability in JSONata via prototype lookup chain traversal.

A critical prototype pollution and sandbox escape vulnerability was discovered in the JSONata query and transformation library before versions 1.8.8 and 2.2.0. By providing a malicious JSONata expression that bypasses ownership checks on object properties, remote attackers can execute arbitrary code in the context of the host Node.js application.

Vulnerability Overview

JSONata is a query and transformation language modeled on XPath that interprets queries and transformations against JSON input datasets. To evaluate expressions, JSONata compiles them into an Abstract Syntax Tree (AST) and steps through the nodes using its core evaluator engine. The engine acts as an interpreter, allowing users to define local variables, query specific fields, and invoke transformation operations. This flexibility requires strict sandbox boundaries when evaluating untrusted user queries.\n\nThe attack surface lies directly in the core evaluator's property resolution bottleneck. In standard Node.js environments, applications often evaluate query strings provided by external users or integrations. If these expressions are executed without safety boundaries, an attacker can access properties outside the scope of the local evaluation context. This behavior occurs because the evaluator performs raw property lookups on user-provided and internal JavaScript objects.\n\nThe vulnerability is classified under CWE-94 (Improper Control of Generation of Code or 'Code Injection'). Specifically, the engine's failure to validate object property ownership allows remote attackers to traverse the standard JavaScript prototype chain. By retrieving the global Function constructor, an adversary can compile and execute arbitrary JavaScript code inside the host process. This bypass leads to complete compromise of the hosting system's confidentiality, integrity, and availability.

Root Cause Analysis

The root cause of the vulnerability exists in JSONata's internal property resolution helper function, located in src/functions.js. During query evaluation, the engine resolves property keys using a central lookup routing function. This function takes an input object and a target key, and then returns the resolved value.\n\nIn JavaScript, all standard object instances inherit helper methods and meta-properties from Object.prototype. These properties include constructor, __proto__, __lookupSetter__, and __defineGetter__. When the lookup resolver evaluates an expression, it retrieves properties by directly indexing the object, e.g., using input[key]. Before the fix, the evaluator checked whether the input was an object and not a function, but it did not verify whether the key belonged to the object as an 'own' property.\n\nBecause of this omission, if a query references an inherited property such as constructor, the engine climbs up the prototype chain. The engine then returns the native prototype function or object to the evaluator scope. An attacker can construct a payload that chains these lookups. This chain moves from a standard object to the prototype accessor, and ultimately retrieves the global Function constructor. Once retrieved, the constructor serves as an execution vector to run arbitrary shell commands with the host process privileges.

Code Analysis

The vulnerability was resolved by introducing explicit property ownership validation in the central resolver in src/functions.js. Below is the code diff of the patch implemented in both the v1 and v2 branches:\n\njavascript\n// Vulnerable Property Lookup\n} else if (input !== null && typeof input === 'object' && !isFunction(input)) {\n result = input[key];\n}\nreturn result;\n\n// Patched Property Lookup\n} else if (input !== null && typeof input === 'object' && Object.prototype.hasOwnProperty.call(input, key) && !isFunction(input)) {\n result = input[key];\n}\nreturn result;\n\n\nThe inclusion of Object.prototype.hasOwnProperty.call(input, key) ensures that the engine only returns values defined directly on the input instance. If the key exists on the prototype chain (such as constructor), the check fails. The resolver then returns undefined instead of returning the inherited function.\n\nInvoking hasOwnProperty indirectly via Object.prototype.hasOwnProperty.call is critical for application stability. Objects created without a prototype, such as Object.create(null), do not inherit methods from Object.prototype. Checking them using input.hasOwnProperty(key) would throw a TypeError, causing the application to crash. The indirect call avoids this issue, ensuring safety across all object types.\n\nAdditionally, supplementary hardening was introduced in PR #806. All internal maps, binding contexts, and regex lookup tables were refactored to use prototype-less objects created with Object.create(null). The maintainers also replaced for...in loops, which naturally traverse prototype properties, with direct Object.keys() iterations. Finally, they blacklisted internal variable prefixes like _jsonata_ to prevent injection vectors.

Exploitation Methodology

Exploitation is achieved by constructing a specific JSONata query that traverses the prototype chain to execute system commands. The sequence uses JavaScript's capability to override or access setters and getters on standard objects.\n\nFirst, the attacker executes __lookupSetter__('__proto__')(constructor) inside the query. This retrieves a reference to the global Function constructor from the prototype chain. Next, the attacker invokes this constructor to compile a dynamic shell payload. The payload retrieves the Node.js child_process module to run commands:\n\njavascript\nconstructor(\"return process.getBuiltinModule('child_process').execSync('id').toString()\")\n\n\nThe compiled payload is then bound as a getter named 'l' on the prototype of standard objects using __defineGetter__('l', ...). Finally, evaluating valueOf().l triggers the getter. This executes the system command within the context of the host process, returning the command output directly to the attacker.\n\nThis attack is highly operationalizable because it requires no specialized local environment variables, user authentication, or specific target configurations. The only prerequisite is that the host application must evaluate user-controlled JSONata expressions using standard runtime contexts. The execution flow can be visualized using the following flow chart:\n\nmermaid\ngraph LR\n A[\"Malicious JSONata Expression\"] --> B[\"Evaluate Expression\"]\n B --> C[\"Call __lookupSetter__('__proto__')(constructor)\"]\n C --> D[\"Access Global Function Constructor\"]\n D --> E[\"Bind Custom Getter 'l' with child_process Payload\"]\n E --> F[\"Trigger valueOf().l\"]\n F --> G[\"Execute Shell Command via host Node.js process\"]\n

Impact Assessment

The potential impact of CVE-2026-77413 is high. Because the JSONata evaluation runs directly within the Node.js runtime process, a successful escape gives the attacker full control of the hosting application. The attacker can execute arbitrary operating system commands, read sensitive system files, access environment variables, or establish persistent backdoors.\n\nThis vulnerability has been assigned a CVSS v4.0 Base Score of 9.3 (Critical). The CVSS vector is CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N. This score reflects that no prior authentication, user interaction, or specialized network conditions are required to trigger execution.\n\nFurthermore, the blast radius is extended because JSONata is commonly deployed in low-code integration platforms, database transformation pipelines, and API gateways. In these environments, applications often evaluate expressions supplied by end-users or third-party webhooks. A compromise in these locations can lead to lateral movement, data exfiltration, or access to cloud metadata services.

Mitigation and Remediation

The primary remediation strategy is upgrading the JSONata library to a secure version. For systems on the v1.x release branch, administrators must upgrade to version 1.8.8 or higher. For systems on the v2.x release branch, administrators must upgrade to version 2.2.0 or higher.\n\nIn addition to upgrading, developers should implement execution guardrails introduced in version 2.2.0. These guardrails restrict runtime resources, helping prevent denial-of-service vectors like exponential backtracking or infinite loops. Below is an example of configuring these safety options:\n\njavascript\nimport jsonata from 'jsonata';\n\nconst options = {\n stack: 500, // Recursion limit\n timeout: 1000, // 1-second timeout\n sequence: 10000 // Intermediate allocation limit\n};\n\nconst expression = jsonata(userInput, options);\nconst result = await expression.evaluate(data);\n\n\nIf immediate patching is not possible, applications should block any JSONata expressions containing keywords linked to prototype access. These keywords include __proto__, constructor, prototype, __lookupSetter__, and __defineGetter__. However, keyword blocking is prone to bypasses and should only be used as a temporary workaround until the package is updated.

Official Patches

JSONata GitHubV2 Release Branch Fix Commit (PR #794)
JSONata GitHubV1 Backport Patch Commit (PR #815)

Technical Appendix

CVSS Score
9.3/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Affected Systems

jsonata npm packageNode.js applications evaluating untrusted JSONata queries
AttributeDetail
CWE IDCWE-94
Attack VectorNetwork
CVSS Score9.3 (Critical)
EPSS ScoreN/A
ImpactUnauthenticated Remote Code Execution
Exploit StatusProof of Concept (PoC) documented
KEV StatusNot Listed
CWE-94
Improper Control of Generation of Code ('Code Injection')

The software constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes the input before it is executed.

Known Exploits & Detection

GitHub AdvisoryProof of concept showing how standard prototype properties can retrieve the global Function constructor to run arbitrary commands via process.getBuiltinModule.

Vulnerability Timeline

OIDC-based package publishing and initial commits integrated.
2026-05-14
Systematic environment hardening merged (PR #806 / Commit f09df8416eab8ff44926fc6527c80fb8701de159).
2026-07-15
JSONata versions 1.8.8 and 2.2.0 released.
2026-07-16
GitHub Advisory published and CVE-2026-77413 registered.
2026-08-21

References & Sources

  • [1]GHSA-8gq3-vp5j-2grp
  • [2]NVD Detail - CVE-2026-77413
  • [3]CVE.org - CVE-2026-77413
  • [4]JSONata v1.8.8 Release Notes
  • [5]JSONata v2.2.0 Release Notes

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•28 minutes ago•CVE-2026-122244
7.7

CVE-2026-122244: Stored Cross-Site Scripting in Budibase Builder Formula Evaluation

CVE-2026-122244 (GHSA-r2q3-7m4h-63qg) is a high-severity cross-privilege Stored Cross-Site Scripting (XSS) vulnerability in Budibase prior to version 3.50.0. The flaw occurs due to defective character escaping in the JSON formatter utility combined with raw HTML rendering via Svelte's {@html} directive in the Budibase Builder interface. A low-privileged application user or an unauthenticated form visitor can store malicious HTML markup in a shared datasource, which subsequently executes arbitrary JavaScript in the browser session of an administrator or application builder inspecting Handlebars formula bindings.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 1 hour ago•CVE-2026-122247
8.2

CVE-2026-122247: Unauthenticated Global-Admin and Database Creation via Tenant-Confusion Bypass in Budibase

A tenant-confusion vulnerability in the user initialization endpoint of the Budibase worker service (prior to version 3.50.0) allows unauthenticated remote attackers to bypass the one-time administrative setup guard. By supplying arbitrary tenant identifiers in POST requests to /api/global/users/init, an attacker can force the underlying CouchDB datastore to dynamically provision unlimited tenant databases and persist latent global administrator accounts. This results in datastore resource exhaustion, denial of service, and unauthorized administrative account creation inside non-default tenant contexts.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 3 hours ago•CVE-2026-103026
8.1

CVE-2026-103026: Arbitrary Method Invocation and State Tampering in Paymenter via Livewire HasConfirmation Trait

Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.

Alon Barad
Alon Barad
3 views•9 min read
•about 4 hours ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 5 hours ago•CVE-2026-69133
5.3

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Amit Schendel
Amit Schendel
3 views•8 min read
•about 5 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
3 views•9 min read