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

CVE-2026-73555: Environment and Information Disclosure via Exception Handling in vLLM

Alon Barad
Alon Barad
Software Engineer

Sep 5, 2026·5 min read·59 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can query vLLM API endpoints with malformed JSON to retrieve full system paths, virtual environment directory structures, and host usernames from error tracebacks.

An information disclosure vulnerability in vLLM prior to version 0.26.0 allows unauthenticated remote attackers to trigger validation errors that expose highly sensitive host machine metadata, absolute paths, environment structures, and usernames. This flaw stems from improper serialization of Pydantic exceptions and an inadequate fallback sanitization function.

Vulnerability Overview

vLLM is a high-performance open-source inference engine designed for serving Large Language Models. In typical deployment topologies, vLLM exposes an HTTP REST API server compliant with OpenAI endpoints. This API boundary forms the primary external attack surface, managing unauthenticated incoming client requests that are parsed into internal structured payloads.

Because these endpoints are accessible directly over the network, robust input validation and error handling are critical security boundaries. CVE-2026-73555 describes an information disclosure vulnerability (CWE-209) residing within this request validation layer. The flaw allows unauthenticated remote users to trigger structured exceptions that leak extensive host metadata.

When a malformed request is processed, the system produces validation tracebacks rather than sanitized client errors. This leakage exposes absolute directory structures, underlying package frameworks, system configuration states, and active local usernames. This reconnaissance metadata simplifies target environment profiling for subsequent attacks.

Root Cause Analysis

The core of the vulnerability lies in how vLLM handles request parsing failures via its FastAPI and Pydantic architecture. When incoming payloads fail validation checks, Pydantic raises a RequestValidationError exception. FastAPI's routing middleware intercepts this exception and processes it through a custom validation handler.

Prior to version 0.26.0, the handler in vllm/entrypoints/serve/utils/server_utils.py converted the raw exception directly into a string representation using str(exc). Under default FastAPI behavior, string conversion of a validation exception serializes the entire contextual route environment. This trace information contains internal application execution paths and local filesystem variables.

Furthermore, the helper library intended to filter sensitive outputs was functionally insufficient. The sanitize_message routine was only designed to strip memory address pointers from object representations using a basic regular expression. It did not parse or neutralize file directories, active operating system paths, or local file trace logs.

Code-Level Diff Analysis

The structural modifications implemented in the patch address both the exception formatting architecture and the fallback mitigation layers.

Below is a comparison of the vulnerable error-generation logic versus the patched approach inside vllm/entrypoints/serve/utils/server_utils.py:

# VULNERABLE APPROACH
async def validation_exception_handler(req: Request, exc: RequestValidationError) -> Response:
    # Raw string conversion of 'exc' serializes FastAPI's route traceback contexts
    exc_str = str(exc)
    errors_str = str(errors)
    if errors and errors_str and errors_str != exc_str:
        message = f"{exc_str} {errors_str}"
    else:
        message = exc_str
 
# PATCHED APPROACH
async def validation_exception_handler(req: Request, exc: RequestValidationError) -> Response:
    # Reconstructs errors using structured fields from exc.errors() instead of str(exc)
    if errors:
        count = len(errors)
        label = "error" if count == 1 else "errors"
        message = f"{count} validation {label}:\n"
        message += "".join(f"  {err}\n" for err in errors)
        message = message.rstrip()
    else:
        message = "Validation error"

Additionally, the patch hardens the fallback mechanism inside vllm/entrypoints/serve/utils/api_utils.py to strip out persistent filesystem details:

def sanitize_message(message: str) -> str:
    """Strip memory addresses, tracebacks, and file paths from error messages."""
    message = re.sub(r" at 0x[0-9a-f]+>", ">", message)
    # Strips raw Python traceback patterns
    message = re.sub(r'\n?\s*File "[^"]+", line \d+, in \S+(\n\s+.*)?', "", message)
    # Filters common base directories
    message = re.sub(
        r"/(?:home|usr|opt|var|tmp|root|lib|mnt|srv)(?:/[\w.\-]+)+", "<path>", message
    )
    # Fallback absolute path replacement
    message = re.sub(r"(?:/[\w\-]+)+/[\w\-]+\.\w+", "<path>", message)
    return message.strip()

Execution Flow Diagram

The following diagram tracks the processing sequence of a malformed client request through the application logic, highlighting how environmental details are exposed during error generation.

Exploitation Methodology

Exploitation of CVE-2026-73555 is straightforward and does not require complex payload mechanics. An attacker targeting the /v1/chat/completions endpoint can purposely submit invalid data types to force a validation failure.

For example, the endpoint expects the messages attribute to contain a list of objects. Transmitting a scalar string instead triggers a validation failure, prompting the server to formulate an error response. Because authentication is often bypassed or absent on these standard serving endpoints, any client on the network interface can generate this payload.

The resulting HTTP 422 Unprocessable Entity response returns the path structure of the virtual environment, the python system engine details, and the local shell username. This allows external threat actors to profile the underlying infrastructure without writing to disk or provoking system alerts.

Impact Assessment

While CVE-2026-73555 is assigned a CVSS score of 5.3 (Medium) due to its read-only impact, its role in a broader attack chain is substantial. Identifying absolute paths and system account names removes key barriers to local privilege escalation or sandbox escape.

Knowing that an instance runs in /home/deployer/vllm-env/ rather than a restricted system container allows attackers to design path-traversal scripts and locate configuration repositories. It also reveals file system permissions, package versions, and operational boundaries.

In environments utilizing containers, this leak compromises the confidentiality of host-mount directories. Because AI infrastructure is frequently deployed in cloud-managed nodes with elevated privileges, exposing the structural design of these endpoints increases the severity of adjacent host exploits.

Mitigation Analysis & Potential Gaps

The primary resolution is upgrading the installation to vLLM version 0.26.0 or higher. This modifies the exception formatter to avoid stringifying raw tracebacks.

However, potential gaps remain in the fallback validation logic. The patterns within sanitize_message rely entirely on Unix-like directory layouts. If vLLM is executed on a native Windows server, backslash-separated absolute directory paths (such as C:\Users\Administrator\vllm\) will not match the current regular expression layout and will still leak to remote users.

Furthermore, non-standard Unix mount directories like /app, /workspace, or /code are not targeted by the default pattern unless they contain a file extension. These omissions could allow some environments to remain partially vulnerable if errors escape the primary validation handler.

Official Patches

vllm-projectvLLM Security Advisory for GHSA-hwrm-c4cx-rf4j

Fix Analysis (1)

Technical Appendix

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

Affected Systems

vLLM API Server deployments running version < 0.26.0

Affected Versions Detail

Product
Affected Versions
Fixed Version
vllm
vllm-project
< 0.26.00.26.0
AttributeDetail
CWE IDCWE-209
Attack VectorNetwork (AV:N)
CVSS v3.15.3 (Medium)
EPSS Score0.00255
ImpactInformation Disclosure
Exploit Statuspoc
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1005Data from Local System
Collection
T1082System Information Discovery
Discovery
CWE-209
Generation of Error Message Containing Sensitive Information

The product generates an error message that contains sensitive information about its environment, applications, or associated data, which can expose internal implementation details to unauthorized parties.

Vulnerability Timeline

Fix commit merged into the codebase
2026-07-09
vLLM v0.26.0 released and CVE-2026-73555 published
2026-08-13

References & Sources

  • [1]vLLM Github Security Advisory
  • [2]vLLM Patch Commit

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-126298
7.5

CVE-2026-126298: Quadratic Algorithmic Complexity Denial of Service in NLTK Tree.chomsky_normal_form

CVE-2026-126298 (also tracked as GHSA-r53h-rw34-8h97) is an algorithmic complexity Denial of Service (DoS) vulnerability in the Natural Language Toolkit (NLTK) Python library affecting all versions prior to 3.10.4. The vulnerability resides in the nltk.tree.transforms.chomsky_normal_form function and its corresponding public method Tree.chomsky_normal_form(). When transforming a parse tree into Chomsky Normal Form using the default right-factoring strategy, the function repeatedly invokes list.pop(0) inside a loop iterating over all children of a node. In CPython, removing the initial element of a standard list requires an O(N) memory shift operation, causing the overall binarization algorithm to degrade to O(N^2) quadratic time complexity relative to the width of a node. Furthermore, converting horizontal node width into vertical tree depth bypasses initial parsing depth bounds, triggering subsequent stack exhaustion (RecursionError) when recursive methods traverse the mutated structure. Unauthenticated remote attackers who can submit bracketed tree strings to applications invoking this transformation can exhaust single-threaded CPU resources or induce unhandled application exceptions.

Alon Barad
Alon Barad
1 views•12 min read
•about 2 hours ago•CVE-2026-126299
7.5

CVE-2026-126299: Quadratic Algorithmic Complexity Denial of Service in NLTK CCG Lexicon Parser

An algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) before version 3.10.4 allows remote unauthenticated attackers to cause a denial of service via crafted Combinatory Categorial Grammar (CCG) lexicon strings. The parser in nltk.ccg.lexicon.fromstring performs repeated immutable string slicing, concatenation, and regex tail capturing, resulting in O(n^2) CPU consumption when processing wide, flat category definitions.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•CVE-2026-126295
7.1

CVE-2026-126295: Path Traversal and Unconfined File Access in NLTK BllipParser

CVE-2026-126295 (also tracked as GHSA-fg9w-wfp5-j933) is a path confinement bypass vulnerability in the Natural Language Toolkit (NLTK) affecting versions 3.10.0 prior to 3.10.4. The flaw resides in nltk/parse/bllip.py within the BllipParser class and its factory method BllipParser.from_unified_model_dir(). Unlike sibling tool wrappers in NLTK that enforce data-root confinement via the nltk.pathsec module, BllipParser passes caller-supplied filesystem paths directly into the third-party bllipparser native C extension without validation. When an application passes untrusted input as model paths or directories to BllipParser, an attacker can force the native extension to open arbitrary files on the local filesystem. This leads to information disclosure through parser diagnostic oracles, local model tampering via shared directories, and denial of service by hanging worker threads on blocking special files (such as FIFOs or device nodes) or exhausting memory via oversized files.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-126300
5.3

CVE-2026-126300: Algorithmic Complexity Denial of Service in NLTK TreebankWordTokenizer.span_tokenize

CVE-2026-126300 (GHSA-ffr9-mgrr-wcvr) is an inefficient algorithmic complexity vulnerability (CWE-407) in the Natural Language Toolkit (NLTK) Python library affecting versions 3.2.5 prior to 3.10.4. The flaw resides in the quote-restoration routine of TreebankWordTokenizer.span_tokenize and NLTKWordTokenizer.span_tokenize, where repeated calls to list.pop(0) over matched quote tokens introduce quadratic O(n^2) time complexity. An unauthenticated remote attacker who supplies input containing long sequences of double-quote characters can exhaust CPU resources and degrade service availability.

Amit Schendel
Amit Schendel
3 views•10 min read
•about 5 hours ago•GHSA-GPWC-27CW-RH9R
5.3

CVE-2026-126301: Quadratic CPU Exhaustion in NLTK LegalitySyllableTokenizer

The Natural Language Toolkit (NLTK) versions 3.6 through 3.10.3 contain an algorithmic complexity vulnerability in the LegalitySyllableTokenizer.tokenize method. When processing tokens composed of continuous runs of vowels, an unguarded string reversal and set membership lookup loop executes in quadratic time relative to the input token length. Remote attackers capable of submitting arbitrary text to applications utilizing this tokenizer can trigger sustained single-core CPU exhaustion and application-level denial of service.

Amit Schendel
Amit Schendel
5 views•10 min read
•about 6 hours 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
6 views•9 min read