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

CVE-2026-105749: Unbounded Table Attributes in Docling Backends Leads to Resource Exhaustion

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 8, 2026·6 min read·24 visits

Executive Summary (TL;DR)

Docling document parsers lack validation checks for table row and column spans, allowing tiny documents with extreme span values to exhaust host memory and CPU resources.

An uncontrolled resource consumption vulnerability exists in the Docling document conversion library. Maliciously structured HTML, JATS, ODS, or BoxNote inputs containing table cells with excessively large 'rowspan' or 'colspan' attribute values trigger algorithmic complexity conditions. This allows unauthenticated remote attackers to initiate resource exhaustion states, crashing or hanging the target document processing pipeline while bypassing configured timeouts.

Vulnerability Overview & Technical Context

Docling is an enterprise-oriented, open-source Python library used to parse, segment, and convert complex document formats into structured, machine-readable formats. It serves as a critical component in automated ingestion pipelines, Retrieval-Augmented Generation (RAG) frameworks, and Large Language Model (LLM) workflows.

The library supports various data backends, adapting its conversion mechanisms for different input file types. These backends parse structured tables (such as HTML, JATS XML, OpenDocument Spreadsheet, and BoxNote JSON documents) to build structured layout matrices. To properly model these tables, the parsers reconstruct the physical arrangement of overlapping grid structures.

In vulnerable versions (prior to 2.131.0), the parsing adapters accepted row and column span attributes without verifying their scale against reasonable upper bounds. This missing validation exposes applications using Docling to uncontrolled resource exhaustion attacks. When processing a crafted file with highly inflated span coordinates, the target system encounters complete resource starvation.

Root Cause & Algorithmic Complexity Analysis

The vulnerability stems from the combined effects of Uncontrolled Resource Consumption (CWE-400) and Memory Allocation with an Excessive Size Value (CWE-789). When Docling ingests tables, the underlying backend adapter instantiates a two-dimensional grid array to map spans and calculate intersecting coordinates. This mapping ensures subsequent processing steps maintain precise cell layout tracking.

Prior to the patch, when the parser processed attributes such as 'rowspan' or 'colspan', it converted the raw metadata strings directly into integers. The parser utilized these values to drive nested execution loops that initialized virtual table cells and populated spatial coordinate sets. An attacker can set these integers to extreme values, forcing the execution of intensive loops that map millions of coordinate intersections.

Because Python objects carry measurable heap memory overhead, allocating large tables or tracking their indexes in coordinate loops leads to quick memory exhaustion. The execution time and memory footprint scale exponentially relative to the magnitude of the supplied span attributes.

Furthermore, Docling provides a 'document_timeout' feature to limit execution runs, but this mechanism is only evaluated between pipeline phases. Because the synchronous table-parsing logic executes inside a single continuous phase, the parser cannot yield control to the scheduler. The timeout check is bypassed entirely, leaving the system to run until it is terminated by an out-of-memory handler or host system starvation.

Code-Level Walkthrough and Fix Verification

The remediation implemented in commit c5b4429cc6500a344c13edeb22e67610c2159b09 addresses the root cause of the resource exhaustion by introducing a static-limit check and context-aware dynamic clamping.

The developers created docling/backend/utils/table_spans.py to define static limits for table attributes:

# Standard limits introduced to prevent algorithmic complexity attacks
MAX_COLSPAN = 1000
MAX_ROWSPAN = 65534
 
def clamp_span(span: int, limit: int) -> int:
    """Clamp a declared span to the safe range [1, limit]."""
    return max(1, min(span, limit))

To prevent a secondary CPU consumption vector—where an exceptionally long digit string causes resource exhaustion during string-to-integer conversion—the code restricts the length of processed numeric substrings before conversion. This logic is implemented in the _extract_num method in html_backend.py:

# Pre-validation check of string lengths to prevent parsing exhaustion
digits = match.group().lstrip('0')
if len(digits) > len(str(MAX_ROWSPAN)):
    return MAX_ROWSPAN
return max(int(digits or '0'), 1)

In addition to static limits, the backends apply dynamic clamping based on the table's physically detected layout. This context-aware bounding is implemented across the distinct parser adapters as shown below:

# Dynamic layout clamping inside boxnote_backend.py
row_span = min(
    _declared_span(cell, 'rowspan', MAX_ROWSPAN),
    len(rows) - row_idx,
)
col_span = min(
    _declared_span(cell, 'colspan', MAX_COLSPAN),
    max(width - col_idx, 1),
)

By ensuring that cells are constrained to both safe static boundaries and the physical boundaries of the table region, the processing complexity remains directly proportional to the actual structural properties of the document.

Exploitation Mechanics and Vector Feasibility

An attack targeting this vulnerability requires zero authentication and minimal operational overhead. The vulnerability can be triggered remotely by supplying a crafted document file to any application utilizing the Docling library for document parsing or automated content ingestion.

A malicious actor can construct a small HTML document containing highly disproportionate table properties to target the underlying HTMLDocumentBackend:

<table>
  <tr>
    <td rowspan='999999999'>Payload Column A</td>
    <td colspan='999999999'>Payload Column B</td>
  </tr>
  <tr>
    <td>Additional Row</td>
  </tr>
</table>

When Docling ingests this file, the conversion process attempts to initialize and iterate over a matrix of size 999999999 x 999999999. This operation triggers immediate heap-allocation calls and locks the active thread in a continuous execution loop.

The exploitation characteristics are highly asymmetric. The malicious payload requires less than a kilobyte of network bandwidth to transmit, yet it causes gigabytes of memory allocation on the server side within milliseconds, leading to a denial of service.

Impact Assessment and Operational Exposure

The successful exploitation of CVE-2026-105749 results in a complete denial of service for the host processing system. Because the vulnerability targets fundamental document parsers, its downstream impact is amplified in automated production environments.

In Retrieval-Augmented Generation (RAG) environments, document parsing pipelines often ingest and chunk large volumes of user-supplied business files. A single malicious upload can crash the parsing service, disabling the ingestion pipeline for all legitimate users. This risk is especially critical in multitenant applications where document ingestion shares physical host resources with core application components.

Because the host process memory limit is quickly exceeded, the operating system's Out-of-Memory (OOM) killer will typically terminate the parent process. In microservice architectures, such as Kubernetes clusters, continuous container crashes can trigger CrashLoopBackOff states. This destabilizes the local service cluster, resulting in broader infrastructure degradation.

This vulnerability has been assigned a CVSS score of 6.5 (Medium), reflecting high availability impact but low confidentiality or integrity exposure. Because exploiting the flaw requires zero authentication or specific privileges, it is highly attractive to adversaries seeking to execute low-cost denial of service attacks.

Remediation and Detection Guidance

Remediation requires upgrading the docling package to version 2.131.0 or higher, which imports docling-core version 2.98.0 or higher. Organizations should verify their current python environment version using pip dependency tools:

pip list | grep docling

If upgrading cannot be implemented immediately, systems can deploy input validation filters to analyze incoming files before they are processed by Docling. Organizations should screen uploaded XML, HTML, and ODS content using regular expressions to detect anomalous span configurations:

(colspan|rowspan)\s*=\s*['"](9{4,}|\d{5,})['"]

Additionally, parsing operations should be isolated within containers with strict memory limits enforced by control groups (cgroups). This deployment pattern ensures that an Out-of-Memory event terminates only the worker container, protecting the parent system and neighboring processes from cascading failures.

Fix Analysis (1)

Technical Appendix

CVSS Score
6.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H
EPSS Probability
0.26%
Top 84% most exploited

Affected Systems

Docling (Python Package)Docling-Slim (Python Package)Document Parsing Microservices utilizing Docling

Affected Versions Detail

Product
Affected Versions
Fixed Version
docling
IBM / docling-project
>= 2.0.0, < 2.131.02.131.0
docling-slim
IBM / docling-project
>= 2.92.0, < 2.131.02.131.0
AttributeDetail
CWE IDCWE-400 (Uncontrolled Resource Consumption)
Attack VectorNetwork / Remote Document Ingestion
CVSS Severity6.5 (Medium)
EPSS Score0.00256 (Percentile: 15.73%)
ImpactComplete Application Hang or Out-of-Memory Crash
Exploit StatusProof-of-Concept Available
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1499.004Endpoint Denial of Service: Application Exhaustion
Impact
CWE-400
Uncontrolled Resource Consumption

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

Vulnerability Timeline

Vulnerability remediation and clamping checks implemented in main branch.
2026-09-29
Security advisory GHSA-cgc7-9qp3-86m3 published.
2026-10-05
CVE-2026-105749 assigned and published.
2026-10-05
Fixed release version 2.131.0 shipped to PyPI.
2026-10-05

References & Sources

  • [1]Docling Advisory (GHSA-cgc7-9qp3-86m3)
  • [2]NVD CVE Record
  • [3]CVE.org Record
  • [4]Fix Commit
  • [5]Fix Pull Request
  • [6]Docling Release Tag v2.131.0

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-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
5 views•10 min read
•1 day ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
11 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
11 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
14 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read