CVE-2026-2270 is a medium-severity confused deputy flaw in the Kubernetes StatefulSet controller, part of kube-controller-manager, that lets a user with namespace-scoped write access to both StatefulSet and ControllerRevision objects create a pod in a namespace they have no rights in. The controller trusts data carried in a ControllerRevision and acts on it with its own high privilege. Pwned Labs teaches the RBAC abuse and controller-trust problems behind flaws like this in live clusters, through Academy labs and the Kubernetes Attack and Defense bootcamp that leads to the KRTP certification.
What is CVE-2026-2270?
CVE-2026-2270 is a confused deputy vulnerability in the StatefulSet controller inside kube-controller-manager. The Kubernetes Security Response Committee rated it Medium with a CVSS 3.1 base score of 5.9 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:N) and published it on 23 September 2026. A user who holds namespace-scoped write permissions on StatefulSet and ControllerRevision objects can make the controller create a pod in a different namespace, with full control over that pod's metadata and specification, including which namespace it lands in. The issue was reported by the researcher ImanOracle and coordinated through the committee; the details are tracked in Kubernetes issue 142097 and the official security advisory.
How StatefulSets and ControllerRevisions work
A StatefulSet is the Kubernetes workload object for pods that need a stable identity and an ordered, predictable rollout, such as databases, message brokers and other stateful services. The StatefulSet controller is one of the reconciliation loops inside kube-controller-manager, and it runs with a high-privilege service account so it can create, update and delete pods on a user's behalf across the whole cluster. That privilege is normal and necessary, because a controller has to act for workloads it does not own.
To support rolling updates and rollbacks, Kubernetes records the history of a StatefulSet as a series of ControllerRevision objects. Each ControllerRevision is a small, immutable snapshot of the StatefulSet's pod template at a point in time, and the controller creates a new one whenever the template changes. When a rollout is reverted, the controller reads the matching ControllerRevision and restores the StatefulSet from it. ControllerRevisions are namespace-scoped API objects in the apps group, which means RBAC can grant a user the right to read, create, update, patch or delete them inside a namespace. The security question is what exactly the controller restores from an object that a namespace user may be allowed to write, and whether it trusts fields it should not.
How the confused deputy attack works
The flaw is that the controller restored more than the pod template specification from a ControllerRevision. Because a ControllerRevision is a namespace-scoped object, a user with write access to it in their own namespace can shape its stored contents. When the StatefulSet controller then reconstructed a StatefulSet from that revision, it acted on attacker-influenced fields, including object metadata such as the target namespace, rather than restoring only the spec field. The controller is the confused deputy in the classic sense: it holds cluster-wide privilege to create pods, and it was induced into using that privilege on data supplied by a user who does not hold it.
The outcome is a pod created in a namespace the user cannot write to directly, with the attacker in control of the pod's metadata and specification. The attacker never calls the pod create API themselves, which is the point: the privileged controller makes the call for them, so the usual namespace authorization check on the user is never the thing that decides where the pod lands. The patched releases close this by restoring only the spec field of a StatefulSet from a ControllerRevision, so attacker-controlled metadata no longer reaches the create call. This post stays at the level of the mechanism and the official fix, not a working exploit, in line with how Pwned Labs teaches offensive technique: enough to understand and defend the flaw, without a copy-paste payload.
What an attacker actually gains
This is where honest scoping matters, because the CVSS vector already signals the limits. The attack needs high privileges (PR:H), namely write access to both StatefulSets and ControllerRevisions in a namespace, and it carries high attack complexity (AC:H). Two conditions keep the impact bounded. First, a pod placed in another namespace is immediately deleted by the garbage collector unless the attacker can build a valid StatefulSet OwnerReference for it, which requires knowing the UID of a StatefulSet that already exists in the victim's namespace. Second, the availability impact is rated None, so this is a confidentiality and integrity problem, not a denial of service. When the conditions are met, a pod running in a namespace the attacker could not otherwise reach can be scheduled with a specification they chose, which can mean running under that namespace's default service account and mounting secrets or config maps scoped to it. In a cluster that uses namespaces as a tenancy or trust boundary, that is a genuine crossing of the line, because a workload the attacker defined is now executing with an identity and access that belong to a different team. That is why confidentiality and integrity are both rated High even though the preconditions are demanding and the availability impact is None.
The limits are as important as the impact. This is not remote code execution against the control plane, it does not by itself grant cluster-admin, and it cannot be fired by an anonymous or unauthenticated client. The value to an attacker is lateral: it is a way to place a chosen workload into a namespace they were walled out of, which matters most as one link in a longer chain rather than as a single decisive break.
Which Kubernetes versions are affected and fixed
CVE-2026-2270 affects kube-controller-manager, so the component to patch is the control plane, not the kubelet or the workloads. The advisory lists these affected and fixed releases:
| Release line | Affected versions | Fixed version |
|---|---|---|
| 1.34 | v1.34.11 and earlier | v1.34.12 |
| 1.35 | v1.35.8 and earlier | v1.35.9 |
| 1.36 | v1.36.4 and earlier | v1.36.5 |
| 1.37 | v1.37.0 only | v1.37.1 |
On a self-managed cluster, the fix is applied by upgrading kube-controller-manager to the patched version for your release line. On managed Kubernetes such as Amazon EKS, Google GKE and Azure AKS, the control plane is operated by the provider, so the practical step is to confirm the cluster is running a patched control-plane version and to follow the provider's guidance. Distribution package numbers, for example in Debian or a vendor build, do not map directly onto these upstream versions, so check against the patched release for the line you actually run.
How to detect and mitigate CVE-2026-2270
Patching is the fix, but there is a durable mitigation worth applying regardless of version. Review who can write ControllerRevisions. Roles that grant create, update or patch on the controllerrevisions resource in apps are the precondition for this attack, and they are easy to hand out by accident when a role is written to let a team manage StatefulSets. Most workload operators never need to write ControllerRevisions directly, because the controller manages them, so removing that verb from namespace roles closes the door even on an unpatched control plane. For detection, Kubernetes audit logs record create and update requests against controllerrevisions and the pods the controller then creates, so a ControllerRevision write from a namespace identity followed by a pod appearing in a different namespace is a signal worth alerting on. Pwned Labs works exactly this kind of RBAC-to-impact path in its Kubernetes labs, so you can see which role grants matter before they become an incident.
A few habits make the mitigation stick. Audit roles and cluster roles for the controllerrevisions resource and keep the write verbs on it to the controllers and operators that genuinely need them. Treat wildcard rules, such as a role that grants all verbs on all resources in the apps group, as a finding in their own right, because they hand out ControllerRevision write without anyone meaning to. Where a cluster already enforces admission policy, a rule that restricts who may create or modify ControllerRevisions adds a second layer behind RBAC. None of these replace the upgrade, but together they shrink the set of identities that could ever reach the flaw and leave a clearer trail if one tries.
Why RBAC on controller-managed objects is the real lesson
CVE-2026-2270 will be patched, but the shape of it keeps recurring: a controller that runs with broad privilege is driven by an object a lower-privilege user can edit, and the trust boundary between the two is thinner than it looks. The same logic sits behind the Kubernetes admission controller bypass patterns, where control depends on who can edit the policy, and behind the broader cluster-takeover chains covered in the Kubernetes penetration testing guide and the walk from a single pod to a cloud account in container escape to cluster admin. The defensive habit that covers all of them is least-privilege RBAC that treats controller-managed objects, like ControllerRevisions, as sensitive rather than incidental, and testing those grants from an attacker's position rather than assuming they are harmless.
Practice this at Pwned Labs
Pwned Labs runs Kubernetes RBAC and cluster-takeover tradecraft as hands-on labs in live clusters and the cloud accounts behind them.
- Exploit Kubernetes Overly Permissive RBAC (Premium, Intermediate): from compromised credentials on an EC2 instance, enumerate what your Kubernetes RBAC permits and abuse overly permissive role bindings to reach cluster control, the same class of write access that CVE-2026-2270 depends on.
- Escalate from Prototype Pollution to EKS Takeover (Premium, Intermediate): exploit prototype pollution in a Node.js app for code execution, break out of the container, and abuse RBAC to take over an Amazon EKS cluster.
- Escalate from SSJI to EKS (Premium, Beginner): chain server-side JavaScript injection through IAM and IDOR weaknesses to reach the Amazon EKS cluster behind the application.
- Secure Kubernetes using OPA Gatekeeper (Premium, Intermediate): switch to defense and use OPA Gatekeeper to enforce admission policy on what workloads a cluster will accept.
Frequently asked questions
What is CVE-2026-2270?
CVE-2026-2270 is a confused deputy vulnerability in the Kubernetes StatefulSet controller, part of kube-controller-manager. A user with namespace-scoped write access to StatefulSet and ControllerRevision objects can get the controller to create a pod in a different namespace, with control over that pod's metadata and specification. It was rated Medium (CVSS 5.9) and published by the Kubernetes Security Response Committee in September 2026.
How severe is CVE-2026-2270?
It is rated Medium, with a CVSS 3.1 base score of 5.9. The score is held down by high privilege requirements and high attack complexity: the attacker must already be able to write StatefulSets and ControllerRevisions in a namespace, and the cross-namespace pod is deleted unless they can attach a valid owner reference in the target namespace. Confidentiality and integrity impact are High, and availability impact is None.
Which Kubernetes versions are affected by CVE-2026-2270?
The advisory lists kube-controller-manager v1.34.11 and earlier, v1.35.8 and earlier, v1.36.4 and earlier, and exactly v1.37.0 as affected. The fixed versions are v1.34.12, v1.35.9, v1.36.5 and v1.37.1. The component to patch is the control plane.
How do I fix CVE-2026-2270?
Upgrade kube-controller-manager to the patched release for your line (v1.34.12, v1.35.9, v1.36.5 or v1.37.1). On managed Kubernetes, confirm the provider has patched your control-plane version. As a durable mitigation, remove create, update and patch on ControllerRevisions from namespace roles that only need to manage StatefulSets, because the controller manages those revisions itself. Pwned Labs recommends testing those role grants from an attacker's position so you can confirm the write access is really gone.
Can CVE-2026-2270 be exploited remotely without credentials?
No. It requires an authenticated identity that already holds namespace-scoped write access to both StatefulSet and ControllerRevision objects. It is not an unauthenticated or anonymous attack, which is part of why it is rated Medium rather than Critical.
What is a confused deputy attack in Kubernetes?
A confused deputy is a component that holds more privilege than the caller and is tricked into using that privilege on the caller's behalf. In CVE-2026-2270 the StatefulSet controller, which can create pods cluster-wide, acted on namespace data a lower-privilege user controlled through a ControllerRevision. Pwned Labs teaches how to find and abuse these controller-trust and RBAC gaps in its Kubernetes Attack and Defense bootcamp.
The fastest way to understand a flaw like CVE-2026-2270 is to work the RBAC that makes it possible. Start with the hands-on cloud and Kubernetes security labs, or go straight to the Kubernetes Attack and Defense bootcamp that leads to the KRTP certification.
About Pwned Labs
Pwned Labs is a hands-on cloud and AI offensive security training platform. It runs real-world attack labs and bootcamps for AWS, Azure, GCP, Kubernetes and AI systems, including the ACRTP, MCRTP, GCRTP, KRTP and AISRTP certifications. Free labs are at pwnedlabs.io/explore.