Back to Blog

WFX Phantom: The GitHub Actions Secret Stealer That Deletes Its Tracks

A coordinated botnet of compromised GitHub accounts launched a widespread attack, opening seemingly harmless pull requests before pushing a malicious shell script directly to default branches. The script, dubbed "wfx", executed through GitHub Actions to steal secrets before the attackers quickly reverted their changes, leaving minimal traces.
Owais Shaikh
View LinkedIn

November 12, 2026

Share on X
Share on X
Share on LinkedIn
Share on Facebook
Follow our RSS feed
Table of Contents

Starting on November 10, 2026, an attacker has been using stolen GitHub tokens to push a CI secret stealer into repositories those tokens can write to. The stealer names itself wfx. It collects every GitHub Actions secret, the runner's memory, and cloud credentials, and it tries to stay in your AWS and Azure accounts after you rotate. Then the attacker reverts the commit and deletes the workflow run, usually within a minute.

The scale is large. As of 07:40 UTC on November 12, GitHub search returns more than 63,000 of the attacker's probe pull requests, about 90% of them still open, and new ones are still appearing every few minutes. A probe is not the stealer itself: the attacker pushes the stealer only where the token's permissions and the repository's setup let it run, which is thousands of repositories rather than all 63,000.

We pulled more than 100 of the attacker's commits from GitHub to study the payload, including commits to nextcloud/docker, webdriverio/webdriverio, juejin-cn/repo-data and ipfs-shipyard/js-ipld-fixtures. This post covers what we found, including two details that change how you detect it:

  • A switch to Telegram. Telegram first appears in our samples at 01:10 UTC on November 12, as a backup to a third collection server. From about 05:30 UTC, new copies send stolen data only to a Telegram chat and carry no collection IP at all, and every copy we sampled between 07:00 and 07:40 UTC worked this way. Blocking the published IP addresses no longer stops it.
  • A fourth hiding place. Besides workflows and a hidden .ci-*.sh file, the attacker also pastes the stealer into ordinary shell scripts that CI already runs, such as update.sh or tests/retry_env.sh.

Check your repositories now

Look for a pull request titled docs: dependency audit notes from a wfx-docs branch, or commits titled ci: refresh build cache, chore: add ci helper or chore: add dependency audit workflow, on or after November 10. Then look for a missing run number in the Actions tab right after that commit. A missing run means the stealer probably ran and the attacker deleted the evidence. Treat every secret and cloud role that workflow could reach as stolen.

How the Attack Works

The attacker does not exploit a bug in GitHub Actions. It has valid tokens for real developer and bot accounts, and it uses them the way a developer would: it opens pull requests and pushes commits. For each repository a token can write to, it runs the same three steps.

Some of the stolen tokens were issued to the Fly.io GitHub App. The attackers are using the Fly.io GitHub App as part of this campaign. On 173 of the probe pull requests, opened from 19 accounts, GitHub records that the request was made through the Fly.io GitHub App (fly-io, app ID 34557). The pull request still shows the account owner as its author. That means the attacker was using tokens that GitHub issues to the Fly.io app when a user connects their GitHub account to Fly.io, which let the app, and so the attacker, act as that user. The PRs arrived in bursts: on November 11 between 10:02 and 10:36 UTC, and again on November 12 around 06:20–06:30 UTC. Each burst created PRs for 4 to 7 unrelated accounts within the same one or two seconds, which suggests one operator working through a pool of these tokens in parallel. The app's permissions include write access to contents, actions and pull requests, enough for every step of the attack.

We have not established how the tokens were obtained, and we have no evidence of a breach of Fly.io's own infrastructure. Most of the campaign's activity uses other credentials, such as personal access tokens. We are sharing our findings with Fly.io. You can see the attribution in GitHub's own records: the API entry for the probe pull request in EbukaLovesTech/2gether, opened at 10:02:50 UTC on November 11, names the app in its performed_via_github_app field (api.github.com/repos/EbukaLovesTech/2gether/issues/1).

GitHub API response for the probe pull request EbukaLovesTech/2gether#1, showing performed_via_github_app with id 34557, slug fly-io, owner superfly, name Fly.io and write permissions for actions, contents and pull requests
GitHub's API record for the probe pull request in EbukaLovesTech/2gether: performed_via_github_app is the Fly.io app (fly-io, ID 34557), with write access to actions, contents and pull requests.

1. Probe: a harmless pull request

The attacker opens a pull request titled docs: dependency audit notes, with the body Routine dependency audit notes, from a branch named wfx-docs. It adds one file, docs/wfx-audit.md, with two lines of text. The file is byte-identical in every pull request we checked.

The pull request does nothing by itself. It tells the attacker that the token can write to the repository. If you see one, the account that opened it is compromised, even if nothing else happened.

GitHub pull request search for docs: dependency audit notes, showing about 63,000 results, the newest opened minutes earlier
GitHub search for the probe pull request on November 12: about 63,000 results, with new ones opened minutes earlier. Run the search.

2. Payload: one stealer, four hiding places

Next the attacker pushes the stealer, a single shell script of about 1,500 lines, in one of these ways:

Commit message What it changes Example
ci: refresh build cacheAdds two steps to an existing workflow such as ci.yml or tests.yml: one that hands the job's internal GitHub Actions tokens to the next step, and one with a harmless-looking name like Restore cache x9xx that holds the whole script.drunomics/nuxtjs-drupal-ce
ci: refresh build cacheAppends the script to an existing shell script that a workflow already runs.nextcloud/docker (update.sh), PancrePal-xiaoyibao/MinerU-xyb (tests/retry_env.sh)
chore: add dependency audit workflowAdds a new workflow, .github/workflows/build-audit-<6 characters>.yml, named Dependency Audit <4 characters>, on a throwaway chore/<8 characters> branch.Commit search
chore: add ci helperTwo commits. The first adds a hidden script, .ci-<6 characters>.sh, at the repository root. The second edits package.json so that an npm script runs it first. In our samples the hooked script was postinstall 11 times, build twice and test once.zerosoul/rc-bullets, juejin-cn/repo-data, ipfs-shipyard/js-ipld-fixtures

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

nextcloud/docker commit b4353fc, ci: refresh build cache, adding 1,496 lines to update.sh, starting with export WF_CALLBACK='http://194.150.166.244:8080/exfil'
In nextcloud/docker, the stealer was appended to update.sh, a script the repository's own workflow runs. Line 211 sets the collection server.
drunomics/nuxtjs-drupal-ce ci.yml at commit deb537f, showing the injected Pass runtime and Restore cache x9xx steps with WF_CALLBACK set to 194.150.166.244
The stealer added to an existing workflow in drunomics/nuxtjs-drupal-ce. The first new step hands the job's internal GitHub Actions tokens to the next one, and the second, Restore cache x9xx, runs the stealer.
zerosoul/rc-bullets commit 72891d4 adding a postinstall script that runs sh ./.ci-7arkno.sh and re-encoding Chinese keywords as unicode escapes
The npm install hook in zerosoul/rc-bullets: a postinstall script runs the hidden .ci-7arkno.sh.

3. Cleanup: revert and delete the run

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

  • drunomics/nuxtjs-drupal-ce. At 09:17:23 UTC on November 11, the stealer was committed to the default branch. A ci: restore commit followed 12 seconds later, pushed by the project's bot account, drubot. The Actions history goes from run #1963 straight to run #1965. Run #1964, the run for the injected commit, is gone.
  • zerosoul/rc-bullets (595 stars). The repository's Pages deploy runs npm install on every push, which fires the hook. Run #62 and run #64 are there; run #63, triggered by the hook commit, is gone. The revert landed two minutes later.
drunomics/nuxtjs-drupal-ce ci workflow runs listing run 1965 ci: restore pushed by drubot directly followed by run 1963, with an annotation noting run 1964 is missing
The only trace left in the Actions tab: run #1964 is missing between #1963 and the attacker's ci: restore run #1965. Annotation added by StepSecurity.

In webdriverio/webdriverio, the two chore: add ci helper commits were pushed as the project's bot account, which was allowed to bypass branch protection. A contributor spotted them within 20 minutes and opened a revert. The same bot account was used to push 56 chore: add ci helper commits across 28 WebdriverIO repositories; no WebdriverIO package release was affected. In both drunomics and WebdriverIO, the token the attacker used belonged to a bot. Automation accounts with write access, and especially with bypass rights, are as valuable to this attacker as maintainers.

webdriverio pull request 16444 reverting two unauthorized commits pushed as the wdio-bot account that added .ci-a4oytg.sh and a postinstall hook sending data to 194.150.166.244
WebdriverIO's revert of the two commits pushed as wdio-bot.

When the cleanup fails: what a surviving run shows

The attacker does not always manage to delete the run. In nextcloud/docker (7,400 stars), the stealer appended to update.sh ran in the repository's update.sh workflow (run #2675) three seconds after the commit, and the run was never deleted. A Nextcloud developer reverted the commit 27 minutes later. Because the run survived, its public log shows what the stealer reports about itself:

updating 32.0.15 [32] fpm-alpine
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 line by line, the log says the stealer collected extra data from the machine itself, because the job ran on Nextcloud's own server rather than one hosted by GitHub. It also read secrets out of the runner's memory and packed everything into an 8,971-byte archive. The script prints a retry message whenever an upload fails, and there is none, so the first upload to 194.150.166[.]244 succeeded. The job then finished green, with nothing visibly wrong.

What the Stealer Does

The script is plain, heavily commented shell, with on/off switches for each feature at the top. It works in four stages.

Collect

  • Every repository secret and variable, passed in as ${{ toJSON(secrets) }} and ${{ toJSON(vars) }}, plus the job's GITHUB_TOKEN and its ability to request cloud sign-in tokens.
  • The memory of the GitHub Actions runner process (Runner.Worker), which holds every secret the job can use in decrypted form, including ones the workflow never asked for. This is how the copies hidden in a shell script or an npm install script steal secrets without changing the workflow file.
  • Every process environment, credential files for AWS, Azure, GCP, Docker, Kubernetes, npm, PyPI, SSH and Vault, API keys for AI providers and coding agents, and, on self-hosted runners, cloud instance metadata credentials.
  • A snapshot of the repository, its recent history and recent workflow artifacts.

Escalate

It uses the job's cloud sign-in token (an OIDC token, which GitHub issues so workflows can log in to cloud providers without stored keys) to open AWS, GCP and Azure sessions, chains into further AWS roles named in the repository, impersonates GCP service accounts, and replays cached Azure CLI refresh tokens to get Microsoft Graph and Key Vault access.

Persist

The script has three features designed to outlast credential rotation:

  • Fake passing checks (built in, not used yet). The script can mark a repository's required checks as passed, which would let a commit through branch protection while the stealer is still running. None of the 101 copies we examined had this turned on.
  • An AWS role open to everyone. It rewrites an assumed role's trust policy to "Principal": {"AWS": "*"} and tries iam:CreateAccessKey for IAM users, giving the attacker long-lived keys.
  • An Azure back door. It adds a federated identity credential named wfx-ci-<n> to Azure AD applications, trusting workflows in the compromised repository. Those workflows can then sign in to Azure with no stored secret at all.

Exfiltrate

Everything is packed into one gzipped archive. The code supports several delivery channels, including three that use GitHub's own infrastructure (the Actions cache, the step summary between <!--WFX-BEGIN--> markers, and an artifact named wfx-loot-<run id>), but those were switched off in every copy we examined. In the 101 copies we examined, delivery was configured three ways:

Configuration First seen in our samples Where the data goes Copies we examined
HTTPNovember 10HTTP POST to 194.150.166[.]244:8080/exfil (54 copies) or 18.143.168[.]96:8080/exfil (3 copies)57
HTTP and TelegramNovember 12, 01:10 UTCHTTP POST to a third server, 153.75.82[.]159:8080/exfil, with its own callback token, and the Telegram chat below as a backup1
Telegram onlyNovember 12, about 05:30 UTCUploaded with sendDocument to api.telegram.org through five bot tokens, into chat -1004340163187. The HTTP callback is set to 127.0.0.1, a dead end. A comment in the script reads "no callback IP anywhere in the payload". Every copy we sampled between 07:00 and 07:40 UTC on November 12 used this configuration.43

The switch to Telegram means blocklists built from the November 10 IP addresses miss the newest copies. An egress allowlist still stops both, because neither a bare IP nor api.telegram.org belongs in a normal build.

Affected Repositories and Searches

These GitHub searches show the campaign's footprint. Code search needs you to be signed in to GitHub.

GitHub commit search for chore: add dependency audit workflow, listing commits in several repositories
Commit search for the new workflows the attacker adds on throwaway branches, chore: add dependency audit workflow.

A sample of public repositories where the stealer was committed. All except vkuznet/gocurl have since been reverted; the links point to the attacker's commits.

Repository File How it was added
nextcloud/dockerupdate.shPasted into an existing script
webdriverio/webdriverio.ci-a4oytg.sh, package.jsonHidden script run by an npm install hook
zerosoul/rc-bullets.ci-7arkno.sh, package.jsonHidden script run by an npm install hook
juejin-cn/repo-data.ci-cdvnwh.shHidden script run by an npm install hook
ipfs-shipyard/js-ipld-fixtures.ci-umshcm.shHidden script run by an npm install hook
drunomics/nuxtjs-drupal-ce.github/workflows/ci.ymlAdded to a workflow
noushiFlex/am-i-cooked.github/workflows/test.ymlAdded to a workflow
PancrePal-xiaoyibao/MinerU-xybtests/retry_env.shPasted into an existing script
vkuznet/gocurl (still live).github/workflows/build.ymlAdded to a workflow
brunoduc/cave.github/workflows/lint.ymlAdded to a workflow (third server, 153.75.82[.]159)

Code search also returns 19 files named SECURITY_INCIDENT_2026-11-10.md, all from one developer who committed an incident write-up to each affected repository after cleaning up.

Affected Packages

Where a repository publishes automatically on push, the stealer reached a release. These versions carry it:

Package Ecosystem Affected versions Notes
digitalelvis/neuronai-studioPackagist3.14.3Ships the .ci-*.sh script and postinstall hook. composer install does not run it, but npm install inside the package directory does. Pin 3.14.2 or earlier.
github.com/onuragtas/docker-envGov1.0.278, v1.0.280The stealer is only in a GitHub Actions workflow file in these tags. Go builds never run workflow files, but block these versions.
github.com/vkuznet/gocurlGov0.0.0-20261111095532-8d5aad0cb0daSame as above: a workflow file only. Go names a version like this after the commit it was built from (a pseudo-version), and Go's module proxy keeps serving it even though the commit was reverted.

Check composer.lock and go.sum for these versions, and rebuild any package you published between a malicious commit and its ci: cleanup revert from a clean commit.

Links to GhostAction and PolinRider

Some of the repositories hit in this wave were also hit in the October GhostAction wave. Three of our samples were injected into a security-audit.yml left behind by GhostAction, which still sent data to 193.32.204[.]199, the October wave's collection server.

One commit we pulled, a chore: add dependency audit workflow commit in Kellie-Brighty/Suinicate, also added a hidden VS Code task that runs a Node.js file when the folder is opened, a technique used by the PolinRider campaign. Neither overlap proves a single actor. Stolen tokens are often sold or shared, and several groups may be using the same pool. What it does show is that an account compromised once tends to be compromised again: if you were hit in October, check for this wave too.

Indicators of Compromise

Type Indicator
Collection servers194.150.166[.]244:8080/exfil, 18.143.168[.]96:8080/exfil, 153.75.82[.]159:8080/exfil
Callback tokensb42d70a7aab9140ca19e8249, 15f44heehnax8jdf41yx (sent with each upload as t=)
Telegramapi.telegram.org sendDocument; chat -1004340163187; bot IDs 8708988906, 9196217635, 9180059428, 8902935164, 8876515636
Pull requestTitle docs: dependency audit notes; branch wfx-docs; file docs/wfx-audit.md (git blob ee6e5addfe591923fc385553cb66cf0d25634a6b)
Commit messagesci: refresh build cache, ci: restore, ci: cleanup, chore: add ci helper, chore: add dependency audit workflow, and chore: initial commit before the workflow in empty repositories
Branches and fileschore/[a-z0-9]{8}; ci-check-[0-9]{4}; .ci-[a-z0-9]{6}.sh; .github/workflows/build-audit-[a-z0-9]{6}.yml; any shell script or workflow containing the markers below
Script contentSteps named Pass runtime and Restore cache <4 characters> or Run audit; WF_CALLBACK, WF_CTOKEN, WF_EXFIL_*, WF_TG_BOTS variables; staging folder .wfx-$$; log notes memscan_files, archive_bytes, deliver_retry
Cloud persistenceAzure federated identity credentials named wfx-ci-*; AWS role trust policies with "Principal": {"AWS": "*"}; AWS sessions named wfx-*

File hashes are of limited use here. Every copy embeds its target repository and random names, so no two copies we examined share a hash.

How StepSecurity Protects You

The stealer arrives in four different ways and then erases its tracks, so no single control covers all of it. StepSecurity layers five:

Control Stealer added to a workflow file Stealer hidden in a shell script or npm install script What it does
Secret Exfiltration PolicyBlocksCovered by Harden-Runner, Malicious Files and Audit LogCancels the run before toJSON(secrets) is read
Secret Exfiltration Attempt detectionDetectsCovered by Harden-Runner, Malicious Files and Audit LogFlags the run, and raises it to High confidence when the run is deleted
Harden-RunnerBlocks and detectsBlocks and detectsBlocks the upload (all three collection IPs are on the Global Block List) and flags the runner memory scan
Malicious Files for GitHubFindsFindsFinds the stealer in git history after the revert
GitHub Audit LogInvestigatesInvestigatesTracks deleted workflow runs and suspicious PAT activity to reconstruct the attack after cleanup

1. Secret Exfiltration Policy: stop the toJSON(secrets) dump

When the stealer is added to a workflow file, it gets every repository secret through one line, ${{ toJSON(secrets) }}, which hands all of them to a step at once. The Secret Exfiltration Policy, under Workflow Run Policies, cancels a run that tries this before the job starts.

  • Turn on Block only when a workflow accesses all secrets at once. This blocks bulk access such as ${{ toJSON(secrets) }} while leaving ordinary references such as ${{ secrets.NPM_TOKEN }} alone.
  • Turn on Analyze default branch runs. The new workflow the attacker adds (chore: add dependency audit workflow) runs on a throwaway branch, which the policy covers by default. The edit to an existing workflow (ci: refresh build cache) is pushed straight to the default branch, so this option is what catches it.
  • Review your exemptions. The policy lets you exempt users and bot accounts. In this campaign, the stolen tokens included bot accounts, so an exempted bot is exactly the account an attacker would use.

Copies hidden in a shell script or an npm install script leave the workflow file unchanged and read secrets from the runner's memory instead. Harden-Runner, Malicious Files and the Audit Log cover those.

StepSecurity Workflow Run Policy page showing a Secret Exfiltration Policy in Enforce mode with Bulk Secrets Only Mode enabled
A Secret Exfiltration Policy in Enforce mode with Bulk Secrets Only Mode enabled, which blocks bulk dumps such as toJSON(secrets).
GitHub Actions run cancelled with annotations saying the run was canceled forcefully by stepsecurity-app bot
A workflow pushed to a branch to dump secrets is cancelled by the StepSecurity app before the job can read them.

2. Secret Exfiltration Attempt detection: deleted runs are a signal, not a gap

The attacker's cleanup is built to defeat anyone who reviews the Actions tab after the fact. StepSecurity analyzes each workflow run as its webhook arrives, so deleting the run afterwards does not erase what was already seen. The Secret Exfiltration Attempt detection flags runs that dump all secrets with toJSON(secrets), and it points to the exact job, step and line.

If the workflow run, the branch or the workflow file is deleted shortly after the run, the detection raises its confidence to High. Deleting the evidence is itself one of the strongest signs of an attack. That is precisely what wfx does to every run it can, so its cleanup works against it. Turn on Notify when a secret exfiltration attempt is detected in Notification Settings to get an alert the moment it happens.

StepSecurity Detections page listing Secret Exfiltration Attempt detections with toJSON(secrets) indicators, one at High confidence because the head branch was deleted after the run
Secret Exfiltration Attempt detections. The second run is raised to High confidence because its branch was deleted after the run, the same cleanup wfx performs. Test runs in a StepSecurity integration org.

3. Harden-Runner: block the upload and catch the memory scan

Harden-Runner watches every outbound connection and process in a GitHub Actions job, however the stealer got there.

  • The collection servers are blocked for everyone. StepSecurity has added 194.150.166.244, 18.143.168.96 and 153.75.82.159 to the Harden-Runner Global Block List, so the upload is blocked in every job that runs Harden-Runner, even in audit mode, and shows up as an Outbound Calls Blocked detection. A blocked call to one of them means the stealer ran in that job and was stopped. In Nextcloud's run, this would have stopped the upload that succeeded.
  • Block mode also stops the Telegram copies. A global block list cannot include api.telegram.org, which has legitimate uses, and every copy we sampled after 07:00 UTC on November 12 sends only to Telegram. With an egress allowlist, that upload is blocked too, because Telegram is not an endpoint a build normally uses.
  • Audit mode flags them. Both destinations show up as anomalous outbound calls that are not in the job's baseline.
  • The memory scan is caught on its own. The stealer reads the runner process's memory to pull out secrets. Harden-Runner raises a Runner-Worker memory-read detection for exactly this behavior, even when the network call is allowed. With a lockdown policy, Harden-Runner terminates the run as soon as it sees the memory read.
Harden-Runner network events showing curl and python3 connections to the bare IP 216.126.225.129 on port 8443 marked Attack Blocked
Harden-Runner blocking a bare-IP collection server on a non-standard port. This run is from the Megalodon campaign (216.126.225.129:8443); wfx's 194.150.166.244:8080 follows the same pattern.
Harden-Runner Suspicious Processes panel showing python3 reading Runner.Worker memory at /proc/2119/mem
Harden-Runner flagging python3 reading the Runner.Worker process memory, here from the compromised actions-cool/issues-helper action. The wfx stealer does the same with python3 and sudo.

Block mode does not stop calls to endpoints the job already needs. The stealer's GitHub API calls and its cloud API calls go to api.github.com and your cloud provider. Treat a memory-read detection as a compromised run, even if the upload was blocked.

To hunt across your organization, check Outbound Calls Blocked detections and search Harden-Runner network events for 194.150.166.244, 18.143.168.96, 153.75.82.159 and api.telegram.org since November 10.

4. Malicious Files for GitHub: find the stealer after the revert

The attacker's cleanup removes the stealer from your branch and the run from your Actions tab, but not from git history. StepSecurity's Malicious Files for GitHub reads every file version in a repository's history, across branches, pull requests and tags. We have added three rules for this campaign:

  • wfx-ci-secret-stealer (critical): the stealer in a workflow or any shell script, whether it sends data to a server or to Telegram. It matches on the stealer's own markers, so it finds copies pasted into scripts like update.sh as well as new files.
  • wfx-npm-script-ci-helper-hook (critical): a package.json script that runs a hidden .ci-*.sh file.
  • wfx-probe-audit-notes (high): the docs/wfx-audit.md probe file. It marks an account whose token was used against the repository, even where no payload followed.

Each finding names the commit and author that introduced the file, so you can go straight to the compromised account. See the Malicious Files for GitHub documentation.

Malicious Files for GitHub rule detail showing ordered filename and content checks, with required and optional checks
A Malicious Files rule is an ordered chain of filename and content checks; it fires only when every required check matches. Shown here for the Miasma campaign; the wfx rules work the same way.

5. GitHub Audit Log: trace deleted runs and compromised tokens

Wfx deletes workflow runs to cover its tracks, but the activity remains visible in StepSecurity's GitHub Audit Log.

  • Track deleted runs. Identify who deleted a workflow run, when, and from which repository using the Deleted runs view.
  • Spot suspicious activity. Investigate repeated deletions across repositories and workflows.
  • Trace compromised tokens. Review PAT activity to identify token owners, request origins, and actions performed.

Even after wfx removes the evidence from GitHub Actions, the Audit Log helps reconstruct the attack and identify compromised accounts.

StepSecurity Audit Log Deleted runs tab showing counters for runs deleted, repositories, users and workflows, breakdowns by repository, user and workflow, and a list of deleted runs with the user who deleted each one

What to Do Now

1. Find out whether you were hit

  • Search your organization's pull requests for 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 and chore: add dependency audit workflow.
  • For each hit, open the Actions tab and look for a gap in run numbers right after the commit. The gap is the most reliable sign that the stealer ran. If the run survived, as in Nextcloud's case, read its log: lines such as archive_bytes are the stealer reporting what it took.
  • If you use StepSecurity, the Audit Log's Deleted runs tab lists the deleted runs, and who deleted them, across your organization.
  • Note which account pushed the commits. That account's tokens are stolen.

2. If the stealer ran, rotate everything it could reach

  • Every repository, environment and organization secret available to that job. Do not stop at the secrets the workflow names; the memory scan collects the rest.
  • npm, PyPI and other publishing tokens. Check for package versions published after the commit.
  • Cloud access the workflow can get by signing in to your cloud provider (OIDC), and any long-lived keys stored as secrets. On self-hosted runners, also rotate the host's own credentials.

3. Remove the persistence, because rotation alone does not

  • AWS: look for role trust policies containing "Principal": {"AWS": "*"} and for IAM user access keys created since November 10. The stealer names its AWS sessions wfx-<pid>, so look in CloudTrail for AssumeRoleWithWebIdentity or AssumeRole with a session name starting wfx-, followed by CreateAccessKey or UpdateAssumeRolePolicy.
  • Azure: list the federated identity credentials on your app registrations and delete any named wfx-ci-*.
  • GCP: review GenerateAccessToken and SignJwt calls made through your GitHub workload identity pool.
  • HashiCorp Vault and Kubernetes: review logins made with GitHub Actions sign-in tokens (issued by token.actions.githubusercontent.com).
  • GitHub: delete leftover wfx-docs and chore/* branches, close the probe pull requests, and check that no commit was merged on the strength of a check the attacker marked as passed.

4. Lock down the compromised account

Revoke the account's personal access tokens, OAuth app grants and SSH keys, and sign out its sessions. For bot accounts, review whether they need permission to bypass branch protection at all.

5. 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 pulled and ran npm install in that window ran the stealer locally. Rotate that developer's credentials too.

Explore Related Posts

‍