CVE-2026-18401
Received Received - Intake

Denial of Service in Jackson Core Async JSON Parser

Vulnerability report for CVE-2026-18401, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-08-04

Last updated on: 2026-08-04

Assigner: HeroDevs

Description

The non-blocking (asynchronous) JSON parser in jackson-core does not enforce the maxNumberLength constraint defined in StreamReadConstraints (default: 1000 characters). An attacker able to submit JSON to an application that uses the async parser API can supply a number token of arbitrary length, leading to excessive memory allocation and potential CPU exhaustion, resulting in a denial of service. The synchronous parser enforces this limit correctly, so the constraint is applied inconsistently depending on which parsing API the application uses. Root cause: the async parsing path in NonBlockingUtf8JsonParserBase and related classes never invokes the number length validation methods. Number parsing methods such as _finishNumberIntegralPart() accumulate digits into the TextBuffer without any length check, then call _valueComplete() to finalize the token. _valueComplete() does not call resetInt() or resetFloat(), which are the methods in ParserBase where validateIntegerLength() and validateFPLength() are performed. Because that validation step is skipped, maxNumberLength is never enforced on the async code path. Impact: an attacker sending a JSON document containing an arbitrarily long number to an application using the async parser (for example a Spring WebFlux or other reactive application) can cause unbounded allocation in the TextBuffer and an OutOfMemoryError. If the application subsequently calls getBigIntegerValue() or getDecimalValue(), the JVM may additionally be tied up in O(n^2) BigInteger parsing, causing CPU-based denial of service. No privileges or user interaction beyond the ability to submit data for parsing are required. This issue affects com.fasterxml.jackson.core:jackson-core from version 2.15.0 through 2.18.5 and from 2.19.0 through 2.21.0, and tools.jackson.core:jackson-core from 3.0.0 through 3.0.x. Versions prior to 2.15.0 are not affected, because StreamReadConstraints -- which defines the maxNumberLength setting -- was first introduced in jackson-core 2.15.0, so no such constraint exists to be bypassed in earlier releases. Note that GHSA-72hv-8253-57qq records the lower bound of the affected 2.x range as 2.0.0.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-08-04
Last Modified
2026-08-04
Generated
2026-08-04
AI Q&A
2026-08-04
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 7 associated CPEs
Vendor Product Version / Range
fasterxml jackson-core From 2.15.0 (inc) to 2.18.5 (inc)
fasterxml jackson-core From 2.19.0 (inc) to 2.21.0 (inc)
fasterxml jackson-core From 3.0.0 (inc) to 3.0.x (inc)
fasterxml jackson-core From 2.0.0 (inc)
com.fasterxml.jackson jackson-core From 2.15.0 (inc) to 2.18.5 (inc)
com.fasterxml.jackson jackson-core From 2.19.0 (inc) to 2.21.0 (inc)
tools.jackson jackson-core From 3.0.0 (inc) to 3.0.x (inc)

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-770 The product allocates a reusable resource or group of resources on behalf of an actor without imposing any intended restrictions on the size or number of resources that can be allocated.

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability affects the non-blocking JSON parser in jackson-core. It fails to enforce the maxNumberLength constraint, allowing attackers to send JSON with extremely long numbers. This causes excessive memory allocation and CPU exhaustion, leading to denial of service. The synchronous parser correctly enforces this limit, but the async parser does not.

Detection Guidance

To detect this vulnerability, inspect your Jackson-core library version. Affected versions are 2.15.0 through 2.18.5 and 2.19.0 through 2.21.0. Check for applications using async JSON parsing (e.g., Spring WebFlux). Monitor for excessive memory or CPU usage during JSON parsing.

Impact Analysis

An attacker can exploit this by sending a JSON document with a very long number to an application using the async parser. This causes unbounded memory allocation and potential OutOfMemoryError. If methods like getBigIntegerValue() are called, it may also lead to CPU-based denial of service due to O(n^2) BigInteger parsing.

Compliance Impact

This vulnerability could impact compliance with GDPR and HIPAA by enabling denial-of-service attacks that disrupt system availability. GDPR requires data processing systems to maintain availability, while HIPAA mandates safeguards against unauthorized resource exhaustion. The flaw allows attackers to consume excessive memory and CPU, potentially violating these availability and security requirements.

Mitigation Strategies
  • Upgrade Jackson-core to version 2.18.6 or 2.21.1 or later to apply the fix.
  • Ensure async JSON parsing paths enforce StreamReadConstraints.maxNumberLength.
  • Review and update dependencies in reactive applications using Jackson-core.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-18401. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart