CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-91776

CVE-2026-91776: Denial of Service via Unbounded Polymorphic Cache in jackson-databind

Alon Barad
Alon Barad
Software Engineer

Sep 30, 2026·6 min read·248 visits

Executive Summary (TL;DR)

An unauthenticated remote attacker can crash Java applications using Jackson-databind by transmitting JSON payloads with high-cardinality, unrecognized polymorphic type IDs, causing unbounded memory retention and JVM heap exhaustion.

CVE-2026-91776 is a high-severity Denial of Service (DoS) vulnerability in the FasterXML jackson-databind library. The vulnerability is caused by uncontrolled resource consumption (CWE-400) where raw, unrecognized polymorphic type IDs are cached indefinitely without boundaries inside TypeDeserializerBase. When name-based polymorphic deserialization is configured with a fallback mechanism (such as a default implementation or custom problem handlers), remote attackers can send crafted payloads containing unique unknown type IDs, causing heap exhaustion, Garbage Collection (GC) overhead limit exhaustion, and an Out-of-Memory (OOM) crash.

Vulnerability Overview

The FasterXML jackson-databind library provides powerful polymorphic type resolution mechanisms, allowing developers to dynamically map input fields to Java objects based on a type identifier. A typical implementation involves decorating target classes with @JsonTypeInfo(use = Id.NAME), instructing the deserializer to interpret a specific JSON property (such as type) as the class indicator. To optimize performance and bypass expensive reflection-based class lookups on every request, jackson-databind maintains an internal cache of resolved type deserializers within the TypeDeserializerBase class.

However, a design vulnerability exists in how the library caches unknown type IDs when fallback configurations are active. If the deserializer is configured with a default implementation (via defaultImpl = ...) or utilizes a custom DeserializationProblemHandler to gracefully handle unknown types, the lookup mechanism resolves any unrecognized type string to that fallback deserializer. The vulnerability arises because the library caches this mapping using the raw, attacker-supplied, unknown type string as the unique key within a long-lived, unbounded map.

Because the underlying cache map (_deserializers) is bound to the lifetime of the ObjectMapper instance—which is almost universally registered as an application-wide singleton—any memory retained by the map remains occupied indefinitely. Remote, unauthenticated attackers can exploit this behavior by sending a stream of payloads, each featuring a newly generated, unique, or exceptionally long unrecognized type identifier. This results in direct, monotonic memory consumption on the JVM heap.

Root Cause Analysis

The root cause of CVE-2026-91776 lies within the polymorphic type resolution implementation of com.fasterxml.jackson.databind.jsontype.impl.TypeDeserializerBase. When processing name-based polymorphic structures, the library relies on the internal method _findDeserializer(DeserializationContext ctxt, String typeId) to retrieve the appropriate deserializer for the given typeId string. The cache of resolved type-to-deserializer mappings is stored in the local map declared as: protected final Map<String, JsonDeserializer<Object>> _deserializers;

When a request contains an unrecognized typeId, and a fallback implementation is defined, the lookup logic maps this invalid ID to the fallback deserializer (e.g., NullifyingDeserializer or the user-defined defaultImpl class). In vulnerable versions, the method executes _deserializers.put(typeId, deser); without validating the size of the _deserializers map or checking the length of the typeId key.

Because this cache lacks an entry-count ceiling and has no key-length restriction, the application fails to control resource consumption (CWE-400). A malicious actor can force the storage of an infinite number of unique string keys in the cache, with each key pointing to the same fallback deserializer object. Since the keys are unique strings, they represent newly allocated memory that cannot be reclaimed by garbage collection, guaranteeing eventual exhaustion of the JVM heap space.

Code Analysis and Patch Verification

The official fix, introduced in commit 2870d1d6dc1b7e1c07ee11dd5b04ab71cddbb577, implements bounds and structural restrictions to neutralize cache-exhaustion techniques.

// Vulnerable logic in TypeDeserializerBase.java directly stored the key:
_deserializers.put(typeId, deser);

The patch introduces two defensive constraints (MAX_CACHED_TYPE_IDS and MAX_CACHED_TYPE_ID_LENGTH) to regulate the caching behavior of _deserializers:

// Hard-caps added in patched version:
final static int MAX_CACHED_TYPE_IDS = 1000;
final static int MAX_CACHED_TYPE_ID_LENGTH = 256;

In addition to these limits, the patch inserts validation checks before putting new entries into the cache:

// Guard conditions to limit cache expansion
if (typeId.length() > MAX_CACHED_TYPE_ID_LENGTH) {
    return deser; // Resolve but do not cache excessively long keys
}
if (_deserializers.size() >= MAX_CACHED_TYPE_IDS) {
    _deserializers.clear(); // Flush cache if it exceeds size limits
}
_deserializers.put(typeId, deser);

Furthermore, the patch modifies _findDeserializer to prevent caching instances of NullifyingDeserializer.instance and other transient deserialization fallbacks resolved via problem handlers. This ensures that transient, context-specific deserialization results do not corrupt or saturate the common cache. If an attacker tries to flood the system with randomized type IDs, the map will safely purge itself once it reaches 1,000 keys, limiting memory usage.

Exploitation Methodology

An attack against CVE-2026-91776 requires three conditions: polymorphic name-based deserialization is active, a default/fallback implementation is declared, and the parsing engine uses a singleton mapper.

The following architectural sequence illustrates how an attacker exploits the unbounded cache inside the JVM heap:

To execute the attack, the adversary transmits HTTP requests containing JSON bodies with randomized string keys. An example attack vector targeting a hypothetical Animal endpoint is structured as follows:

{ "animal": { "type": "exploit_key_9bc4a89d1", "name": "Rover" } }
{ "animal": { "type": "exploit_key_0ef72b4c2", "name": "Rover" } }

With each request, the cache is populated with a unique key. Because the heap footprint grows with each request, an automated script sending thousands of requests per second can quickly exhaust the memory allocated to the JVM. Once the heap is full, performance degrades as garbage collection threads consume CPU cycles in vain, leading to an eventual application crash.

Impact Assessment

The primary impact of CVE-2026-91776 is an unauthenticated, remote denial of service (DoS) on the target host. Because name-based polymorphic parsing is heavily utilized in microservice architectures and RESTful web interfaces, endpoints processing structured JSON inputs are highly exposed.

When exploitation occurs, the physical memory allocated to the JVM is filled with uncollectible references. This forces the JVM Garbage Collector into a loop of aggressive collection sweeps, leading to high CPU usage and thread starvation. Legitimate user requests are delayed, timed out, or dropped.

Once the Garbage Collector cannot reclaim enough space to fulfill new object allocations, the JVM throws a fatal java.lang.OutOfMemoryError: Java heap space and crashes. In containerized environments, such as Kubernetes, this crash triggers container restarts. If the attack continues, it can result in a permanent outage of the target microservice, causing cascading failures across upstream components.

Mitigation and Remediation

The recommended mitigation is to upgrade jackson-databind to a patched release. For environments where immediate patching is not possible, developers can implement several workarounds to reduce risk.

One workaround is to avoid using catch-all fallback classes or default implementations (defaultImpl) in name-based polymorphic mappings. By omitting default implementations, the parser fails immediately when encountering an invalid type ID, preventing cache allocation.

Another option is to implement a strict, custom TypeIdResolver to validate incoming type ID strings against a static list of allowed classes before resolution. This stops unknown inputs from entering the resolution pipeline. In addition, security teams can configure web application firewalls (WAF) to detect and block JSON payloads where polymorphic type fields exceed standard lengths (e.g., more than 256 characters).

Official Patches

FasterXMLGitHub commit applying entry limit and key size validation on TypeDeserializerBase caching logic.

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
EPSS Probability
0.45%
Top 63% most exploited

Affected Systems

FasterXML jackson-databind versions 2.0.0 through 2.18.10FasterXML jackson-databind versions 2.19.0 through 2.21.6FasterXML jackson-databind versions 2.22.0 through 2.22.2FasterXML jackson-databind versions 3.0.0 through 3.1.6FasterXML jackson-databind versions 3.2.0 through 3.2.2

Affected Versions Detail

Product
Affected Versions
Fixed Version
jackson-databind
FasterXML
>= 2.0.0, <= 2.18.102.18.11
jackson-databind
FasterXML
>= 2.19.0, <= 2.21.62.21.7
jackson-databind
FasterXML
>= 2.22.0, <= 2.22.22.22.3
jackson-databind
FasterXML
>= 3.0.0, <= 3.1.63.1.7
jackson-databind
FasterXML
>= 3.2.0, <= 3.2.23.2.3
AttributeDetail
CWE IDCWE-400
Attack VectorNetwork
CVSS Severity7.5 (High)
Exploit StatusProof-of-Concept Available
KEV StatusNot Listed
Vulnerability ClassUncontrolled Resource Consumption

MITRE ATT&CK Mapping

T1499.003Endpoint Denial of Service: Resource Depletion
Impact
CWE-400
Uncontrolled Resource Consumption

The application does not adequately control the allocation and maintenance of a limited resource, enabling an actor to cause a denial of service.

Known Exploits & Detection

GitHubIssue report detailing reproduction steps and JUnit test cases for uncontrolled polymorphic cache growth.

References & Sources

  • [1]GitHub Security Advisory GHSA-wv8q-qhhj-9h54
  • [2]FasterXML Jackson Databind Issue #6203
  • [3]Fix Commit 2870d1d6dc1b7e1c07ee11dd5b04ab71cddbb577
  • [4]Wiz Vulnerability Database Entry for CVE-2026-91776
  • [5]CVE-2026-91776 Record on CVE.org

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.

Amit Schendel
Amit Schendel
5 views•10 min read
•1 day ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.

Amit Schendel
Amit Schendel
7 views•11 min read
•1 day ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.

Alon Barad
Alon Barad
7 views•10 min read
•1 day ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.

Amit Schendel
Amit Schendel
7 views•10 min read
•1 day ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.

Alon Barad
Alon Barad
8 views•11 min read
•1 day ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.

Alon Barad
Alon Barad
7 views•9 min read