Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify JSON endpoint on Scala/JVM service
-
DeliveryCraft deeply nested JSON array/object
-
ExploitSubmit unauthenticated request
-
ExecutionParser contexts grow without depth limit
-
PersistJVM heap exhausted, uncatchable OutOfMemoryError
-
ImpactService process crashes (denial of service)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource allocation limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | No special conditions beyond the target application actually parsing attacker-controlled JSON with Jawn's parse methods (versions prior to 1.7.0), either directly or transitively via circe - unauthenticated remote exploitation against default configurations, since versions before 1.7.0 shipped no depth limit at all. What limits exploitation: the attacker must reach an endpoint that feeds untrusted input to a Jawn parse call; services that only parse trusted/internal JSON are not exposed. On 1.7.0+, the new configurable jawn.parser.maxDepth (default 4096) caps nesting, so the condition is specifically running a pre-1.7.0 version. |
| Impact | This is a genuine but middle-tier priority. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) is internally consistent with the description: any network-reachable endpoint that parses untrusted JSON with Jawn can be crashed by unauthenticated attackers sending deeply nested arrays/objects, with no user interaction and low complexity. The impact is availability-only (C:N/I:N) - this cannot leak data or corrupt state, only crash the JVM via an OutOfMemoryError that, per the description, is a fatal Scala error not caught by scala.util.Try or cats.effect.IO, so normal error-handling wrappers do not contain it. Weighing all signals: no EPSS score, no CISA KEV listing, and no public exploit code are provided, so despite the 7.5 'High' rating there is no evidence of real-world or widespread exploitation; the danger is amplified by the fact that Jawn underpins circe (a very common Scala JSON library), so the flaw can be present transitively in services that never chose Jawn directly. Net: a real, easy-to-trigger DoS worth patching promptly on any internet-facing Scala/JVM service, but not an emergency in the absence of KEV/POC signals and given availability-only impact. |
| Exploit ScenarioDerived | An attacker sends an HTTP request whose body is a JSON payload with tens of thousands of nested opening brackets (e.g. '[[[[...') to any endpoint of a Scala/JVM service that parses request bodies with Jawn (directly or via circe). Jawn grows a parser context per nesting level with no depth cap until the JVM heap is exhausted, throwing an uncatchable OutOfMemoryError that the application's Try/IO wrappers do not handle, crashing the process. No public exploit code is identified, but the payload is trivial to construct and requires no authentication. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 23, 2026
Deeply nested JSON arrays and objects drive JVM heap exhaustion in Typelevel Jawn versions before 1.7.0, where the thrown java.lang.OutOfMemoryError is a fatal Scala/JVM error that neither scala.util.Try nor cats.effect.IO routinely intercepts, turning untrusted JSON into a denial-of-service condition. The assessed impact is availability-only (CVSS:3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so remote unauthenticated attackers need only reach an endpoint that feeds attacker-controlled input into a pre-1.7.0 Jawn parse call, directly or transitively through circe; services that only parse trusted or internal JSON are not exposed. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but this is a genuine, middle-tier priority for any internet-facing JSON API on an affected version; fixed in 1.7.0, which introduces a configurable depth cap.
RemediationAI
Upgrade to Typelevel Jawn 1.7.0 or later (release: https://github.com/typelevel/jawn/releases/tag/v1.7.0), which is the vendor-released fix that adds a nesting-depth cap; the change is carried in commits https://github.com/typelevel/jawn/commit/191cb3a44e77f1afab439ee636bf66bdf3c54a04, https://github.com/typelevel/jawn/commit/6219666641f9408498f85868f835e17bd8a72fed, https://github.com/typelevel/jawn/commit/93ac93e9c992c11b4c03d5455d8551f9fb24da1b and https://github.com/typelevel/jawn/commit/f6ace7e0db715de1a8c4618bed9378333a5c2214, and the advisory is at https://github.com/typelevel/jawn/security/advisories/GHSA-cc4v-rvgp-2pf3. On 1.7.0+ the default limit is 4096 levels and can be tightened or raised with the JVM system property -Djawn.parser.maxDepth=N; lowering it reduces DoS headroom at the cost of rejecting legitimately deep documents, so set it above your deepest expected payload. If an upgrade cannot be shipped promptly, enforce a maximum request body size and a nesting-depth limit before input reaches Jawn - at the reverse proxy, API gateway or WAF, or in a small pre-scan that is itself depth-bounded and strict about token handling - accepting the trade-off that oversized or deep-but-valid payloads will be rejected and that the pre-scan adds parsing cost. Because OutOfMemoryError is a fatal VirtualMachineError, wrapping Jawn parse calls in scala.util.Try or cats.effect.IO does not mitigate this issue, so exception handling and circuit breakers alone are not sufficient controls; additionally consider parsing untrusted JSON in a separate, heap-capped JVM or worker that can be recycled on failure, understanding that this degrades availability and throughput for legitimate traffic rather than eliminating the underlying lack of a depth limit.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 4 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Jawn is a Scala JSON parser used directly and as the parsing backend for libraries such as circe, so exposure is often transitive rather than an explicit dependency. The root cause is CWE-770 (Allocation of Resources Without Limits or Throttling): the recursive-descent parse methods track parser context per opened array or object but prior to 1.7.0 imposed no maximum nesting depth, so a crafted document with deeply nested '[' and '{' tokens grows the parser context stack and associated allocations until the JVM heap is exhausted. The failure mode is significant because java.lang.OutOfMemoryError is a VirtualMachineError, a fatal error rather than a normal exception, which is why ordinary Scala error-handling idioms (scala.util.Try, cats.effect.IO) generally do not catch it and the application loses the request, the thread, or the process. The upstream fix adds a depth counter with a configurable bound: the commit diff replaces the constant 'final val DefaultMaxDepth = 4096' with 'val DefaultMaxDepth: Int = Try(System.getProperty("jawn.parser.maxDepth").toInt).getOrElse(4096)', making the limit overridable via the jawn.parser.maxDepth system property while defaulting to 4096 levels of nesting. The CPE entry cpe:2.3:a:typelevel:jawn:*:*:*:*:*:*:*:* uses wildcard versioning, so version-based resolution must exclude 1.7.0 and later to avoid flagging patched releases.
Know when Jawn 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Unauthenticated remote attacker submits crafted JSON with no user interaction; impact is availability-only process crash via heap exhaustion, no confidentiality or integrity effect.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Jawn is an open source JSON parser. Prior to 1.7.0, Jawn parse methods accept arbitrarily deep JSON array and object nesting without a depth limit, allowing a remote attacker who can submit untrusted JSON to grow parser contexts until the JVM heap is exhausted. The resulting java.lang.OutOfMemoryError is a fatal Scala error that is not ordinarily handled by scala.util.Try or cats.effect.IO, causing denial of service. This issue is fixed in version 1.7.0.
Blast Radius
ecosystem impact- 88 maven packages depend on org.typelevel:jawn-parser_2.12 (10 direct, 78 indirect)
- 140 maven packages depend on org.typelevel:jawn-parser_2.13 (8 direct, 132 indirect)
- 225 maven packages depend on org.typelevel:jawn-parser_3 (9 direct, 216 indirect)
Ecosystem-wide dependent count for version 1.7.0 and other introduced versions.
Technical POC Analysis
CWE-770 (Allocation of Resources Without Limits or Throttling).
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A heap-exhaustion denial-of-service flaw in Typelevel Jawn (versions before 1.7.0) - the JSON parser used directly or via circe by many Scala/JVM services - allows an unauthenticated remote client to crash any internet-facing JSON API that parses attacker-controlled input, simply by sending deeply nested payloads. The resulting java.lang.OutOfMemoryError is a fatal JVM error that standard error handling (scala.util.Try, cats.effect.IO) does not intercept, so affected services terminate or enter restart loops rather than degrading gracefully. This is a service-continuity and availability risk for customer-facing endpoints, not a data-breach risk; no public exploit code and no CISA KEV listing were identified at time of analysis, but exposure is broad because the library is commonly pulled in transitively.
Upgrading to Typelevel Jawn 1.7.0 (with its configurable depth cap) is the definitive fix; until that upgrade is completed, interim mitigations include strict request body size limits and JSON nesting-depth enforcement at the WAF, API gateway, or reverse proxy; pre-screening or rejecting deeply nested payloads in application code before the parse call; isolating parse-heavy endpoints with bounded thread pools, explicit JVM heap limits, and automatic restart supervision; and disabling or gating internet-facing endpoints that parse untrusted JSON on affected pre-1.7.0 versions.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Privilege escalation in the Jawn WordPress theme (by MvpThemes) affects all versions through 1.4.2, allowing an unauthen
Privilege escalation in the Jawn WordPress theme (versions ≤ 1.4.2, by mvpthemes) allows a remote, unauthenticated attac
Denial of service in the Jawn JSON parser for Scala (all artifacts prior to 1.7.0) lets a remote, unauthenticated attack
Same technique Denial Of Service
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| SUSE Linux Enterprise Module for Package Hub 15 SP7 | Affected |
| SUSE Linux Enterprise Module for Package Hub 15 SP6 | Affected |
| openSUSE Leap 15.3 | Affected |
| openSUSE Leap 15.4 | Affected |
| openSUSE Leap 15.5 | Affected |
| openSUSE Leap 15.6 | Affected |
EUVD-2026-85554
GHSA-cc4v-rvgp-2pf3
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB