Skip to main content

KubeSphere CVE-2026-71208

| EUVDEUVD-2026-53205 MEDIUM
Server-Side Request Forgery (SSRF) (CWE-918)
2026-08-05 TuranSec GHSA-w56j-p32j-vmh4
6.5
CVSS 3.1 · Vendor: TuranSec
View

Attack ChainAIDerived

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

  1. Access
    Obtain low-privileged RBAC with Cluster CRD write access
  2. Delivery
    Craft Cluster CRD with cloud metadata URL as API server endpoint
  3. Exploit
    Submit malicious CRD via kubectl or Kubernetes API
  4. Execution
    Controller-manager reconciler calls Discovery().ServerVersion() against 169.254.169.254
  5. Persist
    Retrieve IAM credentials from IMDS HTTP response
  6. Impact
    Use stolen credentials to escalate within the cloud account

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK

2 techniques across 2 tactics: Initial Access, Credential Access

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

The attacker must hold Kubernetes RBAC permissions granting 'create' or 'update' verbs on the clusters resource in the cluster.kubesphere.io API group - this is a low-privilege but non-default permission that must be deliberately assigned via a ClusterRole or Role binding, not simply being an authenticated Kubernetes user. The KubeSphere multi-cluster management feature must be active and the cluster-controller reconciliation loop must be running; single-cluster deployments without this component are not exposed through this specific code path. Exploitation is fully automated once the malicious Cluster CRD is submitted - no administrator review or interaction is required before the controller-manager issues the SSRF request. The highest-impact exploitation path (cloud credential theft) additionally requires the controller-manager pods to be scheduled on nodes where the cloud provider IMDS at 169.254.169.254 is reachable from the pod network, which is the default on AWS, GCP, and Azure unless IMDS access is explicitly blocked at the hypervisor or via IMDSv2 enforcement. On-premises or air-gapped deployments still face SSRF against internal RFC1918 services reachable from the controller-manager pod's network position.

Impact

The NVD-assigned CVSS 3.1 score of 7.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N) correctly reflects the low-privilege prerequisite and high confidentiality impact, but the S:U (Unchanged scope) assignment likely understates real-world impact. SSRF against cloud instance metadata services constitutes a scope change: the affected resource - IAM credentials, instance identity, user-data scripts from IMDS - lies entirely outside the Kubernetes cluster's security authority. An S:C assessment yields a base score of approximately 8.5. No EPSS data was provided in the intelligence feed, which is a gap; without it, probabilistic exploitation likelihood cannot be quantified from available signals. CISA KEV is absent, meaning active in-the-wild exploitation has not been independently confirmed. However, a public researcher write-up exists, reducing the skill barrier for exploitation significantly. Real-world priority should be rated HIGH for any KubeSphere deployment on AWS, GCP, or Azure infrastructure where IMDS is reachable from the pod network: successful SSRF to 169.254.169.254 can return short-lived but high-privilege cloud IAM credentials, enabling full cloud account takeover as a secondary step entirely outside the Kubernetes blast radius. On-premises deployments face SSRF against internal services but cannot reach cloud IMDS, reducing but not eliminating risk.

Exploit ScenarioDerived

A developer or tenant holding a namespace-scoped role that includes 'create' on clusters.cluster.kubesphere.io submits a crafted Cluster CRD with the connection API server URL set to http://169.254.169.254/latest/meta-data/iam/security-credentials/my-ec2-role. The KubeSphere controller-manager's reconciliation loop immediately issues an HTTP GET to that address via Discovery().ServerVersion(), and - because the pod runs on an EC2 node with an attached IAM role - the IMDS returns a JSON credential blob containing an access key, secret key, and session token. A public researcher write-up at https://github.com/ashikmd7/kubeSphere/blob/main/SSRF%20via%20Cluster%20CRD%20KubeConfig/README.md demonstrates this technique, substantially lowering the bar for exploitation.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 05, 2026

Server-Side Request Forgery in KubeSphere's multi-cluster controller allows any low-privileged user with Cluster CRD create or update permissions to weaponize the controller-manager and apiserver pods as HTTP proxies against arbitrary internal addresses, RFC1918 networks, and cloud instance metadata services including AWS IMDS at 169.254.169.254. The flaw resides in pkg/utils/clusterclient/clusterclient.go (addCluster), where the CRD-specified Kubernetes API endpoint undergoes only Go url.Parse() syntax validation before Discovery().ServerVersion() is called - no loopback, private-range, link-local, or metadata-address filtering is applied. A public researcher write-up demonstrating the attack path exists; no active exploitation has been confirmed in CISA KEV at time of analysis.

RemediationAI

No vendor-released patch with an explicit fixed version has been identified at time of analysis. Administrators should monitor the upstream repository at https://github.com/kubesphere/kubesphere for commits addressing SSRF in pkg/utils/clusterclient/clusterclient.go and apply a patched release once available. As an immediate compensating control, restrict Kubernetes RBAC so that only cluster-admin-equivalent roles can create or update Cluster CRDs (clusters.cluster.kubesphere.io); removing 'create' and 'update' verbs on this resource from tenant or developer roles eliminates the PR:L attack surface entirely, limiting exploitation to actors who are already highly privileged. For cloud-hosted deployments, enforce IMDSv2 (Instance Metadata Service v2) on all nodes - this requires a session-oriented PUT request before any GET to the metadata endpoint, blocking naive HTTP-level SSRF probes against 169.254.169.254, though it does not prevent SSRF against other RFC1918 targets. Deploy Kubernetes NetworkPolicy or service-mesh egress rules on the controller-manager pod's namespace to restrict outbound connections to known, trusted Kubernetes API server CIDRs only; this prevents lateral SSRF to internal services but requires accurate enumeration of legitimate destinations and will break multi-cluster functionality if too restrictive. None of these controls address the root cause - the definitive fix is a patched KubeSphere release that implements a destination allowlist or blocklist in addCluster.

Affected VersionsENISA

KubeSphere 4.0.0 ≤4.1.3-rc.0

Affected Packages

euvd kubesphere no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

KubeSphere extends Kubernetes with a Cluster custom resource definition (CRD) to manage federated multi-cluster topologies. Its cluster-controller reconciliation loop processes every Cluster CRD object and, in the addCluster function of pkg/utils/clusterclient/clusterclient.go, reads the .spec.connection field containing the target API server URL and kubeconfig, then immediately invokes client-go's Discovery().ServerVersion() HTTP GET against that URL. URL validation is limited to Go's stdlib url.Parse(), which only checks syntactic correctness and does not validate the destination host against any allowlist of trusted Kubernetes API server addresses or any blocklist for loopback (127.0.0.1/::1), RFC1918 private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), link-local (169.254.0.0/16), or cloud-metadata addresses. CWE-918 (Server-Side Request Forgery) precisely characterizes this root cause: the server accepts a URL from an untrusted source and fetches it without enforcing a destination trust boundary, making the controller-manager pod an unintended HTTP proxy. The CPE cpe:2.3:a:kubesphere:kubesphere:*:*:*:*:*:*:*:* indicates all tracked KubeSphere versions are affected.

Know when Kubesphere 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 (TuranSec) PRIMARY 6.5 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
vuln.today AI 7.7 HIGH

S:C chosen over NVD's S:U because SSRF pivots to cloud IMDS and internal hosts outside the cluster's security authority; all other metrics align with the NVD vector.

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

Primary rating from Vendor (TuranSec).

CVSS VectorVendor: TuranSec

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
None
Availability
None

Lifecycle Timeline

3
Severity Changed
Aug 05, 2026 - 08:22 NVD
HIGH MEDIUM
CVSS changed
Aug 05, 2026 - 08:22 NVD
7.1 (HIGH) 6.5 (MEDIUM)
CVE Published
Aug 05, 2026 - 06:59 cve.org
HIGH 7.1

DescriptionCVE.org

KubeSphere's cluster-controller reconciliation (pkg/utils/clusterclient/clusterclient.go, addCluster) processes every Cluster custom resource's connection configuration and immediately calls Discovery().ServerVersion() against the CRD-specified Kubernetes API endpoint, which is parsed only for URL syntax (url.Parse) with no allow/deny-list for loopback, RFC1918 private ranges, link-local, or cloud-metadata addresses (e.g. 169.254.169.254). A user able to create or update a Cluster CRD can force the controller-manager and apiserver pods to issue outbound requests to arbitrary internal or metadata endpoints.

Executive ViewAI

Why It Matters

KubeSphere's multi-cluster controller contains a server-side request forgery vulnerability (CVE-2026-71208, CVSS 7.1) with publicly available exploit code. The flaw allows low-privileged Kubernetes users with basic Cluster CRD permissions to redirect controller pod traffic toward internal networks and cloud credential services, creating a high-risk lateral movement vector. No vendor patch is currently available, making immediate compensating controls critical for organizations running KubeSphere in cloud environments.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Implement immediate network segmentation to block pod egress to cloud metadata services (AWS IMDS at 169.254.169.254 and equivalent endpoints), restrict Cluster CRD create/update permissions to essential users via RBAC enforcement, deploy Kubernetes network policies to deny traffic from controller-manager and apiserver pods to RFC1918 private ranges, and enable audit logging on Cluster CRD creation attempts to detect exploitation.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
enterprise Kubernetes management platform, widely adopted in Asia-Pacific
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment 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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Partial

Priority Score

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

Attack Technique

Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.

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