Skip to main content

Jackson Core CVE-2026-68498

| EUVDEUVD-2026-103177 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-10-16 HeroDevs
7.5
CVSS 3.1 · Vendor: HeroDevs
View

Attack ChainAIDerived

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

  1. Access
    Send request with giant JSON property name
  2. Delivery
    Parsed via Reader/String/char[] path
  3. Exploit
    Full name buffered to ~200MB unchecked
  4. Execution
    Repeat concurrently to exhaust heap
  5. Impact
    Process 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

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

jackson-core 2.16.0 <2.18.10
jackson-core 2.19.0 <2.21.6
jackson-core 3.0.0 <3.1.6
jackson-core 3.2.0 <3.2.2
jackson-core 2.22.0 <2.22.2

Affected Packages

euvd jackson_core fix: 2.18.10, 2.21.6, 2.22.2, 3.1.6, 3.2.2

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

Vendor (HeroDevs) 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

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.

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

Primary rating from Vendor (HeroDevs).

CVSS VectorVendor: HeroDevs

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

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Ubiquitous
jackson-core is the de facto JSON library across the Java ecosystem
Social Media
3
Sightings
Data Quality
5 sources
Confidence: Medium

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 N/A
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
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.

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