Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconIdentify endpoint accepting arbitrary JSON
-
DeliveryCraft ~2kB payload with 1,000+ nested arrays
-
ExploitSubmit concurrent unauthenticated HTTP requests
-
InstallreadTree() builds deeply nested JsonNode tree
-
C2toString() triggers recursive per-level serialization
-
ExecuteStackOverflowError exhausts processing thread
-
ImpactService availability degraded under sustained load
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption 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 | Exploitation requires that the target application uses two specific Jackson API calls in sequence on attacker-controlled input: ObjectMapper.readTree() to parse the JSON into a JsonNode tree, and JsonNode.toString() to serialize that node back to a string. Both conditions must be present in the same code path; services that deserialize into POJOs, or that serialize via ObjectMapper.writeValueAsString(), are not affected. The deeply nested structure must reach thousands of nesting levels; typical JSON payloads at normal business depths do not trigger the issue. There is no authentication requirement per the CVSS PR:N metric, so any unauthenticated endpoint exercising this pattern is exposed. Limiting factors include: the specific readTree() + toString() pattern must exist in application code reachable from the attacker; Jackson 2.14.0 or the writeValueAsString() workaround fully eliminates the vulnerability without restricting input depth. |
| Impact | The CVSS 4.0 base score of 6.3 (Medium) reflects the conditional nature of the attack: the AT:P (Attack Requirements: Present) metric captures the prerequisite that the target service must use the specific readTree() + toString() code path. Network reachability and zero-authentication requirements (AV:N/PR:N) increase the exposure surface once a vulnerable endpoint is identified. Real-world risk is moderate - the vulnerable pattern is not the only way to use Jackson, but it is common in services that accept arbitrary JSON and pass it through JsonNode for logging, debugging, or downstream forwarding. The availability impact is constrained to the service threads processing the malicious request; sustained concurrent requests can however saturate thread pools. No EPSS data was provided in the input. No CISA KEV listing and no public exploit code is known at time of analysis, which significantly reduces urgency versus an actively exploited vulnerability. A version-range discrepancy exists between the CVE description (2.13.0 as lower bound) and the GHSA package metadata (>= 2.10.0); both ranges should be treated as potentially applicable until resolved with the vendor. |
| Exploit ScenarioDerived | An attacker identifies a REST endpoint that accepts arbitrary JSON, internally processes it with ObjectMapper.readTree(), and emits the result or logs it via JsonNode.toString(). The attacker submits concurrent HTTP requests each carrying a ~2kB payload of approximately 1,000 levels of nested arrays. Each request triggers a StackOverflowError in the processing thread; under sustained load, this exhausts the service thread pool and degrades or halts availability. No public exploit code exists at time of analysis, but the attack is straightforward to replicate given the detailed public description and the small payload size required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 23, 2026
Uncontrolled resource consumption in jackson-databind 2.10.0 through 2.13.5 allows unauthenticated remote attackers to cause a Denial-of-Service by submitting small (~2kB), deeply nested JSON payloads that trigger a StackOverflowError when a service reads the input via ObjectMapper.readTree() and serializes the resulting JsonNode using JsonNode.toString(). The root cause is recursive serialization in the toString() call path, which was replaced with an iterative IteratorStack-based implementation in version 2.14.0. No public exploit code has been identified at time of analysis, and active exploitation has not been confirmed by CISA KEV.
RemediationAI
Upgrade jackson-databind to version 2.14.0 or later, which replaces the recursive JsonNode serialization with an iterative implementation and fully resolves the vulnerability; this is confirmed by commit a1fa4ae4ecf5cee16da465985f135f3e81816f8c and the GHSA advisory at https://github.com/FasterXML/jackson-databind/security/advisories/GHSA-3wrr-7qpf-2prh. If an immediate upgrade is not feasible, the vendor-documented workaround is to replace all calls to JsonNode.toString() used for output with ObjectMapper.writeValueAsString(node), which uses a non-recursive serialization path and is therefore not vulnerable; this requires a targeted code change at every call site where toString() is used for producing JSON strings rather than for debugging. As an additional compensating control, deploying a JSON depth limit at the API gateway or framework layer - for example, configuring Jackson's StreamReadConstraints.maxNestingDepth() introduced in 2.15 - can reject excessively nested payloads before they reach the vulnerable path, with the trade-off that legitimate deeply-nested inputs would also be rejected.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 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
jackson-databind (Maven coordinate com.fasterxml.jackson.core:jackson-databind) is the data-binding and tree-model component of the FasterXML Jackson JSON library, one of the most widely used JSON processing libraries on the JVM. The vulnerability falls under CWE-400 (Uncontrolled Resource Consumption). The underlying mechanism is recursive call-stack growth during JsonNode serialization: when ObjectMapper.readTree() constructs a deeply nested JsonNode tree from JSON input, a subsequent call to JsonNode.toString() internally invokes recursive serialize() calls - one stack frame per nesting level. At roughly 1,000 levels of nesting (achievable with a 2kB payload), the JVM default thread stack is exhausted, triggering an unchecked java.lang.StackOverflowError. The fix (commit a1fa4ae4ecf5cee16da465985f135f3e81816f8c) replaces the recursive traversal in InternalNodeMapper with an iterative loop backed by a custom IteratorStack data structure, eliminating the stack-depth dependency entirely.
Know when Jackson Databind 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:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
AC:H reflects the required non-default code path (readTree plus toString); only availability is impacted via uncontrolled StackOverflowError under concurrent load.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
1DescriptionCVE.org
jackson-databind contains the general-purpose data-binding functionality and tree-model for Jackson Data Processor. From 2.13.0 until 2.14.0, a potential Denial-of-Service exists when attacker sends deeply nested JSON if (and only if) the service reads deeply nested (1000s of levels) JSON as JsonNode (ObjectMapper.readTree()) and writes out same (or modifided) node using JsonNode.toString(). This can consume significant amount of resources with concurrent relatively small requests (1000 nested arrays is 2kB). This vulnerability is fixed in 2.14.0.
Blast Radius
ecosystem impact- 7,613 maven packages depend on com.fasterxml.jackson.core:jackson-databind (2,139 direct, 5,569 indirect)
Ecosystem-wide dependent count for version 2.10.0.
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.
More in Jackson Databind
View allFasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.4 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
A Polymorphic Typing issue was discovered in FasterXML jackson-databind 2.x before 2.9.9. Rated high severity (CVSS 7.5)
FasterXML jackson-databind 2.0.0 through 2.9.10.2 lacks certain xbean-reflect/JNDI blocking, as demonstrated by org.apac
A flaw was found in FasterXML Jackson Databind, where it did not have entity expansion secured properly. Rated high seve
FasterXML jackson-databind 2.x before 2.9.9.1 might allow attackers to have a variety of impacts by leveraging failure t
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind before 2.7.9.3, 2.8.x before 2.8.11.1 and 2.9.x before 2.9.5 allows unauthenticated remote co
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
FasterXML jackson-databind 2.x before 2.9.10.8 mishandles the interaction between serialization gadgets and typing, rela
EUVD-2026-38597
GHSA-3wrr-7qpf-2prh
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB