/

CVE-2026-54234

Severity:

HIGH RISK

(7.5)

Input Validation Flaw (CWE-20) in vLLM Sampler Engine

CVE-2026-54234

Analyzed

Vulnerability type

Category:

Input Validation Vulnerability

CWE:

CWE-20, CWE-1284

Impact:

Denial of Service

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A token handling flaw in vLLM's speculative decoding path allows a recovered token value at the vocabulary boundary to be converted into an invalid, out-of-range token identifier.

When this invalid token flows into the embedding and attention computation on the GPU, it triggers a device-side assertion and crashes the engine worker. A remote client that can send generation and abort requests over gRPC can exploit this to repeatedly crash a shared worker, causing denial of service for other users until the service is restarted.

Affected context

This vulnerability occurs in vLLM deployments that expose the public gRPC Generate and Abort endpoints and use multi-request speculative decoding workloads.

It becomes relevant when the rejection sampler emits a token value equal to the vocabulary size boundary, and downstream logic fails to robustly validate or clamp this value before it is written back into drafter input IDs.

Environments where multiple tenants or clients share the same engine worker are particularly affected, as a single malformed but frontend-legal request sequence can crash the worker and interrupt all concurrent inference sessions.

Exploit preconditions

  • Attack surface: Public or internal gRPC inference interface implementing Generate and Abort RPCs.
  • Required access: Ability to send syntactically valid generation and abort requests to the vLLM service; no direct GPU or host access is required.
  • Trigger point: A specific multi-request speculative decoding pattern that causes the rejection sampler to output a token equal to the vocabulary size boundary, which is then converted to -1 and propagated into the model input IDs.
  • Why exploitation is possible: The token handling and validation logic does not enforce strict bounds on recovered token IDs before they reach the embedding and attention pathways, allowing an out-of-vocabulary index to hit GPU kernels and trigger a device-side assertion.

Why this happens

The underlying bug is insufficient validation and bounds checking around token indices produced by the rejection sampler in a speculative decoding workload.

A boundary token value equal to the vocabulary size is converted into -1 when selecting the next live token, and this negative index is treated as a legitimate input ID and fed into the model's embedding and attention stack.

This maps to CWE-20: Improper Input Validation, because sampler outputs are not constrained to valid token ranges and are trusted by downstream logic, and it is related to CWE-1284, where computations on invalid data lead to hardware faults and process crashes.

Potential impact

  • Remote clients may crash the GPU-backed engine worker, interrupting all in-flight inference requests.
  • Shared inference services could experience repeated downtime, degrading reliability and availability.
  • Other tenants or applications using the same vLLM deployment can lose service until operators detect and restart workers.
  • Automated pipelines that depend on continuous LLM inference may fail or stall due to service-wide denial of service.

General mitigation guidance

Mitigation typically focuses on enforcing strict token index validation and making inference paths resilient to invalid sampler outputs.

Useful defensive patterns include:

  • Applying robust bounds checks and clamping on all token IDs produced by samplers and speculative decoding routines before they are written into model input buffers.
  • Designing the sampler and drafter interaction so that vocabulary boundary values are either rejected, corrected, or replaced with safe defaults rather than propagated into the model.
  • Ensuring GPU kernels gracefully handle unexpected indices by validating inputs at the host level and failing fast with controlled errors instead of device-side assertions.
  • Isolating engine workers per tenant or workload class and applying concurrency controls so failures in one request stream do not take down all clients.
  • Running inference services behind rate limiting and anomaly detection to reduce the impact of repeated crash attempts.

How teams detect issues like this

Detection commonly involves combining runtime monitoring with code-level checks:

  • Runtime observability can track GPU device-side assertion failures, sudden worker exits, and correlated patterns of Generate/Abort calls from specific clients.
  • Static analysis and code review can focus on token handling paths, ensuring all sampler outputs pass through centralized bounds-checking logic before reaching GPU kernels.
  • Defensive coding guidelines can require explicit validation of indices used in embeddings, attention, and other tensor operations, with tests that exercise boundary and error conditions.
  • Automated security and quality tools may flag arithmetic or conversions around vocabulary size boundaries, negative indices, or unchecked array/tensor indexing in the inference engine.

Sources

SourceLink
github.comgithub.com/vllm-project/vllm/commit/8a5cf1ccd65e8ac7635c402c1ec0b08988bc26ca
github.comgithub.com/vllm-project/vllm/pull/44744
github.comgithub.com/vllm-project/vllm/security/advisories/GHSA-8wr5-jm2h-8r4f

Frequently asked

questions

Yes. Any client that can reach the vLLM gRPC Generate and Abort endpoints and craft the required speculative decoding request pattern can trigger the crash remotely.

No. The attacker does not need host-level or GPU-level privileges; they only need logical access to the inference API and the ability to send valid request sequences that exercise the buggy sampler path.

The safest pattern is to enforce strict bounds checking for all token IDs, especially outputs from samplers and speculative decoding logic, and to ensure that any out-of-range or sentinel values are handled gracefully without reaching GPU embedding or attention operations.

Future designs should treat all intermediate numeric outputs as untrusted until validated, centralize index validation before tensor operations, add tests around vocabulary boundaries and error paths, and incorporate runtime guards that fail gracefully rather than allowing invalid data to cause device assertions and service-wide crashes.

Find out what's already
exploitable in your codebase.