Listen to this Post
A Dangerous Break in Kubernetes Authorization Boundaries
Kubernetes security depends heavily on one principle: a user should only be able to do what their assigned permissions allow. Namespace-level access is supposed to remain namespace-level access. Cluster-wide administrative privileges are supposed to be reserved for trusted administrators.
A newly disclosed vulnerability in Red Hat Advanced Cluster Management for Kubernetes (ACM) threatens that separation.
Tracked as CVE-2026-10090, the flaw affects the Application Subscription controller, known as multicluster-operators-subscription. According to the vulnerability details, an attacker who has only namespace-scoped edit permissions on an ACM hub could potentially abuse the application deployment mechanism to obtain cluster-admin privileges.
The reported CVSS v3.1 score is 9.9/10, reflecting the potentially devastating consequences of turning a low-privileged namespace user into an administrator of the Kubernetes cluster.
The vulnerability was publicly disclosed on August 5, 2026, making it one of the latest Kubernetes-management security issues that enterprise administrators should be watching closely.
Red
Red Hat Documentation
+1
What Makes CVE-2026-10090 So Dangerous?
The biggest concern is not simply that a permission check is missing.
The deeper problem is that a relatively weak identity can influence a highly privileged controller.
In Kubernetes, controllers frequently operate with considerably more permissions than ordinary users because they must create, modify, and reconcile resources automatically. That architecture is powerful, but it creates an important security requirement: controllers must carefully validate what users are allowed to make them do.
CVE-2026-10090 reportedly breaks that security assumption.
A user does not need existing cluster-wide administrative privileges. Instead, the attacker reportedly needs only namespace-level edit permissions in an ACM hub namespace.
That distinction is crucial.
The Attack Begins With Namespace-Level Access
The vulnerable workflow involves
A user with sufficient namespace-level permissions can create a Channel pointing to a Helm repository controlled by the attacker.
The attacker can then create a Subscription that references the malicious Channel.
At first glance, this may appear to be an ordinary application-deployment workflow.
The dangerous part comes next.
The Privileged Controller Does the Heavy Lifting
The Application Subscription controller retrieves the referenced Helm chart and processes the Kubernetes resources contained inside it.
Because the controller itself operates with elevated permissions, the resources it creates can have considerably greater privileges than those available to the original user.
This creates a classic confused-deputy-style authorization problem.
The attacker does not directly perform a privileged operation.
Instead, the attacker convinces a trusted component to perform it on their behalf.
The Missing Authorization Check
According to the vulnerability description, the controller does not properly verify whether the person creating the Subscription possesses the required open-cluster-management:subscription-admin role.
That missing authorization check is central to the vulnerability.
A security boundary is only meaningful if it is enforced at the point where privilege actually matters.
If a user can submit a resource that causes a privileged controller to deploy arbitrary objects, checking the user’s permissions elsewhere in the workflow is not enough.
The Namespace Boundary Can Also Be Broken
The second major problem is even more serious.
The vulnerable workflow reportedly does not sufficiently restrict the resources contained in the Helm chart to the namespace where the Subscription was created.
That means the attacker-controlled chart can contain cluster-scoped Kubernetes objects.
Instead of being confined to one namespace, the deployment can potentially reach resources that govern the entire cluster.
This is where a seemingly limited application-management permission can become a cluster-wide security problem.
The ClusterRoleBinding Nightmare
One particularly dangerous example is a ClusterRoleBinding.
A malicious chart could contain a ClusterRoleBinding designed to associate an attacker-controlled ServiceAccount with Kubernetes’ built-in cluster-admin ClusterRole.
If a privileged controller creates that binding successfully, the attacker could effectively obtain unrestricted administrative authority over the cluster.
The attack therefore follows a frightening chain:
Limited namespace editor → malicious Channel → malicious Subscription → privileged controller → cluster-scoped resource → cluster-admin access.
That is an enormous escalation of privilege.
Why Cluster-Admin Access Changes Everything
Kubernetes cluster-admin is not an ordinary administrative role.
It represents broad authority across the cluster.
Once an attacker reaches that level, they may be able to inspect sensitive resources, modify workloads, create privileged workloads, alter role bindings, access secrets, manipulate service accounts, and establish persistence.
In poorly isolated environments, control over the cluster can also become a pathway toward the underlying infrastructure.
This is why Kubernetes privilege-escalation vulnerabilities deserve immediate attention even when their initial access requirements appear relatively modest.
ACM Makes the Potential Blast Radius Larger
Red Hat Advanced Cluster Management adds another dimension to the risk.
ACM is specifically designed to centrally manage applications and Kubernetes clusters. Red Hat describes the product as providing centralized management, application deployment, security capabilities, and multicluster operations.
Red Hat Customer Portal
That means the ACM hub is not merely another Kubernetes cluster.
It can represent a control point for an organization’s broader Kubernetes estate.
If an attacker compromises an ACM hub, the consequences can extend beyond a single application namespace.
The Hub Should Be Treated as a Crown Jewel
Enterprise security teams should already consider centralized Kubernetes-management platforms highly sensitive.
They contain powerful controllers, credentials, configuration, policies, cluster metadata, and automation capabilities.
A vulnerability that turns limited access to such a platform into administrative control should therefore be treated as a potential infrastructure-level incident rather than an ordinary application bug.
The more clusters an organization manages through one hub, the more important that distinction becomes.
The Vulnerability Conflicts With
The reported behavior is particularly concerning because it contradicts the intended security model for ACM application subscriptions.
The documented expectation is that users who are not subscription administrators should have application resources deployed within the Subscription namespace.
CVE-2026-10090 reportedly undermines that assumption.
A namespace editor can potentially influence a privileged controller in a way that causes resources to escape the namespace boundary.
That is exactly the kind of authorization failure that modern cloud-native security architectures are designed to prevent.
CVE-2026-10090 and CWE-267
The weakness is associated with CWE-267, which covers improper handling of privileges and the ability to gain privileges or assume an identity.
That classification makes sense for this vulnerability.
The problem is not simply an unsafe configuration.
It is a failure to correctly enforce the relationship between the privileges of the requesting user and the privileges used by the component executing the requested operation.
Why Helm Repositories Become Part of the Attack Surface
Helm is normally a powerful and legitimate Kubernetes application-management technology.
But when a privileged controller automatically retrieves and applies content from an attacker-controlled repository, the repository becomes part of the trust boundary.
This is an important lesson for Kubernetes administrators.
A deployment system should never assume that application definitions are harmless merely because they arrive through a recognized automation mechanism.
The contents of a chart can determine which Kubernetes objects are created.
If authorization is not enforced before those objects reach a privileged controller, the deployment pipeline itself becomes an escalation mechanism.
The Broader Lesson for Kubernetes Security
CVE-2026-10090 illustrates a recurring problem in cloud-native infrastructure: automation can amplify permissions.
A human user may have limited access.
A controller may have extensive access.
If the controller blindly executes instructions supplied by the user, the effective permission level of that user can become much higher than intended.
This is why Kubernetes RBAC should never be evaluated in isolation.
Organizations must also analyze the permissions of controllers, operators, service accounts, admission components, GitOps engines, and automation systems.
What Organizations Should Do Now
At the time described in the original report, no security erratum had yet been issued for the affected component.
That means administrators should not simply wait for an update while assuming the risk is theoretical.
Red Hat customers should monitor the official Red Hat security advisory and errata channels for the appropriate fix.
Red Hat maintains centralized security bulletins and CVE information through its Customer Portal.
Red Hat Customer Portal
Restrict Namespace Edit Permissions
The most immediate defensive measure is to review who has namespace-level edit privileges on ACM hub namespaces.
Organizations should avoid granting broad editing rights merely for convenience.
A user who can modify resources capable of influencing privileged controllers may have substantially more effective power than the RBAC policy appears to suggest.
Least privilege therefore needs to include controller interaction paths, not just direct permissions.
Review Channel and Subscription Resources
Security teams should identify users, service accounts, groups, and automation systems that can create or modify ACM Channel and Subscription resources.
Unexpected changes should be investigated.
Particular attention should be paid to newly created Channels that reference repositories outside the organization’s approved infrastructure.
Audit Cluster-Scoped Resources
Administrators should also inspect the cluster for unexpected cluster-wide objects.
Look especially for recently created:
ClusterRole
ClusterRoleBinding
CustomResourceDefinition
cluster-scoped operators
unusual ServiceAccounts
unexpected admission controllers
suspicious webhook configurations
unfamiliar controllers
unexpected privileged workloads
A sudden appearance of a ClusterRoleBinding granting broad privileges deserves immediate investigation.
Inspect Recent RBAC Changes
One of the most valuable forensic questions is simple:
What changed recently?
Review Kubernetes audit logs for RBAC modifications and object creation.
For example:
kubectl get clusterrolebindings
Then inspect suspicious bindings:
kubectl describe clusterrolebinding <binding-name>
Look for references to:
cluster-admin
and unfamiliar ServiceAccounts.
Review ACM Subscription Objects
Administrators can also enumerate ACM Subscription objects:
kubectl get subscriptions -A
For deeper inspection:
kubectl get subscriptions -A -o yaml
Depending on the ACM version and resource configuration, administrators should also examine Channels:
kubectl get channels -A
The goal is not to blindly delete resources, but to identify unexpected deployment sources and unusual relationships between Channels and Subscriptions.
Inspect the Subscription Controller
Administrators should identify the running subscription controller:
kubectl get pods -A | grep subscription
Then inspect its image and deployment configuration:
kubectl get deployment -A | grep subscription
Where supported by the environment, administrators can examine the image actually running:
kubectl get pod <pod-name> -n <namespace> \n-o jsonpath='{.spec.containers[].image}'
This can help determine which ACM component version is currently deployed.
Examine Kubernetes Audit Logs
Kubernetes audit logs can provide some of the strongest evidence of exploitation.
Security teams should search for activity involving:
clusterrolebindings
clusterroles
serviceaccounts
subscriptions
channels
They should also investigate unusual activity performed by the service account associated with the ACM subscription controller.
The key forensic question is whether a low-privileged identity caused a highly privileged controller to create resources that the identity itself could not create.
Check for Suspicious ServiceAccounts
An attacker attempting to establish persistent access may create or manipulate ServiceAccounts.
Administrators can review them with:
kubectl get serviceaccounts -A
Suspicious accounts should be correlated with recent events, RoleBindings, ClusterRoleBindings, pods, and secrets.
Do not automatically assume every unfamiliar ServiceAccount is malicious, however. ACM and other operators legitimately create numerous service accounts.
Context and timestamps matter.
Examine ClusterRoleBindings for Escalation
A particularly useful defensive check is to identify bindings involving cluster-admin.
kubectl get clusterrolebindings \n-o custom-columns=NAME:.metadata.name,ROLE:.roleRef.name,SUBJECTS:.subjects
Any newly created binding granting cluster-admin to an unexpected identity should be treated as potentially serious.
This is especially important after detecting suspicious ACM Subscription or Channel activity.
Don’t Forget Managed Clusters
The ACM hub should be investigated first, but defenders should not automatically stop there.
Organizations should determine whether the compromised identity or controller had additional capabilities involving managed clusters.
The exact blast radius depends heavily on deployment architecture, credentials, RBAC configuration, ACM version, network segmentation, and other security controls.
A compromised management plane should therefore trigger a broader review.
Deep Analysis: How the Privilege Escalation Works
Step 1: The Attacker Starts With Limited Permissions
The attacker begins with namespace-level edit access.
That access might appear relatively harmless when viewed through traditional RBAC analysis.
However, the attacker can create or modify resources that are consumed by a privileged controller.
Step 2: A Channel Becomes the Delivery Mechanism
The attacker creates a Channel referencing a repository under their control.
The Channel effectively becomes a pointer toward content that the ACM controller will later process.
This transforms an apparently ordinary configuration object into a potential delivery mechanism.
Step 3: A Subscription Connects the Pieces
The attacker creates a Subscription referencing the malicious Channel.
The Subscription tells ACM to consume and deploy the referenced application content.
The attacker is therefore no longer directly attempting a privileged Kubernetes API operation.
They are manipulating
Step 4: The Controller Executes With Greater Authority
The Application Subscription controller processes the requested deployment.
The security boundary fails if the controller does not correctly verify the creator’s authorization and does not constrain the resulting resources to the intended namespace.
The controller effectively becomes the
Step 5: Cluster-Scoped Objects Escape the Namespace
A normal namespace-scoped user should not be able to create arbitrary cluster-wide RBAC objects.
But if a privileged controller accepts those objects from an attacker-controlled deployment source, the attacker can potentially cross that boundary indirectly.
This is the crucial escalation point.
Step 6: Cluster-Admin Can Become the Final Objective
A malicious ClusterRoleBinding can associate an attacker-controlled ServiceAccount with cluster-admin.
At that point, the original namespace restriction has effectively collapsed.
The attacker can potentially operate at the cluster level.
Step 7: Persistence Becomes Possible
After gaining administrative access, an attacker may attempt to establish persistence.
Potential persistence mechanisms include unauthorized RBAC bindings, modified workloads, service accounts, controllers, admission components, or other cluster resources.
This is why discovering the initial privilege escalation is only the beginning of incident response.
What Undercode Say:
- The Real Vulnerability Is the Trust Relationship
CVE-2026-10090 is best understood as a broken trust relationship between Kubernetes RBAC and an automation controller.
2. Controllers Are Security Boundaries
Controllers should be treated as privileged security components, not merely background automation.
3. High Privileges Require Strong Input Validation
Whenever a controller processes user-controlled resources, authorization must be enforced before privileged actions occur.
4. Namespace Isolation Is Fundamental
Kubernetes namespaces are not perfect security boundaries, but they are an important authorization boundary.
- Namespace Editors Should Not Become Cluster Administrators
The enormous privilege jump described here is precisely what RBAC is intended to prevent.
- Helm Content Must Be Treated as Code
A Helm chart is not just application metadata.
It can describe powerful Kubernetes objects capable of changing the security posture of an entire cluster.
7. Private Repositories Are Not Automatically Safe
A repository should not be trusted solely because it belongs to an organization.
Its authentication, authorization, integrity, and ownership must also be verified.
8. Privileged Automation Magnifies Mistakes
A small authorization failure can become a catastrophic infrastructure compromise when a privileged controller is involved.
9. Management Planes Deserve Extra Protection
ACM hubs should be treated as high-value infrastructure.
10. Centralization Creates Concentrated Risk
Centralized management improves operational efficiency but also creates potentially larger blast radii.
11. RBAC Reviews Need More Context
Security teams should not only ask what a user can directly create.
They should also ask what privileged automation can create on that user’s behalf.
12. Controllers Need Authorization Awareness
A controller should understand the authorization context behind sensitive requests whenever the operation can cross security boundaries.
13. Default-Deny Is Still Important
Where practical, organizations should restrict what resources application-management systems are permitted to deploy.
- Admission Controls Can Add Defense in Depth
Admission policies can potentially block dangerous cluster-wide RBAC configurations even when an upstream component behaves incorrectly.
15. Policy Engines Matter
Organizations using Open Policy Agent, Kyverno, or equivalent controls can create additional barriers around sensitive resource creation.
16. Audit Logging Is Critical
Without Kubernetes audit logs, reconstructing a privilege-escalation chain can become significantly more difficult.
17. Detection Should Focus on Behavior
Security monitoring should detect unusual RBAC changes, not simply known malicious filenames or IP addresses.
18. ClusterRoleBinding Creation Deserves Attention
Unexpected creation of high-privilege bindings should generate alerts.
19. Cluster-Admin Grants Are Especially Sensitive
Any unexpected assignment to cluster-admin should be investigated immediately.
20. ServiceAccounts Need Monitoring
Attackers frequently use service identities to maintain access after the initial compromise.
21. GitOps Does Not Eliminate Risk
Automation can improve consistency while simultaneously increasing the consequences of unauthorized changes.
- Supply-Chain Security Is Part of Kubernetes Security
The deployment source itself can become an attack surface.
23. Application Management Is Security Management
An application deployment controller can possess enough authority to change the security architecture of the cluster.
24. ACM Administrators Should Think Beyond Applications
The question should not simply be, “What application can this user deploy?”
It should be, “What Kubernetes objects can the controller ultimately create for this user?”
25. Privilege Escalation Can Be Indirect
Attackers do not always need to call a privileged API themselves.
26. Confused Deputies Remain Dangerous
A trusted component performing an action on behalf of an untrusted principal is a classic security risk.
- Security Boundaries Must Be Enforced at Execution
Checking permissions only when a request enters the system is insufficient if later components can transform that request into something more powerful.
- Kubernetes Complexity Makes These Bugs Harder to See
Modern Kubernetes environments involve operators, CRDs, controllers, webhooks, GitOps tools, cloud integrations, and automation layers.
29. More Automation Means More Authorization Paths
Every additional automation layer creates another path that defenders need to understand.
- The Hub Should Be Monitored Like Critical Infrastructure
ACM should not be treated like an ordinary application installed on an ordinary cluster.
31. Least Privilege Needs Continuous Review
Permissions that were acceptable months ago may become dangerous after infrastructure changes.
32. Temporary Permissions Can Become Permanent Risk
Organizations should regularly remove obsolete namespace editing privileges.
33. Security Teams Should Map Controller Permissions
Knowing exactly what each
- The Principle of Least Privilege Applies to Controllers Too
Privileged controllers should have only the permissions required for their legitimate functions.
35. Defense in Depth Matters
RBAC, admission control, audit logging, monitoring, network segmentation, and rapid patching should work together.
- One Missing Check Can Defeat Several Controls
A strong-looking RBAC configuration can still fail if a trusted controller bypasses the intended authorization model.
- Incident Response Should Expand Beyond the Initial Namespace
If cluster-admin access is suspected, defenders should assume that the attacker may have moved beyond the original namespace.
38. Managed-Cluster Relationships Must Be Reviewed
The potential consequences depend on how the ACM hub interacts with managed clusters and what credentials are available.
39. Patching Remains the Best Long-Term Fix
Workarounds reduce exposure, but a vendor-provided security update is ultimately the preferred remediation.
- CVE-2026-10090 Is a Warning About Modern Cloud Security
The central lesson is simple: a low-privileged user becomes dangerous when a highly privileged automation system trusts their instructions too much.
✅ CVE-2026-10090 Is Reported as a High-Severity ACM Vulnerability
The supplied vulnerability details are consistent with independent references published around August 5, 2026, which identify CVE-2026-10090 as an ACM Application Subscription controller privilege-escalation issue with a reported 9.9 score.
Red Hat’s own documentation confirms the existence and importance of the multicluster-operators-subscription component within ACM’s application-management architecture.
Red Hat Customer Portal
✅ ACM Is a Centralized Kubernetes Management Platform
Red Hat documentation confirms that Advanced Cluster Management provides centralized management of applications and Kubernetes clusters, supporting the article’s assessment that the ACM hub can represent a particularly sensitive management point.
Red Hat Documentation
+1
⚠️ The Exact Remediation Status Requires Ongoing Verification
The supplied article states that no security erratum had been issued at disclosure time. Because this article is being evaluated several days after the reported August 5 disclosure, administrators should verify the current Red Hat advisory and errata status before treating the absence of a fix as current. Red Hat maintains its security bulletin and CVE infrastructure for this purpose.
Red Hat Customer Portal
Prediction
(+1) Red Hat Will Push a Security Fix and Tighten Controller Authorization
The most likely positive development is a Red Hat security update that strengthens authorization around ACM Subscription processing and prevents namespace-scoped users from using privileged controllers to create unauthorized cluster-scoped resources.
The vulnerability also highlights a broader architectural direction that is likely to continue across Kubernetes platforms: privileged automation will face increasingly strict authorization and resource-boundary checks.
Enterprise Kubernetes operators should expect future security controls to place greater emphasis on verifying not only what resource is being deployed, but also who requested it, where it can be deployed, and which privileges the deployment controller is allowed to exercise.
For defenders, that is good news.
For attackers, it means one of the easiest ways to turn ordinary Kubernetes permissions into administrative access is likely to become considerably harder.
🕵️📝Let’s dive deep and fact‑check.
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
References:
Reported By: cyberpress.org
Extra Source Hub (Possible Sources for article):
https://stackoverflow.com
Wikipedia
OpenAi & Undercode AI
Image Source:
Unsplash
Undercode AI DI v2
🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]
📢 Follow UndercodeNews & Stay Tuned:
𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky | 🐘Mastodon | 📺Youtube
