Tous les articles

wfx-loot: Stolen GitHub tokens pushed a CI secret stealer into 60,000+ repositories (November 2026)

Quincy Castro CISO

TL;DR

  • What happened: Starting around 12:45 UTC on November 10, 2026, an attacker used stolen GitHub credentials to push a CI secret stealer, which calls itself wfx, into every repository those credentials could write to. The campaign was still active on November 12.

  • Scale: Aikido counted 4,837 compromised accounts opening probe pull requests in 61,764 repositories, with the stealer confirmed to have run in more than 1,800 of them. SafeDep counted 8,093 repositories that received malicious commits between November 10 and November 12.

  • What it steals: Every GitHub Actions secret and variable, the workflow GITHUB_TOKEN and OIDC tokens, cloud credential files, SSH and GPG keys, shell histories, runner process memory, and tokens for AI tools including OpenAI, Anthropic, Cursor and Copilot. It then uses what it finds to mint cloud sessions and plant backdoors that survive credential rotation.

  • Supply chain spread: The payload reached at least one published package through automated publishing: Packagist digitalelvis/neuronai-studio 3.14.3. Two tags of the Go module github.com/onuragtas/docker-env (v1.0.278 and v1.0.280) carry the payload in a workflow file only; Go builds do not run workflow files.

  • Chainguard customers: Not affected. Chainguard reviewed its GitHub organizations, including the chainguard-actions catalog, and found no indicators of this campaign. Chainguard Actions are published from pinned upstream commits with signed SLSA provenance, so a customer can verify that the action they run is the one Chainguard built. Chainguard Checks keeps real credentials out of the CI VM entirely, so a payload like wfx has nothing to dump. 

  • What to do: Search every repository you can write to for a wfx-docs branch or a pull request titled docs: dependency audit notes. If the payload ran, rotate every secret and cloud role the repository's workflows could reach, then check AWS trust policies and Azure federated credentials for the backdoors described below.

This is a credential theft campaign, not a flaw in GitHub Actions itself. The attacker already held working GitHub tokens, so the usual advice to pin actions and review pull requests would not have stopped the initial push. What it does show is how much a single CI run can reach: the moment a workflow runs, every secret the repository holds, every cloud role it can assume, and the memory of the runner itself are available to whatever code is in that workflow.

This post covers what happened, how to check whether you were hit, and how Chainguard Actions and Chainguard Checks change the exposure.

How the attack worked

For each repository a stolen token could write to, the attacker ran the same three-step sequence, usually in under a minute:

  1. Probe. Open a pull request titled docs: dependency audit notes from a branch named wfx-docs. This only confirms write access. GitHub search returned more than 61,000 of these pull requests opened between November 10 at 12:45 UTC and November 11 at 15:00 UTC, and roughly 90 percent were still open on November 12. About 10,400 of them went into repositories the compromised account did not own, reached through collaborator or organization access.

  2. Push the payload using one of three variants. Workflow injection (ci: refresh build cache) adds about 1,500 lines to an existing workflow. Install hook (chore: add ci helper) adds a .ci-xxxxxx.sh script and a postinstall hook in package.json so the payload runs on any npm install. Throwaway branch (chore: add dependency audit workflow) adds .github/workflows/build-audit-xxxxxx.yml on a chore/xxxxxxxx branch.

  3. Clean up. Revert the commit within about a minute and delete the workflow run and its logs. A missing run number in a workflow's history is often the only trace left.

The injected step passes the repository's secrets and variables into the environment with toJSON(secrets) and toJSON(vars), then runs the stealer script. The script is about 1,500 lines of plain, commented shell, and it names itself wfx in its logs and variables.

What the stealer does

The script works in four stages. Some features were switched off in this campaign, but the capability is in the code.

  • Collect. GitHub Actions secrets and variables, GITHUB_TOKEN, OIDC and Actions runtime tokens, the full runtime environment, credential files for AWS, Azure, GCP, Docker, Kubernetes, npm, PyPI, Git, SSH, GPG, Vault and Terraform, credentials for OpenAI, Anthropic, Gemini, Hugging Face, Cursor, Copilot, Codex and other AI developer tools, shell histories, every .env, .pem, .p12, .jks, .kdbx and kubeconfig file under $HOME, and the memory of running processes on the runner, with Runner.Worker and Runner.Listener first. On self-hosted runners it also reads cloud instance metadata, Docker state, the runner's RSA parameters and systemd units.

  • Escalate. It mints GitHub OIDC tokens for AWS, GCP and Azure audiences and exchanges them for cloud sessions, chains into other IAM roles it finds and creates long-lived access keys for IAM users, impersonates GCP service accounts, replays cached Azure CLI refresh tokens against first-party Microsoft client IDs, and replays OIDC tokens against HashiCorp Vault and Kubernetes API servers.

  • Persist. Early in the run it posts forged success status checks against the commit using the names of the repository's required checks, which clears branch protection while the payload is still running. It rewrites the trust policy of any AWS role it reached to allow any AWS account. With a Microsoft Graph token it adds federated identity credentials named wfx-ci-… to Azure AD applications, pointing back at the compromised repository, so a workflow there can authenticate to Azure with no stored secret even after every token is rotated.

  • Exfiltrate. It packs everything into a gzipped tarball and, in this campaign, posted it over plain HTTP to 194.150.166[.]244:8080/exfil or 18.143.168[.]96:8080/exfil. The code also supports hiding the archive in the Actions cache, a workflow artifact named wfx-loot-<run id>, or the step summary, but those channels were turned off. The absence of wfx-loot artifacts therefore proves nothing.

Indicators of compromise

GitHub indicators

  • Branches: wfx-docs, chore/[a-z0-9]{8}, ci-check-[0-9]{4}

  • Pull request title: docs: dependency audit notes

  • Commit messages: ci: refresh build cache, ci: restore, chore: add ci helper, ci: cleanup, chore: add dependency audit workflow

  • A workflow run number missing from a workflow's history around November 10 to 12

Network indicators

  • 194.150.166[.]244:8080 (/exfil)

  • 18.143.168[.]96:8080 (/exfil)

Files

  • Stealer script SHA256: 89695abb392d5cfd4972672961e644bb46baa98aa1ed7173c2a2816c762735cf

  • .ci-xxxxxx.sh in the repository root with a matching postinstall hook in package.json

  • .github/workflows/build-audit-xxxxxx.yml

Affected package versions

  • Packagist digitalelvis/neuronai-studio 3.14.3

  • Go module github.com/onuragtas/docker-env v1.0.278 and v1.0.280 (payload in a workflow file only)

Cloud indicators

  • AWS: STS sessions named wfx-<pid>, new IAM access keys you did not create, role trust policies that now contain "Principal": {"AWS": "*"}

  • Azure: federated identity credentials named wfx-ci-… on Azure AD applications

  • GCP: generateAccessToken or signJwt calls from a GitHub OIDC principal you did not configure

How to check if you're affected

  1. Search every repository for the branches, pull request title and commit messages above. GitHub search for the pull request title across your organization is the fastest first pass.

  2. If a probe pull request exists, treat the account that opened it as compromised and rotate its tokens, including GitHub CLI tokens, even if nothing else was pushed.

  3. For each repository with a payload commit, look at the workflow run history for a skipped run number around the commit time. A missing run is the signature of a run that was executed and deleted.

  4. Check status checks on the affected commits for success results posted by an unexpected app or token.

  5. Search DNS, proxy and egress logs for the two exfiltration addresses.

  6. In AWS, Azure and GCP, audit for the cloud indicators above. Rotating secrets alone does not remove a trust policy or a federated credential.

If the payload ran in a repository, assume every secret and cloud role available to its workflows is compromised.

Immediate steps if you're affected

  1. Revoke the stolen GitHub credential. Rotate the personal access tokens, GitHub CLI tokens and SSH keys of the compromised account, and review its OAuth and GitHub App grants.

  2. Rotate every secret the workflow could reach. Repository and organization Actions secrets, deploy keys, package registry tokens, cloud keys in secrets, and the AI provider tokens listed above.

  3. Remove the backdoors. Delete federated identity credentials named wfx-ci-… in Azure, restore AWS role trust policies, and delete IAM access keys and GCP service account keys you did not create.

  4. Reinstate branch protection. Re-run required checks on affected commits and look for forged success results.

  5. Block egress to the two exfiltration addresses and keep the logs.

  6. Remove the payload. Delete injected workflow steps, the .ci-xxxxxx.sh helper and its postinstall hook, and any build-audit-xxxxxx.yml workflow. Remove the affected Packagist and Go versions from your dependencies.

Why Chainguard customers are protected

Chainguard reviewed its own GitHub organizations, including the chainguard-actions catalog, and found no indicators of this campaign: no probe pull requests, no wfx-docs branches, no payload files, and no traffic to the exfiltration addresses. 

Chainguard customers using Chainguard Actions or Chainguard Checks receive ongoing protection from these types of compromises, with Actions preventing Actions compromises and Checks securing all of CI, from the runner to the workflow. 

Chainguard Actions

Chainguard Actions are continuously hardened, drop-in replacements for more than 1,000 popular GitHub Actions. Each one is pulled from upstream at a pinned commit, reviewed by a static ruleset and an AI analysis, and published with a HARDENING.md report and a signed SLSA provenance attestation. Every nested uses: reference and container image inside a hardened action is pinned to an immutable digest.

Two of the checks every action goes through are the ones that matter here. The suspicious run content check flags process memory access, credential file access, outbound exfiltration, persistence and environment secret scraping in run: blocks, which is the complete behavior list of the wfx script. The permissions check flags workflows that leave GITHUB_TOKEN at its default scope or set write-all. An action that behaves like wfx cannot pass hardening, and a customer can verify with the provenance attestation that the action they pull is the one Chainguard reviewed.

Chainguard Checks

Chainguard Checks eliminates the core weakness wfx exploits, which is a CI runner holding credentials. Instead of GitHub Actions runners, it executes jobs inside Chainguard-hardened, managed microVMs, running only what is defined in a repository’s .chainguard configuration. There was no way for the wfx script to execute there unless someone intentionally planted it for research.

And even then, it would have found nothing to take. A Checks microVM holds no credentials. When a job needs cloud access, Chainguard Checks uses a workload identity. It issues a five-minute OIDC token, renews it while the job runs, and keeps the real credentials outside the microVM. The tokens visible to code inside the microVM are sealed stand-ins. Checks swaps in the real token only on requests to the cloud provider’s endpoints.

The bigger picture

  1. The credential is the supply chain. No package, action or registry was compromised at the source. One leaked token per account was enough to reach more than 60,000 repositories, and more than 10,000 of those were reached through access the account had to other people's repositories.

  2. The runner is the target. The payload spends most of its 1,500 lines on what is reachable from a CI VM: secrets, OIDC exchange, process memory and cloud metadata. Reducing what a runner holds is a more durable control than reviewing what a workflow does.

  3. Persistence outlives rotation. Forged status checks, rewritten AWS trust policies and injected Azure federated credentials are designed to survive the standard response of rotating every secret. Cloud configuration has to be audited, not only credentials.

Want to learn more about Chainguard?

Chainguard Actions gives your workflows continuously hardened, digest-pinned, provenance-signed replacements for the actions you already use. Chainguard Checks takes CI checks off GitHub Actions runners and keeps credentials out of the microVM CI runners. Learn more about Chainguard Actions, see how Chainguard Checks works, or get in touch with our team.

Share this article

Commencez à développer avec Chainguard