Back to Intelligence

CVE-2026-67308: Critical GitHub Actions Shell Injection — Detection and Remediation Guide

SA
Security Arsenal Team
August 1, 2026
8 min read

Introduction

A critical vulnerability (CVE-2026-67308) has been identified in GitHub Actions, specifically affecting Wazuh workflows with a CVSS score of 10.0. This vulnerability allows attackers to execute arbitrary commands through crafted pull requests containing malicious VERSION. files, potentially leading to credential theft and complete system compromise.

For organizations leveraging GitHub Actions with Wazuh workflows, this represents a significant security concern that demands immediate attention. The vulnerability enables attackers to inject shell metacharacters into environment variables that are directly interpolated into run steps, creating a pathway for command execution and exfiltration of sensitive credentials, including GITHUB_TOKEN and AWS credentials on self-hosted runners.

Given the widespread use of GitHub Actions in CI/CD pipelines and the critical nature of this vulnerability, security teams should prioritize assessment, detection, and remediation efforts to prevent potential exploitation.

Technical Analysis

Vulnerability Details:

  • CVE ID: CVE-2026-67308
  • CVSS Score: 10.0 (CRITICAL)
  • Affected Component: GitHub Actions in Wazuh workflows
  • Vulnerability Type: Shell Injection
  • Attack Vector: Network
  • Affected Versions: Wazuh workflows before commit 44bf114

Technical Mechanism: The vulnerability exists in how GitHub Actions processes VERSION. files within Wazuh workflows. When processing these files, vulnerable versions of the workflow do not properly sanitize input, allowing attackers to inject shell metacharacters into environment variables that are subsequently used in run steps. This creates a command injection vulnerability that can be exploited by simply submitting a pull request with a crafted VERSION. file.

Attack Chain:

  1. Attacker identifies a repository using vulnerable Wazuh workflows
  2. Attacker creates a fork and modifies the VERSION. file with malicious content
  3. Attacker submits a pull request to the target repository
  4. When GitHub Actions processes the pull request, the malicious content is parsed
  5. Shell metacharacters in the VERSION. file are injected into environment variables
  6. These environment variables are interpolated into run steps, executing the attacker's commands
  7. Attacker can now access and exfiltrate sensitive credentials like GITHUB_TOKEN and AWS credentials

Exploitation Status: While not yet confirmed to be in active exploitation in the wild, the severity (CVSS 10.0) and the simplicity of exploitation (requiring only the ability to submit a pull request) make this an extremely high-risk vulnerability that should be treated as if active exploitation is imminent.

Detection & Response

SIGMA Rules

YAML
---
title: GitHub Actions Suspicious Command Execution from VERSION. Processing
id: 8d9e4a1f-7b5c-4d3e-9f2a-1c8b3d4e5f6a
status: experimental
description: Detects suspicious command execution potentially related to CVE-2026-67308 exploitation in GitHub Actions workflows processing VERSION.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-67308
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1059.004
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    ParentImage|contains: 'actions-runner'
    CommandLine|contains: 
      - 'VERSION.'
      - 'eval $'
      - 'bash -c'
  condition: selection
falsepositives:
  - Legitimate GitHub Actions workflows that process VERSION. files
level: high
---
title: GitHub Actions Credential Access via Environment Variables
id: 7c8f3b2e-6a4d-5c9e-0f1b-2d9e4f5a6b7c
status: experimental
description: Detects potential credential access related to CVE-2026-67308 where environment variables might be accessed in GitHub Actions
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-67308
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.credential_access
  - attack.t1552.001
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    ParentImage|contains: 'actions-runner'
    CommandLine|contains:
      - 'GITHUB_TOKEN'
      - 'AWS_ACCESS_KEY_ID'
      - 'AWS_SECRET_ACCESS_KEY'
      - 'printenv'
  condition: selection
falsepositives:
  - Legitimate credential usage in GitHub Actions workflows
level: medium
---
title: GitHub Actions Suspicious Network Activity from Runner
id: 6b7d2c1f-5a3c-4b8d-9e0a-1c8b2d3e4f5a
status: experimental
description: Detects suspicious outbound network connections from GitHub Actions runners potentially exfiltrating credentials
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-67308
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.exfiltration
  - attack.t1041
logsource:
  category: network_connection
  product: linux
detection:
  selection:
    Image|contains: 'actions-runner'
    DestinationPort|notin:
      - 443
      - 22
  condition: selection
falsepositives:
  - Legitimate outbound connections from GitHub Actions runners
level: medium

KQL (Microsoft Sentinel / Defender)

KQL — Microsoft Sentinel / Defender
// Detect potential CVE-2026-67308 exploitation via suspicious GitHub Actions activity
let SuspiciousCommands = dynamic(['eval $', 'bash -c', '&&', '|', '`']);
let CredentialKeywords = dynamic(['GITHUB_TOKEN', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY']);
DeviceProcessEvents
| where InitiatingProcessFolderPath contains \"actions-runner\" 
| where ProcessCommandLine has_any(SuspiciousCommands) or ProcessCommandLine has_any(CredentialKeywords)
| where ProcessCommandLine has \"VERSION.\"
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, ProcessFileName, ProcessCommandLine
| order by Timestamp desc
| extend AlertDetails = strcat(\"Potential CVE-2026-67308 exploitation detected on Device: \", DeviceName)


// Detect unusual network connections from GitHub Actions runners
DeviceNetworkEvents
| where InitiatingProcessFolderPath contains \"actions-runner\"
| where RemotePort notin (443, 22, 80, 8080)
| project Timestamp, DeviceName, AccountName, InitiatingProcessFileName, RemoteIP, RemotePort, RemoteURL
| order by Timestamp desc
| extend AlertDetails = strcat(\"Suspicious network connection from GitHub Actions runner on Device: \", DeviceName)


// Detect access to sensitive files in GitHub Actions workflows
Syslog
| where ProcessName contains \"actions-runner\" 
| where SyslogMessage has \"VERSION.\" and (SyslogMessage has \"cat\" or SyslogMessage has \"eval\" or SyslogMessage has \"curl\" or SyslogMessage has \"wget\")
| project TimeGenerated, ComputerName, ProcessName, SyslogMessage
| order by TimeGenerated desc
| extend AlertDetails = strcat(\"Potential access to VERSION. in GitHub Actions workflow on: \", ComputerName)

Velociraptor VQL

VQL — Velociraptor
-- Hunt for GitHub Actions runners executing suspicious commands related to CVE-2026-67308
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()\WHERE Name =~ \"runner\" OR Exe =~ \"actions-runner\"
  AND (CommandLine =~ \"VERSION.\" 
       OR CommandLine =~ \"eval\\s\\$\" 
       OR CommandLine =~ \"bash\\s-c\"
       OR CommandLine =~ \"GITHUB_TOKEN\"
       OR CommandLine =~ \"AWS_ACCESS_KEY_ID\")


-- Search for VERSION. files recently accessed by GitHub Actions processes
SELECT FullPath, Mtime, Atime, Size, Mode
FROM glob(globs=\"/**/VERSION.\")
WHERE Atime > now() - 7d
  AND Mode =~ \"^-rw.*\"
ORDER BY Atime DESC


-- Check for unusual network connections established by GitHub Actions runner processes
SELECT Pid, RemoteAddress, RemotePort, State, Family, Uid, StartTime
FROM netstat()
WHERE Pid IN (SELECT Pid FROM pslist() WHERE (Name =~ \"runner\" OR Exe =~ \"actions-runner\"))
  AND RemotePort NOT IN (22, 443, 80, 8080)
ORDER BY StartTime DESC

Remediation Script (Bash)

Bash / Shell
#!/bin/bash
# Script to detect and remediate CVE-2026-67308 in Wazuh workflows

# Colors for output
RED='\\033[0;31m'
GREEN='\\033[0;32m'
YELLOW='\\033[1;33m'
NC='\\033[0m' # No Color

echo \"Checking for CVE-2026-67308 vulnerable Wazuh workflows...\"

# Find all workflow files
echo \"Searching for workflow files...\"
WORKFLOW_DIRS=$(find / -name \".github\" -type d 2>/dev/null | head -20)

if [ -z \"$WORKFLOW_DIRS\" ]; then
  echo -e \"${YELLOW}No .github directories found. If GitHub Actions is used, ensure the script runs in the correct repository context.${NC}\"
  exit 1
fi

# Check for vulnerable Wazuh workflows
VULNERABLE_FOUND=false

for dir in $WORKFLOW_DIRS; do
  WORKFLOW_PATH=\"$dir/workflows\"
  if [ -d \"$WORKFLOW_PATH\" ]; then
    echo \"Checking workflows in: $WORKFLOW_PATH\"
    
    # Look for Wazuh workflows
    WAZUH_WORKFLOWS=$(grep -r -l \"wazuh\" \"$WORKFLOW_PATH\" 2>/dev/null)
    
    for workflow in $WAZUH_WORKFLOWS; do
      echo \"Analyzing Wazuh workflow: $workflow\"
      
      # Check for VERSION. references
      if grep -q \"VERSION.\" \"$workflow\" 2>/dev/null; then
        # Check for commit hash reference
        if ! grep -q \"44bf114\" \"$workflow\" 2>/dev/null; then
          echo -e \"${RED}VULNERABLE: $workflow references VERSION. but does not include the patched commit 44bf114${NC}\"
          VULNERABLE_FOUND=true
          
          # Check for environment variable interpolation
          if grep -E \"\\$\\{.*\\}\" \"$workflow\" 2>/dev/null | grep -q \"VERSION\"; then
            echo -e \"${RED}POTENTIAL EXPLOITATION PATH: Environment variable interpolation with VERSION detected${NC}\"
          fi
        else
          echo -e \"${GREEN}SECURE: $workflow includes the patched commit 44bf114${NC}\"
        fi
      fi
    done
  fi
done

if [ \"$VULNERABLE_FOUND\" = true ]; then
  echo -e \"${RED}ACTION REQUIRED: Vulnerable workflows detected. Please update to Wazuh workflow version 44bf114 or later.${NC}\"
  echo \"To remediate:\"
  echo \"1. Update Wazuh workflows to commit 44bf114 or later\"
  echo \"2. Review and restrict permissions on GitHub Actions runners\"
  echo \"3. Audit GitHub Actions tokens and credentials for potential compromise\"
  exit 1
else
  echo -e \"${GREEN}No vulnerable workflows detected. Current workflows appear to be patched or do not use the vulnerable functionality.${NC}\"
  exit 0
fi

Remediation

Immediate Actions

  1. Update Wazuh Workflows

    • Update all Wazuh workflows to commit 44bf114 or later
    • Verify the update by confirming the presence of commit 44bf114 in your workflow references
    • Official Wazuh guidance: Review the Wazuh GitHub repository for the latest workflow definitions
  2. Review GitHub Actions Runner Permissions

    • Implement principle of least privilege for self-hosted runners
    • Restrict access to sensitive credentials (GITHUB_TOKEN, AWS credentials)
    • Consider using GitHub-hosted runners for critical workflows if feasible
  3. Audit for Compromise

    • Review GitHub Actions logs for suspicious activity or unusual PR processing
    • Rotate GitHub tokens and credentials that may have been accessible to vulnerable workflows
    • Check for unauthorized access to cloud resources using potentially compromised AWS credentials

Long-term Hardening

  1. Implement Code Review Requirements

    • Require code reviews for all pull requests to repositories using GitHub Actions
    • Consider requiring approval from maintainers before Actions workflows are triggered
  2. Implement Branch Protection Rules

    • Enforce protected branches that prevent direct pushes
    • Require status checks to pass before merging
  3. Workflow Security Hardening

    • Use environment secrets for sensitive data rather than hardcoded values
    • Implement secret scanning in repositories
    • Use permissions settings in workflow files to minimize token scope
  4. Monitoring and Alerting

    • Implement the detection rules provided above in your SIEM
    • Set up alerts for suspicious GitHub Actions activity
    • Regularly audit GitHub Actions logs for anomalous behavior

Workarounds (If Immediate Patching is Not Possible)

  1. Disable Affected Workflows

    • Temporarily disable Wazuh workflows that process VERSION. files until they can be updated
  2. Restrict PR Submissions

    • Restrict who can submit pull requests to repositories using vulnerable workflows
    • Require maintainers to manually approve Actions workflow triggers from PRs
  3. Input Validation

    • Implement pre-commit hooks to validate VERSION. files before they are processed
    • Add input sanitization to workflows that process these files

Resources

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.