/

CVE-2026-41050

Severity:

CRITICAL RISK

(9.9)

Improper Authorization in Fleet Helm Deployer

CVE-2026-41050

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-863

Impact:

Cross-Namespace Secret Disclosure Across Downstream Clusters

Severity:

CRITICAL RISK

(9.9)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Fleet's Helm deployer contains an authorization flaw where ServiceAccount impersonation is not fully applied in two deployment code paths.

In environments where tenants can push to Fleet-monitored Git repositories, this gap can allow those tenants to read secrets from any namespace on downstream clusters targeted by their GitRepo.

Affected context

This vulnerability occurs in Fleet-managed Kubernetes environments using the Helm deployer with multi-tenant GitOps workflows.

It is most relevant where:

  • Multiple tenants share a Fleet management plane
  • Tenants have git push access to Fleet-monitored repositories
  • Fleet is configured to deploy workloads across multiple downstream clusters and namespaces using GitRepo resources

In these setups, incomplete ServiceAccount impersonation in the Helm deployer can cause operations to run with broader cluster privileges than intended, crossing namespace and tenant boundaries.

Exploit preconditions

  • Attack surface: GitOps interface via Fleet-monitored Git repositories.
  • Required access: Ability to push changes to a repository watched by Fleet (e.g., tenant with Git write access).
  • Target scope: Any downstream cluster and namespace included in the affected GitRepo deployment targets.
  • Trigger point: Fleet processing of a GitRepo that causes the Helm deployer to execute via code paths where ServiceAccount impersonation is not fully enforced.
  • Why exploitation is possible: The Helm deployer incorrectly performs operations without consistently binding them to the scoped ServiceAccount, allowing actions to execute with higher, shared or default cluster credentials that can read secrets across namespaces.

Why this happens

The underlying bug is an improper authorization pattern where identity and permissions are not consistently enforced in all execution paths.

Specifically, the Helm deployer is designed to operate under a limited ServiceAccount via impersonation, but two code paths fail to fully apply this impersonation when interacting with Kubernetes APIs.

This maps to CWE-863: Incorrect Authorization, where access control checks are incomplete or applied in an inconsistent manner, resulting in operations being performed with privileges that exceed the intended tenant scope.

Conceptually, the implementation relies on a security boundary (ServiceAccount impersonation) that is only partially honored, allowing a tenant-controlled Git change to indirectly leverage elevated cluster-level credentials.

Potential impact

  • Tenants may read Kubernetes Secrets from any namespace on targeted downstream clusters.
  • Confidential data such as database credentials, API keys, TLS private keys, and service tokens can be exposed.
  • Cross-tenant data leakage in shared Fleet deployments, breaking isolation guarantees.
  • Lateral movement by using stolen credentials to access other services or clusters.
  • Regulatory and compliance violations due to unauthorized access to sensitive information.

General mitigation guidance

Mitigations focus on enforcing strict, consistent authorization boundaries and minimizing blast radius:

  • Ensure all deployer code paths consistently apply ServiceAccount impersonation when accessing Kubernetes APIs.
  • Architect the system so that each tenant or application has a dedicated, least-privilege ServiceAccount and does not reuse highly privileged identities for deployment operations.
  • Restrict the scope of GitRepo resources to the minimum necessary clusters and namespaces, avoiding broad cluster-wide targeting where possible.
  • Apply namespace-based multi-tenancy controls (e.g., separate projects or clusters per tenant) so that a compromised tenant deployment path cannot naturally reach unrelated namespaces.
  • Store only necessary secrets in clusters and segment particularly sensitive credentials into separate, more tightly controlled environments or secret managers.
  • Limit who receives git push access to Fleet-monitored repositories and separate infrastructure repos from application repos to reduce who can influence cluster-wide deployments.

How teams detect issues like this

Detection can rely on a combination of configuration review, audit analysis, and policy enforcement:

  • Review Helm deployer and controller code for any Kubernetes client interactions that bypass or conditionally skip ServiceAccount impersonation, especially in error handling or "fast path" logic.
  • Use static analysis or linting rules to flag direct use of high-privilege Kubernetes clients where impersonated clients should be used.
  • Configure Kubernetes Audit Logging on downstream clusters and monitor for:
  • Secret read requests (get, list, watch) from deployment-related identities accessing unexpected namespaces.
  • Access patterns where a Fleet or deployer identity reads secrets across many namespaces.
  • Implement admission policies (e.g., via OPA/Gatekeeper or Kyverno) to:
  • Reject or constrain GitRepo configurations that span excessive namespaces or clusters.
  • Enforce that deployer pods only use namespace-scoped, least-privilege ServiceAccounts.
  • Periodically run access reviews and "who-can" queries to confirm that deployer identities cannot read secrets outside their intended namespaces.

Sources

SourceLink
bugzilla.suse.combugzilla.suse.com/show_bug.cgi?id=CVE-2026-41050
github.comgithub.com/advisories/GHSA-765j-qfrp-hm3j

Frequently asked

questions

Exploitability is high wherever tenants have git push access to Fleet-monitored repositories and Fleet targets multiple namespaces or clusters. A single malicious or compromised tenant in such an environment can potentially read secrets across all namespaces targeted by their GitRepo.

No. The key requirement is git write access to a repository watched by Fleet. The attacker leverages Fleet's Helm deployer behavior and its misapplied authorization to access secrets without holding direct cluster-admin privileges.

The safest pattern is to enforce impersonation or explicit, least-privilege identities for every operation that contacts the Kubernetes API, and to ensure this is applied uniformly across all code paths. Avoid using shared, highly privileged cluster credentials for deployment automation when a scoped ServiceAccount should be used instead.

Adopt a defense-in-depth approach: design for hard multi-tenancy boundaries, mandate least privilege on all deployer identities, enforce authorization via admission and policy engines, and add automated checks (code scanning, policy-as-code, and CI tests) that fail builds when any Kubernetes client is used without proper impersonation or scope controls.

Find out what's already
exploitable in your codebase.