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-91777

CVE-2026-91777: Algorithmic Complexity Denial of Service in FasterXML jackson-databind

Alon Barad
Alon Barad
Software Engineer

Sep 30, 2026·6 min read·245 visits

Executive Summary (TL;DR)

A quadratic-time algorithmic complexity flaw in Jackson's forward-reference resolution mechanism allows unauthenticated remote attackers to trigger severe CPU thread starvation by submitting specialized JSON payloads containing out-of-order references.

An uncontrolled resource consumption vulnerability in FasterXML jackson-databind allows remote unauthenticated attackers to cause a Denial of Service (DoS) via crafted JSON payloads containing out-of-order forward references in identity-enabled collections or maps.

Vulnerability Overview

The security vulnerability CVE-2026-91777 (tracked as GHSA-cxp5-3px4-pw24) is a critical resource consumption defect residing within the FasterXML jackson-databind core deserialization pipeline. It specifically targets endpoints that handle incoming object graphs with cyclical, duplicate, or out-of-order identity-enabled relationships. When an application implements the @JsonIdentityInfo annotation on standard collection or map structures, Jackson generates internal structures to resolve forward-referencing Object IDs during deserialization.

An unauthenticated remote attacker can exploit this mechanism by preparing a specifically crafted JSON body that forces the deserializer's internal accumulator into a worst-case lookup loop. Because the affected parser iterates through arrays in sequential execution order, out-of-order definitions of referenced identifiers cause the processing engine to repeatedly traverse the unresolved queue. This behavior increases processing overhead significantly.

This vulnerability belongs to the algorithmic complexity class (CWE-400), which yields computational denial of service. Traditional defensive parameters, such as restricting nesting depth, fail to prevent this exploitation method because the attack does not rely on deep hierarchy loops or invalid schema configurations. The impact is restricted to the execution context of the JVM, though complete CPU starvation can affect adjacent application threads.

Root Cause Analysis

The root cause of the vulnerability lies in the structural choice of a flat list for tracking pending identity references during collection and map parsing. In legacy versions of jackson-databind, the CollectionReferringAccumulator and MapReferringAccumulator components utilize a standard java.util.ArrayList structure, named _accumulator, to cache pending CollectionReferring objects.

When Jackson parses an array with elements that refer to Object IDs before their explicit definition, it constructs placeholder CollectionReferring nodes and appends them to this array list. When the actual definition of an Object ID is encountered, the deserializer calls resolveForwardReference. This trigger prompts a linear iteration from the beginning of the _accumulator array list via an Iterator structure to locate the target ID node.

If the payload organizes these object definitions in reverse order relative to their initial referencing declarations, the iterator executes a worst-case linear scan of the outstanding list size for each resolution step. Compounding this, the accumulator executes a manual buffer-merging loop using previous.addAll(ref.next) to preserve chronological order for elements parsed after the unresolved ID. The cumulative cost of both operations scales exponentially to O(N^2) time complexity for N forward references.

Code Analysis

To understand the technical issue, analyze the legacy implementation of resolveForwardReference within CollectionDeserializer.java. In this code path, the resolver performs a linear traversal on every invocation to find the matching unresolved ID:

// LEGACY VULNERABLE CODE
public void resolveForwardReference(Object id, Object value) throws IOException {
    Iterator<CollectionReferring> iterator = _accumulator.iterator();
    Collection<Object> previous = _result;
    while (iterator.hasNext()) {
        CollectionReferring ref = iterator.next();
        if (ref.hasId(id)) {
            iterator.remove();
            previous.add(value);
            previous.addAll(ref.next); // Merge buffers (quadratic step)
            return;
        }
        previous = ref.next;
    }
    throw new IllegalArgumentException("Unresolved forward reference id not seen.");
}

The official fix, introduced in commit 37ad9b81712cbb9fb62c2d2c1813593252a24b67, replaces the flat accumulator list with a composite data structure. It utilizes a HashMap named _unresolvedById that maps keys directly to a Deque of CollectionReferring references, yielding O(1) lookup performance. Additionally, it preserves ordering through a flat linear queue structure named _pending coupled with an index pointer, _pendingStart.

// PATCHED SECURE CODE
public void resolveForwardReference(Object id, Object value) throws IOException {
    Deque<CollectionReferring> refs = _unresolvedById.get(id);
    if (refs == null) {
        throw new IllegalArgumentException("Unknown forward reference id.");
    }
    CollectionReferring ref = refs.removeFirst();
    if (refs.isEmpty()) {
        _unresolvedById.remove(id);
    }
    ref.resolve(value);
 
    // Linear sliding-window evaluation
    final int end = _pending.size();
    int i = _pendingStart;
    for (; i < end; ++i) {
        Object pending = _pending.get(i);
        if (pending instanceof CollectionReferring) {
            CollectionReferring pendingRef = (CollectionReferring) pending;
            if (!pendingRef.isResolved()) {
                break; // Halted by the next unresolved reference
            }
            pending = pendingRef.resolvedValue();
        }
        _result.add(pending);
        _pending.set(i, null);
    }
    _pendingStart = (i == end) ? 0 : i;
    if (i == end) _pending.clear();
}

By using this queue sliding window, every parsed and pending object is evaluated and shifted to the destination _result collection exactly once. This shifts the runtime profile from a quadratic O(N^2) scale down to a stable linear O(N) scale.

Exploitation and Payload Analysis

Exploitation of CVE-2026-91777 is highly reliable and requires no specialized prerequisites other than a network path to a vulnerable Jackson deserialization endpoint. The target class must utilize the @JsonIdentityInfo annotation to track references. The attacker constructs a payload consisting of two distinct sections: the list of forward references and the reverse-order declaration definitions.

For a Collection-based exploit, the input array starts with a sequence of string keys matching the generated Object IDs. The parser is forced to cache each reference inside the accumulator as it reads the array from left to right. Immediately following the keys, the attacker provides the full object definitions in reverse numeric order:

[
  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
  "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
  {"id": "19", "name": "node19"},
  {"id": "18", "name": "node18"},
  {"id": "17", "name": "node17"},
  {"id": "0", "name": "node0"}
]

Because each definition from 19 to 0 triggers a linear scan from the beginning of the legacy list, the JVM executes thousands of comparisons for small datasets. For larger payloads of several thousand elements, the calculation yields millions of comparison loops. This process consumes the entire CPU execution slice of the handling thread, triggering rapid denial of service.

Impact and Remediation Assessment

The vulnerability carries a CVSS Base Score of 7.5, indicating a high-impact availability threat. Successful exploitation leads directly to CPU resource exhaustion on the target application node, blocking all standard requests and potentially causing orchestrators to restart the container under load-balancer stress.

Remediation consists of upgrading to the patched Jackson-databind versions. However, the fix itself introduces minor structural constraints. Since unresolved references block the sliding window, a single un-resolved reference at the beginning of an array will hold all subsequent items in heap memory within _pending. This behavior poses a minor risk of memory exhaustion if request payloads are sufficiently large.

Below is a conceptual logical comparison of the legacy vs. patched behavior inside Jackson:

While the patch is functionally complete and eliminates the quadratic lookup vector, administrators must configure maximum packet-size limits. This prevents attackers from bypassing the CPU check by abusing the residual memory retention mechanism in the sliding window buffer.

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

jackson-databind

Affected Versions Detail

Product
Affected Versions
Fixed Version
jackson-databind
FasterXML
>= 2.5.0, < 2.18.112.18.11
jackson-databind
FasterXML
>= 2.19.0, < 2.21.72.21.7
jackson-databind
FasterXML
>= 2.22.0, < 2.22.32.22.3
jackson-databind
FasterXML
>= 3.0.0, < 3.1.73.1.7
jackson-databind
FasterXML
>= 3.2.0, < 3.2.33.2.3
AttributeDetail
CWE IDCWE-400
Attack VectorNetwork
CVSS Score7.5 (High)
EPSS Score0.0045
ImpactDenial of Service (CPU Exhaustion)
Exploit StatusProof of Concept available
KEV StatusNot currently listed

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
CWE-400
Uncontrolled Resource Consumption

The product does not properly control the allocation and maintenance of a limited resource, enabling an actor to cause resource exhaustion.

References & Sources

  • [1]GitHub Security Advisory GHSA-cxp5-3px4-pw24
  • [2]Fix Commit 37ad9b8
  • [3]FasterXML databind Issue #6204
  • [4]NVD - CVE-2026-91777

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

•about 1 hour ago•CVE-2026-126304
8.7

CVE-2026-126304: Symlink Path Traversal in NLTK YCOECorpusReader

CVE-2026-126304 is a symlink path traversal vulnerability (CWE-59) in the Natural Language Toolkit (NLTK) versions 3.10.0 prior to 3.10.4. The YCOECorpusReader class constructs internal sub-readers for the 'psd' and 'pos' subdirectories using FileSystemPathPointer.join(), which relies exclusively on lexical string-prefix validation rather than canonical path resolution. An attacker who supplies a crafted YCOE corpus containing symbolic links in place of the 'psd' or 'pos' subdirectories can bypass directory confinement and read arbitrary files from sibling corpora or sensitive directories within the NLTK data sandbox.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 2 hours ago•CVE-2026-128077
6.5

CVE-2026-128077: Authorization Bypass via Request Path Desynchronization in Nuxt and @nuxt/nitro-server

CVE-2026-128077 (GHSA-r99w-jh2x-3mg9) is an authorization bypass and interpretation conflict vulnerability affecting Nuxt and its underlying @nuxt/nitro-server package in versions 4.6.0 through 4.6.3. When an incoming HTTP request path begins with a double forward slash (e.g., //x/admin), the WHATWG URL parser within the Nuxt server-side page renderer interprets the initial segment as a network host/authority and resolves the remaining path (/admin) against the application's page router. Because Nitro server middleware, route-scoped serverHandlers, and Nitro routeRules evaluate the unparsed request path (//x/admin), path-based access controls, redirects, and security header policies configured for /admin fail to match and are bypassed.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 3 hours ago•CVE-2026-128084
4.8

CVE-2026-128084: Integer Truncation and SQL Query Truncation in sqlite3-ruby

Prior to version 2.10.2, the sqlite3-ruby gem explicitly cast 64-bit Ruby string lengths (long) to 32-bit signed integers (int) when invoking the underlying SQLite C API. On 64-bit platforms, providing a string of 4 GiB (2^32 bytes) or larger causes integer truncation, instructing SQLite to process only a prefix of the string. This flaw affects SQL query preparation, bound parameter values, and return values from custom Ruby-defined SQL functions and aggregates, allowing trailing SQL clauses such as WHERE restrictions to be silently dropped under specific conditions.

Alon Barad
Alon Barad
5 views•11 min read
•about 4 hours ago•CVE-2026-128068
5.3

CVE-2026-128068: Regular Expression Denial of Service in rails-html-sanitizer

CVE-2026-128068 (GHSA-cpgf-5mjf-73p7) is a Regular Expression Denial of Service (ReDoS) vulnerability in the rails-html-sanitizer Ruby gem affecting versions 1.0.3 through 1.7.1. The flaw resides in the Rails::HTML::PermitScrubber#scrub_attribute method, which uses the multiline regular expression /^\s*[^#\s].*/m to enforce local-only URI fragment references on SVG elements. On Ruby runtimes prior to version 3.2 (CRuby <= 3.1 and JRuby), evaluating an attribute value composed of repeated newline and whitespace characters without a hash character triggers quadratic backtracking O(n^2). Applications are only vulnerable if their sanitization allowlist is explicitly configured to permit SVG reference elements such as <use> alongside href or xlink:href attributes.

Alon Barad
Alon Barad
5 views•9 min read
•about 5 hours ago•CVE-2026-126360
5.3

CVE-2026-126360: Regular Expression Denial of Service in OpenTelemetry Python opentelemetry-api

CVE-2026-126360 (GHSA-mf5v-w3w3-f6cg) is an algorithmic complexity vulnerability (Regular Expression Denial of Service) in the trace context propagation logic of the opentelemetry-api package within the OpenTelemetry Python ecosystem. In versions prior to 1.45.2, the TraceContextTextMapPropagator.extract() method utilizes a regular expression susceptible to quadratic-time backtracking when parsing malformed W3C traceparent headers containing long sequences of whitespace followed by an embedded newline character. In Python applications—particularly those using single-threaded asynchronous event loops—an unauthenticated remote attacker transmitting payloads over newline-preserving carriers can monopolize CPU execution and induce application-level Denial of Service.

Alon Barad
Alon Barad
5 views•10 min read
•about 6 hours ago•CVE-2026-126359
3.4

CVE-2026-126359: Cross-Site Scripting via Split Closing Style Tag in Hono CSS Helper

CVE-2026-126359 (GHSA-3gg2-335m-rxc6) is an improper input neutralization vulnerability (CWE-79) in the Hono web framework (`honojs/hono`). Versions from 3.12.0 prior to 4.13.16 evaluate and escape interpolated strings in the `hono/css` helper individually before concatenating template chunks and stripping CSS comments. When a `<` character and a `/style>` sequence are split across template boundaries, adjacent interpolations, or separated by a CSS comment, the sanitizer fails to escape the closing tag sequence. During Server-Side Rendering (SSR), the `<Style />` component outputs an unescaped `</style>` delimiter, permitting an attacker to break out of the CSS raw text context and execute arbitrary HTML and JavaScript in the victim's browser.

Alon Barad
Alon Barad
7 views•10 min read