Skip to content
eastbaycyber

CVE-2026-67308: Wazuh Workflows Shell Injection

CVE explainers 10 min read
SR
Security Research Desk Expert reviewed
Threat intelligence · Human-verified · Updated 2026-08-01
▲ Escalation ViewOne CVE, briefed at three altitudes — skim the Brief, weigh the Impact, or work the Runbook. The way a SOC actually reads it.
CISOBrief · 30-second brief

TL;DR - Critical Wazuh workflow flaw allows shell injection through crafted VERSION.json in pull requests. - Affects workflow revisions before commit 44bf114; patch is available as that fix commit. - Prioritize remediation on self-hosted GitHub Actions runners due to secret theft and CI/CD compromise risk.

Vulnerability at a Glance

Field Value
CVE ID CVE-2026-67308
CVSS 10.0 (Critical)
Attack vector Pull request to vulnerable GitHub Actions workflow using crafted VERSION.json
Privileges required Not reliably published in source material; attackers are described as submitting pull requests
Patch available Yes, fixed before/at commit 44bf114 boundary

CVE-2026-67308 is a critical shell injection issue in Wazuh workflows, specifically in GitHub Actions logic used by the wazuh/wazuh project. According to the NVD description, an attacker can submit a pull request containing a crafted VERSION.json file and trigger command execution because attacker-controlled values are interpolated into shell run steps without safe handling.

The risk is materially higher when the impacted workflows execute on self-hosted runners. In that case, the blast radius can extend beyond the CI job itself to include exposure of GITHUB_TOKEN, AWS credentials, and whatever network or filesystem access the runner already has. Even though this CVE is not currently listed in CISA KEV, defenders should treat it as high priority due to the CI/CD trust implications.

What Is This Vulnerability?

At its core, this is a shell injection vulnerability in GitHub Actions workflow code, not a traditional flaw in the Wazuh runtime agent or manager. The vulnerable behavior arises when data from a pull request, specifically values sourced from VERSION.json, is passed into environment variables and then directly interpolated into shell commands inside workflow run steps. If that data contains shell metacharacters, the shell may interpret them as additional commands rather than plain input.

That distinction matters operationally. This is not an issue that remote attackers exploit by sending traffic to a Wazuh server. Instead, it is a supply chain and CI/CD exposure tied to repository automation. Repositories that accept contributions, especially from forks, are exposed if untrusted input reaches privileged workflow steps. In practical terms, a malicious contributor can attempt to turn a build or validation job into a code execution path on the runner.

Technical Notes

A simplified example of the unsafe pattern described by NVD would look like this:

- name: Read version data
  run: |
    VERSION=$(jq -r '.version' VERSION.json)
    echo "VERSION=$VERSION" >> $GITHUB_ENV

- name: Use version in shell
  run: |
    ./build.sh $VERSION

If VERSION.json contains shell metacharacters, and the workflow uses the value without strict validation and quoting, the shell may execute unintended commands.

A safer pattern is to validate expected format and avoid unsafe interpolation:

- name: Validate version
  run: |
    VERSION=$(jq -r '.version' VERSION.json)
    echo "$VERSION" | grep -Eq '^[0-9A-Za-z._-]+$' || exit 1
    printf 'VERSION=%s\n' "$VERSION" >> "$GITHUB_ENV"

- name: Use version safely
  run: |
    ./build.sh --version "$VERSION"
AnalystImpact · assess the risk

Who Is Affected?

The affected product identified in the available source material is Wazuh workflows / GitHub Actions workflows in the wazuh/wazuh project. The vulnerable range is expressed using a source control boundary rather than a release version string: workflow revisions before commit 44bf114. No formal fixed application version number was present in the provided materials, so defenders should avoid inventing one and instead verify whether their repository state includes the fix commit or a later revision.

This means the primary affected audience is not every Wazuh deployment by default. Organizations are affected if they use the vulnerable Wazuh workflow definitions, fork them, mirror them, or run derived CI pipelines containing the same unsafe logic. Teams using self-hosted GitHub Actions runners are at particularly high risk because a successful workflow compromise can reach internal assets, persistent credentials, and cloud resources.

In the absence of a published semantic version range, defenders should assume that any checked-out workflow configuration predating commit 44bf114 is vulnerable until proven otherwise. If your organization copied the workflow logic into private repositories, you should treat those as potentially affected even if they are not directly tracking upstream.

Technical Notes

To determine whether your repository contains the fix commit:

git rev-parse --verify 44bf114

To check whether your current branch includes it in history:

git merge-base --is-ancestor 44bf114 HEAD && echo "fixed" || echo "not fixed"

To search for workflow usage of VERSION.json:

grep -RIn "VERSION.json\|GITHUB_ENV\|jq -r" .github/workflows/

CVSS Score Breakdown

The NVD entry reports a CVSS base score of 10.0 (Critical). However, the vector string was not present in the provided research output, so it is not possible to responsibly restate the precise component values without guessing. For practitioners, the important takeaway is that NVD assessed this as maximum-severity risk based on the combination of exploitability and impact.

A perfect or near-perfect score for a CI/CD flaw generally signals that exploitation can lead to severe confidentiality, integrity, and availability consequences. Here, the published description explicitly mentions arbitrary command execution and exfiltration of secrets such as GITHUB_TOKEN and AWS credentials. In a self-hosted runner scenario, that can translate to broader infrastructure compromise rather than an isolated build failure.

Because the exact vector components are not available in the cited material, defenders should not overfit response plans to assumed details like attack complexity or privileges required. The safer assumption is that if untrusted pull request data reaches a privileged workflow context, the path to impact is serious enough to justify immediate review and patching.

Technical Notes

Where defenders should focus despite the missing vector string:

Primary impact areas:
- Confidentiality: CI secrets, cloud credentials, tokens
- Integrity: workflow tampering, artifact poisoning, repository actions
- Availability: runner disruption, malicious job termination, cleanup evasion

A practical scoring mindset for incident response is to prioritize this alongside other CI pipeline RCE-class issues, especially where fork-based PRs and self-hosted runners intersect.

Exploitation Status

Based on the provided evidence, there is no confirmed public reporting of active exploitation in the wild. The vulnerability is not listed in CISA KEV as of 2026-08-01. That does not mean it is safe to defer remediation; it only means there is no KEV-backed confirmation of exploitation available in the cited sources.

Likewise, the research note states that a standalone public proof-of-concept repository was not retrieved from the available references. There is, however, enough detail in the NVD description to understand the attack path: a crafted pull request with malicious VERSION.json content reaching shell-executed workflow steps. For capable adversaries, that may be sufficient to reproduce the issue without a public PoC.

The practical conclusion is: PoC not confirmed from provided sources, active exploitation not confirmed, but exploitability is plausible and high-impact. Security teams should assume that once a CI/CD issue is public and the vulnerable pattern is described, copycat testing by attackers is likely.

Technical Notes

Current status snapshot:

Public PoC: Not confirmed from provided sources
Known in-the-wild exploitation: Not confirmed
CISA KEV: No
Operational assumption: Treat as exploitable if vulnerable workflows process untrusted PR input

If your repository handles outside contributions, you should elevate monitoring immediately even before patch rollout completes.

ResponderRunbook · act now

How to Detect It

Detection for this CVE is about identifying suspicious workflow executions and malicious pull request content rather than scanning a network service. Start by reviewing GitHub Actions runs triggered by fork-originated pull requests that touched VERSION.json or related build metadata files. Pay special attention to jobs that unexpectedly spawned shell utilities used in exfiltration or environment discovery, such as curl, wget, env, printenv, aws, or calls to external domains not normally contacted by your pipelines.

You should also inspect self-hosted runner logs for anomalous command lines and outbound connections during pull request validation jobs. Because the described impact includes theft of GITHUB_TOKEN and AWS credentials, any workflow run that prints environment variables, accesses AWS APIs unexpectedly, or makes suspicious outbound HTTP requests during PR processing deserves urgent review. If logs are incomplete, assume higher risk and rotate credentials exposed to the affected workflow context.

Technical Notes

A simple repository history check for suspicious pull requests modifying VERSION.json:

git log --all --name-only --pretty=format:'commit %H %ad %an %s' -- VERSION.json

Example shell-history or runner-log indicators to search for:

VERSION.json
GITHUB_TOKEN
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
printenv
env
curl http
wget http
bash -c
sh -c

Example grep against self-hosted runner diagnostic logs:

grep -RInE 'VERSION\.json|GITHUB_TOKEN|AWS_ACCESS_KEY_ID|printenv|curl |wget |bash -c|sh -c' /path/to/actions-runner/_diag/

Example GitHub Actions hunting query logic to apply in your SIEM or log pipeline:

Find workflow runs where:
- event_name = pull_request OR pull_request_target
- changed_files contains "VERSION.json"
- runner_type = self-hosted
- step logs contain "curl", "wget", "printenv", "aws sts", or unexpected external domains

If you lack centralized CI logging, export and retain job logs now. CI incidents are often discovered after secrets have already been used elsewhere.

Mitigation and Patching

The documented fix boundary is commit 44bf114. Because the available source material does not provide a formal released software version number, the safest guidance is to update the affected workflow definitions so that your repository includes commit 44bf114 or a later revision. If you vendor or copy upstream workflow files into internal repositories, update those copies as well; simply upgrading Wazuh runtime components will not necessarily remediate a workflow logic flaw.

If immediate patching is not possible, reduce exposure by limiting what untrusted pull requests can trigger. Review whether workflows triggered by pull_request or pull_request_target run with secrets, write permissions, or access to self-hosted runners. Remove or restrict sensitive secrets from these contexts, isolate self-hosted runners used for untrusted code, and require stricter validation of values parsed from VERSION.json or similar metadata files. If compromise is suspected, rotate GITHUB_TOKEN, AWS credentials, and any other secrets reachable from the runner.

Technical Notes

To update a local clone and verify the fix commit is present:

git fetch origin
git checkout main
git pull --ff-only
git merge-base --is-ancestor 44bf114 HEAD && echo "fixed" || echo "update required"

If you maintain a fork and need to cherry-pick the fix:

git fetch upstream
git cherry-pick 44bf114

To harden workflows while patching, validate VERSION.json values before use:

- name: Validate VERSION.json fields
  run: |
    VERSION=$(jq -r '.version' VERSION.json)
    echo "$VERSION" | grep -Eq '^[0-9A-Za-z._-]+$' || {
      echo "Invalid version format"
      exit 1
    }

To reduce risk on GitHub Actions, review event triggers and secret exposure. For example, do not expose sensitive secrets to untrusted PR contexts unless absolutely necessary. If self-hosted runners process public contributions, segment them from internal networks and use short-lived credentials wherever possible.

References

The primary public reference is the NVD record for CVE-2026-67308, which provides the verified description, publication date, and severity. That description is the basis for the shell injection characterization and the specific warning about VERSION.json, command execution, and exfiltration of GITHUB_TOKEN and AWS credentials on self-hosted runners.

Upstream and third-party references also help defenders validate scope and remediation direction. The GitHub Security Advisory URL is the vendor-hosted disclosure path referenced by NVD, and the VulnCheck advisory reinforces the attack theme of shell injection via fork pull request handling. Because the available source material does not include a formal release number for the fix, defenders should rely on the documented commit boundary rather than assume a package version.

In short, CVE-2026-67308 is a critical CI/CD security issue centered on unsafe shell interpolation in Wazuh workflows before commit 44bf114. Even without confirmed in-the-wild exploitation, the combination of arbitrary command execution and possible secret theft on self-hosted runners is enough to justify urgent action.

For more information on securing service accounts, refer to our article on securing service accounts in Active Directory. Additionally, you can learn about best practices for home network segmentation in our home network segmentation best practices article.

This article may contain affiliate links. We earn a commission on qualifying purchases at no extra cost to you.

Last verified: 2026-08-01

Disclaimer: This article may contain affiliate links. We earn a commission on qualifying purchases at no extra cost to you.