Skip to main content

JSONata CVE-2026-77414

| EUVDEUVD-2026-64083 CRITICAL
Code Injection (CWE-94)
2026-08-21 GitHub_M GHSA-2943-5xfg-gq5f
9.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach app endpoint accepting JSONata expression
  2. Delivery
    Submit crafted expression with $hasOwnProperty/$constructor bindings
  3. Exploit
    Bypass hasOwnProperty check in environment.lookup
  4. Execution
    Traverse prototype to process.getBuiltinModule
  5. Persist
    execSync child_process shell command
  6. Impact
    Arbitrary 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
1 public PoC Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

jsonata 2.0.0, < 2.2.1
jsonata < 1.8.8

Affected Packages

npm jsonata fix: 1.8.8, 2.2.1

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

Vendor (GitHub_M) PRIMARY 9.3 CRITICAL
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
vuln.today AI 9.8 CRITICAL

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE HIGH
Red Hat 9.8 CRITICAL

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 21, 2026 - 21:02 EUVD
CVE Published
Aug 21, 2026 - 20:51 cve.org
CRITICAL 9.3

DescriptionCVE.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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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

Why It Matters

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.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 72% exploitable
Prevalence
Medium
popular Node.js JSON transformation library, common but not universal
Threat Intel
1
1 source
Social Media
4
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Out-of-Cycle
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
Very High

Priority Score

66
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

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.

Vendor StatusVendor

SUSE

Severity: Important

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy