/

CVE-2026-42296

Severity:

HIGH RISK

(8.1)

Authorization Bypass / Access Control Misconfiguration

CVE-2026-42296

Modified

Vulnerability type

Category:

Authorization Bypass / Access Control Misconfiguration

CWE:

CWE-863

Impact:

Privilege Escalation and Security Control Bypass

Severity:

HIGH RISK

(8.1)

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

Argo Workflows contains an authorization bypass where users with permission to create Workflows can circumvent the templateReferencing: Strict control and inject privileged pod-level settings.

Under these conditions, an attacker may gain host network access, switch service accounts, adjust pod security context, target control-plane nodes, or re-enable service account token mounting, depending on cluster-level defenses.

Affected context

This vulnerability manifests in Kubernetes clusters running Argo Workflows that:

  • Rely on templateReferencing: Strict to constrain what workflow authors can override
  • Allow certain users or tenants to create or submit Workflows
  • Do not have comprehensive, independent Kubernetes-level policy enforcement (e.g., PodSecurity admission, OPA/Gatekeeper) for host networking, service accounts, and pod security contexts

In such environments, the assumption that Strict mode prevents workflows from escalating privileges or altering sensitive pod configuration does not hold.

Exploit preconditions

  • Attack surface: Argo Workflows API / controller via Workflow submission
  • Required access: Ability to create or submit a Workflow object in a namespace where Argo is installed
  • Control in scope: templateReferencing: Strict is configured and expected to limit user-controlled pod specs
  • Trigger point: Crafting a Workflow that references templates or fields in ways that bypass the Strict enforcement, allowing direct specification of:
  • hostNetwork or related network fields
  • serviceAccountName or pod-level service account usage
  • Pod securityContext, tolerations, or node selectors
  • Service account token mounting options
  • Why exploitation is possible: The Strict mode enforcement logic does not comprehensively validate or restrict all pod-level configuration paths that can be influenced by a Workflow, enabling users with create permissions to inject higher-privilege settings than intended.

Why this happens

The underlying issue aligns with CWE-863: Incorrect Authorization, where a security feature is present but incompletely enforced.

Argo's templateReferencing: Strict mode is intended to limit what Workflow definitions can override from reusable templates, acting as a guardrail for pod-level privileges. However, the implementation fails to account for all ways a Workflow can influence the resulting pod spec. Certain fields—such as host networking, service accounts, pod security context, tolerations, and service account token mounting—were either insufficiently validated or left outside the strict enforcement boundary.

Conceptually, this is a design-level access control bug: enforcement is applied at some abstraction layer (workflow templates), but lower-level or alternate configuration paths remain exposed. As a result, users who are supposed to operate within constrained templates can escalate their effective runtime privileges by manipulating overlooked fields.

Potential impact

  • Users with Workflow creation permissions may gain host network access on Kubernetes nodes.
  • Attackers could switch the pod's service account to one with broader RBAC permissions, leading to cluster-level privilege escalation.
  • Workflows may run with a more permissive pod security context (e.g., elevated capabilities, privileged containers).
  • Tolerations can be added to schedule workloads onto control-plane or otherwise restricted nodes.
  • Service account token mounting can be enabled, allowing access to Kubernetes API tokens that were meant to be disabled.
  • Defense-in-depth assumptions relying on Argo's Strict mode may be invalidated, increasing reliance on upstream Kubernetes policy controls.

General mitigation guidance

Addressing this class of issue generally involves strengthening how access control and configuration guardrails are implemented:

  • Treat Argo's configuration constraints (templateReferencing: Strict and similar features) as secondary controls, and ensure primary enforcement is done at the Kubernetes layer using:
  • PodSecurity/PSS profiles
  • Admission webhooks
  • Policy engines such as OPA/Gatekeeper or Kyverno
  • Design authorization checks to cover the full configuration surface:
  • Enumerate all pod-spec fields that affect privileges or isolation (hostNetwork, hostPID/IPC, service accounts, securityContext, volume types, tolerations, node selectors, token mounts).
  • Enforce strict validation or deny-by-default behavior for fields not explicitly allowed.
  • Apply least-privilege principles to Workflow authors:
  • Separate roles for Workflow submission and cluster administration.
  • Limit which namespaces and service accounts workflows can use by policy rather than convention.
  • Use template systems that define a minimal, locked-down pod template and only expose safe parameters, with explicit validation of all user-provided inputs.

These patterns reduce reliance on a single feature flag and help ensure configuration bypasses do not automatically lead to privilege escalation.

How teams detect issues like this

Organizations can detect and monitor for this class of authorization bypass by combining policy, analysis, and review:

  • Configuration and policy review:
  • Inspect Argo configurations where templateReferencing: Strict is enabled and identify assumptions about what users can or cannot override.
  • Review Kubernetes admission policies (PodSecurity, OPA/Gatekeeper, Kyverno) to ensure host networking, service account selection, privileged pods, and token mounting are explicitly governed.
  • Static and configuration analysis:
  • Use policy-as-code tools to scan existing Workflows and templates for:
  • Direct specification of hostNetwork, serviceAccountName, pod securityContext, tolerations, or token-related settings by non-admin users.
  • Patterns where workflow-level parameters map directly to sensitive pod-spec fields.
  • Runtime monitoring:
  • Log and audit Workflow submissions and resulting Pods, flagging:
  • Workloads requesting host networking or privileged contexts.
  • Workflows running under unexpected service accounts.
  • Pods scheduled onto control-plane nodes or restricted node pools.
  • Automated review in CI/CD:
  • Integrate automated checks that block or require approval for workflows containing sensitive pod-spec fields.
  • Employ security-focused linters or admission test harnesses that simulate policy evaluation as part of the development pipeline.

Sources

SourceLink
github.comgithub.com/argoproj/argo-workflows/commit/534f4ff1cbd86908e8ff76d97d553ad5a49a950d
github.comgithub.com/argoproj/argo-workflows/releases/tag/v3.7.14
github.comgithub.com/argoproj/argo-workflows/releases/tag/v4.0.5
github.comgithub.com/argoproj/argo-workflows/security/advisories/GHSA-3775-99mw-8rp4
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-42296
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2468446
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-42296.json

Frequently asked

questions

Exploitation is limited to users who already have permission to create or submit Workflows in Argo. Within that scope, any such user can attempt to bypass templateReferencing: Strict and obtain more powerful pod-level configurations, subject to whatever Kubernetes-level defenses are in place.

An attacker must be able to create Workflow resources in a namespace managed by Argo Workflows. They do not necessarily need cluster-admin privileges; ordinary tenant or application roles that allow Workflow submission can be sufficient if no additional Kubernetes policies block the escalated configuration.

The safest pattern is to ensure that pod-level privilege controls are enforced at the Kubernetes layer through PodSecurity standards or policy engines, while treating Argo's Strict mode as a supplemental guardrail. Additionally, authorization logic should be updated so that all privilege-sensitive fields in the pod spec are either explicitly constrained or denied when workflows are submitted by non-privileged users.

To prevent similar authorization bypasses, design security features with a comprehensive threat model that covers all related configuration paths, adopt deny-by-default policies for high-risk fields, and implement layered defenses. Combine rigorous code review of access control logic with automated policy enforcement and admission testing so that new configuration features cannot silently bypass established security boundaries.

Find out what's already
exploitable in your codebase.