Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSubmit crafted JSONata expression
-
Deliverylookup resolves inherited prototype members
-
ExploitReach constructor and process.getBuiltinModule
-
ExecutionInvoke child_process.execSync
-
ImpactExecute OS commands as host process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the target application evaluate an attacker-controlled JSONata expression string via jsonata(...).evaluate() on a vulnerable version (<= 1.8.7 or 2.0.0-2.1.x) running under Node.js with process.getBuiltinModule/child_process available. The exact trigger is a crafted expression chaining inherited prototype members (__lookupSetter__('__proto__'), __defineGetter__, constructor, valueOf) to reach child_process - as shown in the advisory PoC. What limits exploitation: the attacker must control the expression itself (not merely the JSON data being queried), so deployments that use only static, developer-authored expressions are not remotely exploitable by outside users; it also requires a Node.js runtime (not a hardened/sandboxed JS environment lacking process/child_process) and a pre-2.2.0/1.8.8 version. |
| Impact | The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H, 9.3) reflects the worst case: full compromise with no privileges or interaction. The decisive real-world variable, however, is whether the deploying application feeds attacker-controlled input into jsonata() as an expression. JSONata expressions are usually authored by developers and treated as trusted code; the CVSS PR:N/AV:N rating implicitly assumes the application exposes expression authoring to untrusted users (e.g., user-defined transforms, rules, or mappings). Where expressions are static and developer-supplied, practical exploitability drops sharply toward local/authenticated. No EPSS score, KEV listing, or SSVC decision data was provided; there is no indication of active exploitation, so this is not confirmed in-the-wild. A working PoC in the advisory raises the likelihood of opportunistic use against apps that do accept user expressions. Net: treat as a high-priority patch for any product that evaluates user-supplied JSONata, and as lower urgency where expressions are fixed and trusted - verify your usage model before ranking. |
| Exploit ScenarioDerived | An application lets users submit JSONata expressions to transform their JSON (a common iPaaS/rules-engine pattern) and evaluates them with a vulnerable jsonata version. An attacker submits the advisory PoC expression using __lookupSetter__/__defineGetter__ and constructor to reach process.getBuiltinModule('child_process').execSync('sh'), gaining command execution as the Node service account. A public PoC exists in the GHSA advisory, and with AV:N/AC:L this requires only the ability to supply the expression string. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 21, 2026
Arbitrary code execution in JSONata (npm 'jsonata') versions up to 1.8.7 and 2.0.0-2.1.x allows an attacker who controls a JSONata expression to break out of the query engine and run OS commands via Node's child_process. The flaw stems from the lookup function reaching inherited prototype members (setters/getters, constructor, valueOf) to obtain process.getBuiltinModule and call execSync, executing code with the host process's privileges. Publicly available exploit code exists in the GHSA advisory, and CVSS 4.0 rates it 9.3 (Critical); there is no evidence of active exploitation.
RemediationAI
Vendor-released patch: upgrade to jsonata 2.2.0 (2.x line) or 1.8.8 (1.x backport). Update the dependency directly and via transitive lockfiles (npm audit / package-lock.json, yarn.lock) since jsonata is frequently pulled in indirectly. Details and fix are in PR #794 (commit 4b217d514376e30cba278941298d7ba97c4a6c6e) and the advisory GHSA-8gq3-vp5j-2grp. If you cannot upgrade immediately, the effective compensating control is to never pass untrusted or user-supplied strings into jsonata() as an expression - restrict expression authoring to trusted developers/config, or validate/allowlist expressions before evaluation; note this trades off any feature that lets end users define their own transforms. Running the Node process with least privilege and OS-level command-execution restrictions (e.g., seccomp/AppArmor limiting child_process spawning) reduces blast radius but does not close the vulnerability. Patching remains the only complete fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
JSONata is a widely used JavaScript library for querying and transforming JSON, embedded in Node.js services, low-code/iPaaS platforms, and data-mapping tools. The root cause is CWE-94 (Code Injection): in src/functions.js the lookup function tested only that the target was a non-function object, without an Object.prototype.hasOwnProperty.call guard, so property lookups resolved against the prototype chain rather than own properties. This let crafted expressions traverse inherited members - __lookupSetter__, __defineGetter__, constructor, and valueOf - to reach the Function constructor and Node's process.getBuiltinModule('child_process'), from which execSync runs arbitrary shell commands. The affected package is cpe:2.3:a:jsonata-js:jsonata. The fix (PR #794) adds the missing hasOwnProperty check and removes the older, incomplete D1010 prototype-access error path in favor of returning undefined for prototype members.
Know when Jsonata gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
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
Attacker who supplies an expression (PR:N in exposed apps) achieves RCE with low complexity and full C/I/A on the host process; scope unchanged as code runs as the same process.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
JSONata is a JSON query and transformation language. Prior to 1.8.8 and 2.2.0, the src/functions.js lookup function lacked an Object.prototype.hasOwnProperty check and allowed crafted expressions to access inherited prototype members. An attacker able to supply an expression could use inherited prototype setters and getters, constructor access, valueOf, and process.getBuiltinModule to reach the child_process module and execute arbitrary code with the privileges of the host process. This issue is fixed in versions 1.8.8 and 2.2.0.
Blast Radius
ecosystem impact- 1 npm packages depend on jsonata (1 direct, 0 indirect)
Ecosystem-wide dependent count for version 2.0.0.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
JSONata (npm package), used in Node.js applications for data transformation, contains a critical arbitrary code execution vulnerability (CVE-2026-77413, CVSS 9.3) affecting versions up to 1.8.7 and 2.0.0-2.1.x. Organizations using JSONata to process untrusted expressions face risk of complete system compromise and unauthorized data access. Publicly available exploit code exists, though no evidence of active exploitation has been reported to date.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Arbitrary code execution in the JSONata JavaScript library (npm 'jsonata') before 1.8.8 and 2.2.1 lets an attacker who c
Arbitrary code execution in the JSONata JSON query/transformation library (npm 'jsonata') lets an attacker who controls
JSONata is a JSON query and transformation language. Rated critical severity (CVSS 9.8), this vulnerability is remotely
Prototype pollution in jsonata-js (all versions up to 2.2.0) allows remote unauthenticated attackers to inject arbitrary
EUVD-2026-64155
GHSA-8gq3-vp5j-2grp
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB