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

CVE-2026-105752: Cross-Tenant Prefix-Cache Information Leak via Cache Salt Omission in vLLM Harmony Path

Alon Barad
Alon Barad
Software Engineer

Oct 6, 2026·7 min read·28 visits

Executive Summary (TL;DR)

vLLM fails to propagate the cache partition salt during multi-turn tool execution continuations, exposing post-tool prompt prefixes in the shared global cache and creating a side-channel oracle for co-tenants.

A vulnerability in vLLM prior to 0.30.0 allows an authenticated multi-tenant attacker to infer execution history and prompt structures of other tenants. The multi-turn Responses API ('Harmony' path) fails to propagate the 'cache_salt' parameter during tool-call continuation steps, storing sensitive prompt prefixes in the global, unsalted cache space.

Vulnerability Overview

vLLM is an open-source, high-throughput LLM serving engine designed to optimize inference performance using advanced memory management strategies. A core optimization within this engine is prefix caching, which retains the Key-Value (KV) cache of prompt prefixes across sequential inference requests. By caching the KV states of common prompts or system instructions, the engine significantly reduces the Time-to-First-Token (TTFT) and minimizes redundant graphics processing unit (GPU) computations during high-concurrency operations.

In multi-tenant environments where a single vLLM instance is shared among independent client accounts, sharing a global prefix cache exposes a side-channel vector. A malicious tenant can exploit timing patterns and metadata parameters to determine if other tenants have executed specific instructions. To prevent this cross-tenant information leakage, vLLM introduces the cache_salt configuration argument. The salt acts as a namespace partition by blending the salt value with the prompt prefix hash, thereby isolating cached KV states between different tenants.

CVE-2026-105752 (co-tracked under GitHub Advisory ID GHSA-935w-9g4m-p28p) identifies a flaw in this isolation architecture within vLLM versions prior to 0.30.0. Specifically, the vulnerability resides in the multi-turn GPT-OSS 'Harmony' path executed through the /v1/responses endpoint. When processing multi-turn interactions involving external tools or function calls, the engine fails to preserve and propagate the cache_salt parameter during automatic continuation turns. As a result, subsequent prompt states are stored in the global, unsalted prefix cache, defeating the privacy guarantees of the namespace partitioning mechanism.

Root Cause Analysis

The core of the vulnerability lies in how the vLLM multi-turn Responses API manages context transitions during tool execution. When a model request involves a tool or function call, the communication operates in an execution loop. The client initiates the first turn of the conversation, which correctly incorporates the client-specific cache_salt parameter, ensuring that the initial prompt is cached within an isolated partition.

Once the model triggers a tool, the engine processes the tool call locally, collects the output, and automatically initiates a continuation turn to feed the tool execution results back to the model context. During this transition, the handler must reconstruct the input objects for the next inference phase. However, the logic responsible for creating subsequent input structures fails to carry forward the original cache_salt argument from the initial query context.

Because the cache_salt is omitted during the reconstruction of the continuation engine inputs, the engine defaults to the global, unsalted namespace. Consequently, the prefix representing the post-tool execution state is cached in the shared storage area rather than the tenant-isolated sandbox. This omission compromises the cryptographic isolation of the cache and creates a reliable side-channel oracle for co-tenants.

Code Analysis and Diff

An analysis of the vulnerable codebase in vllm/entrypoints/openai/responses/serving.py confirms that the continuation logic was completely blind to the cache_salt configuration. During the evaluation loop of a multi-turn conversation, the context was updated via the HarmonyContext rendering functions, but the instantiation of tokens_input occurred without parameter forwarding:

# PRE-FIX VULNERABLE CODE
# Location: vllm/entrypoints/openai/responses/serving.py
if isinstance(context, HarmonyContext):
    token_ids = context.render_for_completion()
    # BUG: The tokens_input helper is called without passing the cache_salt
    engine_input = tokens_input(token_ids) 
 
    sampling_params.max_tokens = max_model_len - len(token_ids)

The patch implemented in commit 6a2a2bb02b563b83f946012959fd3927984d072a fixes the issue by extracting the cache_salt value from the original request inputs and passing it down to a newly developed rendering routine on the online_renderer object:

# POST-FIX PATCHED CODE
# Location: vllm/entrypoints/openai/responses/serving.py
# The fix extracts the salt from the first turn of the engine input
cache_salt = cast(str | None, engine_input.get("cache_salt"))
 
# ...
if isinstance(context, HarmonyContext):
    # The cache_salt is explicitly passed to the online renderer
    engine_input = self.online_renderer.render_responses_harmony_messages(
        context.messages,
        cache_salt=cache_salt,
        tok_params=tok_params,
    )
 
    sampling_params.max_tokens = max_model_len - self._extract_prompt_len(
        engine_input
    )

Additionally, vllm/renderers/online_renderer.py was extended to include the render_responses_harmony_messages helper method, which binds the extracted cache_salt directly into the final tokens_input parameters during downstream processing. This guarantees that all subsequent turns are correctly partitioned inside the isolated namespace:

# POST-FIX PATCHED RENDERER
# Location: vllm/renderers/online_renderer.py
def render_responses_harmony_messages(
    self,
    messages: list[OpenAIMessage],
    *,
    cache_salt: str | None,
    tok_params: TokenizeParams | None = None,
) -> EngineInput:
    arrival_time = time.time()
    prompt = TokensPrompt(prompt_token_ids=render_for_completion(messages))
    if tok_params is not None:
        tok_params.apply_post_tokenization(
            self.renderer.tokenizer,
            prompt,
        )
    # The salt is applied to the output engine_input structure
    engine_input = tokens_input(prompt["prompt_token_ids"], cache_salt=cache_salt)
    engine_input["arrival_time"] = arrival_time
    return engine_input

Exploitation Methodology

To exploit this vulnerability, an attacker must have low-privileged API access on the same multi-tenant vLLM server as the targeted victim. The attacker must also possess sufficient understanding of the victim's application workflow to reconstruct or predict the low-entropy structure of the post-tool execution prompt. This scenario is highly plausible in systems running standardized agent templates or commercial frameworks.

First, the victim issues a multi-turn request that incorporates a specific cache_salt and invokes a tool call. The vLLM engine processes the tool, drops the salt during the continuation turn, and caches the resulting post-tool prefix in the global, unsalted prefix cache namespace. Because the metadata contains standardized formatting around tool outputs, the cached prefix becomes predictable.

Next, the attacker constructs a probe request using the anticipated post-tool prompt structure and submits it to the /v1/responses endpoint. By analyzing the returned response, the attacker inspects metadata attributes such as cached_tokens_per_turn or evaluates the response latency. A non-zero cache count or significantly faster response time indicates a cache hit, verifying that another tenant executed that specific tool workflow. This timing side-channel acts as a precise membership oracle.

Impact Assessment

The security impact of CVE-2026-105752 is classified as a low-severity information leak. Although the vulnerability does not allow attackers to directly exfiltrate model weights, raw database records, or explicit conversation transcripts, it breaks the core tenant isolation boundaries defined by the prefix cache architecture.

The primary danger is metadata leakage and behavioral monitoring. An attacker can determine whether other users are interacting with sensitive internal tools, executing specific database queries, or generating routine financial transactions. This metadata exposure is highly critical in enterprise multi-tenant deployments where strict operational privacy is required.

The CVSS v3.1 score of 3.1 reflects the operational complexity of the attack. Exploitation requires high attack complexity because the attacker must anticipate the prompt formatting and have active low-privilege co-tenancy access. However, because prefix caching is enabled by default to optimize infrastructure costs, the affected attack surface is broad for setups leveraging the Harmony Responses framework.

Remediation and Mitigation

The definitive fix for this vulnerability is to upgrade the vLLM installation to version 0.30.0 or later. The update introduces the required code alterations to ensure that the cache_salt is persistently propagated through all internal continuation loops of the multi-turn processing lifecycles.

If upgrading is not immediately possible in production environments, administrators can mitigate the issue by disabling prefix caching globally. To apply this change, start the vLLM engine without the caching flag or set the parameter explicitly: --enable-prefix-caching=false. Note that disabling this parameter will degrade latency (specifically Time-to-First-Token) and increase computational costs under high workloads.

Additionally, security teams should implement monitoring controls on the vLLM server. Track the distribution of prompt cache hits across distinct tenant API tokens. An anomalous density of cache hits matching standard agent templates across different user accounts may indicate active probing or membership enumeration attempts.

Official Patches

vllm-projectPull Request #51818: Implement salt propagation during Harmony responses multi-turn loop.

Fix Analysis (1)

Technical Appendix

CVSS Score
3.1/ 10
CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:N

Affected Systems

vLLM engine deployments utilizing the multi-turn Responses API ('Harmony' path) with prefix caching enabled.

Affected Versions Detail

Product
Affected Versions
Fixed Version
vLLM
vllm-project
< 0.30.00.30.0
AttributeDetail
CWE IDCWE-524, CWE-200
Attack VectorNetwork
CVSS v3.1 Score3.1 (Low)
EPSS Score0.00043
ImpactPartial Tenant Cache Isolation Failure / Metadata Leakage
Exploit Statusnone
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1005Data from Local System
Collection
T1552Unsecured Credentials
Credential Access
CWE-524
Use of Cache Containing Sensitive Information

The product uses a cache that contains sensitive information, but the cache is not properly protected or isolated, allowing unauthorized actors to access or infer the cached data.

Vulnerability Timeline

Vulnerability identified and reported internally to vLLM maintainers
2026-02-10
Fix commit merged into main branch (PR #51818)
2026-02-15
vLLM v0.30.0 released containing the patch
2026-02-18
CVE-2026-105752 and Advisory GHSA-935w-9g4m-p28p published
2026-02-20

References & Sources

  • [1]GitHub Security Advisory: GHSA-935w-9g4m-p28p
  • [2]NVD - CVE-2026-105752 Detail
  • [3]CVE.org Authority Record for CVE-2026-105752
  • [4]vLLM v0.30.0 Release Tag

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

•18 minutes ago•CVE-2026-77382
5.9

CVE-2026-77382: Cryptographic Precision Loss in falcon-rust Discrete-Gaussian Sampler

A cryptographic soundness defect in the discrete-Gaussian sampler of falcon-rust prior to version 0.2.0 degrades acceptance-probability precision to approximately 2^-33. By evaluating exponential approximations using 32-bit fractional fixed-point arithmetic (FixedPoint64) and left-shifting polynomial inputs by 31 bits, the implementation violates Falcon's required precision bound of 2^-40 to 2^-46, invalidating the theoretical security reduction against statistical private key leakage.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 1 hour ago•CVE-2026-62955
7.2

CVE-2026-62955: Authenticated Path Traversal and Remote Code Execution via realpath() Bypass in baserCMS BcThemeFileService

CVE-2026-62955 is an authenticated path traversal vulnerability in baserCMS affecting versions 5.2.3 up to, but not including, 5.3.0. The flaw resides in the BcThemeFileService::getFullpath() method within the bc-theme-file plugin and represents an incomplete remediation of CVE-2026-30940. Because the path containment check relies on PHP's realpath() returning a non-false value, supplying a nonexistent theme subdirectory causes the verification guard to be skipped entirely. An authenticated administrator can exploit this flaw to read, write, overwrite, or delete arbitrary files within the permissions of the PHP process, leading to remote code execution when executable PHP files are written to the webroot.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-63012
6.5

CVE-2026-63012: Authorization Bypass and Information Disclosure in baserCMS Administrative API

CVE-2026-63012 is an authorization bypass and information disclosure vulnerability in baserCMS versions prior to 5.3.0. An architectural flaw in the authentication service configuration combined with overly permissive API access control rules allows low-privileged operator accounts to query restricted administrative API endpoints by supplying a matching HTTP Referer header.

Alon Barad
Alon Barad
1 views•9 min read
•about 3 hours ago•CVE-2026-102945
4.9

CVE-2026-102945: Unrecovered Goroutine Panic via Malformed NGAP PathSwitchRequest in Aether Project AMF

CVE-2026-102945 is a denial-of-service vulnerability affecting the Access and Mobility Management Function (AMF) of the Aether Project (omec-project/amf) prior to version 3.1.6. When processing an NGAP PathSwitchRequest message over the 3GPP N2 interface, the HandlePathSwitchRequest function fails to verify the byte slice lengths of extensible APER bit strings inside the UESecurityCapabilities Information Element before accessing index zero. Because the NGAP receive goroutine lacks a panic recovery handler, supplying a zero-length bit string triggers an out-of-bounds slice read panic that terminates the entire AMF daemon.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 4 hours ago•CVE-2026-103025
8.7

CVE-2026-103025: Unbounded Memory Allocation and Decompression Bomb in bep/imagemeta PNG Parser

CVE-2026-103025 (GHSA-7hvw-3c2q-45qg) is a high-severity denial-of-service (DoS) vulnerability in github.com/bep/imagemeta prior to version 0.17.3. The PNG metadata parser fails to validate declared chunk lengths prior to heap buffer allocation (CWE-789) and inflates zlib-compressed zTXt IPTC chunks without an output size limit (CWE-409). Additionally, out-of-bounds slice indexing in the PNG zTXt handler and IPTC character set resolver allows remote attackers to trigger runtime panics.

Amit Schendel
Amit Schendel
2 views•1 min read
•about 5 hours ago•CVE-2026-103033
5.3

CVE-2026-103033: Pre-Verification Nil-Map Panic and Denial of Service in ALTCHA Go Library

CVE-2026-103033 (GHSA-gfwj-45pc-w6r5) is an unauthenticated pre-verification Denial of Service (DoS) vulnerability in the Go implementation of the ALTCHA bot-prevention library (github.com/altcha-org/altcha-lib-go). In versions 2.0.0 and 2.0.1, the internal function parseServerSignature conditionally initializes the ServerSignatureVerificationData.Extra map only when url.ParseQuery returns no error. When an attacker submits a payload containing both an unrecognized query parameter and malformed percent-encoding in the VerificationData field, url.ParseQuery returns partially parsed parameters alongside an error. Because execution continues without initializing the Extra map, the subsequent loop attempts to write unknown parameters into a nil map, triggering a fatal Go runtime panic before cryptographic signature verification occurs.

Alon Barad
Alon Barad
2 views•10 min read