From 01345197afcaf83f7faf2db9969672f92f128c3a Mon Sep 17 00:00:00 2001 From: Max Kong Date: Tue, 6 Oct 2026 16:14:39 +0800 Subject: [PATCH] [diffusion] chore: harden OpenAI upload filename handling (#17270) = --- docs/docs/sglang-diffusion/api/openai_api.mdx | 4 + .../runtime/entrypoints/openai/image_api.py | 5 +- .../runtime/entrypoints/openai/mesh_api.py | 7 +- .../openai/realtime/realtime_adapter.py | 4 +- .../runtime/entrypoints/openai/utils.py | 42 +++- .../runtime/entrypoints/openai/video_api.py | 9 +- .../multimodal_gen/runtime/utils/image_io.py | 15 +- .../unit/realtime/test_realtime_runtime.py | 2 +- .../test/unit/test_openai_security.py | 179 ++++++++++++++++++ 9 files changed, 255 insertions(+), 12 deletions(-) create mode 100644 python/sglang/multimodal_gen/test/unit/test_openai_security.py diff --git a/docs/docs/sglang-diffusion/api/openai_api.mdx b/docs/docs/sglang-diffusion/api/openai_api.mdx index 8e5a3f8d51..ea46cdffe0 100644 --- a/docs/docs/sglang-diffusion/api/openai_api.mdx +++ b/docs/docs/sglang-diffusion/api/openai_api.mdx @@ -215,6 +215,10 @@ curl -sS -X POST "http://localhost:30010/v1/images/generations" \ This endpoint accepts a multipart form upload with input images and a text prompt. The server can return either a base64-encoded image or a URL to download the image. +Uploaded filenames are sanitized, and saved uploads are constrained to the +server's upload directory. This also applies to image uploads for video and mesh +generation. + **Curl Example (b64_json response):** ```bash Command diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py index c483f0104b..18f856cc49 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/image_api.py @@ -45,6 +45,7 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( process_generation_batch, request_extra_value, resolve_sampling_params_cls, + sanitize_upload_filename, save_image_to_path, temp_dir_if_disabled, ) @@ -470,10 +471,12 @@ async def edits( try: for idx, img in enumerate(image_list): filename = img.filename if hasattr(img, "filename") else f"image_{idx}" + safe_name = sanitize_upload_filename(filename, f"image_{idx}") input_path = await save_image_to_path( img, - os.path.join(uploads_dir, f"{request_id}_{idx}_{filename}"), + os.path.join(uploads_dir, f"{request_id}_{idx}_{safe_name}"), prefer_remote_source=server_args.input_save_path is None, + uploads_root=uploads_dir, ) input_paths.append(input_path) except Exception as e: diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py index be917951d7..fd3d10d6e0 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/mesh_api.py @@ -31,6 +31,7 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( add_common_data_to_response, merge_image_input_list, process_generation_batch, + sanitize_upload_filename, save_image_to_path, ) from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -164,9 +165,12 @@ async def create_mesh( os.makedirs(uploads_dir, exist_ok=True) img = image_list[0] filename = img.filename if hasattr(img, "filename") else "input_image" + safe_name = sanitize_upload_filename(filename, "input_image") try: input_path = await save_image_to_path( - img, os.path.join(uploads_dir, f"{request_id}_{filename}") + img, + os.path.join(uploads_dir, f"{request_id}_{safe_name}"), + uploads_root=uploads_dir, ) except Exception as e: raise HTTPException( @@ -200,6 +204,7 @@ async def create_mesh( input_path = await save_image_to_path( img_src, os.path.join(uploads_dir, f"{request_id}_input_image"), + uploads_root=uploads_dir, ) req = MeshGenerationsRequest(**payload) diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py index 55446272bd..524dec982b 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/realtime/realtime_adapter.py @@ -83,7 +83,9 @@ async def save_realtime_first_frame( else: target_path = os.path.join(uploads_dir, f"{session.id}_first_frame") - request.first_frame = await save_image_to_path(first_frame, target_path) + request.first_frame = await save_image_to_path( + first_frame, target_path, uploads_root=uploads_dir + ) def build_realtime_sampling_params( diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py index cb43d29873..46e7ed4875 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/utils.py @@ -4,6 +4,7 @@ import dataclasses import inspect import json import os +import re import shutil import tempfile import time @@ -33,7 +34,10 @@ from sglang.multimodal_gen.runtime.pipelines_core.schedule_batch import OutputBa from sglang.multimodal_gen.runtime.scheduler_client import AsyncSchedulerClient from sglang.multimodal_gen.runtime.server_args import get_global_server_args from sglang.multimodal_gen.runtime.utils.common import parse_size -from sglang.multimodal_gen.runtime.utils.image_io import save_base64_image_to_path +from sglang.multimodal_gen.runtime.utils.image_io import ( + ensure_path_within_root, + save_base64_image_to_path, +) from sglang.multimodal_gen.runtime.utils.logging_utils import ( init_logger, log_batch_completion, @@ -299,14 +303,33 @@ def resolve_sampling_params_cls(server_args: Any) -> type[SamplingParams]: return sampling_params_cls +def sanitize_upload_filename(filename: str, fallback: str) -> str: + name = os.path.basename((filename or "").replace("\\", "/")) + if not name or name in {".", ".."}: + name = fallback + + stem, ext = os.path.splitext(name) + safe_stem = re.sub(r"[^A-Za-z0-9._-]+", "_", stem).strip("._") + safe_ext = re.sub(r"[^A-Za-z0-9.]+", "", ext) + if not safe_stem: + safe_stem = re.sub(r"[^A-Za-z0-9._-]+", "_", fallback).strip("._") or "upload" + return f"{safe_stem}{safe_ext}" + + async def save_image_to_path( image: Union[UploadFile, bytes, str], target_path: str, *, prefer_remote_source: bool = False, + uploads_root: str | None = None, ) -> str: + if uploads_root is not None: + target_path = ensure_path_within_root(target_path, uploads_root) input_path = await _maybe_url_image( - image, target_path, prefer_remote_source=prefer_remote_source + image, + target_path, + prefer_remote_source=prefer_remote_source, + uploads_root=uploads_root, ) if input_path is None: input_path = await _save_upload_to_path(image, target_path) @@ -345,6 +368,7 @@ async def _maybe_url_image( target_path: str, *, prefer_remote_source: bool = False, + uploads_root: str | None = None, ) -> str | None: if not isinstance(img_url, str): return None @@ -355,19 +379,25 @@ async def _maybe_url_image( if prefer_remote_source: return img_url # download image from URL and persist on disk - input_path = await _save_url_image_to_path(img_url, target_path) + input_path = await _save_url_image_to_path( + img_url, target_path, uploads_root=uploads_root + ) return input_path elif img_url.startswith("data:image"): if prefer_remote_source: return img_url # encode image base64 url and persist on disk - input_path = save_base64_image_to_path(img_url, target_path) + input_path = save_base64_image_to_path( + img_url, target_path, uploads_root=uploads_root + ) return input_path else: raise ValueError("Unsupported image url format") -async def _save_url_image_to_path(image_url: str, target_path: str) -> str: +async def _save_url_image_to_path( + image_url: str, target_path: str, *, uploads_root: str | None = None +) -> str: """Download image from URL and save to target path.""" def _is_retryable_download_error(error: Exception) -> bool: @@ -433,6 +463,8 @@ async def _save_url_image_to_path(image_url: str, target_path: str) -> str: ) target_path = f"{target_path}{ext}" + if uploads_root is not None: + target_path = ensure_path_within_root(target_path, uploads_root) with open(target_path, "wb") as f: f.write(response.content) diff --git a/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py b/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py index 29992ed58c..2aa7eb00d9 100644 --- a/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py +++ b/python/sglang/multimodal_gen/runtime/entrypoints/openai/video_api.py @@ -49,6 +49,7 @@ from sglang.multimodal_gen.runtime.entrypoints.openai.utils import ( process_generation_batch, request_extra_value, resolve_sampling_params_cls, + sanitize_upload_filename, save_image_to_path, ) from sglang.multimodal_gen.runtime.entrypoints.utils import prepare_request @@ -371,9 +372,13 @@ async def _save_first_input_image( os.makedirs(uploads_dir, exist_ok=True) filename = image.filename if hasattr(image, "filename") else "url_image" - target_path = os.path.join(uploads_dir, f"{request_id}_{filename}") + safe_name = sanitize_upload_filename(filename, "url_image") + target_path = os.path.join(uploads_dir, f"{request_id}_{safe_name}") return await save_image_to_path( - image, target_path, prefer_remote_source=prefer_remote_source + image, + target_path, + prefer_remote_source=prefer_remote_source, + uploads_root=uploads_dir, ) diff --git a/python/sglang/multimodal_gen/runtime/utils/image_io.py b/python/sglang/multimodal_gen/runtime/utils/image_io.py index e40b64915b..3d9f2209d8 100644 --- a/python/sglang/multimodal_gen/runtime/utils/image_io.py +++ b/python/sglang/multimodal_gen/runtime/utils/image_io.py @@ -2,9 +2,20 @@ import base64 import os import re +from pathlib import Path -def save_base64_image_to_path(base64_data: str, target_path: str) -> str: +def ensure_path_within_root(target_path: str, root_dir: str) -> str: + root_path = Path(root_dir).resolve() + candidate = Path(target_path).resolve() + if root_path != candidate and root_path not in candidate.parents: + raise ValueError("Upload path escapes the uploads root") + return str(candidate) + + +def save_base64_image_to_path( + base64_data: str, target_path: str, *, uploads_root: str | None = None +) -> str: b64_format_hint = ( "Failed to decode base64 image. " "Expected format: `data:[];base64,`" @@ -28,6 +39,8 @@ def save_base64_image_to_path(base64_data: str, target_path: str) -> str: else: ext = "jpg" target_path = f"{target_path}.{ext}" + if uploads_root is not None: + target_path = ensure_path_within_root(target_path, uploads_root) os.makedirs(os.path.dirname(target_path), exist_ok=True) try: diff --git a/python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py b/python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py index d9b05dccfc..a396640f0a 100644 --- a/python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py +++ b/python/sglang/multimodal_gen/test/unit/realtime/test_realtime_runtime.py @@ -239,7 +239,7 @@ def test_sana_wm_realtime_camera_state_uses_sana_normalizer(): def test_sana_wm_realtime_adapter_preserves_requested_size(): - async def fake_save_image_to_path(image, target_path): + async def fake_save_image_to_path(image, target_path, *, uploads_root): return target_path old_save_image_to_path = realtime_adapter.save_image_to_path diff --git a/python/sglang/multimodal_gen/test/unit/test_openai_security.py b/python/sglang/multimodal_gen/test/unit/test_openai_security.py new file mode 100644 index 0000000000..c3f15222c8 --- /dev/null +++ b/python/sglang/multimodal_gen/test/unit/test_openai_security.py @@ -0,0 +1,179 @@ +# SPDX-License-Identifier: Apache-2.0 + +import asyncio +import io +from pathlib import Path +from types import SimpleNamespace + +import httpx +import pytest +from fastapi import FastAPI, HTTPException +from fastapi.testclient import TestClient +from starlette.datastructures import UploadFile + +from sglang.multimodal_gen.configs.sample.sampling_params import SamplingParams +from sglang.multimodal_gen.runtime.entrypoints.openai import ( + image_api, + mesh_api, + utils, + video_api, +) +from sglang.multimodal_gen.runtime.utils.image_io import ensure_path_within_root + + +@pytest.mark.parametrize( + "filename,expected", + [ + ("../../evil.txt", "evil.txt"), + (r"..\..\evil.txt", "evil.txt"), + ("/tmp/evil.txt", "evil.txt"), + ("..", "fallback"), + ("", "fallback"), + ("unsafe\x00 name.png", "unsafe_name.png"), + ], +) +def test_sanitize_upload_filename(filename, expected): + assert utils.sanitize_upload_filename(filename, "fallback") == expected + + +def test_ensure_path_within_root_rejects_escape(tmp_path): + root = tmp_path / "uploads" + with pytest.raises(ValueError, match="escapes"): + ensure_path_within_root(root / ".." / "evil.txt", root) + + +@pytest.fixture(params=["upload", "bytes", "base64", "url"]) +def image_source(request, monkeypatch): + if request.param == "upload": + return UploadFile(io.BytesIO(b"image"), filename="image.png"), "" + if request.param == "bytes": + return b"image", "" + if request.param == "base64": + return "data:image/png;base64,aW1hZ2U=", ".png" + + client_cls = httpx.AsyncClient + transport = httpx.MockTransport( + lambda req: httpx.Response( + 200, headers={"content-type": "image/png"}, content=b"image" + ) + ) + monkeypatch.setattr( + utils.httpx, + "AsyncClient", + lambda **kwargs: client_cls(transport=transport, **kwargs), + ) + return "https://example.invalid/image.png", ".png" + + +def test_save_image_sources_within_uploads_root(tmp_path, image_source): + source, suffix = image_source + root = tmp_path / "uploads" + saved = asyncio.run( + utils.save_image_to_path(source, str(root / "input"), uploads_root=str(root)) + ) + assert Path(saved) == root / f"input{suffix}" + assert Path(saved).read_bytes() == b"image" + + +def test_save_image_sources_reject_escape_before_writing(tmp_path, image_source): + source, _ = image_source + root = tmp_path / "uploads" + with pytest.raises(ValueError, match="escapes"): + asyncio.run( + utils.save_image_to_path( + source, str(root / ".." / "outside"), uploads_root=str(root) + ) + ) + assert not list(tmp_path.iterdir()) + + +def test_final_upload_path_cannot_follow_symlink_outside_root(tmp_path, image_source): + source, suffix = image_source + root = tmp_path / "uploads" + root.mkdir() + outside = tmp_path / "outside" + outside.write_bytes(b"unchanged") + (root / f"input{suffix}").symlink_to(outside) + with pytest.raises(Exception, match="escapes"): + asyncio.run( + utils.save_image_to_path( + source, str(root / "input"), uploads_root=str(root) + ) + ) + assert outside.read_bytes() == b"unchanged" + + +@pytest.mark.parametrize( + "source", ["https://example.invalid/image.png", "data:image/png;base64,aW1hZ2U="] +) +def test_prefer_remote_source_still_avoids_disk_io(tmp_path, source): + root = tmp_path / "uploads" + saved = asyncio.run( + utils.save_image_to_path( + source, + str(root / "input"), + uploads_root=str(root), + prefer_remote_source=True, + ) + ) + assert saved == source + assert not root.exists() + + +def test_video_upload_sanitizes_filename_and_preserves_metadata(tmp_path): + filename = "../../../evil.png" + upload = UploadFile(io.BytesIO(b"image"), filename=filename) + saved = asyncio.run( + video_api._save_first_input_image([upload], "request", str(tmp_path)) + ) + assert Path(saved) == tmp_path / "request_evil.png" + assert Path(saved).read_bytes() == b"image" + assert upload.filename == filename + + +@pytest.mark.parametrize( + "api,endpoint,stop_at,relative_path", + [ + ( + image_api, + "/v1/images/edits", + "build_sampling_params", + "uploads/request_0_evil.png", + ), + ( + mesh_api, + "/v1/meshes", + "_build_sampling_params_from_request", + "outputs/uploads/request_evil.png", + ), + ], +) +def test_multipart_upload_is_sanitized_before_generation( + monkeypatch, tmp_path, api, endpoint, stop_at, relative_path +): + monkeypatch.chdir(tmp_path) + args = SimpleNamespace( + input_save_path=str(tmp_path / "uploads"), + output_path=str(tmp_path / "outputs"), + ) + monkeypatch.setattr(api, "get_global_server_args", lambda: args) + monkeypatch.setattr(api, "generate_request_id", lambda: "request") + monkeypatch.setattr( + image_api, "resolve_sampling_params_cls", lambda args: SamplingParams + ) + + def stop_before_generation(*args, **kwargs): + assert (tmp_path / relative_path).read_bytes() == b"image" + raise HTTPException(status_code=418, detail="upload verified") + + monkeypatch.setattr(api, stop_at, stop_before_generation) + app = FastAPI() + app.include_router(api.router) + with TestClient(app) as client: + response = client.post( + endpoint, + data={"prompt": "test"}, + files={"image": ("../../../evil.png", b"image", "image/png")}, + ) + assert response.status_code == 418, response.text + assert not (tmp_path / "evil.png").exists()