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-*.shfile, the attacker also pastes the stealer into ordinary shell scripts that CI already runs, such asupdate.shortests/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).

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.
.png)
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 cache | Adds 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 cache | Appends 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 workflow | Adds 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 helper | Two 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.

update.sh, a script the repository's own workflow runs. Line 211 sets the collection server.
Restore cache x9xx, runs the stealer.
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: restorecommit 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 installon 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.

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.

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_varsRead 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'sGITHUB_TOKENand 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 triesiam:CreateAccessKeyfor 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 |
|---|---|---|---|
| HTTP | November 10 | HTTP POST to 194.150.166[.]244:8080/exfil (54 copies) or 18.143.168[.]96:8080/exfil (3 copies) | 57 |
| HTTP and Telegram | November 12, 01:10 UTC | HTTP POST to a third server, 153.75.82[.]159:8080/exfil, with its own callback token, and the Telegram chat below as a backup | 1 |
| Telegram only | November 12, about 05:30 UTC | Uploaded 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.
- Probe pull requests titled docs: dependency audit notes
- Commits titled ci: refresh build cache
- Commits titled chore: add ci helper
- Commits titled chore: add dependency audit workflow
- Code containing 194.150.166.244 and code containing 18.143.168.96

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/docker | update.sh | Pasted into an existing script |
| webdriverio/webdriverio | .ci-a4oytg.sh, package.json | Hidden script run by an npm install hook |
| zerosoul/rc-bullets | .ci-7arkno.sh, package.json | Hidden script run by an npm install hook |
| juejin-cn/repo-data | .ci-cdvnwh.sh | Hidden script run by an npm install hook |
| ipfs-shipyard/js-ipld-fixtures | .ci-umshcm.sh | Hidden script run by an npm install hook |
| drunomics/nuxtjs-drupal-ce | .github/workflows/ci.yml | Added to a workflow |
| noushiFlex/am-i-cooked | .github/workflows/test.yml | Added to a workflow |
| PancrePal-xiaoyibao/MinerU-xyb | tests/retry_env.sh | Pasted into an existing script |
| vkuznet/gocurl (still live) | .github/workflows/build.yml | Added to a workflow |
| brunoduc/cave | .github/workflows/lint.yml | Added 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-studio | Packagist | 3.14.3 | Ships 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-env | Go | v1.0.278, v1.0.280 | The 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/gocurl | Go | v0.0.0-20261111095532-8d5aad0cb0da | Same 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 servers | 194.150.166[.]244:8080/exfil, 18.143.168[.]96:8080/exfil, 153.75.82[.]159:8080/exfil |
| Callback tokens | b42d70a7aab9140ca19e8249, 15f44heehnax8jdf41yx (sent with each upload as t=) |
| Telegram | api.telegram.org sendDocument; chat -1004340163187; bot IDs 8708988906, 9196217635, 9180059428, 8902935164, 8876515636 |
| Pull request | Title docs: dependency audit notes; branch wfx-docs; file docs/wfx-audit.md (git blob ee6e5addfe591923fc385553cb66cf0d25634a6b) |
| Commit messages | ci: 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 files | chore/[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 content | Steps 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 persistence | Azure 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 Policy | Blocks | Covered by Harden-Runner, Malicious Files and Audit Log | Cancels the run before toJSON(secrets) is read |
| Secret Exfiltration Attempt detection | Detects | Covered by Harden-Runner, Malicious Files and Audit Log | Flags the run, and raises it to High confidence when the run is deleted |
| Harden-Runner | Blocks and detects | Blocks and detects | Blocks the upload (all three collection IPs are on the Global Block List) and flags the runner memory scan |
| Malicious Files for GitHub | Finds | Finds | Finds the stealer in git history after the revert |
| GitHub Audit Log | Investigates | Investigates | Tracks 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.


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.

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.96and153.75.82.159to 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.


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 likeupdate.shas well as new files.wfx-npm-script-ci-helper-hook(critical): apackage.jsonscript that runs a hidden.ci-*.shfile.wfx-probe-audit-notes(high): thedocs/wfx-audit.mdprobe 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.

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.

What to Do Now
1. Find out whether you were hit
- Search your organization's pull requests for
docs: dependency audit notesand branches namedwfx-docsorchore/<8 characters>. - Search commits since November 10 for
ci: refresh build cache,ci: restore,ci: cleanup,chore: add ci helperandchore: 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_bytesare 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 sessionswfx-<pid>, so look in CloudTrail forAssumeRoleWithWebIdentityorAssumeRolewith a session name startingwfx-, followed byCreateAccessKeyorUpdateAssumeRolePolicy. - Azure: list the federated identity credentials on your app registrations and delete any named
wfx-ci-*. - GCP: review
GenerateAccessTokenandSignJwtcalls 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-docsandchore/*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.
.png)



