# React2STEAL Uses GitHub Actions to Exploit React2Shell

> Source: <https://opensourcemalware.com/blog/react2steal-github-actions>
> Published: 2026-11-18 06:30:00+00:00

**Recommendation:** Patch React Server Components 19.0.0–19.2.0 and Next.js middleware, and keep cloud and AI API keys out of server environment variables that a single RCE can dump.
More in the playbook "Securing agents and AI tools": <https://wpnews.pro/playbooks/agent-security>

BLOG

# React2STEAL Uses GitHub Actions to Exploit React2Shell

Stolen AWS credentials, AI keys and .env files from 1,200+ hosts are sitting in public repos for anyone to read.

By cb482791-4ef1-4762-96ad-b0ca4bdd538e ·

Earlier today, I got a message from Karina Reaño, a Cyber Threat Intelligence Lead. She'd found a set of GitHub repositories that were scanning for apps vulnerable to React2Shell (CVE-2025-55182) and the Next.js middleware authorization bypass (CVE-2025-29927), and trying to exploit them.

By the time she reached out, she'd uncovered 38 of these repos on her own. She said the repos had targeted more than 20,000 hosts and compromised about 277 of them, and that some of the repos contained stolen data sitting in plaintext. She asked for a review of her research since OpenSourceMalware is a dedicated source for GitHub threats. We're calling the campaign React2STEAL, after the React2Shell flaw it exploits and what it does once it's in. Its repos are all named ci-wk-<number>. We dug in, and our findings confirmed her discoveries and expanded the scope:

1. **We confirmed what she found:** These repos are attack infrastructure, not a malicious Action that someone would install. They host an infostealer and the exploit scripts that deliver it, and they double as the drop site for what it steals, which makes them malicious repositories even though nobody downloads them. Each holds its own GitHub Actions workflow that uses GitHub's runners to scan for Next.js servers and attempt to exploit known CVEs (React2Shell and CVE-2025-29927) against them. When an exploit works, it runs a credential-stealing script on the victim's server that grabs environment variables, cloud credentials and API keys, and the workflow commits what it took back into the same public repo.
2. **We expanded the dataset:** In total we found 45 React2STEAL repos, set up in three waves since October 22. They were still committing new results about every 11 minutes when we published this analysis. Those results list at least 1,281 victim hostnames across about 1,100 domains. The result files hold process environment dumps, and the credentials that show up most often are database URLs, Stripe keys and AI provider keys. We also found that the payload steals full config files and the server's AWS credentials, and that the stolen records are strong evidence that it actually ran on those servers.
3. **We found a connection to another campaign:** wfx-loot is a separate campaign, running since November 10, that uses thousands of hijacked GitHub accounts to steal CI secrets. Most of the React2STEAL repos carry the probe file wfx-loot pushes before it plants its stealer, and most React2STEAL owners have wfx-loot probe pull requests on their repos.

We're tracking the campaign under the [ci-wk tag](https://opensourcemalware.com/?search=%23ci-wk).

What we don't know (yet) is who runs React2STEAL, how the account tokens were obtained, or whether one operator used them for both attacks. The evidence shows that the GitHub accounts running React2STEAL were also used in wfx-loot.

## GitHub repos exploiting React and Next.js servers

Both flaws these repos go after are public and have fixes:

- **[CVE-2025-55182](https://nvd.nist.gov/vuln/detail/CVE-2025-55182)** **(React2Shell):** A pre-authentication remote code execution flaw in React Server Components versions 19.0.0, 19.1.0, 19.1.1 and 19.2.0. React unsafely deserializes payloads sent to Server Function endpoints, so a single crafted HTTP request can run code on the server. Next.js apps built on those versions are exposed too.
- **[CVE-2025-29927](https://nvd.nist.gov/vuln/detail/CVE-2025-29927)****:** An authorization bypass in Next.js middleware. Vulnerable versions trust an internal header,`x-middleware-subrequest` , so a request that includes it can skip middleware entirely, including authentication checks.

Karina shared a detailed analysis with us as a jumping off point. She wrote that "the combination of automated exploitation, sensitive credential collection, and credential validation strongly indicates malicious exploitation intent rather than conventional vulnerability research." Here's a summary of her findings:

- **The repos:** 38 distinct GitHub repositories spread across different accounts and  follow "a distinctive ci-wk-<number> naming convention."
- **The workflow:**`.github/workflows/scan.yml` runs the scans from GitHub-hosted runners, with up to 400 concurrent requests during discovery and two exploitation processes at 250 concurrent requests each.
- **Discovery:**`bin/prefilter_nextjs.py` picks out likely Next.js targets from hostname inventories she describes as "reportedly derived from certificate transparency data."
- **Exploitation:**`bin/batch_output.py` attempts React2Shell, probes CVE-2025-29927, and tries server-side request forgery through the Next.js image optimization endpoint to reach AWS instance metadata.
- **Post-exploitation:**`bin/fast_recon.js` collects environment variables, configuration files, database credentials, cloud secrets and API keys, and tests discovered AI service credentials against providers such as OpenAI, Anthropic, and Gemini.
- **Telegram:** A hard-coded Telegram bot configuration, shared across repos.

## What the React2STEAL repos run

The repos went up in three waves, each within minutes:

Wave

Created (UTC)

Repos

What stands out

1

Oct 22, 02:05 to 02:13

At least 26

Different accounts, all within about 7 minutes. Hundreds of victim hosts per repo, though seven stopped scanning on Oct 28. 22 of 26 later got wfx-loot's probe.

2

Nov 11, 04:15 to 04:16

8

About 26 seconds apart, the day after wfx-loot began. About 90 to 100 victim hosts per repo. 3 of 8 got wfx-loot's probe.

3

Nov 14, 14:43 to 14:44

5

About 90 seconds apart. Staged only, with the same 1,845-host target list in all five. No results and no wfx-loot probes.

The five third-wave repos hold only the scripts, a one-line README and a staged host list. All five hold the same list of 1,845 target hosts, none of which appear among the victims, and they hadn't produced anything when we looked.

### The pipeline

Here's how the campaign works, step by step.

1. **Feed it targets:** The operator commits a large list of hostnames into a repository.
2. **Start the workflow:** A manually dispatched GitHub Actions workflow launches a temporary Ubuntu server on GitHub's infrastructure.
3. **Find likely victims:** The runner makes hundreds of concurrent requests to identify hosts using Next.js.
4. **Attempt exploitation:** It starts two parallel scanners, each configured for up to 250 concurrent targets. The scanner tries seven variations of the React2Shell request to bypass filtering. If that doesn't work, it tries the Next.js middleware bypass and a request that pulls AWS credentials from the server's cloud metadata service.
5. **Steal data automatically:** When exploitation succeeds, attacker-supplied JavaScript runs inside the victim's Node.js application. It collects environment variables, credentials and internal system information. Newer variants also take complete .env and configuration files.
6. **Validate stolen keys:** The victim server is instructed to test AI provider credentials against services such as OpenAI, Anthropic and Gemini. These requests come from the victim's server, not from GitHub.
7. **Return and package the loot:** The stolen data is returned in the exploit response and saved as plaintext, JSON and ZIP files on the GitHub runner.
8. **Commit everything:** The workflow is configured with write access to the repo and automatically runs`git add` ,`git commit` and`git push` , preserving the stolen data in the public repository and its Git history.
9. **Repeat across accounts:** Multiple repositories perform the same process with different target chunks. Some record the same victims seconds apart, suggesting a central controller dispatching parallel scanning lanes.

Every repo carries the same four files: `.github/workflows/scan.yml`, `bin/prefilter_nextjs.py`, `bin/batch_output.py` and `bin/fast_recon.js`. The two Python files are identical in every repo. `fast_recon.js` comes in two variants.

1. `scan.yml`**:** The workflow runs on GitHub-hosted` ubuntu-latest` runners and is triggered by`workflow_dispatch` .
2. `prefilter_nextjs.py`**:** Runs the Next.js check.
3. `batch_output.py`**:** Handles exploitation. The seven React2Shell variants include chunked encoding, an 8 KB padding prefix and a randomized multipart boundary. The middleware bypass uses the`x-middleware-subrequest` header. The metadata request is an SSRF through`/_next/image` that looks up the server's IAM role and pulls that role's temporary AWS credentials.
4. `fast_recon.js`**:** The payload that runs on the victim server. Besides the process environment, it looks for cloud credential files, Kubernetes tokens and`.env` files. It tests AI keys against ten providers with real inference requests, and for some providers it also pulls the account balance, so the tests can show up as charges. The newer variant returns the full contents of .env and config files, up to 300 KB per victim. In one repo, 142 of 143 victim records included those files. The payload doesn't install anything that stays on the server or download a second payload.

The result commits are authored by `w <w@w>`. A typical first-wave repo has about 1,280 `chunk` commits and about 1,050 `results` commits. When we checked on November 17, new ones were still landing about every 11 minutes. Because each result is saved in three formats, deleting one file doesn't remove the data. In a snapshot of 11 repos that were still accessible, we found about 9,100 ZIP archives, 3,800 JSON files and 3,000 plaintext records, around 7.4 GB in all, with the same victims repeated across files and repos.

There's also a Telegram bot token and chat ID hard-coded in `batch_output.py` in every repo. But sending is switched off unless an environment variable is set, and nothing sets it. So the real exfiltration channel is the public repos, which means anyone can read the loot, not just the operator.

Dumping stolen data into public GitHub repos has become a common pattern in software supply chain attacks. Here it could be a mistake, or it could be deliberate: when the loot is public, anyone could have pulled the credentials from it, which gives whoever uses them some plausible deniability.

### What's in the repos

At the latest commit, the 34 live repos with results hold 1,281 unique victim hostnames. That’s a floor, because we didn’t read earlier versions of the files. Per repo the count runs from 38 to 894. Most of the October 22 repos hold hundreds each, though seven hold only 38 to 48, because their scanner stopped running on October 28. The November 11 repos hold 86 to 101.

Those hostnames cover about 1,100 distinct domains. Most belong to small and mid-sized organizations of every kind, with a few large or institutional names, and many are dev, staging or admin hosts.

The per-host result files contain process environment dumps, and file names across the repos match credential patterns. The most common are database URLs, Stripe keys and AI provider keys.

Those records are strong evidence that the payload actually ran on those systems. They hold things the scanner could only collect from inside the victim's Node.js process: the full environment, hostname, network interfaces, listening ports and config file contents. We haven't tested whether any of the exposed credentials still work.

## Victims' GitHub accounts run the scanner

The evidence indicates that the people whose accounts run this scanner are victims. The scanner runs from their accounts, with their own tokens, but the evidence points to someone else holding those tokens.

### One controller behind many accounts

The workflows are dispatched through the API with each owner's own token. We read run metadata in two repos. In both, the newest 100 runs were `workflow_dispatch` runs triggered by the repo owner's account, and the two repos' runs were timestamped about 9 seconds apart. That points to one controller looping over many accounts. The same victims also show up in separate repos seconds apart, as if one scheduler hands out targets across accounts. 

GitHub's API ties the w <w@w> result commits in every live repo we checked to a single GitHub account, dascxzcw. GitHub makes that link from the commit email, so whoever controlled dascxzcw claimed the w@w address at some point. That makes it our best lead on the operator, and we think it's likely an account the operator controlled. The account now returns a 404, which is what GitHub shows for suspended or deleted accounts, but the commits are still attributed to it. Commit author names and emails match each owner, and the owners' own earlier commits carry each owner's local time zone.

### Who the owners are

The owners themselves don't look like an attacker's fleet. The 45 repos belong to 44 owners (one owns two), and we could read 26 of their profiles. Among those 26, the median owner has 4 public repos, and 6 have the React2STEAL repo as their only public repo. 20 of the 26 have no followers. The accounts were created anywhere from 2011 to 2026, they use real-looking identities, and some sit on company email domains.

### Signs the tokens were stolen

Several things point to stolen tokens. Most of these accounts were also used in wfx-loot, a campaign built on hijacked accounts, and four of them have wfx-loot's payload commits on their other repos. We can't rule out that an owner here or there rented out access, but we're treating them all as victims.

How the operator got the tokens isn't established. One possibility we think the industry should strongly consider is OAuth tokens leaking through a flaw in a widely used third-party app. We have no evidence, but it would explain why so many recent attacks leave the same open question of how the attacker got the credentials. In wfx-loot, one vendor found probe pull requests made through a third-party GitHub App's tokens.

The other possibilities are ordinary token theft, tokens the scanner itself pulled off servers it scanned, accounts sold or rented to the operator, or software the owners ran themselves.

### One account hit by three campaigns

One account stands out as an exception. In addition to being a victim of React2STEAL, the owner has also been infected with the PolinRider and GhostAction campaigns (separately). That suggests their machine and credentials were compromised more than once, by more than one group.

## The branch that tied React2STEAL to wfx-loot

wfx-loot is a separate campaign that started on November 10. Its operator uses hijacked GitHub accounts and works in three steps:

1. **Probe:** Open a pull request titled "docs: dependency audit notes" from a branch named`wfx-docs` , which adds a two-line file,`docs/wfx-audit.md` .
2. **Steal:** Push a stealer that grabs the repo's CI secrets.
3. **Clean up:** Revert the stealer within a minute and delete the workflow run.

Reports put its scale at up to 4,837 compromised accounts, more than 66,200 probe pull requests, 8,093 public repos with a malicious commit on the default branch, and at least 1,835 repos where the payload ran.

You can see our related threat reports [here](https://opensourcemalware.com/?search=%23wfx).

### What wfx-loot left in the React2STEAL repos

When we went through the git metadata of the 39 React2STEAL repos we could examine, here's what we found from wfx-loot:

- **The probe branch:** 25 have a`wfx-docs` branch. That's 22 of the 26 first-wave repos and 3 of the 8 second-wave repos. None of the 5 third-wave repos has one, which fits their creation date of November 14, after the probe wave.
- **The probe file:** Each of those 25 branches holds a single commit, "docs: add dependency audit notes," that adds`docs/wfx-audit.md` . In 24 of them, that file is byte for byte the wfx-loot probe file, with git blob hash`ee6e5addfe591923fc385553cb66cf0d25634a6b` (55 bytes). The other one has the same text with Windows line endings, and it's in the PolinRider/GhostActions repo from the previous section.
- **Pushed with the owner's credentials:** Every one of those commits is authored and committed under the repo owner's identity, never as GitHub. That points to a direct push with the owner's credentials, not a pull request from someone else. Author fields can be set by whoever holds the token, though, so it fits the owner, the token holder or someone copying the owner's identity.
- **Inside the probe window:** The commits are dated November 10 from about 13:00 to 22:42 UTC in the first-wave repos, and November 11 from about 05:12 to 08:03 UTC in the second-wave repos. That's the window vendors give for the wfx-loot probe wave.
- **Probe pull requests:** 25 of the 38 owners we searched have wfx-loot probe pull requests on their repos, all dated November 10 to 13. For 12 of the 23 owners whose searches worked, those pull requests sit in the React2STEAL repos. Four owners also have wfx-loot payload-stage commits ("ci: refresh build cache" and "ci: restore") on other repos, dozens each. 16 of our 228 searches errored, and GitHub's commit search only covers default branches, so a zero means we found nothing, not that the account is clean.

Five of the React2STEAL repos also have a branch we can't attribute to either campaign. These branches are named `ci-sync-<6 characters>` (six across the five repos), and each holds one commit, "ci: sync config," dated October 31 and authored under the repo owner's identity. The commit adds an 18-line workflow that prints the repo's secrets into the Actions log, base32-encoded. In all five repos, the React2STEAL scanner had stopped running three days earlier, on October 28, and runs of this new workflow don't show up in their Actions history. Printing base32-encoded secrets to the run log matches a technique documented for wfx-loot, but that's a shared technique, not shared code.

### What the timing shows

The timing shows that React2STEAL and wfx-loot had working access to the same accounts at the same time, and that nobody revoked those tokens in between.

- **Second wave:** The November 11 React2STEAL repos were created at 04:15 UTC, and three of them got a wfx-loot`wfx-docs` branch one to four hours later.
- **Third wave:** 3 of the 4 owners behind the November 14 React2STEAL repos had already been hit by wfx-loot, and their tokens still worked for React2STEAL days later.

So either one operator ran both, or two parties were drawing on the same pool of live tokens. The timing can't tell those apart. What it does show is that these accounts stayed usable through both campaigns, so a token stolen once kept getting used.

Not every React2STEAL repo got the wfx-loot branch. Five of the 8 second-wave repos and 4 of the 26 first-wave repos have none. That matches what we saw across the owners' other repos: wfx-loot either got an account or it didn't, and some owners with dozens of repos have no probes at all. The likeliest explanation is that wfx-loot never had those owners' tokens, or never got around to using them. Either way, a missing `wfx-docs` branch doesn't mean wfx-loot's operator lacks access to that account.

## What this is and isn't

Let's start with what we can confirm with evidence:

- **The same accounts:** Many of the same accounts running React2STEAL are also wfx-loot victims.
- **No shared code:** We checked the React2STEAL scripts on every branch of the 32 repos we cloned for wfx-loot's variable names, file prefixes and exfiltration paths. None of them are there.
- **No shared infrastructure:** wfx-loot's server IPs, Telegram bots and Telegram group don't appear anywhere in those 32 repos, outside the large result files we didn't scan.
- **A separate Telegram setup:** React2STEAL's bot reports to its own private chat, and sending is switched off.
- **Different ways of operating:** wfx-loot deletes its workflow runs and reverts its commits within a minute. React2STEAL leaves its loot in public repos for weeks.

We can't be sure whether one operator or two used these accounts, but these differences tilt us slightly toward separate operations. However one actor can run several tools, and we've seen lots of examples lately of rapid iteration enabled by LLMs, so it's still possible this is one operator.

## If you run React or Next.js

Fixing these flaws usually means a React or Next.js upgrade, and that can take a while to plan and test. So start by finding out whether the scanner already reached you, and reduce your exposure in the meantime.

1. **Check your logs:** Look in request and WAF logs for the`x-middleware-subrequest` header repeated five times, and for`/_next/image?url=` requests pointing at the cloud metadata address.
2. **Rotate and review:** If you find those requests, rotate every secret that server's process could reach (not just the ones that look like keys!) and treat its config files as disclosed, and review usage on any AI provider keys it held. The scanner tests those keys from your own server, so the calls will look like yours.
3. **Block the header at the edge:** Strip or reject the`x-middleware-subrequest` header on incoming requests at your proxy or WAF. That closes off the CVE-2025-29927 bypass until you can upgrade.
4. **Lock down instance metadata:** Enforce IMDSv2, so an SSRF can't simply read instance credentials.

We're handling disclosures to affected organizations separately.

## If you hunt on GitHub

What to learn from this is that a stolen GitHub token doesn't get used just once. These accounts ran a scanner against other people's servers for weeks and carried a wfx-loot probe in the middle of it, and three of them got fresh React2STEAL repos after wfx-loot had already been through. Once a token is out, whoever holds it keeps finding uses for it.

The repo name is the least reliable thing to search for.

1. **Search by content, not name:** Repos can be renamed or deleted, and`ci-wk-<number>` is easy to change. Look for repos holding`batch_output.py` ,`prefilter_nextjs.py` and`fast_recon.js` together.
2. **Look for the wfx-loot probe:** A`wfx-docs` branch, a pull request titled "docs: dependency audit notes," or a`docs/wfx-audit.md` blob with hash`ee6e5addfe591923fc385553cb66cf0d25634a6b` . For wfx-loot payload runs, a missing workflow run number is often the most reliable trace, because the run gets deleted.
3. **Treat a matching account as compromised:** If one of these is your account, revoke your tokens and app grants, and check for repos, branches and workflow runs you didn't create.
4. **Restrict CI egress:** An egress allowlist on CI runners blocks a stealer like wfx-loot from sending secrets out.
5. **Deleting a repo isn't remediation:** Clones, forks, caches and git history can keep the stolen data after a repo is deleted or made private. Every exposed secret still needs to be rotated, and affected organizations should review credential use from the time of compromise onward.

These GitHub code searches match the React2STEAL scripts and results. A single hit on `bissa_cve_boundary` isn't enough on its own, because incident reports and defensive configs contain that string too. Repos that match several of these are much stronger candidates.

```
"Capture FULL env vars for exploitation"
"VULNERABLE_TARGETS_FILE" "send_telegram_document"
"x-middleware-subrequest" "AWS_SESSION_TOKEN" "ssrf_vulnerable"
filename:scan.yml "SCAN_REGISTRY_DB" "git push || true"
filename:fast_recon.js "llm_checks" "writable_paths"
filename:batch_output.py "bissa_cve_boundary"
path:vulnerables "env_vars" "writable_paths" "listening_ports"
```

## Indicators of compromise

### Files

File

Notes

`.github/workflows/scan.yml`

Scanner workflow, triggered by `workflow_dispatch`

`bin/prefilter_nextjs.py`

Next.js prefilter, identical in every repo

`bin/batch_output.py`

Exploit script, identical in every repo, hard-coded Telegram config

`bin/fast_recon.js`

Post-exploitation recon, two variants

### Requests

Indicator

Role

`x-middleware-subrequest` header repeated five times

CVE-2025-29927 attempt

`/_next/image?url=` pointing at the cloud metadata address

SSRF to instance metadata

AI provider API calls originating from your web server

`fast_recon.js` testing harvested keys

`Next-Action: x` header with multipart boundary `bissa_cve_boundary`

React2Shell attempt (one variant randomizes the boundary)

### Git markers

- Repository names matching `ci-wk-<number>`
- Commits authored by `w <w@w>` with`chunk` and`results` messages
- Branch `wfx-docs` with commit "docs: add dependency audit notes"
- `docs/wfx-audit.md` blob`ee6e5addfe591923fc385553cb66cf0d25634a6b`
- Pull requests titled "docs: dependency audit notes"
- wfx-loot payload-stage commits "ci: refresh build cache" and "ci: restore"
- Branches named `ci-sync-<6 characters>` with commit "ci: sync config" (unexplained)
