Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach app endpoint accepting JSONata expression
-
DeliverySubmit crafted expression with $hasOwnProperty/$constructor bindings
-
ExploitBypass hasOwnProperty check in environment.lookup
-
ExecutionTraverse prototype to process.getBuiltinModule
-
PersistexecSync child_process shell command
-
ImpactArbitrary code execution 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 a JSONata expression that the attacker can control or influence (e.g., jsonata(userInput).evaluate(...)), running on a JavaScript engine with access to process.getBuiltinModule/child_process - i.e., a Node.js host, not a locked-down browser sandbox lacking those built-ins. No authentication is required at the JSONata layer itself (CVSS PR:N), and no special JSONata configuration flag must be enabled - the vulnerable lookup path exists in default behavior of affected versions (< 1.8.8 and 2.0.0-2.2.0). The principal limiting factor is architectural: if the application only ever runs static, developer-authored expressions with no attacker input reaching the expression string, the vulnerability is not remotely reachable. Platform limiter: the child_process RCE payload depends on a Node.js/server-side runtime; environments without those built-in modules cannot reach the demonstrated command-execution impact. |
| Impact | This is a genuine high-priority issue, not a high-CVSS-but-low-real-risk case, wherever the affected application evaluates JSONata expressions that originate even partly from untrusted input. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H, base 9.3) reflects full confidentiality, integrity, and availability compromise of the host process, and a concrete published PoC demonstrates reliable exploitation with low complexity, so the practical barrier is low once expression input is reachable. The decisive real-world variable is architectural rather than technical: risk is critical for services that let users supply or influence JSONata expressions (multi-tenant transformation/integration platforms, low-code rule engines, API gateways), and negligible for deployments that only ever run static, developer-authored expressions. EPSS was not provided and there is no CISA KEV entry, so there is currently no evidence of mass active exploitation; because a public exploit exists, any operator that exposes attacker-controllable expressions should treat patching as urgent regardless of the missing EPSS signal, while operators using only trusted static expressions can schedule the upgrade with normal change management. |
| Exploit ScenarioDerived | An application exposes a feature letting users define JSONata expressions to transform JSON (for example a mapping rule, webhook filter, or report template). An attacker submits a crafted expression that reassigns $hasOwnProperty and $constructor to climb the prototype chain and calls process.getBuiltinModule('child_process').execSync('sh'), running arbitrary commands as the service user; a public PoC in the vendor advisory makes this straightforward to reproduce given AV:N/AC:L. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 21, 2026
Arbitrary code execution in the JSONata JSON query/transformation library (npm 'jsonata') lets an attacker who controls a JSONata expression break out of the evaluation context and run OS commands with the host process's privileges. The flaw stems from a bypassable hasOwnProperty check in environment.lookup that permits prototype-chain traversal to reach process.getBuiltinModule('child_process'). A working proof-of-concept is published in the vendor GHSA advisory, and vendor patches (1.8.8 and 2.2.1) are available; no CISA KEV listing has been identified.
RemediationAI
Upgrade the jsonata dependency to a fixed release: 2.2.1 for the 2.x line or 1.8.8 for the 1.x line (Vendor-released patch: 1.8.8 and 2.2.1), per https://github.com/jsonata-js/jsonata/security/advisories/GHSA-2943-5xfg-gq5f, with the code change in https://github.com/jsonata-js/jsonata/pull/799 and commit 59e25144fc3b7125f6befd71b8a6e14e1fa610d2. Audit lockfiles for transitive pulls of jsonata and rebuild/redeploy so the patched version is actually shipped, not just declared. If an immediate upgrade is impossible, the primary compensating control is to stop evaluating untrusted or user-influenced JSONata expressions: restrict expression sources to vetted, developer-authored templates and reject or strongly validate any externally supplied expression before evaluation (the trade-off is loss of dynamic/user-defined transformation functionality). Where JSONata runs server-side, also reduce blast radius by running the evaluation process under least privilege and, if feasible, in a hardened sandbox or container without a usable child_process/shell path, accepting the operational overhead that isolation adds.
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 embedded JavaScript library used server-side (Node.js) and in integration/automation tooling to query and transform JSON, similar in spirit to XPath for XML. The vulnerability is a CWE-94 code injection: the engine's variable-lookup routine (environment.lookup in src/jsonata.js, lines ~1863-1871) used an object's own hasOwnProperty method, which attacker-controlled expressions could shadow/override via $hasOwnProperty, $spread, $string, and $constructor bindings. By reassigning these and walking __proto__/constructor, an expression escapes the intended value-lookup boundary into the JavaScript object prototype, ultimately invoking process.getBuiltinModule('child_process').execSync to spawn a shell. The fix (PR #799) systematically replaces plain object literals with Object.create(null) and switches to Object.prototype.hasOwnProperty.call / Object.keys iteration to eliminate the prototype-pollution/lookup bypass surface. Affected CPE is cpe:2.3:a:jsonata-js:jsonata.
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
Network-reachable expression evaluation with low complexity and no auth at the JSONata layer (PR:N); full host-process compromise gives C:H/I:H/A:H, S:U as impact stays within the host process authority.
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.1, the src/jsonata.js environment.lookup function used a bypassable hasOwnProperty check. Crafted expressions could use $hasOwnProperty, $spread, $string, prototype access, and $constructor to reach the object prototype and invoke process.getBuiltinModule with child_process, executing arbitrary code with the privileges of the host process. This issue is fixed in versions 1.8.8 and 2.2.1.
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, a widely-used JSON transformation library, contains a critical vulnerability enabling attackers to execute arbitrary commands on systems running affected versions. Any application processing JSONata expressions-particularly those accepting user-supplied or external expressions-faces immediate risk of complete system compromise and unauthorized access to sensitive data.
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 JSONata (npm 'jsonata') versions up to 1.8.7 and 2.0.0-2.1.x allows 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-64083
GHSA-2943-5xfg-gq5f
NVD
CVE.org
EPSS
Exploit-DB