The short version: Starting November 10, 2026, an attacker used stolen credentials for 4,837 GitHub accounts to open look-alike pull requests across 61,764 repositories, confirm write access, then push a disguised commit that ran a credential stealer inside GitHub Actions. The stealer dumped every workflow secret, the job's GITHUB_TOKEN, OIDC tokens, and cloud and package-registry credentials, then reverted itself and deleted the workflow run within about a minute. Researchers at Aikido, OX Security, and SafeDep converge on the same core numbers: thousands of accounts, tens of thousands of repos probed, and well over 1,800 where the payload actually ran and secrets were confirmed stolen. The campaign, nicknamed wfx-loot after the attacker's own file labels, is a clean illustration of a structural problem: any secret a CI runner can read in plaintext is a secret an attacker can read too, the moment they get code execution in that job.
What happened
Security researchers at Aikido, OX Security, and SafeDep independently tracked the same campaign through mid-November 2026 and arrived at consistent figures. Aikido counted 4,837 compromised GitHub accounts that opened probe pull requests in 61,764 repositories, with the stealer confirmed to have run and exfiltrated credentials in at least 1,806 of them — a figure Aikido later revised upward to 1,835 as its own investigation continued. SafeDep, using a different detection method focused on malicious commits rather than confirmed runs, found the pattern in over 8,000 repositories, a reminder that different researchers measuring different signals at different times will not produce identical numbers, even when they agree on the shape of the attack.
The attacker did not exploit a bug in GitHub Actions. Every account used in the campaign held a genuinely valid, already-stolen GitHub credential — in at least one documented case, a leaked GitHub CLI OAuth token. Aikido also found that accounts previously compromised in October's unrelated GhostAction campaign were significantly more likely to show up in wfx-loot, and that in more than 100 repositories the new stealer was injected directly into GhostAction's own leftover workflow files. The two campaigns appear to be the work of different actors recycling the same pool of weak credentials.
The three-phase attack
Every documented wfx-loot intrusion follows the same sequence, which is what let researchers fingerprint it so quickly.
1 · Account takeover
The attacker starts with a working GitHub credential for someone else's account — a leaked personal access token, a stolen GitHub CLI OAuth token, or in some cases a credential already burned in an earlier campaign. No password reset or phishing step is required at this stage; the token already works.
2 · Mass PR probing
Using that token, the attacker opens a pull request titled "docs: dependency audit notes" from a branch named wfx-docs in every repository the account can write to. The PR itself carries no payload — it only confirms that the stolen token has write access. Researchers say this probe alone is enough to treat the account as compromised, whether or not anything follows it.
3 · Payload, only once it runs — then self-erase
Where write access is confirmed, the attacker pushes a second commit disguised as routine CI maintenance (commit messages like "ci: refresh build cache" or "chore: add ci helper"), either into an existing workflow, as a throwaway new workflow, or as an npm postinstall hook. The commit sits on the branch only long enough for the CI job to start, dumps the entire secrets and variables context plus the job's GITHUB_TOKEN and any OIDC token, and in some cases adds a federated identity credential to an Azure AD application for persistent cloud access. Then the attacker reverts the commit and deletes the workflow run and its logs, usually within about a minute.
What the stealer actually took
This wasn't a narrow grab. Based on the researchers' analysis, a successful run could exfiltrate:
- GitHub Actions secrets and variables for the repository and organization, plus the job's own
GITHUB_TOKEN - OIDC tokens used for keyless cloud authentication, and in some cases new Azure AD federated identity credentials added for persistence
- AWS, Google Cloud, and Azure keys
- npm, PyPI, and other package-registry publish tokens
- SSH keys and
.envfiles present in the runner - API keys for AI services and developer tools, including OpenAI, Anthropic, Gemini, Cursor, and Copilot
The npm postinstall variant is worth flagging separately: it doesn't only run in CI. Any developer who ran npm install against an affected package between the hook commit and the cleanup commit ran the same stealer on their own laptop.
GitHub's own GITHUB_TOKEN is short-lived and scoped to the job, which limits how long a stolen copy stays useful. The damage here came from the other categories — long-lived cloud keys, publish tokens, and AI API keys that don't expire when the job ends, plus the Azure persistence mechanism designed to survive a rotation.
Why "secrets in CI" keeps producing this exact outcome
The mechanics of wfx-loot are specific to this campaign, but the underlying failure mode is not new, and it isn't specific to GitHub. Whenever a CI job needs to call AWS, publish to npm, or hit an AI API, the common pattern is to decrypt a stored secret and drop it into the runner's environment as plaintext — an env var, a file, or an in-memory token the job code can read directly. Once an attacker has any form of code execution inside that job, reading process.env or dumping the GitHub Actions secrets context is not a sophisticated step. It's the intended, documented behavior of the platform, aimed at an attacker instead of a build script.
This is the pattern behind most of the credential-theft campaigns our security team has covered, including the npm worm detailed in our Shai-Hulud writeup and the broader survey in Your Secrets Live in Cleartext. The specific delivery method changes — a compromised npm maintainer, a poisoned dependency, a hijacked GitHub account — but the outcome is identical whenever the runner itself is allowed to hold the real credential.
An egress-proxy model changes what's available to steal, not whether the attacker gets code execution. Under that model, the CI job never receives the actual AWS key, npm token, or AI API key in its environment at all. It holds a reference that only resolves to a real credential when a request leaves through a controlled egress point, where the actual key is injected onto the wire for that one outbound call and never returned to the caller. Dumping process.env or the Actions secrets context in that setup surfaces placeholders with no standalone value — they can't be replayed from the attacker's own infrastructure, because the real credential never left the egress layer.
How to check if you were affected
Researchers published consistent indicators that are worth searching your organization for now, even if you've seen no alerts:
- A pull request titled "docs: dependency audit notes," especially from a branch named
wfx-docs - Branches matching
chore/followed by 8 random characters, orci-check-followed by 4 digits - Commit messages: "ci: refresh build cache," "chore: add ci helper," "chore: add dependency audit workflow," "ci: restore," or "ci: cleanup"
- A gap in workflow run numbers around the time a suspicious commit landed, which is often the only trace left once the attacker deletes the run itself
Because the cleanup step deletes the run and its logs, the absence of any of these artifacts does not prove nothing was taken. If a probe pull request exists at all, researchers recommend treating the account that opened it as compromised and rotating its tokens — including GitHub CLI tokens — regardless of whether a payload commit ever followed.
What to do now
If your organization has repositories that accept pull requests from external or automated accounts, or you've found any of the indicators above:
- Search your organization for the probe pull request title and branch patterns across every repository, not just ones you remember granting access to.
- Rotate every secret and variable any potentially affected workflow could reach — not just the ones you can confirm were read.
- Check Azure AD applications tied to affected repositories for unfamiliar federated identity credentials before you consider a rotation complete.
- Set default
GITHUB_TOKENpermissions to read-only at the organization level, so a compromised job can't use it to push further changes. - Review whether CI secrets genuinely need to live in the runner's environment at all, versus being resolved through a gateway that never discloses the underlying key.
Teams evaluating the second architecture can compare approaches in our gateway comparison, including how this applies to AI API traffic specifically, and what it costs on our pricing page.