/

CVE-2026-42880

Severity:

CRITICAL RISK

(9.6)

Information Disclosure in Argo CD

CVE-2026-42880

Modified

Vulnerability type

Category:

Information Disclosure

CWE:

CWE-200, CWE-212, CWE-201

Impact:

Sensitive Data Exposure of Kubernetes Secrets

Severity:

CRITICAL RISK

(9.6)

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

A missing authorization check and data masking in Argo CD's ServerSideDiff endpoint allows users with only read-level Argo CD access to retrieve plaintext Kubernetes Secret values.

By abusing the Kubernetes API server's Server-Side Apply dry-run mechanism, an attacker can cause Argo CD to disclose secret data stored in etcd that should normally remain masked.

Affected context

This vulnerability affects Argo CD instances that:

  • Run affected versions of Argo CD (3.2.0–3.2.10 and 3.3.0–3.3.8)
  • Expose the ServerSideDiff endpoint to users with read-only or otherwise limited Argo CD permissions
  • Are connected to a Kubernetes cluster where Secrets are stored in etcd and accessible via the Kubernetes API

The issue manifests when Argo CD performs server-side diff operations against live cluster resources and fails to properly enforce authorization or mask secret fields in the diff output.

Exploit preconditions

  • Attack surface: Argo CD API / UI, specifically the ServerSideDiff endpoint.
  • Required access: Valid Argo CD account or access token with read-only (or similar) permissions to trigger diff operations on applications or resources.
  • Cluster context: Argo CD must be configured to talk to a Kubernetes cluster where Secrets are stored in etcd and retrievable through the Kubernetes API server.
  • Trigger point: Invocation of ServerSideDiff, directly or indirectly (e.g., via UI actions), that causes Argo CD to request server-side apply dry-run from the Kubernetes API.
  • Why exploitation is possible: The ServerSideDiff logic does not fully enforce authorization boundaries for secret data and neglects to mask sensitive fields when constructing diff responses, allowing plaintext secret values to leak back to the user.

Why this happens

The core issue stems from insufficient access control and data sanitization around a sensitive API path, mapping to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor and CWE-212: Improper Removal of Sensitive Information Before Storage or Transfer.

When Argo CD calls the Kubernetes API's Server-Side Apply dry-run functionality to compute diffs, it receives resource representations that include sensitive fields from Secrets.

Due to a missing or incomplete authorization check, users with only read permissions can trigger this operation on resources containing secrets.

Furthermore, the diff output pipeline fails to consistently mask secret values before returning them in the ServerSideDiff response, effectively turning an internal comparison mechanism into an oracle for extracting plaintext secret data.

Potential impact

  • Attackers with read-only Argo CD access may obtain plaintext Kubernetes Secret values (e.g., API keys, database passwords, tokens).
  • Compromise of downstream services authenticated with the exposed secrets (databases, message queues, external APIs).
  • Lateral movement within the Kubernetes cluster using disclosed credentials or service account tokens.
  • Escalation from limited Argo CD access to broader infrastructure compromise if secrets grant administrative or cloud-provider permissions.
  • Long-term persistence and data exfiltration if stolen secrets are not rotated promptly.

General mitigation guidance

Effective mitigation generally focuses on tightening authorization boundaries and ensuring that sensitive data is never returned from diff or diagnostics endpoints:

  • Treat any API that compares or inspects cluster resources (diff, preview, dry-run) as high-risk, and enforce strict authorization and role checks before allowing access.
  • Apply systematic secret masking routines to all responses that might contain Kubernetes Secret data, regardless of the code path or caller privilege level.
  • Architect diff/preview features so they operate on redacted or type-only representations of Secrets rather than real secret values; wherever possible, limit comparisons to metadata and checksums.
  • Segment access so that read-only roles cannot indirectly trigger operations that require higher privilege on secret-bearing resources.
  • Apply the principle of least privilege to Argo CD service accounts and avoid granting broad secret read permissions unless absolutely necessary.
  • Introduce defense-in-depth controls such as restricting which namespaces and resource types Argo CD manages, and limiting its ability to fetch sensitive Secrets when not required for deployment.

How teams detect issues like this

Organizations can use several approaches to detect and monitor for this class of issue:

  • Static analysis & code review:
  • Flag endpoints that aggregate or proxy Kubernetes resources, especially Secrets, and confirm they consistently apply authorization and masking.
  • Look for code paths that call Kubernetes Server-Side Apply, dry-run, or diff operations and verify they sanitize responses before returning to clients.
  • Review authorization middleware usage across Argo CD APIs to ensure all sensitive endpoints are protected by appropriate policy checks.
  • Configuration and policy enforcement:
  • Enforce RBAC policies so that read-only roles cannot perform actions that effectively access or transform secret data.
  • Use cluster-level admission controllers or policy engines (e.g., OPA/Gatekeeper, Kyverno) to constrain which resources Argo CD can read and modify.
  • Runtime monitoring:
  • Monitor Argo CD audit logs and HTTP access logs for unusual or high-frequency calls to diff/preview-related endpoints.
  • Track access patterns to Kubernetes Secrets and correlate them with Argo CD actions to identify unexpected read pathways.
  • Automated tooling:
  • Incorporate security scanning tools into CI/CD to check for information disclosure patterns in API handlers and to validate that secret masking is enforced consistently.

Sources

SourceLink
github.comgithub.com/argoproj/argo-cd/security/advisories/GHSA-3v3m-wc6v-x4x3
access.redhat.comaccess.redhat.com/errata/RHBA-2026:12433
access.redhat.comaccess.redhat.com/errata/RHSA-2026:20943
access.redhat.comaccess.redhat.com/errata/RHSA-2026:20947
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-42880
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2467882
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-42880.json

Frequently asked

questions

The issue is broadly exploitable in affected Argo CD versions wherever users with read-only or limited roles can access the ServerSideDiff functionality. Any such user could potentially turn the diff mechanism into a secret-disclosure channel, but it still requires valid Argo CD access rather than full unauthenticated internet exposure.

An attacker generally needs a valid Argo CD user or token with at least read-level permissions on applications or projects that trigger the ServerSideDiff endpoint. They do not need direct access to Kubernetes Secrets or etcd; Argo CD acts as the bridge that surfaces the secret data.

A robust fix pattern includes enforcing strict authorization checks on all endpoints that can read or transform sensitive resources, ensuring that any response containing potential secret data passes through a centralized masking/redaction layer, and designing diagnostic features (like diffs) to operate on redacted or hashed representations rather than raw secret values.

Prevention typically combines secure design and process controls: treat secret data as a special class with dedicated handling, centralize secret masking logic, require security review for any new or modified API endpoints that touch Secrets, and integrate automated checks that look for direct inclusion of secret fields in API responses. Additionally, maintain strong RBAC segmentation and regularly test diff, preview, and debugging endpoints to confirm they never leak sensitive information.

Find out what's already
exploitable in your codebase.