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
GitReporesources
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
GitRepodeployment targets. - Trigger point: Fleet processing of a
GitRepothat 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
GitReporesources 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
GitRepoconfigurations 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.

