evilgrade 2026: 225 Modules Meet a Leaked eMudhra CA

November 15, 2026
evilgrade 2026

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/hosts edit, 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:

  1. Modernize the framework — recursive module loader, a selectable SSL cert per demo, core cleanup.
  2. 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’s PERL5LIB broke the system interpreter under sudo — handled with env -u in 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, and setup.py runs at build time. A bare pip install evilpkg with DNS pointed at pypi.org is enough. Vulnerable: pip whose certifi bundle still carries AAA — stock macOS /usr/bin/python3, plenty of distro/corporate Pythons. Not: a pip whose certifi already 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 to setup.py. Nothing runs on clone; it triggers on the habitual next step. Vulnerable: git on the OpenSSL backend (Homebrew, Linux, or forced via http.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-certificates had already removed AAA; its own curl/openssl reject the leaf. We’d written homebrew_update.pm and 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-url shortcut — corrected. An early pip demo pointed --index-url at evilgrade, which inflated the success feeling (no victim types that). A later commit moved it to the realistic :443 + DNS-spoof flow with a bare pip 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.

ToolContent 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/pip bundles. Fixing the system store doesn’t fix a Python whose bundled roots still carry AAA. Pin or refresh certifi, prefer wheels, use a hash-pinned lockfile.
  • Treat curl | sh as 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

Continue Reading

The latest handpicked blog articles

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

November 15, 2026

Participamos de un encuentro del Posgrado en Gestión Estratégica de la Ciberseguridad de la Universidad del CEMA, donde Marcos Carabajal, CRO de Faraday, compartió una mirada sobre los desafíos actuales

November 2, 2026

Not every workspace carries the same risk. A critical finding in a staging environment doesn’t weigh the same as one in a production system that runs your business, yet most

October 30, 2026

Stay Informed, Subscribe to Our Newsletter

Enter your email and never miss timely alerts and security guidance from the experts at Faraday.

Faraday provides a smarter way for Large Enterprises, MSSPs, and Application Security Teams to get more from their existing security ecosystem.

Headquarters

Research Lab & Dev

Solutions

Open Source

© 2025 Faraday Security. All rights reserved.
Terms and Conditions | Privacy Policy