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.shscript plus apostinstallhook inpackage.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 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.
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-NNNNand short-livedchore/xxxxxxxx; the pull request titledocs: dependency audit notes; commitsci: refresh build cache,chore: add ci helper,ci: restoreandci: 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 forwfx-*sessions followed byCreateAccessKeyorUpdateAssumeRolePolicy, 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 installon an affected commit as compromised. Blockdigitalelvis/neuronai-studio3.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.