Quick Answer
The ChainDrop npm worm struck on August 4, 2026, poisoning 444 packages and 2,212 versions in under four hours by compromising the GitHub account of a keyv maintainer. The payload steals npm tokens, cloud credentials, and CI/CD secrets, then self-replicates. Any developer whose environment installed affected packages during that window should treat every credential as compromised and rotate them immediately.
Key Takeaways
- 444 packages and 2,212 versions were poisoned in under four hours on August 4, 2026, according to StepSecurity’s analysis as of 18:10 UTC that day.
- Patient zero was [email protected], a caching library with over 150 million weekly downloads; flat-cache and file-entry-cache were also among the earliest and most-downloaded victims.
- The payload self-propagates by using stolen npm tokens to enumerate and republish every package the victim can publish, without requiring any further attacker action.
- ChainDrop uses EtherHiding, resolving its command-and-control server address from an Ethereum smart contract rather than a hardcoded domain, which defeats standard domain-blocklist defenses.
- Treat any machine that ran npm install on an affected version as fully compromised and rotate all npm tokens, GitHub tokens, cloud credentials, SSH keys, and CI/CD secrets immediately.
What Is the ChainDrop npm Worm and When Did It Hit?
On August 4, 2026 (UTC), a self-propagating supply chain worm called ChainDrop spread through the npm registry, poisoning 444 packages and 2,212 versions across more than a dozen victim organizations in under four hours. The packages affected include some of the most widely depended-upon utilities in the JavaScript ecosystem, which is what makes this incident unusually severe compared with typical malicious-package discoveries.
Researchers named the campaign ChainDrop rather than treating it as a standard Shai-Hulud variant because this version uses the Ethereum blockchain for command and control, a technique known as EtherHiding. Security researchers trace the ChainDrop payload back to the Shai-Hulud malware family, the same lineage behind the Mini Shai-Hulud campaign that hit TanStack, Mistral AI, and OpenSearch packages in May 2026. The August 4 wave is a meaningfully upgraded iteration, not a simple rerun of earlier attacks.
Which npm Packages Were Compromised?
The confirmed high-download victims include [email protected] (over 150 million weekly downloads), [email protected] (149.9 million), and [email protected] (147.6 million). Those three packages sit inside a large share of the JavaScript ecosystem, from ESLint, which depends on flat-cache and file-entry-cache, to everything built on cache-manager and cacheable.
The reach of the compromise is significant: keyv alone received over 600 million downloads in the prior month, with related packages compounding the exposure, including flat-cache at near 580 million, cacheable-request at over 137 million, cacheable at over 30 million, and cache-manager at over 16 million monthly downloads. All told, Aikido Security warned that 444 packages across 1,381 versions were compromised, with a combined total of more than two billion monthly downloads.
The table below summarizes the highest-download packages confirmed as directly affected, based on data from StepSecurity, Elastic Security Labs, and Aikido Security as of August 4, 2026 at 18:10 UTC. The list is likely incomplete, as the campaign was still ongoing at that time.
| Package | Confirmed Malicious Version | Approx. Weekly Downloads | Notable Dependents |
|---|---|---|---|
| keyv | 6.0.0 | 150M+ | cache-manager, cacheable |
| flat-cache | 6.1.24 | 149.9M | ESLint |
| file-entry-cache | 11.1.6 | 147.6M | ESLint |
| cacheable | Versions published on/after Aug 4 | 30M+/month | cache-manager |
| cacheable-request | Versions published on/after Aug 4 | 137M+/month | got, node-fetch wrappers |
Packages associated with Deliveroo, Ornikar, OneReach, Picsart, and Qlik were also compromised as part of the campaign. Developers at those organizations and at any project that installed any of the affected packages during the exposure window should assume their build environments were exposed.
How Did ChainDrop Infect the npm Registry?
On August 4, 2026, attackers compromised the GitHub account of a maintainer behind keyv, cacheable, flat-cache, and file-entry-cache, pushed malicious code directly to the main branch, and triggered the maintainer’s own GitHub Actions pipelines to build and publish infected versions straight to the npm registry, complete with valid digital signatures. This is the mechanism that made ChainDrop particularly difficult to detect on arrival: the poisoned versions carried legitimate provenance.
The attacker did not forge a signature. They compromised a maintainer’s GitHub account, pushed a poisoned commit, and let the project’s own release workflow sign the malware for them. Every attestation was real. The malicious versions carried valid SLSA provenance and Sigstore attestations, meaning they were cryptographically indistinguishable from authorized builds. Security tooling that relies on provenance verification as a trust signal would not have flagged these versions at install time.
Once a developer or CI/CD system ran npm install on an affected package, a hidden preinstall script called setup.mjs kicked off automatically. To dodge detection, it downloaded a temporary Bun runtime executable, which then ran a heavily obfuscated payload named Math_Symbol.js. That payload is an aggressive credential harvester. The preinstall hook executes before the package installation completes, with the full privileges of whoever ran npm install.
What Does the ChainDrop Payload Actually Steal?
ChainDrop is designed to steal various sensitive developer data and credentials, potentially exposing developer workstations, continuous integration pipelines, cloud environments, and downstream software users across numerous organizations. The credential sweep is broad rather than narrowly targeted.
Previous Shai-Hulud waves grabbed SSH keys, ~/.aws credentials, npm tokens, Vault secrets, Kubernetes secrets, and GitHub Actions runner secrets scraped straight out of /proc/<pid>/mem. ChainDrop retains all of those targets. The worm also injects configuration files for Claude (.claude) and VS Code (.vscode) so that it persists and spreads when developers share or sync their configuration, a technique aimed at reaching both human developers and AI coding agents that consume the same project metadata.
Once the credential sweep is complete, the payload packages what it found before sending anything. The stolen data is gzip-compressed and then encrypted with a randomly generated AES-256-GCM key. That AES key is then RSA-encrypted with the attacker’s hardcoded public key, meaning only the attacker who holds the corresponding private key can decrypt the data. This encryption design makes the exfiltrated bundle unreadable to anyone who intercepts it in transit.
How Does ChainDrop Self-Propagate Across the npm Registry?
The worm component activates when the credential sweep turns up an npm token, but only if that token meets 2 specific requirements: package write permissions and the ability to publish without two-factor authentication. Once a qualifying token is found, the worm enumerates every package the victim has publish rights to. After stealing credentials, it authenticates to npm, enumerates all packages the compromised identity can publish, and then republishes each one with the same preinstall hook.
The only mechanism that explains synchronized, cross-organization publication of an identical payload by each victim’s own credentials is automated propagation: credentials harvested on one victim’s machine or CI runner are used by the payload’s own publishing engine to infect every package the next victim can publish. Per Semgrep’s analysis, the worm jumped between organizations every two to seven minutes, hitting scopes including @servicetitan, @qlik, @nebula.js, and @ornikar.
ChainDrop also installed a host-level kill switch that checked the GitHub API every 60 seconds using the stolen token, and if the token stopped working, it deleted its state and exited. It also self-destructed after 24 hours, complicating forensic analysis. This behavior is important for incident response: rotating credentials quickly is the right move, but it may also trigger the kill switch and erase local forensic evidence before a full investigation is complete. Preserve disk images and memory captures before rotating tokens if your organization needs to conduct a thorough post-incident review, and consult your security team or a forensic specialist before taking that step.
How Does ChainDrop’s Ethereum Command-and-Control Work?
ChainDrop does not hardcode a command-and-control domain. Instead, it queries an Ethereum smart contract at address 0xE1f2395ee43e45A1556EC6438a88c31B83493103 to retrieve the current exfiltration endpoint at runtime. The practical effect is that the attacker can rotate C2 infrastructure by updating the smart contract without touching the payload. This defeats domain-based blocklists because there is no fixed domain to block.
The contract emits no events, so domain rotation is a silent state write. Defenders who block today’s domain may not notice when the operator changes it unless they are polling the contract. The worm rotates through roughly 60 public Ethereum RPC endpoints until one answers, making it resilient to any single provider blocking the request. If the contract discovery fails, ChainDrop searches GitHub commit history for a cryptographically signed marker (“thebeautifulmarchoftime”) and accepts a C2 domain only after validating it against an embedded RSA public key.
Late on August 4, 2026, researchers observed the adversary silently reconfiguring the worm’s entire C2 infrastructure through a single Ethereum transaction, without requiring any update to the deployed malware. That live demonstration of blockchain-based C2 rotation is a meaningful escalation in attacker infrastructure technique, and Microsoft and Wiz Security both published analysis of the campaign, including indicators of compromise and mitigation advice.
What Should Developers Do Right Now?
If your environment ran npm install between approximately 09:35 and 13:20 UTC on August 4, 2026, treat every credential that was present in that environment as compromised. The steps below follow the remediation guidance from StepSecurity, Elastic Security Labs, Expel, and Palo Alto Networks Unit 42. Work through them in order, and stop to contact your organization’s security team or a qualified incident response firm before making changes to production infrastructure or forensic evidence.
- Audit your lockfiles first. Check your lockfiles (package-lock.json, yarn.lock, and pnpm-lock.yaml) for any of the affected packages and versions, including transitive dependencies. If any match is present, assume compromise and treat any machine or CI runner that installed those versions as compromised.
- Rotate all credentials immediately. Rotate all credentials, tokens, and secrets that were present in affected environments, including npm tokens, cloud credentials, SSH keys, and CI/CD secrets.
- Review CI/CD pipeline activity. Review unexpected npm publishing and GitHub repository activity, and revoke and rotate any potentially exposed npm, GitHub, cloud, SSH, and automation credentials.
- Check for persistence artifacts. The payload installs a token monitor at ~/.local/bin/gh-token-monitor.sh plus a systemd user service or a macOS LaunchAgent that polls api.github.com/user every 60 seconds. Remove these files and disable any related services.
- Revert to known clean versions or pin dependencies. Scan projects, CI/CD pipelines, and local environments for references to affected package versions in package-lock.json, yarn.lock, or pnpm-lock.yaml, then revert to known clean versions or pin dependencies.
- Consult a professional for production or high-sensitivity environments. If your organization publishes npm packages, operates public-facing services, or handles sensitive user data, engage a qualified incident response team. Do not attempt solo forensic analysis of a potentially compromised CI/CD system without professional guidance, as improper steps can destroy evidence or trigger additional payload activity.
For the full affected package list and indicators of compromise, see the StepSecurity ChainDrop analysis, the Elastic Security Labs technical breakdown, the Palo Alto Networks Unit 42 report, and the Microsoft Security Blog analysis. These are the primary technical sources for this incident and are updated as new information becomes available.
For related coverage of software supply chain and developer-environment security risks, see The Fake CAPTCHA Scam: How ‘Verify You’re Human’ Installs Malware and The ‘AI Worm’ in Microsoft Word: What It Is and How to Stay Safe. For context on why AI-assistant credential targeting matters, see How to Remove AI From Windows 11 (and What You Still Can’t). To compare tools that check whether your code actually reaches a vulnerable dependency, see Aikido vs Cycode.
FAQ
Is ChainDrop the same as the Shai-Hulud worm?
ChainDrop is a heavily evolved descendant of the Shai-Hulud 2.0 worm, now with an Ethereum blockchain command-and-control system using EtherHiding, analyst-proof encrypted exfiltration, and additional persistence mechanisms. The ChainDrop worm is clearly part of the Shai-Hulud code lineage, but researchers cannot yet confirm whether it is operated by the group known as TeamPCP or by another group adapting the published toolkit for their own purposes.
Did the poisoned packages have valid digital signatures?
The poisoned versions were published to npm with valid provenance signed by GitHub Actions, because the attacker used the compromised maintainer’s own publishing pipeline. The malicious versions carried valid SLSA provenance and Sigstore attestations, making them cryptographically indistinguishable from authorized builds. Provenance signatures confirm build origin, not whether the build was authorized by the account’s legitimate owner.
Was keyv the only starting point for the infection?
Patient zero was [email protected], a caching library pulling 153.7 million weekly downloads, published at exactly 09:35:00Z through a legitimate, OIDC-authenticated trusted-publishing workflow. The attackers took over a maintainer’s GitHub account and pushed malicious code to the main branch, then let a preinstall script steal npm, GitHub, cloud, and CI/CD credentials on every npm install. The worm then used those stolen credentials to spread autonomously to every other package that maintainer could publish.
Can I trust the npm provenance system after ChainDrop?
Npm provenance still serves its stated purpose of verifying that a package was built from a specific repository at a specific commit. What ChainDrop demonstrates is that provenance does not verify whether the account that initiated that build was under the legitimate owner’s control at the time. Attackers trojanized the monorepo and embedded a self-propagating worm that used stolen npm credentials to automatically backdoor every other package the maintainer had publish rights to, all while generating fully valid provenance records. Provenance is a useful signal but not a complete trust guarantee.
What does ChainDrop targeting AI coding tools mean for developers?
ChainDrop uses stolen npm tokens and GitHub credentials to infect more repositories, and it injects configuration files for Claude (.claude) and VS Code (.vscode) so that the worm persists and spreads when developers share or sync their configuration, a technique aimed at reaching both human developers and AI coding agents that consume the same project metadata. Developers who use AI coding assistants connected to their project directories should check for unexpected changes to .claude or .vscode configuration files and treat any such changes during the exposure window as a potential persistence artifact. For related context, see That ‘Free ChatGPT’ App Might Be a Scam: How to Spot Fakes and Android’s Sideloading Rules Are Changing: What It Means for You.
