WFX Phantom: the GitHub Actions secret stealer that deletes its tracks

Since November 10, 2026, someone has been using stolen GitHub tokens to push a secret stealer into the repositories those tokens can write to. It does not exploit any GitHub Actions flaw. It uses valid credentials and does what a developer would do: open a pull request and push a commit.

On November 12, StepSecurity published its analysis of the campaign, which it calls WFX Phantom. What follows is my reading of that report: what the attack does, which parts are measured and which are not, and what I would do this week if I had repositories with CI.

Six-step diagram: probe, payload, collect, escalate, persist, and exfiltrate with cleanup.

Original diagram, drawn from the StepSecurity report. It is not a screenshot and not an image made by the attacker.

What exactly happened

StepSecurity describes a network of compromised GitHub accounts. Each one opens a harmless-looking pull request and, if the token can write, then pushes a shell script that runs in GitHub Actions. The script steals the secrets, and the attacker reverts the commit and deletes the run, usually within a minute.

The scale is what stands out. At 07:40 UTC on November 12, GitHub search returned more than 63,000 probe pull requests, about 90% still open. According to StepSecurity, a probe is not the stealer itself. The script is only pushed where the token’s permissions and the repository setup allow it, which means thousands of repositories, not all 63,000.

Screenshot of GitHub pull request search for the title docs: dependency audit notes, 68k results.

Real screenshot of GitHub’s public pull request search, taken on November 16, 2026 (68k results, opened three days earlier). I blanked the third-party account and repository names. This is my own check of the count, not StepSecurity’s November 12 figure.

One piece of context needs care. On 173 of those pull requests, opened from 19 accounts, GitHub records that the request went through the Fly.io GitHub App. StepSecurity says it has not established how the tokens were obtained and has no evidence of a breach of Fly.io’s own infrastructure. I have none either. The only defensible statement today is that tokens issued to that app were in use by the attacker.

Timeline from November 10 to 12: start, first burst of probes, Telegram appears, and more than 63,000 probes.

Original diagram using the UTC times StepSecurity publishes from its samples.

How it gets in: a probe, a payload and four hiding places

The first step is a probe. The attacker opens a pull request titled docs: dependency audit notes, from the branch wfx-docs, which adds a single file, docs/wfx-audit.md, with two lines. The file is byte-identical in every pull request StepSecurity checked. It does nothing by itself. It only confirms the token can write.

That has a practical consequence. If you find that pull request, the account that opened it is compromised, even if nothing else happened.

The second step is the payload: one shell script of about 1,500 lines, pushed in four different ways.

Commit messageWhat it changes
ci: refresh build cacheAdds two steps to an existing workflow, one that passes the internal tokens and one with an innocent name such as Restore cache x9xx that holds the script.
ci: refresh build cacheAppends the script to a shell script the workflow already runs, such as update.sh or tests/retry_env.sh.
chore: add dependency audit workflowCreates a new workflow, build-audit-<6 characters>.yml, on a throwaway chore/<8 characters> branch.
chore: add ci helperTwo commits: a hidden .ci-<6 characters>.sh script at the root and an edit to package.json so an npm script runs it first.

The first method is by far the most common. According to the report, GitHub commit search returns more than 21,000 commits with the message ci: refresh build cache between November 10 and 12.

The last two methods deserve a pause. In the second, the workflow file does not change, so a review that only reads the YAML sees nothing. In the fourth, the npm hook also runs on a developer laptop, not just on the runner. In StepSecurity’s samples, the hooked script was postinstall in 11 cases, build in two and test in one.

What it steals and how it reaches beyond the repository

The script has per-feature switches at the top and four stages: collect, escalate, persist and exfiltrate.

Collect. It takes the repository secrets and variables with ${{ toJSON(secrets) }} and ${{ toJSON(vars) }}, the job’s GITHUB_TOKEN and the ability to request cloud access tokens. It also reads the memory of the Runner.Worker process, which holds every secret of the job in decrypted form, including ones the workflow never asked for. That is why variants hidden in a shell script or an npm hook steal secrets without touching the workflow.

It also takes every process environment, credential files for AWS, Azure, GCP, Docker, Kubernetes, npm, PyPI, SSH and Vault, keys for AI providers and coding agents, and, on self-hosted runners, the instance metadata credentials. It saves a copy of the repository, its recent history and recent artifacts.

Escalate. It uses the job’s OIDC token. That token exists so a workflow can sign in to the cloud without stored keys. The script uses it to open sessions in AWS, GCP and Azure, chain into other AWS roles named in the repository, impersonate GCP service accounts and replay cached Azure CLI refresh tokens to reach Microsoft Graph and Key Vault.

Persist. It has three mechanisms built to outlast a credential rotation:

  • Fake checks. It can mark a repository’s required checks as passed, which would let a commit through branch protection. StepSecurity says none of the 101 copies it examined had this switched on.
  • An open AWS role. It rewrites a role’s trust policy to "Principal": {"AWS": "*"} and tries iam:CreateAccessKey. The Principal element is exactly what decides who can assume the role.
  • An Azure back door. It adds a federated credential named wfx-ci-<n> to Azure AD applications. From then on, workflows in the compromised repository can sign in to Azure with no stored secret at all. That is how workload identity federation works, used here in the attacker’s favor.

Exfiltrate. Everything goes into one gzip archive. The code supports several channels, including three that use GitHub’s own infrastructure (the Actions cache, the step summary and an artifact named wfx-loot-<id>), but those were switched off in every copy StepSecurity analyzed.

The switch to Telegram that breaks IP blocklists

This is the detail that interests me most for defense. Of the 101 copies examined, delivery was configured like this:

Bar chart: 57 copies HTTP only, 1 with HTTP and Telegram, 43 Telegram only.

Original diagram. The figures are StepSecurity’s, measured on its own sample. There is no independent replication.

The first copies sent an HTTP POST to bare-IP servers on port 8080: 194.150.166[.]244 (54 copies) and 18.143.168[.]96 (3 copies). On November 12 at 01:10 UTC Telegram appears as a backup to a third server, 153.75.82[.]159. From about 05:30 UTC, new copies upload the data with sendDocument to api.telegram.org through five bots, and the callback address is set to 127.0.0.1, a dead end. Every copy StepSecurity sampled between 07:00 and 07:40 UTC used that configuration.

The lesson is simple. A blocklist built from the November 10 IP addresses does not stop the newest copies. An allowlist of destinations does stop both, because neither a bare IP nor api.telegram.org belongs in a normal build.

How it cleans up: the deleted run is the clue

Once the workflow starts, the attacker pushes a revert commit, ci: restore (sometimes followed by ci: cleanup), and deletes the workflow run with its logs.

In drunomics/nuxtjs-drupal-ce, the stealer was committed to the default branch at 09:17:23 UTC on November 11. Twelve seconds later a ci: restore arrived, pushed by the project’s bot account. The Actions history jumps from run 1963 to run 1965. Run 1964, the one for the injected commit, is gone.

In zerosoul/rc-bullets the same thing happens with runs 62, 63 and 64. The Pages deploy runs npm install on every push, and that fires the hook.

Run history with number 1964 missing between 1963 and 1965, and 63 missing between 62 and 64.

Original diagram. It reproduces the run numbers StepSecurity cites, without showing third-party screenshots.

A gap in the numbering is, according to StepSecurity, the most reliable sign that the script ran. But no gap does not prove you are safe. In nextcloud/docker (7,400 stars), the script appended to update.sh ran three seconds after the commit and the run was never deleted. A Nextcloud developer reverted the commit 27 minutes later. The job finished green.

Run list of the update.sh workflow in nextcloud/docker: run 2676 is the revert of ci: refresh build cache and run 2675 is missing.

Real screenshot of the public run list for update.sh in nextcloud/docker, taken on November 16, 2026. Run 2676 is the revert of ci: refresh build cache, and the list jumps from 2677 to 2674.

Here is a nuance I verified myself. StepSecurity wrote on November 12 that run 2675 survived. On November 16, the public list no longer shows it. I do not know when or by whom it was removed, and there is no basis to attribute it to the attacker: the project itself may have deleted it later. It is a good reminder that a run log is not durable evidence. If you are hit, export what you need while it exists.

Because the run survived, its public log shows what the script reports about itself:

memscan_files 3
gcp_gcloud_auth_empty
gcp_live token=0 projects=0 gcloud=0
selfhosted_collected
az_graph_token_fail
oidc_discovery arn=none gcp=none azure=none
archive_bytes 8971
exfil_no_runtime_vars

Read it like this: it pulled secrets from the runner’s memory, collected extra data because the job ran on a Nextcloud server rather than a GitHub-hosted one, and packed everything into an 8,971-byte archive. No retry message appears, so the first upload to 194.150.166[.]244 worked. On this specific case, StepSecurity does not say what was stolen or whether harm followed, only what the script reports.

What the report does not establish

To separate analysis from a recap, these are the limits I would put on what is known today:

  • It is a single vendor analysis. The figures (63,000 probes, 21,000 commits, 101 copies, 57/1/43) are measured by StepSecurity and I have no independent replication.
  • A probe is not a compromise. 63,000 probe pull requests do not mean 63,000 repositories with the script. The report itself says thousands.
  • The origin of the tokens is unclear. How they were obtained is not established. The link to the Fly.io app is recorded in GitHub’s API for 173 pull requests, and nothing more.
  • No attribution to an actor. Some repositories also appeared in the October GhostAction wave, and one commit includes a hidden VS Code task that recalls the PolinRider campaign. The report states that neither overlap proves a single actor.
  • Package impact is small and specific. Three published versions carry the script. WebdriverIO confirmed none of its releases was affected.

What I would do this week

The report proposes a response list. This is my version, ordered by urgency.

1. Find out whether you were hit. Search for pull requests titled docs: dependency audit notes and branches named wfx-docs or chore/<8 characters>. Search commits since November 10 for ci: refresh build cache, ci: restore, ci: cleanup, chore: add ci helper or chore: add dependency audit workflow. For each hit, open the Actions tab and look for a missing run number right after it. Note which account made the commit: its tokens are stolen.

You can also check the organization audit log to see who deleted runs and when.

2. If the script ran, rotate everything the job could see. Every repository, environment and organization secret, not only the ones the workflow names, because the memory scan collects the rest. Also npm and PyPI publishing tokens and cloud access. On self-hosted runners, rotate the host’s own credentials too.

3. Remove the persistence, because rotation is not enough.

  • AWS: look for trust policies with "Principal": {"AWS": "*"} and IAM access keys created since November 10. In CloudTrail, look at AssumeRoleWithWebIdentity or AssumeRole with a wfx- session name, followed by CreateAccessKey or UpdateAssumeRolePolicy.
  • Azure: list the federated credentials on your app registrations and delete the ones named wfx-ci-*.
  • GCP: review GenerateAccessToken and SignJwt calls made through your GitHub workload identity pool.
  • Vault and Kubernetes: review logins made with tokens issued by token.actions.githubusercontent.com.
  • GitHub: delete the wfx-docs and chore/* branches, close the probes and check that no commit was merged on the strength of a check marked as passed.

4. Lock down the compromised accounts. Revoke personal access tokens, OAuth app grants and SSH keys, and sign out their sessions. For bot accounts, review whether they really need to bypass branch protection. In WebdriverIO the bot had that permission, and the same account pushed 56 chore: add ci helper commits across 28 repositories.

5. Do not forget developer machines. The package.json hook runs on any machine that installs dependencies. The window was short, usually a minute or two before the revert, but anyone who ran git pull and npm install in that span ran the script locally.

Indicators to search for

TypeIndicator
Collection servers194.150.166[.]244:8080/exfil, 18.143.168[.]96:8080/exfil, 153.75.82[.]159:8080/exfil
Telegramapi.telegram.org, sendDocument, chat -1004340163187
Pull requestTitle docs: dependency audit notes, branch wfx-docs, file docs/wfx-audit.md
Files and branches.ci-[a-z0-9]{6}.sh, .github/workflows/build-audit-[a-z0-9]{6}.yml, chore/[a-z0-9]{8}
ContentWF_CALLBACK, WF_CTOKEN, WF_EXFIL_*, WF_TG_BOTS, memscan_files, archive_bytes, deliver_retry
CloudFederated credentials wfx-ci-*, sessions wfx-*, "Principal": {"AWS": "*"}

File hashes are of little use here. Each copy embeds its target repository and random names, and no two share a hash.

Frequently asked questions

Is this a GitHub Actions vulnerability?

No, according to StepSecurity. The attacker uses valid tokens for real accounts and bots, and performs ordinary git operations.

How do I know whether the script ran in my repository?

Look for a gap in the Actions run numbers right after a suspicious commit. If the run survived, read its log for archive_bytes or memscan_files.

Is blocking the three IPs enough?

No. Since November 12, new copies send data only to Telegram and carry no collection IP. An allowlist of destinations for your runners covers both cases.

Is rotating the secrets enough?

No. The script tries to leave access that survives rotation, such as an open AWS role or an Azure federated credential. You have to review and remove those.

Does it affect my packages if I publish from CI?

It can. StepSecurity lists digitalelvis/neuronai-studio 3.14.3, github.com/onuragtas/docker-env v1.0.278 and v1.0.280, and a pseudo-version of github.com/vkuznet/gocurl. If you publish automatically, rebuild from a clean commit anything released between the malicious commit and its revert.

Sources

Blog

Let's talk security

Talks, press or partnerships: get in touch.