CVE-2026-27112: Akuity Kargo Privilege Escalation Flaw

CVE-2026-27112 Overview

CVE-2026-27112 is a critical improper authorization vulnerability affecting Akuity Kargo, a GitOps continuous delivery platform that manages and automates the promotion of software artifacts in Kubernetes environments. The vulnerability exists in the batch resource creation endpoints of both Kargo's legacy gRPC API and newer REST API, which accept multi-document YAML payloads. Specially crafted payloads can exploit a bug in the endpoint logic to inject arbitrary resources into the underlying namespace of an existing Project using the API server's own permissions.

Critical Impact
Attackers can exploit this vulnerability to escalate their own permissions, potentially achieving remote code execution or exfiltrating secrets including artifact repository credentials. These credentials can then be leveraged to execute further supply chain attacks.

Affected Products

Akuity Kargo versions 1.7.0 to before v1.7.8
Akuity Kargo versions 1.8.0 to before v1.8.11
Akuity Kargo versions 1.9.0 to before v1.9.3

Discovery Timeline

2026-02-20 - CVE-2026-27112 published to NVD
2026-02-25 - Last updated in NVD database

Technical Details for CVE-2026-27112

Vulnerability Analysis

This vulnerability stems from improper authorization (CWE-863) in Kargo's resource creation endpoints. The flaw allows authenticated users to bypass intended authorization controls and inject resources into namespaces they should not have access to. The vulnerability is network-accessible and requires low privileges to exploit, making it a significant risk for organizations running Kargo in their Kubernetes clusters.

The attack surface is particularly concerning because successful exploitation can lead to a chain of escalating compromises. An attacker who gains elevated permissions can access secrets stored in the cluster, including credentials for artifact repositories. In configurations where the Kargo control plane's underlying Kubernetes cluster permits it, attackers may also leverage elevated permissions to achieve remote code execution via kubectl.

Root Cause

The root cause lies in flawed logic within the batch resource creation code paths. Specifically, the code was tracking newly created Projects without properly checking whether the creation operation succeeded. This allowed the system to incorrectly associate resources with Projects even when errors occurred, enabling attackers to inject resources into existing Project namespaces using the API server's elevated permissions.

Attack Vector

The attack exploits the multi-document YAML parsing capability of Kargo's API endpoints. An authenticated attacker can craft a malicious YAML payload that:

Exploits the race condition in Project creation tracking
Injects arbitrary resources (of specific types) into target Project namespaces
Uses the API server's permissions rather than the attacker's own permissions
Escalates privileges to access sensitive resources or execute code

The following security patch addresses the vulnerability by adding proper error checking before tracking created Projects:

 		}
 		// If we just created a Project successfully, keep track of this Project
 		// being one that was created in the course of this API call.
-		if result.CreatedResourceManifest != nil && resource.GroupVersionKind() == projectGVK {
+		if err == nil && result.CreatedResourceManifest != nil && resource.GroupVersionKind() == projectGVK {
 			createdProjects[resource.GetName()] = struct{}{}
 		}
 		// Convert to protobuf result

Source: GitHub Commit Details

The fix ensures that Projects are only tracked as created when the operation completes without errors, preventing the authorization bypass.

Detection Methods for CVE-2026-27112

Indicators of Compromise

Unexpected resources appearing in Kargo Project namespaces that were not created through normal workflows
Audit logs showing resource creation requests with multi-document YAML payloads from unexpected sources
Unusual access patterns to artifact repository credentials or Kubernetes secrets
Evidence of kubectl commands executed with elevated permissions that don't match normal operational patterns

Detection Strategies

Enable comprehensive audit logging for Kargo API endpoints, specifically monitoring batch resource creation requests
Implement alerting for resource creation events that reference Projects the authenticated user should not have access to
Monitor for anomalous patterns in YAML payload sizes or structures submitted to the API
Review Kubernetes RBAC audit logs for unexpected privilege usage by the Kargo API server service account

Monitoring Recommendations

Deploy runtime security monitoring to detect unauthorized resource injection in Kargo namespaces
Implement network segmentation monitoring to identify lateral movement following credential exfiltration
Set up alerting on secret access patterns that deviate from baseline behavior
Monitor for kubectl execution from unexpected contexts or with elevated permissions

How to Mitigate CVE-2026-27112

Immediate Actions Required

Upgrade Akuity Kargo to patched versions: v1.7.8, v1.8.11, or v1.9.3 immediately
Review audit logs for any evidence of exploitation attempts prior to patching
Rotate artifact repository credentials that may have been accessible through Kargo
Audit Kubernetes RBAC configurations to ensure least-privilege principles are applied to Kargo service accounts

Patch Information

Akuity has released security patches addressing this vulnerability in versions v1.7.8, v1.8.11, and v1.9.3. The fix adds proper error checking (err == nil) before tracking Projects as created, preventing the authorization bypass. Organizations should upgrade to the appropriate patched version based on their current deployment:

Version 1.7.x users should upgrade to v1.7.8 or later
Version 1.8.x users should upgrade to v1.8.11 or later
Version 1.9.x users should upgrade to v1.9.3 or later

For complete details, refer to the GitHub Security Advisory GHSA-7g9x-cp9g-92mr.

Workarounds

Restrict network access to Kargo API endpoints using network policies until patching is complete
Implement additional authentication layers or API gateway controls to limit access to resource creation endpoints
Review and tighten Kubernetes RBAC permissions for the Kargo API server service account
Enable enhanced audit logging and monitoring as an interim detection measure

bash

# Example: Apply network policy to restrict API access
kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: kargo-api-restriction
  namespace: kargo
spec:
  podSelector:
    matchLabels:
      app: kargo-api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kargo-access: allowed
EOF