Skip to main content

Typelevel Jawn CVE-2026-59990

| EUVDEUVD-2026-85554 HIGH
Allocation of Resources Without Limits or Throttling (CWE-770)
2026-09-23 GitHub_M GHSA-cc4v-rvgp-2pf3
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Identify JSON endpoint on Scala/JVM service
  2. Delivery
    Craft deeply nested JSON array/object
  3. Exploit
    Submit unauthenticated request
  4. Execution
    Parser contexts grow without depth limit
  5. Persist
    JVM heap exhausted, uncatchable OutOfMemoryError
  6. Impact
    Service 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.6% exploitation probability (EPSS)

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

Alert me

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

jawn < 1.7.0

Affected Packages

maven org.typelevel:jawn-parser_2.12 fix: 1.7.0
maven org.typelevel:jawn-parser_2.13 fix: 1.7.0
maven org.typelevel:jawn-parser_3 fix: 1.7.0
euvd jawn fix: 1.7.0

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

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Unauthenticated remote attacker submits crafted JSON with no user interaction; impact is availability-only process crash via heap exhaustion, no confidentiality or integrity effect.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Sep 23, 2026 - 20:03 EUVD
CVE Published
Sep 23, 2026 - 18:41 cve.org
HIGH 7.5

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.6%
Top 52% exploitable
Prevalence
Low
niche Scala/JVM JSON parser, but underpins circe so reach is amplified
Threat Intel
1
1 sources
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub VulDB

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 HIGH
CISA KEV No
Public POC No
EPSS 0.6%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor 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

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