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

CVE-2026-105748: Local File Inclusion and Arbitrary File Disclosure in Docling Document Parser

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 8, 2026·5 min read·27 visits

Executive Summary (TL;DR)

Docling is vulnerable to Local File Inclusion via crafted JSON inputs, allowing attackers to read local system images or verify file existence.

A Local File Inclusion (LFI) and Arbitrary File Disclosure vulnerability exists in Docling and Docling Slim versions >= 2.16.0 up to 2.131.0. When parsing serialized DoclingDocument structures using the JSON input format, the backend fails to restrict image URI schemes, allowing remote attackers to retrieve local files and verify path existence on the host system during embedded document export.

Vulnerability Overview

The Docling document conversion library offers capabilities for parsing, structured layout extraction, and format conversions. It supports a declarative input schema via serialized JSON models, identified as the InputFormat.JSON_DOCLING backend. Within this input flow, the parser processes metadata structures including image definitions to rebuild or render document elements.

Historically, the parser accepted remote or local source references within its image schema without restricting the target protocols. This lack of restriction allows untrusted serialized JSON payloads to specify local file paths. Because the system subsequently attempts to access and embed these image references during export, it exposes the host system to Local File Inclusion (LFI).

An attacker can exploit this behavior by passing a crafted JSON document containing arbitrary local system file paths. The impact spans beyond file reading, allowing path validation, file existence mapping, and, under specific conditions, full exfiltration of sensitive graphical or binary files. The vulnerability exposes any deployment where Docling processes untrusted documents on a server-side backend.

Root Cause Analysis

The root cause lies in how Docling resolves asset URI schemes during its export pipeline. When a client imports a document using InputFormat.JSON_DOCLING, the backend deserializes the payload into Pydantic models. Within this model hierarchy, ImageRef objects represent individual images and store their locations in a uri property.

When exporting the parsed document using an embedded image mode (such as ImageRefMode.EMBEDDED), the engine calls internal resolution routines. Specifically, the method DoclingDocument._with_embedded_pictures delegates to ImageRef.pil_image to fetch the source asset. Because the uri property lacked validation filters, it can point directly to local filesystem paths.

The library resolves the path and invokes the Pillow (PIL) library's Image.open method. If the file is a valid image, Pillow reads its binary contents, which are subsequently Base64-encoded and outputted. If the path exists but fails image validation, or does not exist, the server throws specific exceptions. An attacker can analyze these error variations to discover file existence and directories.

Code Analysis

The vulnerability was addressed by introducing input sanitization filters within the JSON ingestion backend. In vulnerable versions, deserialization parsed the model directly and preserved local file paths in the ImageRef.uri fields without verification.

The remediation patch introduces the function _clear_local_image_refs inside docling/backend/json/docling_json_backend.py. This helper recurses down the entire Pydantic object hierarchy to find ImageRef instances. If the schema validator detects an asset URI that does not conform to a whitelisted secure remote scheme, the URI is wiped and set to None.

_KEPT_IMAGE_URI_SCHEMES = frozenset({"data", "http", "https"})
 
def _is_kept_image_uri(uri: AnyUrl | Path) -> bool:
    # Restrict URIs to whitelisted web protocols
    return isinstance(uri, AnyUrl) and uri.scheme.lower() in _KEPT_IMAGE_URI_SCHEMES
 
def _clear_local_image_refs(node: object) -> int:
    cleared = 0
    if isinstance(node, BaseModel):
        for name, value in node:
            if isinstance(value, ImageRef):
                if not _is_kept_image_uri(value.uri):
                    # Strips local files or unapproved schemes by replacing with None
                    setattr(node, name, None)
                    cleared += 1
            else:
                cleared += _clear_local_image_refs(value)
    # Tree-walking continues for list, tuple, and dict structures
    return cleared

This defensive filter blocks local paths from propagating into the core export engines. By applying this logic during initial JSON loading, downstream processes cannot trigger local image rendering.

Exploitation Methodology

Exploitation requires that an application ingest an attacker-controlled JSON file and export it using embedded graphics. Because the attack utilizes standard parser functions, the adversary needs no privileges on the target environment.

An attacker constructs a payload targeting local configurations, keys, or screenshots stored as images on the host filesystem. An example target path is /opt/app/sensitive_system_graphic.png or directories containing readable administrative assets.

{
  "schema_name": "DoclingDocument",
  "version": "1.0.0",
  "name": "Exploit payload",
  "pictures": [
    {
      "image": {
        "mimetype": "image/png",
        "dpi": 72,
        "size": {"width": 100, "height": 100},
        "uri": "/opt/app/sensitive_system_graphic.png"
      }
    }
  ]
}

When the converter processes this file and converts it into markdown with embedded objects, it writes out the Base64 representation of the file. The attacker receives this serialized output, decodes it, and recovers the target image. If non-image files are targeted, the application might return diagnostic error logs that reveal the presence or absence of the files, exposing a secondary path existence verification vulnerability.

Residual Risks and Security Gaps

A major residual risk exists for applications interacting directly with low-level components. The remediation code resides inside the docling high-level backend parser package, rather than the core schema definitions of docling-core.

If a developer ingests JSON directly using DoclingDocument.model_validate_json or similar schema-level methods in docling-core, the input sanitization filters are completely bypassed. Because the core library is unpatched, downstream pipelines operating directly on the schema remain vulnerable to the same local file exposure vector.

Additionally, the default protocol whitelist permits http and https schemas. This configuration exposes the server to Server-Side Request Forgery (SSRF) threats. An attacker can reference internal addresses or metadata endpoints, causing the host server to fetch local sensitive details or probe internal networks.

http://169.254.169.254/latest/meta-data/

Lastly, parser inconsistencies between Pydantic's AnyUrl parsing and the operating system's file resolver could lead to bypasses. For instance, Windows UNC paths or local administrative paths might elude the standard scheme filters but still trigger file access when handled by Python's underlying file APIs.

Fix Analysis (1)

Technical Appendix

CVSS Score
4.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N
EPSS Probability
0.22%
Top 89% most exploited

Affected Systems

docling-project/doclingdocling-project/docling-slim

Affected Versions Detail

Product
Affected Versions
Fixed Version
docling
docling-project
>= 2.16.0, < 2.131.02.131.0
docling-slim
docling-project
>= 2.16.0, < 2.131.02.131.0
AttributeDetail
CWE IDCWE-73 (External Control of File Name or Path)
Attack VectorNetwork
CVSS Score4.3 (Medium)
EPSS Score0.00218
ImpactLow Confidentiality (Local File Inclusion / Path Probing)
Exploit StatusPoC / Non-weaponized
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1005Data from Local System
Collection
T1552Unsecured Credentials
Credential Access
CWE-73
External Control of File Name or Path

The software allows user input to control paths or filenames, leading to unauthorized access to local filesystem resources.

References & Sources

  • [1]GitHub Security Advisory
  • [2]Official Fix Commit
  • [3]Official Pull Request
  • [4]Release Notes (v2.131.0)
  • [5]National Vulnerability Database (NVD)

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
6 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
13 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