← Back to all posts
Published on · by Renaud Deraison

The pull request came from your account

Since November 10, an attacker has used stolen tokens for 4,837 GitHub accounts to push a credential stealer into more than 8,000 repositories, 771 of them as an npm postinstall hook that runs on developer laptops. Coding agents run npm install after every pull. In Bromure Agentic Coding, the hook runs in a VM where every GitHub, AWS and AI key is a stand-in, the connection to the attacker's server is refused and traced back to the install, and the stolen tokens can't put your account on the next list.

The attacker pushed to 8,000 repositories as people who already had write access to them, with tokens stolen in an earlier wave from laptops and CI runners.

On November 12, Aikido Security and SafeDep published their analyses of a campaign that started on November 10 at 12:46 UTC. The Hacker News summed it up: stolen credentials for 4,837 GitHub accounts, used to plant a secret stealer in repositories those accounts could write to.

It starts with a probe. From a branch named wfx-docs, the attacker opens a pull request titled docs: dependency audit notes to check that the token can write. GitHub search found about 61,800 of these probe pull requests, and 91% were still open when SafeDep looked. Where the probe works, the stealer follows, in one of three forms:

  • ci: refresh build cache, about 1,500 lines added to an existing GitHub Actions workflow (7,309 repositories);
  • chore: add ci helper, a .ci-xxxxxx.sh script plus a postinstall hook in package.json (771 repositories);
  • chore: add dependency audit workflow, a new workflow in an empty repository (16).

Then ci: restore and ci: cleanup remove it. SafeDep counted 8,093 repositories that received malicious commits, using only GitHub's search of public default branches, so private repositories and other branches aren't in that number.

The commits use the noreply addresses of real users and they're unsigned. In 1,343 repositories the author isn't the owner but a collaborator or a bot. Aikido and THN note an overlap with the October GhostAction wave: accounts hit in October were about 1,000 times more likely than other active accounts to show up this week. Aikido doesn't attribute the two waves to the same actor. The tokens from one wave still fed the next.

What the stealer takes

The same script runs in all three forms. In CI, it takes every secret and variable the workflow can read, the GITHUB_TOKEN, Actions runtime tokens and secrets in runner memory. It trades GitHub OIDC tokens for AWS, Azure and GCP sessions, then leaves a way back in: new IAM access keys, role trust policies opened to any AWS account, and federated credentials named wfx-ci-* on Entra apps that keep working after you rotate the client secret.

On a developer's machine, the postinstall variant runs the same script on every npm install. SafeDep lists what it collects: cloud CLI configs, ~/.ssh, ~/.gnupg, registry tokens, kubeconfig, shell history, crypto wallets, AI tool configs, plus .env, *.tfvars and *.tfstate from the repository. Aikido names Claude, Codex, Cursor and Copilot among the AI tools. It all goes into a gzipped tarball, sent by HTTP POST to port 8080 on one of three IP addresses, or to a Telegram chat.

The advice from both firms is that a machine that ran npm install on an affected commit is compromised and every key on it gets rotated.

Agents run npm install after every pull

A coding agent doesn't wait for a release. "Pull main and fix the failing test", "check out this branch and see if it builds", "update the dependencies": each one ends in npm install, often on an allow list because installing packages is most of what agents do. If the commit the agent pulled is one of the 771, the hook runs as soon as the install starts. It doesn't need the agent to approve anything or read a malicious instruction.

What's on a developer laptop is what the next wave needs: the gh token in ~/.config/gh, the PAT in ~/.git-credentials, SSH keys with push access, AWS keys, the ANTHROPIC_API_KEY in the shell profile. Each GitHub token adds an account to the attacker's list, along with every repository that account can push to, including the ones it reaches as a collaborator, an organization member or a bot.

The wfx campaign, November 10–12Stolen tokens4,837 GitHub accounts,many hit in Octoberowners, collaborators,org members, botsProbe pull requestwfx-docs →"docs: dependency audit notes"~61,800 openedStealer pushed7,309 into a workflow771 as a postinstall hookthen ci: restore, ci: cleanup8,093 repos (public)Someone pullsnpm installa developer, a CI job,or a coding agentthe hook runsWhat the hook takes from a laptop, gzipped and posted to :8080 or Telegramgh / git tokens ~/.ssh ~/.gnupg cloud CLI configs kubeconfig AI tool keys .envEvery GitHub token in that tarball is another account for the next wave.
How the wfx campaign spreads: stolen tokens open a probe pull request, then push the stealer. In 771 repositories it becomes an npm postinstall hook, so the developer or agent who runs npm install on that commit hands over the tokens for the next round.

The same pull in Bromure Agentic Coding

Bromure Agentic Coding runs Claude Code, Codex, Grok, Kimi and omp in Ubuntu VMs on your Mac, one VM per machine. The agent's shell, its npm and every script a package runs stay inside that VM. Credentials in the VM are stand-ins, and every connection out passes through a virtual switch and a proxy on the Mac.

Take the worst case: the agent pulls a branch that holds chore: add ci helper and runs npm install without asking anyone. The postinstall hook runs, inside the machine.

Every token it finds is a stand-in

The stealer looks in the usual places and finds what it expects, in the right format. ~/.git-credentials and the gh config hold a ghp_ token, GH_TOKEN is set, ANTHROPIC_API_KEY starts with sk-ant-api03-brm-, and ~/.aws has an access key and a secret. GitHub never issued that token, and the AWS secret is fake: the guest signs with it, and the proxy strips the signature and re-signs on the Mac with the real key. Claude and Codex sign-ins happen on the Mac, so the agent's own auth files hold stand-in keys too.

The real values stay encrypted on the Mac. The proxy swaps each stand-in for its real value only on requests to the host that credential belongs to, and never on a request to a look-alike domain.

~/.ssh holds no private key. SSH_AUTH_SOCK is a bridge to an agent on the Mac that can list keys and ask for signatures, and the key bytes never enter the VM. Keys on a YubiKey or in 1Password go through the same bridge, with the touch or PIN prompt on your Mac.

Your Mac's home folder, Keychain and browser profiles aren't in the VM. The .env files the hook can sweep up are the ones in the machine's own checkouts.

Your account stays off the next list

Say the tarball does reach the attacker. The GitHub token in it doesn't sign in to GitHub. Nobody can use it to open a probe pull request or push to your repositories, or to the repositories of the organizations and projects you collaborate on. Your account doesn't join the 4,837, and the next wave has one account and its repositories fewer to work with.

If the stealer uses a stand-in from inside the VM against any host other than the one it was minted for, the proxy recognizes it. The request is blocked with HTTP 451, the VM pauses, and an alert titled This environment may have been compromised names the credential, the host it belongs to and the host it was sent to.

Incident response gets shorter too. SafeDep and Aikido's checklist says to rotate every key on a machine that ran the install. The machine held none of your real keys, so the list is mostly the stand-ins Bromure re-issues on the next launch.

Port 8080 is not on the list

Every connection out of the VM goes through the Mac. Set the Bromure Firewall's Unmatched traffic to Deny, and the machine reaches the hosts on its list and nothing else. Or switch the machine to OpenShell + Sentry: the starter policy allows GitHub, npm and PyPI read-only, plus Ubuntu's mirrors, and denies everything else. An HTTP POST to 194.150.166.244:8080 is refused, and so is a Telegram bot. Neither is on the list.

With Enforce binaries on, a root-owned attestor in the VM ties every connection to the program that opened it, and each rule names the programs allowed to use it. A refusal names the rule and the program that tried. The same mode takes away every path to root, so the stealer can't reach for sudo or Docker.

It can't use the token to spread

A worm doesn't have to send tokens home. It can use them on the spot, the way this campaign uses stolen tokens: open a pull request, push a commit. From inside a Bromure machine, both go through the proxy with the real token swapped in, and both are writes.

New machines put GitHub, GitLab and Bitbucket in Prompt before write. Every write pauses for a dialog on the Mac titled Allow write on "<scope>" from workspace "<name>"? and shows the exact operation: POST /repos/<owner>/<repo>/pulls for a probe pull request, git-receive-pack for a push. You were asking the agent to fix a test. A pull request to someone else's repository from a wfx-docs branch is easy to refuse.

The agent watchdog watches the session from outside the VM: bursts of blocked requests, credentials that don't belong, new destinations once the session has settled, outbound volume far above its baseline. Set to Quarantine, it cuts the network, pauses the VM and asks you what to do.

The packages that were built during the window

SafeDep asks maintainers to rebuild any package version built between the malicious commit and ci: cleanup, because the hook can ship inside the release. At least 50 of the compromised users publish to npm, Go, Packagist, PyPI or crates. On the consuming side, Bromure's supply-chain checks run on the Mac for every package an agent fetches. The age gate, on by default, refuses any version younger than two days, which covers a release cut in the middle of a 40-hour campaign. With script stripping on, the proxy removes preinstall, install, postinstall and prepare from npm tarballs in flight. With socket.dev configured, a package flagged for a rogue install script is held, and you're asked before it goes in.

Machine VMAgent runsgit pull && npm installpostinstall runs .ci-xxxxxx.shWhat the stealer findsghp_…, AWS, sk-ant-…-brm-: stand-insSSH agent bridge, no key bytesno Mac home, no KeychainEnforce binarieseach connection tied to its program;no sudo, no DockerYour MacDefault deny194.150.166.244:8080 refusedTelegram refusedTripwiresstand-in to a foreign host:HTTP 451, VM pausedPR or push: Prompt before writeReal tokens, Keychain-sealedswapped in only on requests tothe host each one belongs toSee it, undo itNetwork lineageprompt → claude → bash → npm→ sh .ci-xxxxxx.sh→ :8080 refusedRewind home…home as it was at an earlierboot, before the pullOff the next listthe attacker's ghp_ copysigns in to nothing
The same npm install in a Bromure machine. The postinstall hook runs in the VM, finds only stand-ins and an SSH bridge, and its POST to port 8080 meets default deny on the Mac. A push or a pull request with the real token waits for your approval. The kernel sentry traces the refused connection to the agent's npm install, and Rewind home removes what the hook left.

You can see which pull ran it

The agent's transcript shows an npm install that finished. The hook never went through a tool call, so the agent has no record of it.

On a machine with the kernel sentry, a small kernel module reports every program launch and every connection from inside the VM's kernel, over a channel the agent can't silence. The refused POST shows up as a red Network row in the Security Timeline. Double-click it and its network lineage opens: the prompt you gave, the agent's reasoning and stated intent, the tool call (Bash, npm install), and the process chain from claude through bash and npm down to the hook's script. Other flows from this tool call lists everything else that install connected to.

That one row gives you the indicator to look for in the rest of your fleet, and the branch to report to the repository's owner. If the commit author is a colleague, they need to revoke their tokens today.

Undoing it

The pulled commit, .ci-xxxxxx.sh, and anything the hook wrote to ~/.bashrc or ~/.config all live in the machine's home, which is its own disk image. Bromure takes a copy-on-write checkpoint of it on the first successful boot of each day. Shut the machine down, open ⋯ › Rewind home…, and pick a point from before the pull. The next start comes up with the home as it was then, and the current home is kept as a new point in case you want a file back.

If the compromise alert fired, the machine is marked compromised and won't boot until you choose Wipe and Launch, which wipes its disk image and home and keeps your tokens, SSH keys and settings. For a repository you're not sure about, bromure-cli vm run --rm gives you a throwaway machine that is deleted when it stops.

Nothing worth stealing

The stealer finds a ghp_ stand-in, fake AWS and AI keys, and an SSH bridge with no key bytes. The real tokens never enter the VM.

Off the next list

A stolen stand-in doesn't sign in to GitHub, so your account and every repository it can push to stay out of the next wave.

No way to spread

Port 8080 and Telegram are refused by default deny. A pull request or push with the real token waits for your approval on the Mac.

One row, then rewind

The kernel sentry ties the refused POST to the hook and the agent's npm install. Rewind home takes the machine back to before the pull.

What to do this week

  • Search your organizations for the indicators: branches wfx-docs, ci-check-NNNN and short-lived chore/xxxxxxxx; the pull request title docs: dependency audit notes; commits ci: refresh build cache, chore: add ci helper, ci: restore and ci: cleanup. Close the probe pull requests and delete the branches.
  • If a commit author's account shows up, revoke that account's tokens, OAuth grants, SSH keys and sessions, and turn on 2FA. Rotate every secret and variable the affected repositories can read.
  • Check Entra ID for wfx-ci-* federated credentials, CloudTrail for wfx-* sessions followed by CreateAccessKey or UpdateAssumeRolePolicy, GCP for token generation from your GitHub workload identity pool, and Vault for JWT logins from GitHub's OIDC issuer.
  • Treat any laptop that ran npm install on an affected commit as compromised. Block digitalelvis/neuronai-studio 3.14.3 and the listed Go versions.

Then move your agents' git pull and npm install into a machine where the tokens a stealer finds sign in to nothing and the server it reports to is unreachable. Credentials and stand-ins are covered in the Credentials & the Wire Boundary chapter of the manual, and default deny and the kernel sentry in Sandbox Policy.