DNS Benchmark ProReal-time DoH latency analysis

Tech Infrastructure

Tech Infrastructure Shaken: Eight eMudhra CA Keys Cracked

By Nattapong Sukkasem · Published · Updated .

TL;DR — Eight eMudhra intermediate certificate authority keys were never stolen. They were generated with so little randomness that anyone holding the public certificate can derive the private key, and one of them turned out to be the number 4. Root programs at Mozilla, Chrome, Apple and Microsoft blocked the certificates between 17 and 20 October, and Go, Node.js, NSS, certifi, Debian, Ubuntu and Cloudflare have all shipped fixes. The uncomfortable part of this tech infrastructure failure is what it says about the eighteen months before anyone noticed.

A certificate authority's private key is meant to be the one number in the tech infrastructure of the public web that nobody else can hold. On 17 October a researcher credited only as “Wayne” demonstrated otherwise, sending the browser root programs a message signed with each of eight eMudhra intermediate keys. Security researcher Scott Helme then recovered all eight from the public certificates in, by his account, under a second. The published values are small integers — 4, 56 and 115 from Helme, with other researchers reporting 66, 155, 156, 230 and 237 — where a P-384 private key should be an unguessable number drawn from a space of roughly 10115.

The Bengaluru skyline at night, home city of certificate authority eMudhra, whose compromised CA keys triggered emergency tech infrastructure fixes across browsers
Bengaluru, where eMudhra is headquartered. The Indian certificate authority says it has issued more than 60 million certificates; the affected intermediates were created in a single key ceremony in April 2025.

What actually failed

eMudhra's own account is that a flaw in its 30 April 2025 key ceremony produced a second, weak key set alongside the intended strong one, and that the weak set was the one submitted to the browser root stores. Its root-cause investigation is still running. The company says its infrastructure was not breached, that only one of the eight intermediates was ever deployed in production, that none of them issued end-entity certificates, and that its global TLS business is about one per cent of revenue. It filed a statement with the BSE on 21 October.

ItemDetail
Reported byA researcher credited as “Wayne”, 17 October, with a message signed by each of the eight keys
AffectedSix TLS intermediates (EM DV / OV / EV TLS CA - G3B and - G3C) and two code-signing intermediates (EM OV CS CA - G3B, - G3C)
RootThe six TLS intermediates chain to emSign ECC Root CA - G3; each also exists as a Sectigo cross-sign under AAA Certificate Services
CauseInsufficient entropy during key generation — the private keys are computable from the public certificates
Response timeChrome had a CRLSet block live 1h40m after receiving the report; Mozilla reproduced the key recovery independently inside two hours
Evidence of abuseNone established. Chrome found no certificate chaining to the six TLS intermediates in Certificate Transparency before the block; CERT-In (CIAD-2026-0050) says public disclosures do not establish confirmed malicious use

Not a stolen key, and not a zero-day vulnerability

It is worth being precise about which trust layer broke, because it is not the one the industry spent early October worrying about. When a registry or a domain is hijacked, an attacker abuses the issuance path: they convince a CA that they control a name, and a certificate is issued to them. CAA records, registry lock and domain-control validation all sit on that path. Possession of an intermediate's private key skips it entirely. There is no request, no validation, no CA involvement and no issuance record — just a signature. Nor is there a zero-day vulnerability anywhere in this story. No software was exploited. The certificates were valid, correctly formed and trusted; the arithmetic behind them was simply wrong.

The eMudhra certificate authority logo, the Indian CA whose eight weak intermediate keys forced emergency root store updates across tech infrastructure
eMudhra, the Indian certificate authority at the centre of the incident. India's Ministry of Electronics and Information Technology has formed a team to investigate.

Certificate Transparency is the one control that still bites, and only partly. Browsers require signed certificate timestamps, so a forged certificate that never reached a CT log is useless against Chrome or Firefox. But CT enforcement is a browser behaviour. The enormous volume of machine-to-machine TLS crossing ordinary server infrastructure — API clients, sync agents, monitoring pollers, package fetchers, embedded devices — validates a chain to a trusted root and never asks whether anyone logged it. That population is both the largest and the least observable, and it is the one where these keys would have been usable.

Why a CA key compromise is a DNS story

A private CA key is inert on its own. To spend one you must already be in the path between a client and the service it wants, and the cheap ways to get there are not exotic: a poisoned resolver answer, a rogue DHCP server, a captive network, or a hijacked route. For the overwhelming majority of networks, the realistic interception primitive is name resolution.

That is what actually changed on 17 October, and it is worth stating plainly: nothing about your resolver posture moved. The consequence of it did. Under normal conditions, a hijacked DNS answer is self-limiting, because the attacker cannot produce a certificate for the name they have stolen and the user gets a loud, unmissable warning. DNS tampering fails noisily, which is precisely why most teams treat resolver integrity as an availability concern rather than a confidentiality one. With one of these eight keys in hand, the same tampering would have ended in a clean padlock. A DDoS attack writes itself into every graph you own; this writes nothing at all, because the handshake succeeds.

DNS over HTTPS is the usual recommendation at this point, and it remains a good one, but the circularity deserves acknowledging: DoH protects the resolution path with a TLS connection validated against the same trust store that was carrying these intermediates. Encrypting the transport does not help if the thing you are trusting to authenticate the far end is the layer that failed. The durable advice is duller and older — know which resolver each host is actually using, choose resolvers you have reason to trust, and keep records you could query afterwards.

DNS Benchmark Pro results ranking public resolvers by DNS server performance, a baseline for teams reviewing resolver trust after the eMudhra CA key compromise
Resolver rankings by DNS server performance. Resolver choice is a trust decision as much as a speed one, and the two are usually settled by whoever set the network up years ago.

The remediation is the bigger operational risk

Most of the fixes that shipped do not block eight keys. They remove a root — because removing a root is the only lever most trust stores expose. That also breaks every legitimate certificate chaining through emSign ECC Root CA - G3. Mozilla, Canonical and Red Hat have each warned of server-side outages as a result, and Chrome intends to drop the root in root store version 43, expected to reach devices on 27 October.

ComponentFixed inApproach
Go1.27.3, 1.26.10 (CVE-2026-111943)Denylist in crypto/x509; applies to system verifiers too; rebuild required
Firefox / NSS158.0.1, ESR 153.5.1, ESR 115.43.1; NSS 3.131.1OneCRL block, then root removal
Node.js26.12.1, 24.22.1, 22.23.4Key rejection plus an updated root list
Bundlescertifi 2026.10.19, webpki-roots 1.0.10, Composer ca-bundle 1.6.0, Debian DSA-6572-1, Ubuntu USN-8944-1Root removal

Go is the instructive case. Its fix is compiled in, so upgrading the toolchain changes nothing for binaries already built and shipped; every affected service has to be rebuilt and redeployed. That is a decent proxy for the wider problem, and it is a cloud security problem as much as a desktop one: container images carry frozen CA bundles, appliances carry firmware trust stores, and language runtimes carry their own. Nobody maintains an inventory of these. There is no zone file for the trust store, no console that lists every copy, and no way to ask a fleet which roots it currently honours without going and looking.

The Mozilla headquarters building in San Francisco, whose root program recovered the weak eMudhra CA keys within two hours of disclosure
Mozilla's San Francisco offices, photographed in 2021. Mozilla's cryptography engineering team reproduced the private-key recovery independently within two hours of receiving the report and had a OneCRL block distributed the same evening.

What to check this week

  1. Find your trust stores. Operating systems, container base images, language bundles, appliances and anything with a pinned CA list. This is the inventory nobody has, and building it is the lasting IT security outcome of the incident.
  2. Rebuild Go services against 1.27.3 or 1.26.10. A toolchain upgrade alone does not change a deployed binary.
  3. Test before you distrust. Removing emSign ECC Root CA - G3 can break working services. Stage it.
  4. Verify from the client side using the public test hosts the disclosure provides, rather than assuming an update landed.
  5. Baseline resolution. Confirm which resolver each managed host genuinely uses, and keep logs long enough to answer a retrospective question.
Network latency comparison across public DNS resolvers, a network diagnostic tool for confirming resolver behaviour across server infrastructure
Per-resolver network latency distribution. A resolver benchmark is the quickest network diagnostic tool for establishing which resolver a host is really talking to — use the DNS lookup tool to confirm what it answers.

What it means

The open questions are the awkward ones. Nobody can say whether these keys were used between April 2025 and October 2026, because outside CT-enforcing browsers there is no method to detect past misuse. eMudhra's root cause is unpublished. Mozilla says it does not currently believe other CAs are affected and Chrome says it checked its whole store and found no other instance of this failure mode — two reassuring statements that both rest on the same assumption, namely that this class of defect is visible to anyone who looks.

The web's trust model is not short of cryptography. What this tech infrastructure incident exposed is that it is short of inventory and short of revocation reach: browsers were patched in hours because they have a push channel, while the far larger population of non-browser clients depends on somebody noticing, rebuilding and redeploying. For eighteen months the certificate layer that normally makes DNS tampering fail loudly would have quietly endorsed it instead, and that is the dependency worth writing down — the padlock was never the security boundary. Name resolution was, and the padlock was just the part that complained when it went wrong. Compare this with the ccTLD registry hijacks of 8 October: different layer, same lesson about what sits beneath the controls you actually monitor.

Sources

Related articles

Browse every DNS news article by month →

DNS angle

Review resolver logs for the systems discussed above and compare unexpected names with your approved services. A successful lookup does not establish that a destination is safe. Use the DNS lookup tool to inspect current answers, then compare them with your own resolver and incident records.

Source: The Hacker News — Eight eMudhra CA Keys Compromised, Triggering Emergency Fixes Across Browsers and Software ().