The campaign has no CVE. Nothing in GitHub failed. Every gate that fired on November 10 did exactly what its operators had configured it to do — the attacker simply held the same keys a team member holds, and used them the way they are documented to be used.

The mechanism, precisely

An attacker with a stolen token never needs to defeat anything. SafeDep's analysis notes the payload commits were authored as the repositories' real users — their noreply email, no signature — which is the fingerprint of token use rather than account access, and in 1,343 of the repositories the author is an account other than the owner: a collaborator or a bot. Aikido counted 4,837 compromised accounts, 10,431 of whose probes landed in repositories those accounts did not own — reached through collaborator and organization membership. One phished member of a community organization is exposure for every repository that member can write.

The sequence per repository:

  1. Probe. A pull request titled docs: dependency audit notes from a branch named wfx-docs, body "Routine dependency audit notes.", adding a small notes file. It tests write access. SafeDep counted 61,879 of these across 61,734 repositories from 4,833 accounts; 91% were still open when their search ran. Aikido's snapshot: 61,839 probes between November 10, 12:45 UTC and November 11, 15:00 UTC from 4,837 accounts into 61,764 repositories; 92% still open.
  2. Payload. One of three deliveries, decided by what the repository offers (SafeDep's split: 7,309 / 771 / 16):
  3. ci: refresh build cache — injects roughly 1,500 lines into an existing workflow;
  4. chore: add ci helper — writes a .ci-xxxxxx.sh script and a postinstall hook in package.json, so the payload runs on any npm install — on a developer's laptop, not just in CI;
  5. chore: add dependency audit workflow — adds .github/workflows/build-audit-xxxxxx.yml on a throwaway chore/xxxxxxxx branch, for the 16 empty repositories that first got a chore: initial commit.
  6. Cleanup. The commit is reverted — Aikido: "at most one minute"; SafeDep documents the concrete envelope in Panelinha-34/tech-challenge-01: payload in at 14:01 UTC, reverted at 14:05 — and the workflow run is deleted with its logs. Follow-up commits are named ci: restore and ci: cleanup.

The payload is the same script in all three variants: about 1,500 lines of shell, heavily commented, not obfuscated, self-designating as wfx in its logs and filenames. The workflow it rides in declares what it needs — contents: read, actions: read, id-token: write, statuses: write — and its first step copies the Actions runtime tokens (ACTIONS_RUNTIME_TOKEN, ACTIONS_RUNTIME_URL, ACTIONS_CACHE_URL, ACTIONS_RESULTS_URL) into the job environment, then hands the script ${{ toJSON(secrets) }} and ${{ toJSON(vars) }} wholesale.

A missing run number in the workflow's history is often the only trace that any of this happened.

What it takes

Everything the runner holds, then everything the runner holds implicitly:

  • repository and organization secrets and variables, the workflow GITHUB_TOKEN, and the OIDC and Actions runtime tokens;
  • a filtered copy of the environment — variable names matching token, secret, pass, cred, aws, azure, gcp, openai, anthropic, stripe and dozens more;
  • credential files in their well-known paths: AWS, Azure, GCP, Docker, Kubernetes, npm, PyPI, Git, SSH, GPG, Vault, Terraform — plus every .env, .pem, .p12, .jks, .kdbx and .kubeconfig under $HOME, recursively;
  • credentials for AI services and AI developer tools: OpenAI, Anthropic/Claude, Gemini, Hugging Face, Cursor, Copilot, Codex, Continue, Codeium, Aider, Weights & Biases, Ollama. The AI keys live in the same chest as everything else — this site counted what a coding agent writes down last week; wfx is the route by which that whole class leaks at once;
  • shell histories for bash, zsh, mysql, psql, python and node;
  • the environment and memory of running processes on the runner, prioritizing Runner.Worker and Runner.Listener, extracting JWTs, GitHub PATs, AWS keys and AI provider tokens;
  • a snapshot of the repository, files matching its catalog of secret patterns, the last 100 commits, recent workflow artifacts.

On self-hosted runners the sweep extends to the machine: cloud instance metadata credentials, Docker container state, the runner's RSA key parameters, its systemd units.

Where escalation begins: the repository is the credential

id-token: write is the load-bearing grant. The script mints GitHub OIDC tokens for AWS, GCP and Azure audiences and exchanges them for cloud sessions, even in repositories with no cloud configuration:

  • AWS — chains into IAM roles the repository's workflows can assume, then calls iam:CreateAccessKey to mint long-lived credentials on IAM users. Sessions are named wfx-<pid>.
  • GCP — signs JWTs with service-account keys using a dependency-free Python RSA implementation, lists projects and service accounts, and impersonates them via generateAccessToken and signJwt.
  • Azure — exchanges OIDC tokens or client secrets for management tokens, lists subscriptions and Key Vaults, and replays cached Azure CLI refresh tokens against first-party Microsoft client IDs (the FOCI trick) to obtain Graph, ARM and Key Vault tokens.
  • Vault and Kubernetes — replays the same OIDC tokens against any HashiCorp Vault and against the API servers found in kubeconfig files.

Then the persistence layer, which is the part that survives the response everyone else performs:

  • AWS: rewrites the chained role's trust policy to "Principal": {"AWS": "*"} — the role now trusts every AWS account on the platform. An access key minted now, plus a role trusting the world, means your rotation of secrets changed nothing about the backdoor's usefulness.
  • Azure: adds new federated identity credentials, named wfx-ci-…, to Entra app registrations, pointing back at the compromised repository. Any workflow on that repository's main branch can authenticate to Azure as that application — with no stored secret at all — after you have rotated every token you own. The credential was never a token; it was the repository's right to claim one. That is the honest description of OIDC: the repo is now the credential, and the repository's push policy is the credential's real access control list.
  • Branch protection: the script can post forged success status checks against its own commit using the context names of the repository's required checks — branch protection matches on context name, not on which app posted it — early in the run, before collection. Aikido's account of the campaign has the script actually setting them; in the four payload samples SafeDep dissected, that flag was off. Both statements come from the same day; the divergence is carried here rather than resolved, and neither reading makes you safer — an attacker with the write token can also simply force-push around protection on the branches it owns.

The loot leaves the runner however the configuration says: direct HTTP POST with backoff, a secondary callback, a Telegram bot, an AES-encrypted commit back into the repository, base32 in the run log — and three channels that abuse GitHub's own egress (Actions cache entries, step summaries wrapped in <!--WFX-BEGIN--> markers under 700 KB, artifacts named wfx-loot-<run id>) which exist specifically for private repositories and were disabled in this wave's deployed configuration. In SafeDep's 200-sample dissection, about half of the payloads shipped to 194.150.166[.]244:8080/exfil and a fifth to Telegram only; Aikido and SafeDep together list 18.143.168[.]96 and 153.75.82[.]159 as the other collectors. Since configs for private repositories exist in the code, absence of wfx artifacts proves nothing about private repositories — which brings us to what the numbers can and cannot see.

The numbers, and what they do not cover

  • 61,879 probe pull requests (SafeDep) / 61,839 probes in a tighter window (Aikido), from ~4,830 compromised accounts, into ~61,750 repositories. GitHub search still listed more than 66,000 of the characteristic probes on Thursday noon with ~4,300 opened that day (heise).
  • 8,093 repositories received payload commits between November 10, 12:46 UTC and November 12, 04:36 UTC — and the campaign was still active when that search ran (SafeDep).
  • At least 1,806 repositories ran the payload (Aikido's count, with its own caveat that the run logs were deleted so it "may understate"; Aikido's summary hardens the same figure to 1,835 "and have had credentials exfiltrated"). Three percent of the probed repositories paid out; the other ninety-seven percent were only probed.
  • At least 50 of the compromised accounts publish packages to npm, Go, Packagist, PyPI or crates (Aikido).

The supply-chain spillover is smaller than it looks and worse than it looks at the same time. On Packagist, digitalelvis/neuronai-studio v3.14.3 carries the payload — SafeDep's minute-by-minute reconstruction shows the tag was created at 12:29:20 on top of the hook commit and pushed by the compromised account at 12:29:22, with no Actions run producing it (the release workflow's own run failed at its push step thirty-eight seconds earlier because main had moved under it), while carrying the github-actions[bot] identity CI normally sets; the revert landed at 12:29:30 and the tag had already shipped. A machine that installed that version — or ran npm install on any repository where the postinstall variant was live — is done: rebuild it, do not clean it. The Go modules (github.com/onuragtas/docker-env v1.0.278/280/282, github.com/onuragtas/redock, and a pseudo-version of github.com/vkuznet/gocurl still served by the module proxy) carry the payload inside a workflow file that ordinary go get never executes, so consumers are unlikely to have been hit — but the proxy caches those versions permanently, which is how a reverted attack becomes a permanent distribution. SafeDep also found payloads still live at write time in vkuznet/gocurl, Kellie-Brighty/Suinicate, and two repositories with the postinstall hook still in their package.json.

All eight-digit counts above are counts of public repositories. Public search is the only view anyone outside GitHub has, and the payload ships with configurations for private repositories. Treat every number in this post as a floor visible through a window.

Where the tokens came from — the part that is known

Fly.io's statement, posted November 12 at 22:00 UTC, is the first confirmed supply of stolen material documented first-party: when an app was deployed from GitHub through the dashboard or automatic deploys, the deploy process left a GitHub access token in the .git/config of the build directory, and apps that packaged their build directory into their image — and served it over HTTP — served the token at their public URL. The tokens were GitHub App installation tokens: write to repository contents, Actions and pull requests, across every repository the user could access where the app was installed. On the affected accounts the campaign opened more than 250 of the probe pull requests. Fly.io's systems were not breached; the apps themselves served the keys. Its guidance is the sharpest single check in this whole incident: request https://<your-app>.fly.dev/.git/config — if a git configuration file comes back, your app is serving its repository and its history, put .git in .dockerignore, redeploy, and rotate every credential ever committed there.

And then the addendum, fourteen hours later: the revocation Fly.io kicked off through GitHub's own UI did not complete — GitHub acknowledged the process stopped partway through and committed to resuming, with the company's own note speculating about yesterday's large-scale Microsoft outage on GitHub's side. The cleanup of one token supply is itself still a work in progress as of this writing.

Credit where it is due in this story: StepSecurity — Ashish Kurmi and team — spotted the Fly.io app inside the campaign and contacted Fly.io directly, which is the only reason this root cause reached a first-party statement at all.

Honesty column

  • The numbers are two security vendors' censuses of public observability. Aikido sells secret scanning, and its "rotate now" economics should be read with that in mind; SafeDep independently reproduced the technical anatomy and the topline counts (61,879 probes / 8,093 payload commits, active campaign), and a Cloud Security Alliance research note and heise's English-language report corroborated the same day. Where the two vendors disagree on one behavioral claim (forged status checks deployed vs. present-but-disabled), both readings are carried above.
  • Deletion of run logs is structural here, not incidental: every number about executed payloads is a lower bound by construction.
  • Nothing in GitHub or Actions broke. There will be no CVE, no KEV entry, no patch deadline — exploitation is pure credential abuse, and CISA's catalog never sees it. That is not underreporting; there is nothing to file.
  • Token provenance is partially known: Fly.io documented its own leak; where the majority of the other ~4,800 accounts' tokens came from is not established. GitHub had published no statement at the time of writing (per heise). No attribution exists.
  • This is the third wave of its class in two months: SafeDep's related reading lines up Megalodon and prt-scan; heise covered the testmetest worm in late October; Aikido notes accounts and indicators overlapping October's GhostActions wave (fake security-audit.yml/audit.yml/ci-check.yml scanners shipping repository and history keys to 193.32.204[.]199; one compromised account here also carried a ci-check-2830 branch from October 20). The loot target is stable across all of them: CI credentials.

The translation for a community forge

Gitea Actions and Forgejo Actions execute the same workflow YAML against the same secrets model, on runners that trust the same grant names. A stolen token at a community forge buys the identical loot wherever a workflow holds secrets — and the countermeasures are identical because the failure mode is identical: the runner worked correctly. The lessons that transfer, in the order of what they protect:

  1. There is no patch to wait for. Credential theft is not a release-note event. The defenses are account-level: two-factor authentication for every forge account (an org's compromise surface is its weakest member), tokens that expire, and the removal of write access that a member does not actually need — this campaign reached 10,431 repositories it had no business reaching because membership is broad and write access follows membership.
  2. The default branch is the credential's real ACL. Where OIDC federation, deploy keys, or runner registration trust a repository, the ability to push to that repository's default branch is the key. Protected branches with required reviews limit who can turn repo access into cloud access — and note the honest limit: subject-binding your OIDC federation to repo:main does not distinguish which workflow in that repo is minting, so it constrains the blast radius of a stolen write token only as far as the branch protection does.
  3. The audit trail must live where write access does not reach. The attacker deleted the runs and their logs; the surviving records were the fork-level platform logs and the patterns in neighboring systems. Fly.io's checklist points operators at GitHub's security log for deleted runs — the platform-level ledger persists where the repository-level ledger is deletable, and the same architecture applies to a self-hosted forge: mirror push and run events out via webhook to a machine whose credentials are not on the forge, keep the runner's own journal on a filesystem the workflows do not read, and put your reverse proxy in front of the run history so deletion has a witness.
  4. Self-hosted runners are workstations. The payload's self-hosted branch steals Docker state, systemd units, RSA parameters and instance metadata. A community CI box that also serves other duties is not a CI box after a compromise; isolate runners per job in throwaway machine, or accept the runner as the crown jewels and lock it like one.

The operator section

In this order:

  1. Fingerprint search across your organization's repositories for: a branch named wfx-docs; a pull request titled docs: dependency audit notes; a file named docs/wfx-audit.md; commits named ci: refresh build cache, chore: add ci helper, chore: add dependency audit workflow, ci: restore, ci: cleanup; short-lived branches chore/ + eight characters or ci-check- + four digits. Presence alone — even without a follow-up payload — marks the account as compromised (Aikido). Appvia has published an open-source scanner for exactly this campaign; SafeDep's 54-row IoC table is the reference list.
  2. Run-number gap check on every workflow that has secrets. Find the workflow's run history for the period since November 10; a gap where a commit landed is the surviving tell. git log --since=2026-11-10 --oneline -- .github/workflows/ on a mirror gives you the commit layer that the revert tried to hide.
  3. Deleted runs in the platform security log. The repository-level list is what the attacker deleted; the security/audit log is where deleted runs remain visible (this is Fly.io's explicit instruction to its customers — the same principle generalizes: audit data outside the blast radius).
  4. Cloud backdoor hunt, in every cloud any workflow could reach:
  5. AWS — roles whose trust policy says "Principal": {"AWS": "*"}; access keys created since November 10; sessions named wfx-*;
  6. Azure — Entra app registrations carrying federated identity credentials named wfx-ci-…; remove the federation, not merely the secrets;
  7. GCP — new service-account impersonation artifacts; Vault and Kubernetes — unfamiliar OIDC-bound auth entries. Rotation is step five, not step one, precisely because of this layer: rotating a secret does not touch a federated credential pointing back at your repository.
  8. Rotate every secret the affected workflows could read — repository and organization secrets, registry tokens, cloud keys, the AI provider keys (the OpenAI-and-friends list above is the loot menu, not the exception list).
  9. Rebuild, do not clean: any machine that installed digitalelvis/neuronai-studio v3.14.3, or ran npm install on a repository carrying a .ci-*.sh postinstall hook, is assumed compromised. Go and Composer consumers of the workflow-file variants are unlikely to have executed anything — remove the modules and move on, knowing the module proxy remembers.
  10. Then the structural work from the forge section, in the order a small team can afford it: expiry on every token, two-factor everywhere, default branches protected, secrets scoped to the workflows that need them, OIDC audiences bound and id-token: write treated as the privilege it is, event mirror to storage outside the forge.

The one-line summary of the fortnight's two chapters: the Apache fix shipped two weeks after the scanner's report and the artifact you pinned was rewritten in place were software failures with patch releases; this one is a permission failure, and its fix is what permissions never patch — the way we hand out keys, and whether anyone is watching the doors they open.

Sources: Aikido Security — Oliver Smith, "wfx-loot campaign pushes CI secret stealer to tens of thousands of repositories", November 12, 2026 (account and repository counts, payload anatomy, OIDC escalation and persistence, exfil channels, package census); SafeDep — Kunal Singh, "wfx: GitHub Actions Credential Stealer Hits 8,000 Repos", November 12, 2026 (12:46 UTC–04:36 UTC window, probe/payload splits, 1,343 non-owner authorships, still-live payload list, FOCI and wfx-ci- details, 54-row IoC table, neuronai-studio minute-by-minute timeline); Fly.io — "Security: GitHub tokens exposed by apps deployed from GitHub", November 12, 2026 22:00 UTC, with the November 13 addendum on the stalled GitHub revocation (.git/config token exposure, first-party root cause, operator checklist including the security-log instruction); heise security — Manuel Masiero, "Stolen tokens: Secret stealer targets thousands of GitHub repositories" (Thursday search counts, Fly.io .git/config sourcing, GitHub-statement-pending note); Cloud Security Alliance research note, November 12, 2026; Appvia wfx-loot-scanner (open-source org/repo scanning); StepSecurity credited by Fly.io for identifying its GitHub App inside the campaign.