[Bugfix][Security] Bound embedding densification before to_dense() (#54632)

Signed-off-by: lzhan011 <35493221+lzhan011@users.noreply.github.com>
Co-authored-by: Cyrus Leung <tlleungac@connect.ust.hk>
This commit is contained in:
lzhan011
2026-09-01 08:45:14 +00:00
committed by GitHub
co-authored by Cyrus Leung
parent 8905633687
commit ce7391712b
8 changed files with 226 additions and 18 deletions
@@ -2,7 +2,13 @@
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
"""
Tests verify that malicious sparse tensors are rejected before they can trigger
out-of-bounds memory writes during to_dense() operations.
out-of-bounds memory writes, or an unbounded allocation, during to_dense()
operations.
A sparse tensor carries its own declared shape, so the two failure modes are
independent: invalid *indices* are what the invariant checks catch, while a
valid tensor with an enormous declared *shape* passes those checks and is
bounded by `VLLM_MAX_EMBED_DECODE_BYTES` instead.
"""
import io
@@ -12,9 +18,12 @@ import pybase64 as base64
import pytest
import torch
import vllm.envs as envs
from vllm.exceptions import VLLMValidationError
from vllm.multimodal.media import AudioEmbeddingMediaIO, ImageEmbeddingMediaIO
from vllm.multimodal.media.video import VideoEmbeddingMediaIO
from vllm.renderers.embed_utils import safe_load_prompt_embeds
from vllm.utils.sparse_utils import safe_to_dense
@pytest.fixture
@@ -397,3 +406,136 @@ class TestSparseTensorValidationIntegration:
with pytest.raises((RuntimeError, ValueError)):
io_handler.load_base64("", attack_payload.decode("utf-8"))
# The real attack payload: 4 TiB of float32 once densified, from a single
# stored element. Only ever measured, never decoded.
BOMB_SHAPE = (2**20, 2**20)
# What the size-limit tests below actually build. Each of them also lowers
# `VLLM_MAX_EMBED_DECODE_BYTES` to `TEST_LIMIT_BYTES`, so the guard still has
# something to reject while nothing here can allocate more than 4 MiB even if
# the guard regressed. Keeping the 4 TiB shape in these tests would make the
# outcome depend on the runner: with `vm.overcommit_memory=0` the allocator
# refuses it outright, but with `vm.overcommit_memory=1` the malloc succeeds
# and the zero-fill is what fails, which would OOM the test process.
OVERSIZED_SHAPE = (1024, 1024) # 4 MiB dense
TEST_LIMIT_BYTES = 4096
EMBEDDING_MEDIA_IO = [
(ImageEmbeddingMediaIO, "image_embeds"),
(AudioEmbeddingMediaIO, "audio_embeds"),
(VideoEmbeddingMediaIO, "video_embeds"),
]
def _create_oversized_sparse_tensor(shape: tuple[int, int]) -> torch.Tensor:
"""A *valid* sparse tensor with one stored element and a declared `shape`.
Indices are in bounds, so `check_sparse_tensor_invariants()` accepts it.
That is the point: the invariant checks are not what stops this one.
"""
indices = torch.tensor([[0], [0]])
values = torch.tensor([1.0])
return torch.sparse_coo_tensor(indices, values, shape, dtype=torch.float32)
@pytest.fixture
def small_decode_limit(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setenv("VLLM_MAX_EMBED_DECODE_BYTES", str(TEST_LIMIT_BYTES))
class TestEmbeddingDecodeSizeLimit:
"""Bound the dense allocation a payload can declare.
`weights_only=True` stops code execution and the invariant checks stop
out-of-bounds indices, but neither bounds the declared shape.
"""
def test_oversized_sparse_tensor_rejected(self, small_decode_limit):
with pytest.raises(VLLMValidationError) as exc_info:
safe_to_dense(
_create_oversized_sparse_tensor(OVERSIZED_SHAPE),
parameter="prompt_embeds",
)
assert "VLLM_MAX_EMBED_DECODE_BYTES" in str(exc_info.value)
assert "prompt_embeds" in str(exc_info.value)
def test_default_limit_would_reject_the_real_payload(self):
"""The shipped default has to bound the actual attack, not just the
shrunken shape used above. Checked arithmetically so no test ever asks
the allocator for 4 TiB."""
dense_bytes = BOMB_SHAPE[0] * BOMB_SHAPE[1] * 4
assert dense_bytes > envs.VLLM_MAX_EMBED_DECODE_BYTES > 0
def test_attack_payload_is_tiny(self):
"""The payload really is small - this is amplification, not an upload."""
assert len(_encode_tensor(_create_oversized_sparse_tensor(BOMB_SHAPE))) < 4096
def test_valid_tensors_still_densify(self):
assert safe_to_dense(
_create_valid_dense_tensor(), parameter="prompt_embeds"
).shape == (10, 768)
dense = safe_to_dense(_create_valid_sparse_tensor(), parameter="image_embeds")
assert dense.shape == (3, 3)
assert not dense.is_sparse
def test_limit_is_configurable(self, monkeypatch: pytest.MonkeyPatch):
# 32 x 32 float32 == 4096 bytes, exactly at the limit.
monkeypatch.setenv("VLLM_MAX_EMBED_DECODE_BYTES", str(TEST_LIMIT_BYTES))
at_limit = _create_oversized_sparse_tensor((32, 32))
assert safe_to_dense(at_limit, parameter="image_embeds").shape == (32, 32)
over_limit = _create_oversized_sparse_tensor((33, 32))
with pytest.raises(VLLMValidationError):
safe_to_dense(over_limit, parameter="image_embeds")
def test_limit_can_be_disabled(self, monkeypatch: pytest.MonkeyPatch):
monkeypatch.setenv("VLLM_MAX_EMBED_DECODE_BYTES", "0")
tensor = _create_oversized_sparse_tensor(OVERSIZED_SHAPE)
assert safe_to_dense(tensor, parameter="image_embeds").shape == OVERSIZED_SHAPE
@pytest.mark.parametrize("io_cls,parameter", EMBEDDING_MEDIA_IO)
def test_media_io_rejects_oversized_base64(
self, io_cls, parameter, small_decode_limit
):
encoded = _encode_tensor(_create_oversized_sparse_tensor(OVERSIZED_SHAPE))
with pytest.raises(VLLMValidationError) as exc_info:
io_cls().load_base64("", encoded.decode("utf-8"))
assert parameter in str(exc_info.value)
@pytest.mark.parametrize("io_cls,parameter", EMBEDDING_MEDIA_IO)
def test_media_io_rejects_oversized_file(
self, io_cls, parameter, tmp_path, small_decode_limit
):
path = tmp_path / "embeds.pt"
torch.save(_create_oversized_sparse_tensor(OVERSIZED_SHAPE), path)
with pytest.raises(VLLMValidationError):
io_cls().load_file(path)
@pytest.mark.parametrize("io_cls,parameter", EMBEDDING_MEDIA_IO)
def test_media_io_rejects_non_tensor_payload(self, io_cls, parameter):
"""These three had no `isinstance` check, so a non-tensor payload
surfaced as an `AttributeError` (500) rather than a 4xx."""
buffer = io.BytesIO()
torch.save({"not": "a tensor"}, buffer)
encoded = base64.b64encode(buffer.getvalue()).decode("utf-8")
with pytest.raises(VLLMValidationError) as exc_info:
io_cls().load_base64("", encoded)
assert "torch.Tensor" in str(exc_info.value)
@pytest.mark.parametrize("io_cls,parameter", EMBEDDING_MEDIA_IO)
def test_media_io_still_accepts_valid_embeddings(self, io_cls, parameter):
tensor = torch.randn(4, 16, dtype=torch.float32)
encoded = _encode_tensor(tensor)
assert torch.equal(io_cls().load_base64("", encoded.decode("utf-8")), tensor)