We earn commissions when you shop through the links below, at no extra cost to you. Our guides and technical recommendations are written independently of these relationships: a commission never decides what we recommend, how we diagnose a problem or what we publish, and the content does not depend on it. Affiliate disclosure

News · Published 2026-11-12

wfx GitHub Actions Stealer: Check Repos, Cloud Roles

Stolen GitHub tokens push the wfx CI secret stealer, then delete the run. Tested gh checks for your repos, plus AWS and Azure persistence to remove.

The attack and the three checks in 4 minutes. It loads from YouTube only when you press play. Watch on YouTube ↗

TL;DR

  • Since 10 November 2026, someone with stolen GitHub tokens is pushing a CI secret stealer into repositories those tokens can write to. It is not a GitHub bug. The tokens belong to real developer and bot accounts, and the attacker uses them the way a developer would.
  • The pattern: a harmless probe pull request (docs: dependency audit notes, branch wfx-docs), then the stealer, then a revert and a deleted workflow run, usually within a minute. A missing run number in your Actions tab is often the only trace.
  • The stealer takes everything the job can reach: every repository, environment and organization secret (also the ones the workflow never names, read from the runner's memory), the GITHUB_TOKEN, cloud sessions through OIDC, and credential files on the runner.
  • Rotating secrets is not enough. The script tries to stay: it opens AWS role trust policies to "Principal": {"AWS": "*"}, creates IAM access keys, and adds Azure federated credentials named wfx-ci-* that trust your repository.
  • Blocking the published IP addresses is not enough either. According to StepSecurity, since about 05:30 UTC on 12 November new copies send the data to Telegram only (Aikido's analysis describes HTTP to the two addresses).

How big it is

The counts depend on who counted and when:

SourceWhenWhat they counted
StepSecurity07:40 UTC, 12 Novembermore than 63,000 probe pull requests, about 90% still open
Aikido Security12 November (no time given)4,837 accounts opened probe pull requests in 61,764 repositories; the payload ran in at least about 1,800 of them (the post gives both 1,806 and 1,835), which they say may understate it
Our GitHub search13:33 UTC, 12 November66,000 pull requests titled docs: dependency audit notes and 28,315 commits titled ci: refresh build cache since 10 November
Our GitHub search02:34 UTC, 13 November68,044 pull requests with that title (59,156 still open) and 31,034 commits with that title since 10 November

Per day, the same search on 13 November shows the wave moving from probing to planting. Probe pull requests: 15,145 on 10 November, 46,046 on 11 November, 6,853 on 12 November. Commits titled ci: refresh build cache: 4,926, then 8,800, then 17,308. The probes dropped on 12 November while the stealer commits doubled. These are GitHub search totals for a title, so they can include unrelated commits with the same words.

Aikido also lists published packages that picked up the payload through automated publishing: Packagist digitalelvis/neuronai-studio 3.14.3, and the Go module github.com/onuragtas/docker-env at tags v1.0.278 and v1.0.280. For the Go module the payload is in a GitHub Actions workflow file only; Aikido says the Go source and release binaries are unchanged. It counts at least 50 compromised accounts that publish packages (npm, Go, Packagist, PyPI, crates). If your project depends on a package whose maintainer was hit, check which version you installed since 10 November.

As of 13 November we found no statement from GitHub or Fly.io about the campaign. Fly.io's status page does record that it "reset all connections between Fly.io accounts and GitHub" at 17:34 UTC on 12 November (resolved 21:46 UTC), so Fly.io users had to sign in with GitHub again for automatic deploys on push. The page gives no cause and does not mention the campaign, so we cannot say whether the two are connected.

A probe is not a theft. The probe only tells the attacker that a token can write to a repository; the stealer follows only where the repository's setup lets it run. But if a probe pull request was opened from one of your accounts, that account's token is stolen, whether or not anything else happened.

How the attack works

According to both reports, for each repository a stolen token can write to:

  1. Probe. A pull request titled docs: dependency audit notes, body Routine dependency audit notes, from a branch wfx-docs, adding one file, docs/wfx-audit.md.
  2. Payload. One shell script of about 1,500 lines, hidden in one of four places:
Commit messageWhere the stealer goes
ci: refresh build cachetwo new steps in an existing workflow (named like Pass runtime and Restore cache x9xx), or appended to a shell script that a workflow already runs, such as update.sh
chore: add dependency audit workflowa new .github/workflows/build-audit-xxxxxx.yml on a throwaway chore/xxxxxxxx branch
chore: add ci helpera hidden .ci-xxxxxx.sh at the repository root, plus a package.json script (postinstall, build or test) that runs it
  1. Cleanup. A ci: restore (sometimes ci: cleanup) revert, and the workflow run is deleted together with its logs.

StepSecurity also found that some of the stolen tokens were issued to the Fly.io GitHub App (173 probe pull requests from 19 accounts at the time of its report). It says it has no evidence of a breach of Fly.io itself and does not know how the tokens were obtained. Several of the commits it studied were pushed as project bot accounts, one of them allowed to bypass branch protection.

Check whether you were hit

You need the GitHub CLI (gh), signed in with access to the repositories you check. Run these from a trusted machine, not from a CI runner.

1. Search for the probe and the commits

# Probe pull requests in your organization or account since 10 November (OWNER = org or user)
gh search prs "docs: dependency audit notes" --owner OWNER --created ">=2026-11-10"
# The stealer's commit messages
gh search commits "ci: refresh build cache" --owner OWNER --committer-date ">=2026-11-10"
gh search commits "chore: add ci helper" --owner OWNER --committer-date ">=2026-11-10"
gh search commits "chore: add dependency audit workflow" --owner OWNER --committer-date ">=2026-11-10"

No output means no match. We ran these against our own account on 12 November (no results, exit 0) and the same queries across all of GitHub (66,000 and 28,315 results), so the syntax matches the campaign. Search covers what your token can see; private repositories need a token with access to them. Also check pull requests your own people opened elsewhere: gh search prs "docs: dependency audit notes" --author USER --created ">=2026-11-10".

2. Look for missing run numbers

Every workflow numbers its runs 1, 2, 3, and a deleted run leaves a hole. This lists the holes in one repository since 10 November:

# Missing run numbers per workflow, OWNER/REPO as the first argument
gh api "repos/$1/actions/runs?created=>=2026-11-10&per_page=100" --paginate \
  --jq '.workflow_runs[] | "\(.workflow_id) \(.name) \(.run_number)"' |
sort -k1,1n -k3,3n |
awk '$1==w && $3>n+1 {print "gap in \"" $2 "\": runs " n+1 "-" $3-1 " missing"} {w=$1; n=$3}'
# Real output from our test repository: three runs, run 2 deleted by hand
gap in "obf-gap": runs 2-2 missing

A gap is a lead, not proof: your own team or a cleanup job may delete runs too. Compare the time around the gap with the commits from step 1. Two limits: the chore: add dependency audit workflow variant adds a brand-new workflow, whose first run is number 1, so it leaves no gap, and a whole deleted workflow file disappears from this list. For those, the commit search and step 3 are the check. On GitHub Enterprise Cloud, the organization audit log also records deleted runs (not tested: gh api -X GET orgs/ORG/audit-log -f phrase='action:workflows.delete_workflow_run created:>=2026-11-10').

3. Search the Git history, where the revert does not reach

The revert removes the stealer from the branch, not from history. In a fresh clone of each repository:

# Fetch every branch, then look for the commit messages, the stealer's own variable and its files
git fetch --all --prune
git log --all --since=2026-11-10 --format='%h %an %ad %s' --date=iso -i -E \
  --grep='^(ci: refresh build cache|ci: restore|ci: cleanup|chore: add ci helper|chore: add dependency audit workflow)'
git log --all --since=2026-11-10 --format='%h %an %s' -S WF_CALLBACK
git log --all --since=2026-11-10 --format='%h %s' --name-status -- '.ci-*.sh' 'docs/wfx-audit.md' '.github/workflows/build-audit-*.yml'
# Real output from a test repository: a harmless file with the marker, committed and then reverted
9f4ca9a OpsBreakFix 2026-11-12 15:35:04 +0200 chore: add ci helper
8a9ce02 OpsBreakFix Revert "chore: add ci helper"
9f4ca9a OpsBreakFix chore: add ci helper
8a9ce02 Revert "chore: add ci helper"

D	.ci-obftst.sh
9f4ca9a chore: add ci helper

A	.ci-obftst.sh

-S WF_CALLBACK finds the commit that added the script and the one that removed it, even when the commit message was something else, such as the stealer pasted into update.sh. WF_CALLBACK is one of the variable names both reports list; the reports list more (WF_CTOKEN, WF_TG_BOTS). Throwaway branches that were already deleted are not in a fresh clone, so steps 1 and 2 still matter.

Note the author of every hit. That account's tokens are stolen, including bot accounts.

If the stealer ran

Work from a clean machine, in this order.

  1. Contain the account. For the account that pushed the commits: revoke its personal access tokens, sign out its sessions, and review its authorized OAuth and GitHub Apps (Settings, Applications). For a bot account, replace its token and remove any branch-protection bypass it does not need.
  2. Keep the evidence first. Note the commit SHAs, the gap in the run numbers and any surviving run logs before you clean anything up. A surviving log with lines such as archive_bytes is the stealer reporting what it took.
  3. Rotate every secret the job could reach. Repository, environment and organization secrets, not only the ones the workflow names: the memory scan collects the rest. Include package-publishing tokens (npm, PyPI, crates, Packagist) and check for versions published after the bad commit. On a self-hosted runner, the host's own credentials and cloud instance role are exposed too.
  4. Remove the persistence. Rotation does not touch it. See the next section.
  5. Re-run CI only from a known-good commit, after the workflow files, the scripts they call and package.json are reviewed.

AWS: roles open to everyone and new access keys

Not tested: we have no AWS account to run these against. They are read-only.

# Roles whose trust policy allows any AWS principal (needs jq)
aws iam list-roles --output json |
  jq -r '.Roles[] | select([.AssumeRolePolicyDocument.Statement[]? | .Principal.AWS? // empty] | flatten | index("*")) | .RoleName'
# Access keys created since 10 November, per IAM user
for u in $(aws iam list-users --query 'Users[].UserName' --output text); do
  aws iam list-access-keys --user-name "$u" --query "AccessKeyMetadata[?CreateDate>='2026-11-10'].[UserName,AccessKeyId,CreateDate]" --output text
done
# Trust-policy changes and new keys in CloudTrail (management events, this region)
aws cloudtrail lookup-events --lookup-attributes AttributeKey=EventName,AttributeValue=UpdateAssumeRolePolicy --start-time 2026-11-10
aws cloudtrail lookup-events --lookup-attributes AttributeKey=EventName,AttributeValue=CreateAccessKey --start-time 2026-11-10

Restore a changed trust policy from your infrastructure code (aws iam update-assume-role-policy), deactivate and then delete unexpected keys (aws iam update-access-key --status Inactive, then aws iam delete-access-key), and look in CloudTrail for sessions named wfx-*, which StepSecurity lists as an indicator.

Azure: federated credentials named wfx-ci-*

Tested on 12 November 2026 with Azure CLI 2.92.0 on our own Entra tenant: we created a test app registration with a federated credential named wfx-ci-test (fake subject), ran the loop below, deleted the credential by name and then the app. Reading app registrations needs no Azure subscription role; your Entra role decides which apps you can see.

# Federated credentials named wfx-ci-* on every app registration you can read
for app in $(az ad app list --all --query '[].appId' -o tsv); do
  az ad app federated-credential list --id "$app" --query "[?starts_with(name, 'wfx-ci-')].{app:'$app', name:name, subject:subject}" -o tsv
done
# Real output: the planted test credential (app ID masked)
<app-id>	wfx-ci-test	repo:example-org/example-repo:ref:refs/heads/main

The subject shows which repository and branch the credential trusts: that is the compromised repository. Delete what you find with az ad app federated-credential delete --id APP_ID --federated-credential-id NAME (the name works as the ID; we checked that the list was empty afterwards), then check the app's role assignments and Key Vault access, because the stealer also replays cached Azure CLI tokens for Microsoft Graph and Key Vault.

Kubernetes

If a kubeconfig or service-account token was on the runner or in a secret, treat it as stolen: rotate it and read the API server audit log for requests from it since 10 November. We have not seen a report of what the attacker did with Kubernetes credentials; the reports only list them among the files the script collects.

What would have stopped which step

No single control covers all four hiding places. Each of these closes a specific gap this campaign used:

  • Required reviews on CI files, with no bypass. A ruleset or branch protection on the default branch, and CODEOWNERS entries for /.github/workflows/, package.json and the scripts CI runs. Several commits here were pushed straight to the default branch, some by bot accounts with bypass rights.
  • OIDC trust tied to an environment. If your AWS role or Azure federated credential trusts only repo:ORG/REPO:environment:production (for repositories created after 15 July 2026 the subject carries IDs: repo:ORG@ORG-ID/REPO@REPO-ID:environment:production; gh api repos/ORG/REPO/actions/oidc/customization/sub shows which one yours sends), and that environment needs an approval, a step injected into ci.yml cannot get a cloud session. A trust that accepts any branch or any workflow in the repository can.
  • Minimal GITHUB_TOKEN permissions (permissions: contents: read at the top of each workflow, more only where a job needs it), so the token the stealer grabs can do little.
  • Fewer secrets in reach. Secrets in environments, not at repository or organization level, are only decrypted for jobs that use that environment. The memory scan reads what the job has, so a job that has nothing gives nothing.
  • An egress allowlist on runners. Neither a bare IP on port 8080 nor api.telegram.org belongs in a normal build. A blocklist of the published IPs already missed the Telegram copies.
  • Short-lived, scoped tokens for people and bots. Fine-grained tokens with an expiry, limited to the repositories they need, and a periodic review of the apps that hold tokens for your account.

What is not known yet

  • How the tokens were stolen. Neither report says. StepSecurity links some victims to the October GhostAction wave and one commit to a technique from the PolinRider campaign, and says that does not prove a single actor.
  • The real number of victims. The counts above are lower bounds from public repositories at a point in time; private repositories are not in them.
  • How often the persistence worked. The script tries to change AWS and Azure; whether it succeeded depends on the permissions of each victim's cloud role. Neither report counts successful cloud changes.
  • What comes next. StepSecurity notes a built-in feature to fake passing status checks that was switched off in every copy it examined.

Related guides

Sources

More from the blog

This article is educational information, not incident-response or legal advice. Verify package status with your operating system, hosting, or runtime vendor.