Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend request with giant JSON property name
-
DeliveryParsed via Reader/String/char[] path
-
ExploitFull name buffered to ~200MB unchecked
-
ExecutionRepeat concurrently to exhaust heap
-
ImpactProcess OOM crash / denial of service
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 | The application must parse untrusted JSON from a character-based source - java.lang.String, java.io.Reader, or char[] - which routes through ReaderBasedJsonParser (e.g. an HTTP request body already read into a String). Exploitation is NOT possible when parsing raw UTF-8 bytes via UTF8StreamJsonParser, UTF8DataInputJsonParser, or the non-blocking async parsers, which re-validate maxNameLength on every name-buffer growth. It works against default configuration because StreamReadConstraints.maxDocumentLength is disabled by default (-1), so no other limit bounds the oversized token first. Affected versions are com.fasterxml.jackson.core:jackson-core 2.16.0 onward and tools.jackson.core:jackson-core 3.0.0 onward; releases before 2.16.0 are unaffected because maxNameLength did not yet exist. The primary limiting factor is the character-input requirement - the single most important condition for defenders to check in their deployment. |
| Impact | All signals point to a genuine but bounded availability risk. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) is internally consistent with the description: a remote, unauthenticated, low-complexity attack with pure availability impact (CWE-400 resource exhaustion). No EPSS score, KEV listing, or SSVC decision data was provided, and no public exploit was identified at time of analysis - so exploitation is currently theoretical/not-yet-observed rather than active. This is not a high-CVSS-but-trivial issue: the memory-amplification (promised ~100 KB name bound vs. actual ~200 MB allocation, roughly 2000x) is real and crash-capable under concurrency. However, the realistic footprint is narrower than raw AV:N/PR:N suggests, because exploitation only works when the application feeds untrusted JSON through character-based input (String/Reader/char[] via ReaderBasedJsonParser); byte-input parsers (UTF8StreamJsonParser, UTF8DataInputJsonParser, async) are explicitly unaffected. This is a deployment-dependent limiter not captured by the CVSS vector, so treat raw 7.5 as an upper bound. Patch availability is confirmed via the vendor GHSA advisory and merged PR #1643, which materially lowers priority for anyone able to upgrade. |
| Exploit ScenarioDerived | An attacker sends an HTTP request whose body is read into a Java String and then parsed by a jackson-core 2.16.0+ (or 3.0.0+) application using the character-input path, containing a single JSON object property name of up to ~100,000,000 characters. Because the per-name maxNameLength bound is not applied incrementally on this path, the parser buffers the entire name (~200 MB+) before throwing, and repeating this across concurrent requests exhausts the heap and crashes the process. No public exploit code was identified, but the conditions are simple and require no authentication or user interaction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 16, 2026
Heap exhaustion denial of service in FasterXML jackson-core 2.16.0 and later allows an unauthenticated remote attacker to force allocation of roughly 100 MB or more per oversized JSON property name whenever untrusted JSON is parsed from a character-based source (String, Reader, or char[]), which is the normal path for a request body already read into a String. Because the maxNameLength bound (default 50,000 characters, ~100 KB) is only validated after the entire name has been buffered, the much larger maxStringLength bound (default 100,000,000 characters, roughly 200 MB with segment bookkeeping overhead) governs first, and repeating this across concurrent requests can exhaust the heap and crash the process. The impact is availability-only (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/C:N/I:N/A:H); no public exploit code or confirmed active exploitation was identified at time of analysis, and a vendor patch is available.
RemediationAI
Apply the vendor fix. For the 2.x line, upgrade com.fasterxml.jackson.core:jackson-core to the patched release identified in the upstream release notes and CREDITS-2.x for issue #1643, version 2.18.10, or a later 2.18.x/2.x release that contains it; the fix was merged via PR #1643 (https://github.com/FasterXML/jackson-core/pull/1643) and commit 2cd206de1163e3fcff7bdaca425274f00668b075. For the 3.x line, the same change is mirrored through that PR/commit, but the exact released 3.x version is not specified in the provided data, so verify the current 3.x release notes (https://github.com/FasterXML/jackson-core/blob/3.x/release-notes/VERSION) before certifying patched status. If immediate upgrade is impossible, the highest-value workaround is to stop feeding character input: change call sites to parse raw UTF-8 bytes from an InputStream or byte[] instead of a String or Reader, which routes through UTF8StreamJsonParser and enforces maxNameLength incrementally - this requires application plumbing changes and does not help where the body must be a String. A second option is to explicitly configure StreamReadConstraints with a finite maxDocumentLength (default is -1/disabled) so nothing else bounds the oversized token; trade-off is that legitimate large documents will be rejected. A third is to lower maxStringLength substantially so TextBuffer.finishCurrentSegment() rejects sooner; trade-off is that legitimate large string values will fail to parse, and the check still fires only after a segment has been buffered. Do not rely on maxNameLength as a mitigation, since it is enforced only after full buffering. Enforce HTTP request-body size limits at the reverse proxy, framework, or servlet-container layer as defense in depth, understanding those limits are per-request and do not prevent multiple concurrent in-flight allocations within the allowed size.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-400 (uncontrolled resource consumption) in the character-input parsing path of the Jackson JSON library. StreamReadConstraints.maxNameLength was introduced in jackson-core 2.16.0 with a default of 50,000 characters specifically to bound the memory a single JSON Object property name can consume, independently of maxStringLength (default 100,000,000 characters) which bounds ordinary string values - a roughly 2000x difference. In ReaderBasedJsonParser._parseName2() (and the non-standard, "odd" unquoted-name path _handleOddName2()), the parser accumulates the name into a TextBuffer and, when a segment fills, calls TextBuffer.finishCurrentSegment(), which enforces only maxStringLength. The correct check, StreamReadConstraints.validateNameLength(int), is not reached until CharsToNameCanonicalizer.findSymbol() runs - after the whole name has already been scanned to its closing quote and buffered in memory. Byte-oriented parsers (UTF8StreamJsonParser, UTF8DataInputJsonParser) and the non-blocking/async parsers are not affected because ParserBase._growNameDecodeBuffer() re-validates maxNameLength on every growth of the name-decode buffer, rejecting an oversized name after only tens of kilobytes. The issue is exploitable under default configuration because StreamReadConstraints.maxDocumentLength is disabled by default (-1), so no other limit bounds the oversized token first. The upstream fix (PR #1643, commit 2cd206de) tracks total accumulated length in _parseName2() and _handleOddName2() and calls validateNameLength() on each segment fill, keeping the per-character loop tight.
Know when Jackson Core 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
Remote unauthenticated single crafted request causes heap exhaustion with availability-only impact; char-input requirement is a deployment property, not per-attempt complexity, so AC:L, PR:N, C:N, I:N, A:H.
Primary rating from Vendor (HeroDevs).
CVSS VectorVendor: HeroDevs
DescriptionCVE.org
StreamReadConstraints.maxNameLength (default 50,000 characters) is intended to bound how much memory a single JSON Object property name can consume while being parsed, independently of the much larger maxStringLength (default 100,000,000 characters) that bounds ordinary string values. For parsers built over character input - Reader, String or char[] sources, all served by ReaderBasedJsonParser - that bound is not applied while the name is being accumulated. The code path instead re-uses the string-value length check, which is roughly 2000x larger by default.
In the character-input slow path, ReaderBasedJsonParser._parseName2() accumulates the name into the TextBuffer and, when a segment fills, calls TextBuffer.finishCurrentSegment(), which validates only maxStringLength. The correct check, StreamReadConstraints.validateNameLength(int), is reached afterwards in CharsToNameCanonicalizer.findSymbol(), once the entire name has been scanned to its closing quote. By that point the full name - up to maxStringLength characters - has already been buffered in memory.
A remote attacker who can have a single sufficiently long JSON Object property name parsed through this path can force allocation on the order of 100,000,000 characters (approximately 200 MB, with segment bookkeeping pushing real peak usage higher) before any StreamConstraintsException is thrown, instead of the approximately 50,000-character (about 100 KB) bound the API promises. Repeating this across concurrent requests can exhaust the heap and crash the process. No authentication or user interaction is required. Because StreamReadConstraints.maxDocumentLength is disabled by default (-1), nothing else bounds the token first, so the issue is exploitable under default configuration.
Byte-input parsers are not affected: UTF8StreamJsonParser, UTF8DataInputJsonParser and the non-blocking (async) parsers re-validate maxNameLength on every growth of the name-decode buffer via ParserBase._growNameDecodeBuffer(), rejecting an oversized name after allocating only tens of kilobytes. Applications are exposed when untrusted JSON is parsed from a String, Reader or char[] - for example an HTTP request body already read into a String - rather than from raw UTF-8 bytes.
This issue affects com.fasterxml.jackson.core:jackson-core from 2.16.0 and tools.jackson.core:jackson-core from 3.0.0. Releases before 2.16.0 are not affected, because StreamReadConstraints.maxNameLength was first introduced in jackson-core 2.16.0.
Technical POC Analysis
CWE-400, Uncontrolled Resource Consumption - a resource limit exists and is documented, but is applied on the wrong code path so it does not bound allocation at the point where allocation happens.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
A remotely reachable denial-of-service flaw in the widely embedded FasterXML jackson-core JSON library (2.16.0 and later) lets any unauthenticated client that can submit JSON to a service drive the process into heap exhaustion and crash it, taking the affected application offline. Because jackson-core sits inside most Java services and APIs, the exposure spans any internet- or partner-facing endpoint that parses untrusted request bodies, making this a broad service-availability risk rather than a data-confidentiality one. Leadership should care because the likely business outcome is unplanned downtime and degraded customer-facing transactions across multiple systems from a single unauthenticated request pattern, and a vendor fix is already available.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Jackson Core
View allDenial of service in FasterXML jackson-core's non-blocking (async) JSON parser allows unauthenticated network attackers
Memory exhaustion in jackson-core's non-blocking async parser allows remote unauthenticated attackers to exhaust JVM hea
Uncontrolled-recursion denial of service in FasterXML jackson-core 3.0.0 through 3.0.x lets a remote attacker crash JSON
Denial of service in FasterXML jackson-core 2.8.0 and later: an unauthenticated remote attacker who can supply a malform
EUVD-2026-103177
NVD
CVE.org
GitHub
Exploit-DB