A research log. We modernized evilgrade — 225 modules, a recursive loader, a selectable SSL cert — and used the October 2026 eMudhra CA compromise as the test case to point it at what actually matters today: the software install channel, not the auto-updater. The honest headline up front: as a real-world attack, this is narrow. It needs an on-path position, a client whose trust store still trusts the cross-signing root, and an install channel with no second signature — and macOS had closed most of it before we finished. The value wasn’t a big exploit. It was drawing the exact line between where a TLS-only attack works and where it doesn’t, and shipping an updated tool that lets defenders check which side they’re on.
Let’s set expectations first
If you came for a sky-is-falling story, this isn’t one. Here’s the honest blast radius of the eMudhra-based attack we built, stated before any of the fun details:
- It needs an active on-path or DNS position — not a lab
/etc/hostsedit, a real MITM. That’s already a high bar. - It only works against clients whose trust store still contains the cross-signing root (AAA Certificate Services) and hasn’t applied the eMudhra distrust. Browsers were protected the day after the leak; macOS command-line tools were fully fixed on Nov 9 (more below).
- It only works on install channels with no second integrity layer — and a lot of the ecosystem has one.
So the surviving real-world surface is a slice: unpatched machines, some Linux clients, and tools shipping their own stale root bundle. Small. We think the research is worth writing up anyway, precisely because mapping a small attack honestly is more useful than inflating it — and because evilgrade needed the modernization regardless.
What we actually set out to do
evilgrade made its name attacking auto-update mechanisms: MITM the “check for updates” call, serve a malicious “new version.” Still valid, but it assumes the target runs an updater with a weak check. We wanted to move the lens to the channel every build, CI run, and laptop setup leans on today — how software gets installed in the first place — and to measure, honestly, which install idioms are exploitable by default and which aren’t.
The work lived on a branch (feature/modern-update-modules, 11 commits) with two goals:
- Modernize the framework — recursive module loader, a selectable SSL cert per demo, core cleanup.
- Re-aim at the install channel —
pip,git clone,curl | sh— and write down the scope truthfully.
The organizing idea: in 2026 the weak link usually isn’t the updater, it’s the TLS trust decision an installer makes when a trusted intermediate CA is compromised.
The framework work (the part that’s just engineering)
- Recursive module loader (
main.pm): modules used to live flat; they now load from subdirectories (modules/linux/,modules/macos/,modules/package_managers/). - Selectable SSL cert (
set sslcert <dir>): choose the cert/key pair per demo (certs/emudhra_mitm,certs/selfsigned,certs/emudhra_authorized) instead of a hardcoded cert — so a demo can switch between a self-signed cert that should trip alarms and a chain that, against an un-distrusted store, doesn’t. - Static-dir request type in the webserver (
webserver.pm): serves a tree of static files, which let us serve a dumb-HTTP git repo with no git backend. - Robustness fixes in the demo runners: poll the bind instead of a fixed
sleep, and a fix for a Perl ABI mismatch (the shell’sPERL5LIBbroke the system interpreter undersudo— handled withenv -uin the runners).
None of that is dramatic. It’s the plumbing that makes the rest reproducible.
The conceptual pivot: a real compromised CA, not a planted one
The unrealistic way to demo this is to first inject a CA into the victim’s trust store. Nobody’s threat model cares — if you can do that, it’s already over.
The honest version: present a leaf signed by a real, leaked eMudhra intermediate (EM DV TLS CA - G3C) that cross-chains to the public AAA Certificate Services root. The intermediate’s private key is the one that leaked. So the chain validates against any store that still trusts AAA and hasn’t applied the eMudhra distrust — with nothing touched on the client. No --cert, no flag, no planted root. That’s what moves it from “theoretical, with preconditions” to “default-exploitable on a concrete, shrinking slice of clients.”
The research diary: what worked
Each module documents the mechanism and who is actually vulnerable. The scoping is the point.
pip install—pypi_update.pm. PyPI dropped PGP signatures for sdists in 2023, so sdist integrity is now TLS plus trust-on-first-use, andsetup.pyruns at build time. A barepip install evilpkgwith DNS pointed atpypi.orgis enough. Vulnerable: pip whosecertifibundle still carries AAA — stock macOS/usr/bin/python3, plenty of distro/corporate Pythons. Not: a pip whosecertifialready removed AAA. This depends on the client’s bundle age, not on anything the attacker picks.curl | sh—curlbash_installer.pm. The most common install idiom on earth, with zero integrity below TLS. We built the payload as a faithful two-stage preinstaller: stage 1 (ours) runs, then stage 2 pulls the genuine installer from the real CDN (which we don’t intercept), so the victim ends up with a working tool. In the published demo, stage 2 just runs--version— proof it fetched the real binary without shipping a weaponized flow.git clone+pip install .—git_clone_faraday.pm. We serve a real source tree over dumb-HTTP with a reverse shell prepended tosetup.py. Nothing runs on clone; it triggers on the habitual next step. Vulnerable: git on the OpenSSL backend (Homebrew, Linux, or forced viahttp.sslBackend=openssl).
The research diary: what didn’t work (the useful half)
The real output was the list of “obvious” vectors that are not exploitable by default. Two commits exist just to record it (drop Homebrew/git — not exploitable, honest scoping).
- Homebrew — dropped. Homebrew’s
ca-certificateshad already removed AAA; its owncurl/opensslreject the leaf. We’d writtenhomebrew_update.pmand an installer include, then deleted both — they implied an exploitability that didn’t exist by default. - Apple Secure Transport — immune. macOS blocked the eMudhra intermediates for framework-based validation on 2026-10-19, so Apple’s
/usr/bin/git(Secure Transport) rejects the MITM. The git vector only works on the OpenSSL backend. Documented as a transport caveat, not hidden. - pip is not “always” vulnerable. It’s the client’s
certifi, not an attacker flag. The module header says who falls and who doesn’t. - The dishonest
--index-urlshortcut — corrected. An early pip demo pointed--index-urlat evilgrade, which inflated the success feeling (no victim types that). A later commit moved it to the realistic:443+ DNS-spoof flow with a barepip install. - Second-signature vectors — out of scope by design.
apt/yum(GPG), Go modules (GOSUMDB), signed Terraform providers (GPG + lockfile) don’t fall to TLS alone — there’s a second signature to forge. The TLS-only attack works exactly where that layer is absent.
That’s the whole finding, in one sentence: a TLS-only attack is default-exploitable only where there’s no second signature and the store still trusts the root — curl | sh, pip (post-2023), git clone+build — and not where the ecosystem moved the trust store (Homebrew, Apple) or kept an independent signature (apt/yum, Go). Both halves are the result.
The whole surface, tool by tool
Two things decide each row. Premise A is the attacker’s side: an on-path position presenting the leaked-but-still-trusted eMudhra chain, so TLS validates with nothing touched on the client. Layer B is the defender’s side: a content signature on the artifact itself, independent of TLS. Where Layer B is missing, premise A alone is enough for code execution; where it exists, the attacker would also have to forge that signature, and the attack is blocked.
| Tool | Content signature (Layer B)? | Honest RCE under premise A? |
|---|---|---|
pip (PyPI) | ❌ None — PyPI dropped PGP signatures in 2023 | ✅ Yes — the cleanest |
npm install | ❌ Not verified on install by default; postinstall runs | ✅ Yes |
gem / composer / helm | ❌ Optional, off by default | ✅ Yes |
curl | bash (rustup, nvm, get.docker.com, Homebrew installer…) | ❌ TLS only, by design | ✅ Yes — the purest |
apt / yum / dnf | ✅ GPG by default | ❌ Blocked |
go modules | ✅ GOSUMDB | ❌ Blocked |
| Terraform providers | ✅ GPG + lockfile | ❌ Blocked |
The pattern is the point: the green column on the left is the red column on the right. A second signature is the whole difference between an install channel that trusts whoever holds the cert and one that doesn’t.
The macOS window, and why it’s largely closed
Being exact here, because an earlier draft of this post overstated it:
- Oct 18 — the eMudhra intermediates are revoked (recoverable private keys).
- Oct 19 — Apple blocks them for Safari, Mail, and anything on its security frameworks. Browsers safe without a macOS update.
- Oct 26 — macOS 27.2 did not fix the command-line path, and reverted manual /etc/ssl/cert.pem edits some admins had applied.
- Nov 9 — macOS 27.2.1 (and 26.7.3, 15.8.3) closed it. Per Apple’s advisory: “Starting in macOS 27.2.1, these command-line tools stop accepting these certificates.” It also removed five root CAs from /etc/ssl/cert.pem — including AAA Certificate Services, the cross-sign our chain relied on. On a patched Mac, that path is simply gone.
So the macOS system-tool window was open for about three weeks and is shut. What remains after the patch is narrow but real: tools that ship their own root list (Apple is explicit — “Some apps and tools include their own list of root CA certificates and don’t use Apple’s block or /etc/ssl/cert.pem… contact the developer”), which is exactly pip/certifi with an older bundle; plus any unpatched fleet and Linux clients whose distro ca-certificates still ships AAA.
Credit where it’s due
We surfaced this while rebuilding evilgrade, not before it, and we’re not claiming the discovery. Others flagged it publicly first: International Cyber Digest (@IntCyberDigest) warned that git, curl and python3 on macOS still trusted the compromised certs after Apple was told, and Corey Quinn (@QuinnyPig) noted the 27.2 update “ROLLED BACK the eMudhra cert removal from /etc/ssl/.” Two independent voices landing on the same facts is what told us it was worth measuring carefully rather than loudly.
The actual news: evilgrade 2026
The thing worth announcing isn’t the attack — it’s that the tool is current again:
- 225 implemented modules, 275+ documented CVEs (2018–2026), across 18 categories — OS updaters, browsers, enterprise apps, dev tools, IoT/firmware, security/VPN, package managers (npm, PyPI, Maven, Cargo, RubyGems…), and AI/ML (Hugging Face, PyTorch, TensorFlow).
- A recursive module loader and an automated generator, so coverage grows as install systems ship new footguns.
- A selectable SSL cert per module, so you can demonstrate the difference between a cert that trips alarms and a chain that doesn’t.
Use it the way it’s meant to be used — authorized only: pentests with permission, bug bounty, research, disclosure.
A short history
evilgrade isn’t new. Francisco Amato released it as ISR-evilgrade in July 2008 — the Full Disclosure post was titled “Using DNS cache poisoning to exploit poor update implementations.” The premise: software checked for updates over channels that trusted whatever answered, so redirecting a victim’s DNS turned “check for updates” into “install this.” Dan Kaminsky’s DNS flaw made that redirect trivial at internet scale, and he referenced evilgrade in his Black Hat USA 2008 talk; HD Moore’s reaction was a Metasploit post titled “Evilgrade Will Destroy Us All,” and Brian Krebs wrote it up for the Washington Post after interviewing Amato.
Version 2.0 followed in October 2010 (63 modules, DEF CON 18); written in Perl and open source, it moved under Faraday Security Research. The 2026 rebuild keeps the idea and moves the target — from the auto-updater to the install channel, and from a planted CA to a real leaked one. Eighteen years on, the premise hasn’t changed: software still trusts whoever holds the cert.
If you want to harden against this class (modest, not urgent)
The attack is small, but the structural weakness — install channels that make a single TLS trust decision — is worth a second opinion that doesn’t rest on one CA:
- Patch macOS (27.2.1 / 26.7.3 / 15.8.3). A macOS update can replace
cert.pem, so don’t restore a pre-update backup over it. - Check your
certifi/pipbundles. Fixing the system store doesn’t fix a Python whose bundled roots still carry AAA. Pin or refreshcertifi, prefer wheels, use a hash-pinned lockfile. - Treat
curl | shas structurally fragile. Where you can’t avoid it, pin the host’s cert/pubkey, or fetch-verify-then-run against an independent checksum instead of piping to a shell. - Prefer channels with a second signature — GPG-signed repos, Go’s checksum DB, signed artifacts. They’re the ones that didn’t fall here.
Want to see where your install and update tooling makes a one-CA trust decision — and prove which side of the line it’s on? Faraday · evilgrade on GitHub →
Sources: Apple — About the compromised eMudhra intermediate CAs (HT149555) · 9to5Mac — Today’s macOS updates fix the eMudhra gap · MacRumors — macOS 27.2.1 fixes the eMudhra flaw in command-line tools · Mozilla Bugzilla 2083449

