Back to Explore
NewsVibeFix editorialUpdated Nov 19, 2026

4,837 Stolen Accounts, 61,764 Repositories: wfx-loot Came for Everything in Your CI — Including Your AI Keys

From 10 November 2026, attackers used 4,837 stolen GitHub accounts to push a CI secret stealer into 61,764 repositories; at least 1,835 had credentials stolen. It exploits no GitHub bug — it exploits stolen identities.

Inside a data centre, an engineer connects a blue network cable at an open server rack, bundles of blue and yellow cables plugged into the patch panel

In short: 4,837 stolen accounts, 61,764 repositories — and the target was everything in your CI

Starting at 12:45 UTC on 10 November 2026, an attacker began using stolen GitHub account credentials to push a credential stealer into tens of thousands of repositories. Security firm Aikido disclosed the campaign on 12 November and gave it a name: wfx-loot. The numbers look like this: 4,837 compromised accounts opened probe pull requests in 61,764 repositories, and in at least 1,835 of them the stealer actually ran and credentials were stolen. The stealer itself is a shell script of about 1,500 lines — unencrypted, unobfuscated, lying in plain sight inside workflow files — yet it turns a whole CI environment inside out: every GitHub Actions secret, cloud credentials, AI service API keys, nothing spared. Worse, it rewrites cloud trust configuration so the stolen access keeps working even after secrets are rotated.

This hits developers in the vibe coding era directly. What sits in your CI today? An OpenAI key, an Anthropic key, Cursor and Copilot credentials, cloud access keys, npm and PyPI publishing tokens. These used to be scattered across individual machines; now they are all concentrated in the pipeline: one build calls a model, publishes a package and deploys to the cloud, so the secrets naturally all pile into CI. The attacker understood this and stopped trying to break into GitHub itself, instead walking through the front door with stolen account identities. Aikido puts it bluntly: if the probe pull request ran, that account is compromised, even if the stealer stage never executed. This article covers four things: the steps of the attack, what exactly it steals, what the three easily confused numbers each mean, and what you should check and rotate tonight.

Four steps: probe, poison, clean up

Step one is the probe. Using stolen credentials, the attacker opens a pull request titled "docs: dependency audit notes" from a branch called wfx-docs against a target repository. The request carries no malicious content at all; its only job is to confirm that the stolen key can write to that repository. Aikido counted via GitHub search: between 12:45 UTC on 10 November and 15:00 UTC on 11 November — about 26 hours — 61,839 such probe pull requests were opened. Of those, 10,431 went into repositories the account does not even own, reached through collaborator or organisation access. At the time Aikido published, 92% of the probe requests were still open, which means the overwhelming majority of repository owners had not noticed. The probe is devious precisely because it looks completely normal: a title that reads like routine dependency auditing, a branch name that reads like ordinary documentation tidy-up, lost among the thousands of automated pull requests opened every day, triggering no alarm.

Step two is poisoning. Once write access is confirmed, the attacker injects the stealer using one of three methods. The first is workflow injection: a commit titled "ci: refresh build cache" adds about 1,500 lines of malicious steps to an existing GitHub Actions workflow file. The second is an install hook: a commit titled "chore: add ci helper" adds a .ci-xxxxxx.sh script and a postinstall hook in package.json, so anyone running npm install triggers it. The third is a throwaway branch: a commit titled "chore: add dependency audit workflow" creates a new .github/workflows/build-audit-xxxxxx.yml workflow file on a randomly named chore/xxxxxxxx branch. OX Security's breakdown shows that of the 8,093 public repositories SafeDep counted as receiving a malicious commit, 7,309 came through workflow injection, 771 through npm hooks, and 16 through new workflow files. All three methods share the same roughly 1,500-line script — only the way in differs.

Step three is the clean-up, and it is the most alarming part of the whole operation. Within at most one minute, the attacker reverts its own commit — titled "ci: restore" or "ci: cleanup" — and deletes the workflow run together with its logs. By the time a repository owner looks, the scene has been swept clean: no malicious code in the commit history, no trace of that execution in the run history, logs gone. Aikido says the most reliable remaining trace is, paradoxically, an absence: a missing run number in the workflow's history. Run numbers are sequential, so a gap in the middle means a run was deleted by someone. StepSecurity confirms this: a missing run number is often the only clue left. That an attacker can steal things and wipe its footprints relies on no advanced technique — only on knowing GitHub's workflow machinery well enough to know that run records can be deleted, logs can be deleted, and that after a revert the repository looks perfectly normal.

There is no real step four — the attacker does not need to do anything else, because the pipeline does the remaining work for it. The next workflow run, the next npm install, and the stealer executes. Aikido's data shows credentials were confirmed stolen from at least 1,835 repositories; elsewhere in the same post it writes that at least 1,806 repositories showed signs the payload ran. Both figures are lower bounds, because the run logs were deleted — the real number can only be larger, never smaller. SafeDep's counting window ran from 12:46 UTC on 10 November to 04:36 UTC on 12 November, and the campaign was still active when the window closed. The Hacker News also found new probe pull requests appearing after Aikido's search ended, and it is unclear whether the stealer followed. In other words, the 12 November disclosure was not the end of the incident — only a snapshot taken midway.

What it steals: the list is frighteningly long

The roughly 1,500-line script works in four stages — collect, escalate, persist and exfiltrate — with configuration flags at the top switching individual features on and off. The list below comes from Aikido's line-by-line breakdown of the script, and it is worth reading through, because it is essentially a complete catalogue of "what is valuable in your CI".

The collect stage takes every credential available on the runner: all GitHub Actions secrets and variables, the workflow's GITHUB_TOKEN, OIDC tokens and Actions runtime tokens; the full runtime environment, plus a filtered copy of variables matching dozens of keywords including token, secret, pass, cred, aws, azure, gcp, openai, anthropic and stripe; credential files for AWS, Azure, GCP, Docker, Kubernetes, npm, PyPI, Git, SSH, GPG, Vault and Terraform; credentials for AI providers and AI developer tools, including OpenAI, Anthropic/Claude, Gemini, Hugging Face, Cursor, Copilot, Codex, Continue, Codeium, Aider, Weights & Biases and Ollama; shell histories for bash, zsh, mysql, psql, python and node; every .env, .pem, .p12, .jks, .kdbx and kubeconfig file found by recursively searching the home directory; and the environment and memory of running processes on the runner, prioritising Runner.Worker and Runner.Listener, from which it extracts JWTs, GitHub personal access tokens, AWS keys and AI provider tokens. On self-hosted runners it gets even more: cloud instance metadata credentials, Docker container state, the runner's RSA parameters and systemd units. Finally, it takes a snapshot of the repository: files matching its catalogue of secret patterns, the last 100 commits, and recent workflow artifacts.

The escalate stage turns stolen credentials into deeper cloud access. It mints GitHub OIDC tokens for AWS, GCP and Azure audiences and exchanges them for cloud sessions; in AWS it chains into other IAM roles found in the repository, then calls iam:CreateAccessKey to create long-lived credentials for IAM users; in GCP it signs JWTs with stolen service account keys — the script carries its own dependency-free Python RSA implementation — exchanges them for access tokens, lists projects and service accounts, and calls generateAccessToken and signJwt to impersonate service accounts; in Azure it exchanges OIDC tokens or client secrets for management tokens, lists subscriptions and Key Vaults, and replays cached Azure CLI refresh tokens (FOCI tokens) against first-party Microsoft client IDs to obtain Graph, ARM and Key Vault tokens; against HashiCorp Vault and Kubernetes API servers found in kubeconfig files, it replays OIDC tokens the same way. By now it should be clear: the stealer does not just steal "secrets" as objects — it steals identity itself, and one identity buys more identities.

The persist stage is the most insidious part of the campaign, with three moves, all aimed at making secret rotation useless. The first is forging successful status checks: early in the run, before most collection, the script posts forged success statuses against the commit SHA, using the context names of the repository's required checks. Branch protection matches on the context name, not on the app that posted it, so the forged checks clear the merge gates while the payload is still running. The second is rewriting AWS trust policies: it sets the chained role's trust policy to "Principal": {"AWS": "*"}, opening the role to any AWS account. The third is injecting federated identity credentials into Azure: with a Microsoft Graph token, it adds new federated identity credentials named wfx-ci-… to Azure AD applications, pointing back at the compromised repository. After that, any workflow in that repository can authenticate to Azure without a stored secret — even after every token has been rotated. Aikido is careful to note that these persistence features exist in the script, and that no victim has yet confirmed they were used against a real account. But the mere existence of the capability is alarming enough: the standard response of rotating secrets is, for the first time, not sufficient on its own.

The exfiltrate stage packs everything into a gzipped tarball and sends it out. The script supports several delivery channels, three of which use GitHub's own infrastructure to get around network egress restrictions: the Actions Cache API (storing the tarball as a cache entry, retrievable later with a matching key), the step summary (for archives under 700 KB, base64-encoding the tarball into the workflow step summary between <!--WFX-BEGIN--> markers), and artifact upload (uploading the tarball as a workflow artifact named wfx-loot-<run id>). The other channels are a direct HTTP POST to the callback server, a secondary callback URL, an AES-encrypted copy committed to the repository, base32-encoded output written to the workflow run log, and exfiltration via a Telegram bot. In this campaign's actual configuration, only the HTTP POST channel was enabled, targeting 194.150.166[.]244:8080/exfil or 18.143.168[.]96:8080/exfil; the cache, step summary and artifact channels only run when a private-repository flag is set, and the deployed configuration turns it off; the encrypted-commit and run-log channels are disabled, and no secondary callback is set. Aikido adds a counter-intuitive warning: the absence of wfx-loot artifacts, wfx- cache entries or WFX-BEGIN step summaries in your repository does not mean data was not taken — the run itself is usually deleted. Having no trace is, in this campaign, the normal state of affairs.

The wfx-loot funnel: 61,764 repositories received probe pull requests, 8,093 public repositories received a malicious commit, and in at least 1,835 the stealer ran and exfiltrated credentials

Do not confuse the three numbers: probed, committed and stolen are three different things

Three numbers in the coverage of this incident are most easily mixed up: 61,764, 8,093 and 1,835. They measure three different things, and confusing them gives a completely wrong impression of the scale. 61,764 is the number of repositories the probe pull requests touched: 4,837 compromised accounts opened "docs: dependency audit notes" in them, only confirming write access, with no payload delivered yet. 8,093 is the number SafeDep counted as receiving a malicious commit on the default branch of public repositories: after the probe, the stealer was actually injected. 1,835 is the number Aikido confirmed as having the stealer run and credentials exfiltrated. The three numbers form a funnel from large to small: most probed, fewer poisoned, fewest actually robbed. But even the smallest number is large — 1,835 repositories' entire CI secrets and cloud credentials, and that is only a lower bound.

The figures differ slightly between research teams, because their counting methods and time windows differ — no reason to doubt any of them. StepSecurity counted more than 63,000 probe pull requests via GitHub search by 07:40 UTC on 12 November; SafeDep's window ended at 04:36 UTC on 12 November with 8,093 malicious commits; Aikido's summary figure is at least 1,835 repositories with confirmed theft, while elsewhere in its post it writes at least 1,806 repositories with signs the payload ran. GitGuardian's 13 November analysis uses its own dataset: 28,500 payload patches from 2,367 accounts across 17,715 repositories. These numbers come from different angles of observation on the same campaign. When judging the scale, the shape of the funnel matters more than any single precise figure: the conversion rate at each step is low, but the base is so large that even the smallest number is a disaster.

Two more figures deserve to be pulled out separately. The first is 50: at least 50 compromised users are themselves package publishers, spanning npm, Go, Packagist, PyPI and crates. That means the attacker did not only steal secrets — it also carried the stealer into publicly released packages: Packagist package digitalelvis/neuronai-studio version 3.14.3 has been confirmed to carry it, and Go module github.com/onuragtas/docker-env tags v1.0.278 and v1.0.280 contain the payload in a workflow file only — the Go source and release binaries are unchanged, so consumers of the module may not have been affected, but Aikido still recommends removing those versions. The second is 92%: of the probe pull requests, 92% are still open. The owners of the vast majority of those 61,000-plus repositories still have not noticed that somebody came knocking.

Not a GitHub bug — an identity bug

StepSecurity states the characterisation most clearly: the attack exploits no vulnerability in GitHub Actions itself. The attacker used legitimately issued but stolen tokens, following normal procedures, doing what a normal account can do. The commits were authored as the real users, using their GitHub noreply addresses, and were unsigned — which OX Security reads as stolen access tokens rather than a platform flaw. As for how the credentials of those 4,837 accounts were stolen in the first place, no research team has published an answer as of writing. That is the most unsettling part: the entry point of the attack is still unknown, and the other end of that unknown may connect to more compromised accounts that have not been found yet.

This campaign overlaps with October's GhostAction wave, but Aikido judges the two to be distinct campaigns, likely carried out by different actors. Accounts hit in October were significantly more likely than baseline to be hit again in November — according to analysis cited by The Hacker News, about 1,000 times more likely; Aikido's own wording is "significantly more likely". In more than 100 repositories, wfx-loot was injected directly into GhostAction's own workflow files. The infrastructure, tooling and tradecraft differ, and stolen credentials are often resold between threat actors, so Aikido does not attribute the two to the same group. GitGuardian's data supports that judgement: of the 2,367 accounts it counted, 431 (about 20%) had already been compromised in the GhostAction wave. GhostAction itself is worth a sentence: a campaign that stole secrets through malicious workflows, plus a developer-machine stealer — JavaScript disguised as a font file (public/fonts/fa-solid-400.woff2), with a hidden VS Code task that runs it when the folder is opened, taking ~/.git-credentials, SSH keys, npm, PyPI, AWS and Claude credentials, and installing a cron job tagged #ghc2 that polls a command server. Two waves sharing the same pool of "dirty accounts" shows that stolen credentials are an organised underground market, not a one-off haul.

GitHub's own response is also worth recording: as of the reporting on 12–13 November, GitHub had published no public statement on the campaign — no blog post, no changelog entry, no public response. Meanwhile, GitHub's platform defences were working, but only up to a point. GitGuardian's 13 November analysis found that the workflow-file versions of the stealer were all placed in action_required status — all seven November payload runs still visible in workflow files sat in that held state and never started. But the attacker pivoted immediately: npm hook commits rose from 838 on 11 November to 1,210 on 12 November, because a hook only changes package.json and a .ci-xxxxxx.sh script, riding the repository's own unchanged workflows and bypassing the hold aimed at workflow files. GitGuardian also found an earlier warning sign: a small precursor ran between 24 and 29 October — 80 payload patches, 7 accounts, 12 repositories. In other words, the mass outbreak of 10 November did not come out of nowhere; two weeks earlier, the attacker had already tested the water at small scale.

There is one more later development: from 12 November, new versions of the stealer began exfiltrating via a Telegram bot instead, with the HTTP callback address going dead. A sample cited by The Hacker News showed about a fifth of 200 sampled payload commits had already switched to Telegram. The attacker changed its exfiltration channel on the very day of public disclosure, which shows disclosure itself is pushing the attacker to iterate. Blocking the two known IP addresses is obviously necessary — but blocking IPs alone is not enough, because the channel changed while the playbook carries on.

The checklist: check these tonight

If you maintain any GitHub repository, it is worth spending 15 minutes tonight going through Aikido's indicators one by one. First, search for wfx-docs branches and pull requests titled "docs: dependency audit notes" appearing on or after 10 November. If either appears, treat that account as compromised — Aikido's own words are that if the probe ran, the user is compromised, even if the workflow stage did not run. Second, search for the three commit titles "ci: refresh build cache", "chore: add ci helper" and "chore: add dependency audit workflow", plus short-lived branches named chore/ followed by eight random characters. Third, check whether any workflow's run numbers have a gap: a missing number is often the only evidence the stealer ran. Fourth, check package.json for an added postinstall hook, and the repository root for a .ci-xxxxxx.sh script. Fifth, if you installed digitalelvis/neuronai-studio 3.14.3, or used docker-env v1.0.278 or v1.0.280, follow Aikido's advice: treat any machine that installed the former as compromised, and remove the latter two versions.

If the stealer is confirmed to have run, remediation has three layers, and skipping any one of them leaves the job unfinished. The first layer is rotating every secret the workflows could reach: Actions secrets, cloud credentials, AI service keys, npm and PyPI tokens — not one left behind. The second layer is checking the cloud for persistence backdoors: whether any AWS role's trust policy was opened to all accounts, whether iam:CreateAccessKey created any long-lived keys that should not exist; whether any Azure application gained federated identity credentials named wfx-ci-…; and whether any forged successful status check cleared a merge through branch protection. Rotating secrets without cleaning these backdoors is like changing the locks without noticing the attacker kept a spare key. The third layer is the account itself: the compromised GitHub account needs its tokens revoked, credentials reset and two-factor authentication enabled; if several accounts in an organisation were hit, check along the GhostAction overlap — accounts hit in October were far more likely to be hit again in November.

For individual developers, there is one more check that is easy to miss: self-hosted runners. The stealer can take far more from a self-hosted runner than from a GitHub-hosted one, including cloud instance metadata credentials, Docker container state and the runner's RSA parameters. If a machine at home or a company server runs a self-hosted runner and happened to run a suspicious workflow after 10 November, the scope of the check should expand to the whole machine, not just the repository. GitGuardian's data adds one more warning: about 90 AI provider environment-variable prefixes are on the stealer's matching list, including OpenAI, Anthropic, Gemini, Bedrock, Hugging Face, Mistral, OpenRouter and Cursor. The keys sitting in your .env files are being called out by name.

Judgement: why this is a signature incident of the vibe coding era

Put wfx-loot next to the Git recursive-clone flaw from the same week, and you can see the developer trust chain being breached at two different points within days. The Git flaw is a defect in the tool itself: fix it, and an upgrade solves it. wfx-loot has no tool defect to fix: it exploits stolen identities, and how those identities were stolen remains unknown. One needs a code fix, the other needs a trust fix — and the second is far harder. GitHub can ship a fixed Git within days, but nobody can ship a patch for "how 4,837 accounts lost their credentials". That is the real bad news of the week: the weakest link is not the code, but how the keys in people's hands are kept.

At a deeper level, wfx-loot is the first large-scale CI credential theft campaign to list AI keys as a primary prize. In the stealer's collection list, credentials for AI services and AI developer tools get their own entry: OpenAI, Anthropic, Gemini, Hugging Face, Cursor, Copilot, Codex, Aider, Weights & Biases, Ollama. A few years ago, stealing CI secrets meant stealing cloud credentials and publishing tokens; now AI keys sit alongside cloud credentials as loot worth its own list. That is no accident: vibe coding has made every developer a heavy user of AI services, with OpenAI and Anthropic keys lying in the CI configuration of countless repositories, and Cursor and Copilot credentials following developers into every project. Attackers simply follow the value — wherever valuable things concentrate, that is where they aim.

Finally, this incident rewrites a piece of conventional wisdom: CI used to be considered the "relatively safe" link, because it runs on the provider's infrastructure, with a permissions model, logs and auditing. wfx-loot proves CI is precisely the most valuable link in the whole development chain: it concentrates every secret, can reach the cloud, can publish packages, and can execute arbitrary code on your behalf. An attacker does not need to break GitHub — stealing one key that can write to a repository is enough, and the pipeline does the rest. Defence has to change with it: secrets must be handed out on least privilege, workflows must be limited to the secrets they can reach, self-hosted runners must be isolated from sensitive credentials, and publishing flows need an extra human check on suspicious commits. None of this advice is new, but wfx-loot has pushed its priority far up the list — because this time, the attacker has demonstrated what it costs not to do it.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality