← ALL POSTS
Investigations·12 min read

eMudhra's compromised CA keys: what happened and how to protect yourself

Eight eMudhra intermediate CA keys turned out to be trivially recoverable. What we know, what is disputed, and what to update across browsers, servers, code and appliances.

Researched and drafted with AI assistance · reviewed by Prince

Developing story — last updated 21 October 2026.

On Saturday 17 October, an independent researcher reported that the private keys behind eight intermediate certificates operated by eMudhra, an Indian certificate authority, could be recovered by anyone from the public certificates. Six of those intermediates could issue TLS certificates trusted by Chrome, Firefox, Safari and Windows; the other two were for code signing and trusted by Microsoft. Browsers blocked them within hours, eMudhra revoked them the next morning, and by 20 October Mozilla and Google had decided to stop trusting the eMudhra root above them altogether. Nobody has reported a forged certificate in the wild. The reason this still matters to you is the long tail: plenty of software doesn’t receive browser-style revocation updates, and it will keep trusting these keys until someone updates its certificate bundle.

We’ve built this from the primary sources and say where they disagree. If you only want the actions, skip to How to protect yourself.

Timeline

All times are UTC. “Confirmed” means a primary source states it; “Reported” means it comes from one party without independent confirmation; “Disputed” means primary sources disagree.

Date and time (UTC)EventStatus
30 Apr 2025The eight intermediates are created in an eMudhra key generation ceremony, part of a batch of 24Confirmed (eMudhra, Mozilla)
14 May 2025Sectigo cross-signs the same eight keys under its AAA Certificate Services rootConfirmed (certificate data on the incident tracker)
17 Oct 2026, 18:05The researcher emails Apple, Chrome, Microsoft, Mozilla and eMudhra with signed proof of key controlConfirmed (Google; researcher’s timeline)
17 Oct, 19:45Chrome ships a CRLSet update blocking the eight keys by public-key hashConfirmed (Google)
17 Oct, 20:06Mozilla receives the report, forwarded by the Chrome Root ProgramConfirmed (Mozilla)
17 Oct, 21:48Mozilla independently recovers the keys without the reporter’s methodConfirmed (Mozilla)
17 Oct, 22:59Firefox’s OneCRL block reaches all users with standard settingsConfirmed (Mozilla)
18 Oct, 09:24–09:38eMudhra revokes all eight intermediates with reason caCompromiseDisputed: eMudhra’s later statement says 19 October
19 OctApple blocks the intermediates; Sectigo revokes its cross-signs; Go 1.27.3 and 1.26.10 ship a denylistApple: Reported (incident tracker). Sectigo, Go: Confirmed
20 OctMicrosoft blocks the intermediatesReported (incident tracker)
20 OctFirefox 158.0.1 and ESR updates, NSS 3.131.1; Ubuntu and Debian ship updated ca-certificatesConfirmed (Mozilla, Canonical, Debian)
20 Oct, 13:06Mozilla announces emergency removal of trust in emSign ECC Root CA - G3; Chrome commits to the sameConfirmed (Mozilla, Google)
20 Oct, 16:27eMudhra stops issuing from every intermediate under that rootConfirmed (eMudhra in Bugzilla)
27 Oct (planned)Chrome’s root removal reaches all devices that rely on the Chrome Root StoreConfirmed as planned (Google)

What went wrong

A P-384 private key is meant to be a random 384-bit number. According to Mozilla’s analysis in the incident bug, all eight affected keys were integers below 256. In other words, the key was almost entirely zeros, and you could find it by simply trying the first 256 possible keys. Mozilla’s engineer reports that local AI agents recovered the keys on their first attempt with a one-line prompt. Google’s description is the same finding in plainer words: the keys were generated with insufficient randomness.

How did that happen inside a certified ceremony? eMudhra says the keys were generated on FIPS 140-2 Level 3 hardware security modules, and that a key wrap and unwrap step in the ceremony procedure produced a second, weak set of keys alongside the intended strong ones. The weak set is what ended up in the published certificates. It went unnoticed for about 18 months and two audit cycles. eMudhra is clear that it has not yet confirmed the exact root cause and will publish it when its investigation finishes. Mozilla notes it could not recover the keys of eMudhra’s other P-384 intermediates from the same batch, and Google says it found no other keys in its root store with the same failure.

Mozilla also points to a 2025 bug in which eMudhra published revocation lists with invalid signatures for exactly these six TLS intermediates, and doubts the overlap is chance. That’s an open question, not a conclusion.

Which certificates, and what each could do

There are eight keys but sixteen certificates, because each key appears in an eMudhra-issued certificate and in a Sectigo cross-signed one. The eMudhra-issued versions sit under two eMudhra roots, emSign Root TLS CA - G3 and emSign Root CS CA - G3, which are themselves chained into the widely trusted emSign ECC Root CA - G3. The Sectigo versions chain to AAA Certificate Services, an older Sectigo root that Mozilla and Chrome had already removed but that Apple and Microsoft still trusted.

IntermediatePurposeOperatorSPKI SHA-256 (first 16 hex)
EM DV TLS CA - G3BTLS (domain validation)eMudhra BVEBED6475C2C2D80F
EM OV TLS CA - G3BTLS (organisation validation)eMudhra BV43BFFA19D6EF6514
EM EV TLS CA - G3BTLS (extended validation)eMudhra BVE0254C7FCDC265E2
EM DV TLS CA - G3CTLS (domain validation)eMudhra Inc49DD353DC2B919A3
EM OV TLS CA - G3CTLS (organisation validation)eMudhra Inc63ECEFEE431D4952
EM EV TLS CA - G3CTLS (extended validation)eMudhra Inc5C0660A2B164910D
EM OV CS CA - G3BCode signingeMudhra BVEC4FFA1AD0AC8808
EM OV CS CA - G3CCode signingeMudhra Inc92C063D67E8F14DB

Mozilla’s bug lists the full fingerprints of all sixteen certificates, and the tracker’s impacted-intermediates.json has the full key hashes. Search with those, not the prefixes above.

What could someone holding these keys do? With a TLS key, they could sign a certificate for any website, and a client that trusts the chain would accept it. With a code-signing key, they could sign software that would chain to a root Windows trusted. Mozilla’s bug is careful on scope: the six TLS intermediates were trusted by all four major root programmes, the two code-signing ones by Microsoft only.

Realistic impact

A forged TLS certificate on its own does nothing. The attacker also needs to sit in the path of your traffic, through a hostile Wi-Fi network, a compromised router or proxy, or DNS hijacking. That makes the realistic threat targeted interception, not mass compromise.

Then there’s Certificate Transparency. According to the reporter’s tracker, Chrome, Firefox, Edge and Safari only accept publicly trusted certificates that have been recorded in public CT logs. Google states that no TLS certificate chaining to the six intermediates was logged before Chrome’s block, so none could have been used against a CT-enforcing client. Google also says it has worked with CT log operators so the logs now reject certificates chaining to these CAs. eMudhra says none of the eight ever issued an end-entity certificate, and that seven were never used in production at all.

The gap is everything that doesn’t enforce CT or consume fast revocation: command-line tools, language runtimes, embedded devices, appliances, and containers built months ago. The reporter’s tracker makes the point directly, and it adds that nobody knows whether anyone exploited the flaw against such clients during the 18 months it existed. Cloudflare says its own review found no active exploitation on its services. Mozilla says several people have since recovered the keys independently, and some disclosed that publicly, so you should assume the keys are available to anyone.

What’s disputed or still unknown

Some early coverage read this as “eMudhra certificates can’t be trusted”. The primary sources are narrower. Eight intermediate keys were weak. Mozilla and Chrome are removing one eMudhra root, emSign ECC Root CA - G3, as a precaution for clients that can’t block individual intermediates, and Mozilla says it is not removing emSign Root CA - G1. eMudhra says most of its TLS certificates chain to other hierarchies and its eSign services are unaffected.

The accounts also differ in detail. eMudhra’s 21 October update describes eight Global TLS intermediates, while Mozilla’s bug and the certificate data show six TLS and two code-signing. eMudhra says it learned of the issue late on 18 October India time and revoked on the 19th; the researcher’s timeline in the bug has eMudhra acknowledging the report at 21:28 UTC on 17 October, and the revocation records are dated 18 October. On scale, eMudhra’s statement mentions one affected customer ecosystem in the United States, while its comment in the bug estimates about 30,000 certificates to migrate, 97% of them issued through ACME. Both can be true. The root cause itself is still unconfirmed.

How to protect yourself

Browsers protected their users within hours, and they’re the easy part. The work is in everything else that verifies TLS with its own copy of the trust list. Here’s how we’d approach it by role.

Everyday users

Update your browser and operating system, and restart them. The major browsers already block these intermediates; Firefox 158.0.1 builds the block in for anyone who’d turned off remote updates, and Firefox for Android needed 158.0.2 to apply it reliably. On Android, Google says a restart pulls the Play Services update straight away. You can test your own browser on the incident tracker’s test page (it’s in the sources below): a certificate error there is the result you want.

System administrators

Update the ca-certificates package everywhere, including hosts you rarely touch. These are the fixed versions published so far:

PlatformFixed version
Ubuntu 22.04, 24.04, 26.04, 26.1020260816ubuntu0.<release>.1 (USN-8944-1)
Ubuntu 14.04 to 20.04Ubuntu Pro (ESM) updates in USN-8944-2, which also remove AAA Certificate Services
Debian 12 (bookworm)20250419~deb12u2 (DLA-4845-1)
Debian 13 (trixie)20250419+deb13u1 (DSA-6572-1)
Mozilla NSS3.131.1
Others (Fedora, Alpine, Arch, Gentoo, Homebrew, Chainguard)see the list on the incident tracker; FreeBSD was still pending on 21 October

On macOS, the browser and system frameworks are protected, but the reporter notes that the built-in curl, git, python3, perl, ruby and openssl read /etc/ssl/cert.pem without checking revocation, and that file hadn’t been updated. Cloudflare saw the same behaviour. The tracker gives a tested workaround; until Apple ships a fix, it’s worth applying on build machines and admin laptops.

Developers

Look below your SDK. Cloudflare’s framing is the right one: an API client may hand certificate checks to an HTTP library, a language runtime, the operating system or its own bundle, so updating the SDK alone may change nothing.

For Go, upgrade to 1.27.3 or 1.26.10 and rebuild. The fix (CVE-2026-111943) is a denylist inside crypto/x509, so an old binary stays exposed until it’s rebuilt. For Python, update certifi to 2026.10.19 or later. Node.js 22.23.4, 24.22.1 and 26.12.1 move their bundled roots to NSS 3.131.1. We found no JDK advisory in the sources we checked, so look in your JDK’s cacerts for emSign ECC Root CA - G3 and AAA Certificate Services yourself, and check Rust, Electron, Composer and the rest against the tracker’s list.

Containers and appliances are the trap. A CA bundle baked into an image is frozen at build time, so rebuild from updated base layers and redeploy, and ask your load balancer, proxy and VPN vendors when they’ll ship an updated trust store. If the updates start throwing certificate errors, don’t fix them by turning verification off. That removes exactly the protection you’re adding.

Enterprises

Your organisation probably has trust stores nobody owns, and the TLS inspection proxy is the one to start with: it validates the real server certificate on your users’ behalf, so its trust store decides what your users trust. Then push updated bundles to MDM-managed devices and check custom root lists in configuration profiles and group policy. If anything pins to emSign ECC Root CA - G3 or AAA Certificate Services, plan to re-pin; and if you remove AAA by hand, as the tracker’s workarounds do, test first, because anything still relying on it will stop validating. The two code-signing intermediates were trusted only on Windows, and eMudhra says they issued nothing, so the practical step is to confirm Windows hosts have Microsoft’s 20 October trust updates.

How to check your exposure

First, find the keys. Compute the public-key hash of each certificate in a trust store or chain and compare it with the eight full hashes in the tracker’s JSON:

BASH
openssl x509 -in cert.pem -noout -pubkey | openssl pkey -pubin -outform DER | openssl dgst -sha256

Then look outward. Search Certificate Transparency (crt.sh, or a monitoring service) for certificates issued for your own domains and check that every issuer is one you expect. Review TLS inspection and proxy logs for any connection whose chain included one of the sixteen certificates. Finally, test the actual verification path: point each important client at the reporter’s test hosts. A browser passing tells you nothing about a background service using a different library.

A prevention checklist

  1. Update CA bundles on a schedule, not just when there’s news, and include them in patch reporting.
  2. Inventory every trust store you own: operating systems, language runtimes, containers, appliances, proxies and MDM profiles.
  3. Monitor Certificate Transparency for your domains, and alert on any issuer you don’t use.
  4. Publish CAA records naming the CAs you use.
  5. Avoid hard-pinning to a single CA or root; pin with a backup, or don’t pin.
  6. Keep a CA-distrust runbook: who updates what, how you rebuild images, and how you test.

Be clear about what those last steps can and can’t do. CAA is checked by a CA before it issues; RFC 8659 says clients must not use it to validate certificates, and it doesn’t stop mis-issuance by an authorised CA. Someone holding a CA’s private key can sign a certificate without going near that check, so CAA wouldn’t have helped here. CT monitoring still earns its place, because CT-enforcing browsers only accept certificates that appear in public logs, as Google’s and the reporter’s accounts both rely on. A forged certificate used against those browsers has to be logged, and a monitor watching your domains would see it.

Lessons for PKI operators

A few lessons follow from the sources, and they’re practical rather than moral. Mozilla’s analysis shows the weakness was visible in the public certificates themselves; our reading is that an automated sanity check of every new public key before publication would have caught it. Google could block by public key rather than by certificate, which the sixteen-certificate tail of cross-signs shows is worth having. And protection reached two browsers in under three hours because their root programmes already had a reporting channel and a way to push revocations without a software release.

eMudhra has said it will publish its root cause and review every step of its key ceremonies. We’ll update this post when that report appears.

Sources

  1. Protecting Firefox users following the compromise of eMudhra intermediate certificates — Mozilla Security Blog · accessed
  2. Bug 2083449: Private key compromise of eMudhra Intermediate Certificates — Mozilla Bugzilla · accessed
  3. Protecting Chrome and Android Users from Compromised eMudhra Intermediate CA Certificates — Google Chrome and Android Security Teams · accessed
  4. eMudhra Statement on Recent Certificate Security Incident — eMudhra · accessed
  5. eMudhra Intermediate CA Compromise — Dennis Jackson (incident tracker) · accessed
  6. 8 eMudhra certificates are compromised. Here's what you need to know — Cloudflare · accessed
  7. MFSA 2026-111: Security Vulnerabilities fixed in Firefox 158.0.1 — Mozilla · accessed
  8. CVE-2026-113470 — CVE Program (Mozilla) · accessed
  9. CVE-2026-111943: Distrust compromised intermediate certificates in crypto/x509 — CVE Program (Go) · accessed
  10. Go release history (go1.27.3, go1.26.10) — The Go Project · accessed
  11. USN-8944-1: ca-certificates update — Canonical · accessed
  12. USN-8944-2: ca-certificates update — Canonical · accessed
  13. DSA-6572-1: ca-certificates security update — Debian · accessed
  14. DLA-4845-1: ca-certificates security update — Debian LTS · accessed
  15. Node.js v24.22.1 release notes — Node.js · accessed
  16. RFC 8659: DNS Certification Authority Authorization (CAA) Resource Record — IETF · accessed
  • pki
  • certificate-authority
  • tls
  • incident-analysis
  • trust-stores

Keep reading

Investigations12 min read

Qilin ransomware: a profile for Gulf leaders, and what to do in 30 days

Investigations12 min read

OpenAI's AI agents and the Hugging Face intrusion: a technical breakdown

Advisories10 min read

FreeSWITCH CVE-2026-116779: one SIP message can run commands, and it is exploited