> ## Content Index
> Fetch the complete content index at: https://nelson-dayan.ghost.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# LowByte: The eMudhra Single-Byte CA Key Compromise
- URL: https://nelson-dayan.ghost.io/lowbyte-the-emudhra-single-byte-ca-key-compromise/
- Published: 2026-10-23T23:28:18.000Z
- Updated: 2026-10-24T02:17:04.000Z
- Author: Nelson Dayan

## Summary

Since 17 months, eight trusted eMudhra intermediate CAs were using P-384 private keys whose values were all below 256\. One of them was the number 4.... Yeah.... 4.  
Anyone holding the public certificates could recover every key in milliseconds and mint certificates for any domain, or sign code as a verified publisher using any device with bare specs.

The keys were broken from when created in an April 30, 2025 key ceremony, and were effectively public from the moment the certificates existed. Root programs revoked the intermediates: Mozilla removed the emSign ECC Root CA - G3 from NSS, and Chrome is removing it too.

All major browsers were protected within hours of the October 17, 2026 report, but programs like curl, Python, Go, Node, containers, CI runners and embedded devices that trust a CA bundle on disk and never check revocation are still very much at risk.

## Why "LowByte"

A P-384 private key is 48 bytes. In all eight eMudhra keys, the top 47 bytes were zero and only the lowest byte carried a value. The entire secret lived in the low byte, so I'm naming the incident after it. Plus it's heavily inspired from Scott Helme's Article [Eight Bits of Trust; eMudhra's CA keys cracked in milliseconds](https://scotthelme.co.uk/eight-bits-of-trust-emudhras-ca-keys-cracked-in-milliseconds/?ref=nelson-dayan.ghost.io) and "The eMudhra CA Key Compromise Incident" doesn't flow as well as the "Low Byte" incident.

![](https://storage.ghost.io/c/19/90/19908236-9a1d-4145-995d-52fdc2f2ad44/content/images/2026/10/meme-2.jpeg)

## Background: the emSign G3 hierarchy

The compromised keys sat two levels below an ECC root that Chrome, Apple and (until October 20) Mozilla trusted for TLS. eMudhra is India's largest licensed certifying authority and sells publicly trusted certificates under the emSign brand through companies in India, the US and the Netherlands.

On April 30, 2025, eMudhra ran one key generation ceremony that produced 24 intermediates. There were three series (A, B, C), two algorithms (RSA-4096 and P-384) and four purposes (DV, OV, EV, code signing). Every P-384 key in the B and C series was broken; the A series, its May 2025 replacement A-1, and the RSA keys were not found to be weak.

The B series was issued to eMudhra BV for European customers and the C series to eMudhra Inc for US customers, to address data-sovereignty requirements. eMudhra says only EM DV TLS CA - G3C reached production, and that none of the eight issued an end-entity certificate.

Key values as published by [Scott Helme](https://scotthelme.co.uk/eight-bits-of-trust-emudhras-ca-keys-cracked-in-milliseconds/?ref=nelson-dayan.ghost.io) and [SOCRadar](https://socradar.io/blog/emudhra-ca-key-compromise-weak-keys-risks-and-fixes/?ref=nelson-dayan.ghost.io); CCADB IDs and fingerprints are in [Mozilla Bug 2083449](https://bugzilla.mozilla.org/show%5Fbug.cgi?id=2083449&ref=nelson-dayan.ghost.io). These keys are revoked, distrusted and already public.

On May 14, 2025, Sectigo cross-signed all eight public keys under its AAA Certificate Services root. That doubled the number of certificates carrying each broken key to 16 and opened a second path to trust. Chrome and Firefox had already dropped AAA Certificate Services for TLS in April 2025, but Apple and Microsoft still trusted it, and so did many Linux bundles. Sectigo revoked its copies on October 19, 2026.

![](https://storage.ghost.io/c/19/90/19908236-9a1d-4145-995d-52fdc2f2ad44/content/images/2026/10/weak-keys-diagram-v2.png)

Removing the emSign ECC root cuts only the left-hand path; clients that still trust AAA Certificate Services or emSign Root CS CA - G3 need the intermediates blocked directly.

## The cryptographic flaw

Each key had about 8 bits of entropy instead of roughly 384, so recovering it takes at most 255 point multiplications. On a laptop that is a millisecond or two.

### What an ECDSA P-384 key is

The private key is an integer d chosen uniformly from 1 to n − 1, where n is the order of the P-384 base point G. The public key in the certificate is the point Q:

$$Q = d \\cdot G, \\qquad 1 \\le d \\le n - 1, \\qquad n \\approx 2^{384}$$

Computing Q from d is cheap. Going back from Q to d is the elliptic-curve discrete logarithm problem, which is infeasible only because the search space is about 10^115 values. Every bit of that security comes from d being large and random.

### What eMudhra's keys looked like

All eight scalars were below 256\. Written as the 48-byte big-endian value an HSM would store, a key looked like this:

```
d = 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E6   (230)

```

A healthy P-384 key has 48 bytes of noise. These had 47 zero bytes and one byte of value. Base64-encoded, the private keys show a long run of `AAAA…`, which several readers on the Mozilla bug pointed out.

### Why recovery is trivial

The attacker reads Q from the certificate and computes 1·G, 2·G, 3·G and so on until one matches. The worst case is 255 steps:

$$\\text{work} \\le 2^{8} \\text{ scalar multiplications} \\quad \\text{versus} \\quad \\approx 2^{192} \\text{ for Pollard's rho on a random P-384 key}$$

The baby-step giant-step which is an algorithm to solve the discrete logarithm problem also finishes near-instantly, but a plain linear scan is enough. The script below reproduces the attack by brute forcing, using only the public key.

```python
# Recover a P-384 private scalar known to be below 256 from its public key alone.

def bruteforce_pub_key(public_key):
    for i in range(1,256):
        private_key = ec.derive_private_key(i, public_key.curve)
        if private_key.public_key().public_numbers() == public_key.public_numbers():
            print("Success on d = "+str(i))
            return private_key

```

Running this in my environment took 0.0080 seconds to derive the private key where it was `d=4`.

```
Bruteforrcing for key : Public Keys\CN=EM OV TLS CA - G3C,O=eMudhra Inc,C=US.pem
Success on d = 4
Took 0.0080 seconds

```

I have created a [GitHub repository](https://github.com/NelsonDayan/eMudhra-Private-Key-Retrieval?ref=nelson-dayan.ghost.io) with the private keys for all the eight weak keys and included the script used to generate it.

### Why nothing looked wrong

A point derived from d = 4 is a valid P-384 point. The encoding is standard, the curve is standard, and the signatures verify. Linting, CT logging, audits and root-program review all check structure and policy, not whether the private scalar is small. The only way to see the flaw is to try small scalars against the public key.

Two independent recoveries confirm how low the bar was. Mozilla recovered the keys on its own 1 hour 42 minutes after receiving the report, without knowing the reporter's method. Mozilla engineer Dennis Jackson and Scott Helme both reported that AI agents recovered the keys from a single short prompt.

## Root cause: a ceremony that made two key sets

eMudhra's preliminary account is that one ceremony produced two key pairs per CA, and the weak pair was the one certified.

![](https://storage.ghost.io/c/19/90/19908236-9a1d-4145-995d-52fdc2f2ad44/content/images/2026/10/key-ceremony-diagram.png)

The strong keys were generated as intended, but a flawed wrap/unwrap test, run because the B and C keys were meant for export to US and European data centres, left a second, weak pair on the HSM. With similar labels, the weak pair went into the CSRs that the emSign roots signed and Sectigo cross-signed. The strong keys were later used to sign CRLs, which is why those CRLs failed.

eMudhra says its infrastructure was not breached, its HSMs are FIPS 140-2 Level 3 devices, the RSA keys followed a different code path, and the A and A-1 series were made on Entrust HSMs. It cites human error at several steps and has committed to re-verifying every ceremony it has performed.

### What the account does not yet explain

An HSM's approved key-generation mechanism draws d from its internal random source. It does not produce a scalar below 256 by itself. There were still open questions:

- **Imported or supplied material** The weak key came from a value, seed or wrapped blob fed to the module, for example through an unwrap or object-creation call rather than in-module generation. That would conflict with eMudhra's CPS, which says issuing-CA keys are generated in a FIPS 140-2 Level 3 device.
- ***A module configuration that permits it*** The HSM could be made to create such a key internally, which would raise questions for every CA using the same hardware.

Root-program participants have asked for the ceremony script, the exact PKCS#11 or vendor call that created the second pair (for example C\_GenerateKeyPair, C\_UnwrapKey or C\_CreateObject), the ceremony and witness reports, the HSM firmware and CMVP certificate, and whether the module ran in FIPS-approved mode. Commenters also argue that Baseline Requirements required a qualified auditor's witness report or video for this ceremony, because Sectigo, an unaffiliated root, cross-certified the keys.

## The missed warning: bad CRL signatures in 2025

The key mismatch surfaced 16 months earlier and was closed as a paperwork error. In June 2025, [Bug 1970728](https://bugzilla.mozilla.org/show%5Fbug.cgi?id=1970728&ref=nelson-dayan.ghost.io) recorded invalid CRL signatures from exactly the six affected TLS intermediates.

- **What eMudhra said then:** a manual CRL process used the wrong CA key configuration on May 29, 2025\. Corrected CRLs were published on June 6, 2025, and eMudhra committed to automated post-signing checks.
- **What it says now:** the original CRLs were signed with the intended, strong keys. Those signatures failed because the certificates held the weak public keys, so the CRLs were re-signed with the weak keys, which made them verify.

In other words, the operator found that its CA certificates did not match its intended keys, picked the key that made the error go away, and kept operating. Why eMudhra did not halt and revoke at that point, why the 2025 report omitted that two key pairs existed per CA, and was Sectigo or any root program told? These questions still need answering.

## How root programs and browsers responded

Chrome also checked every other CA certificate in its store and reported no other instance of this failure mode. Mozilla said it does not currently believe other CAs are affected.

**Why distrust the root and not just the intermediates?**

Mozilla's reasoning was that multiple people had independently recovered the keys and some had published them. Many clients cannot consume revocation data or block individual intermediates, so removing the root was the only lever that reached them. The cost is collateral: every legitimate certificate under the G3 ECC root breaks for those clients, which is why Mozilla, Canonical, Red Hat and CERT-In all warned of outages.

**Certificate Transparency held the line for browsers.** Chrome found no TLS certificate chaining to the six intermediates in CT logs before its block. Because Chrome, Safari and Firefox require CT, no forged certificate could have been trusted by default in them. CT detects mis-issuance rather than preventing it, and most non-browser clients never check it.

## Blast radius: why LowByte cannot be fully contained

The residual risk is every TLS client that trusts a bundle on disk, skips revocation and ignores CT, and those clients stay exposed until someone updates them. A stolen key has a thief and a moment of theft; LowByte had neither, so there is no point after which you can say the key was safe.

### What an attacker could do with the keys

- **TLS interception.** With any of the six TLS keys, anyone on the network path can mint a certificate for any hostname and man-in-the-middle a client that trusts the chain. Helme minted a certificate for api.stripe.com and I have demonstrated the same by minting outloook.com. In case you want to research more on how you can mint your own certificates you can refer the "Bonus" section below and check out [eMudhra Private Key Retrieval](https://github.com/NelsonDayan/eMudhra-Private-Key-Retrieval?ref=nelson-dayan.ghost.io) .
- **Code signing.** The two CS keys chain to emSign Root CS CA - G3, which Microsoft trusts. Malware signed with them would look like software from a verified publisher on Windows hosts that do not check revocation. Code-signing certificates are not CT-logged, so there is no public record to search.
- **Both trust paths.** Removing the emSign root alone is not enough where AAA Certificate Services is still trusted, because the Sectigo cross-signs chain the same keys there.

### Who is still exposed

- **Installer pipes and self-updaters** that fetch scripts or binaries over HTTPS with no signature check.
- **CI/CD runners and build containers** that hold cloud, registry and signing credentials and run on stale base images.
- **Server-to-server calls**: payment APIs, webhooks, OAuth token exchange and cloud SDKs, which often use certifi or Go's verifier.
- **Compiled Go programs**, which keep the old behavior until rebuilt with a patched toolchain.
- **IoT, embedded and OT devices** with frozen bundles. The intermediates are valid until July 2039.

### What limits the damage

eMudhra says only one of the eight CAs issued anything, and none issued end-entity certificates. Chrome found no forged TLS certificates in CT, and no malicious use had been confirmed as of October 21\. eMudhra's Indian digital signature and eSign businesses run on separate infrastructure regulated by the Controller of Certifying Authorities, and India's IT ministry says they are unaffected.

None of that rules out silent use against non-CT clients during the 17-month window. The keys could have been recovered by anyone who looked, and no log would show it. Chrome's October 21 CT count also had to set aside precertificates logged after October 17 under EM DV TLS CA - G3B, so certificates have been signed with that now-public key since disclosure.

## Downstream fixes

Two strategies shipped: block the eight keys directly, or drop the roots above them. Key blocking is precise; root removal is blunt and also breaks legitimate G3 certificates. You can find the live list is on Dennis Jackson's [tracking site](https://emudhra.we-have-a-problem.com/?ref=nelson-dayan.ghost.io).

## Operator playbook

Browsers are covered; the work left is servers, pipelines and devices that manage their own trust. Work through these in order.

1. **Update every trust store you ship.** Apply OS ca-certificates updates, bump certifi, pip, uv, webpki-roots and Electron, then rebuild container images from patched bases rather than patching running containers.
2. **Rebuild Go and Electron binaries** with Go 1.27.3 or 1.26.10 and a patched Electron. Deployed binaries keep their old behaviour.
3. **Block both trust paths on frozen devices.** Distrust the eight intermediates and their eight Sectigo twins (fingerprints in [Bug 2083449](https://bugzilla.mozilla.org/show%5Fbug.cgi?id=2083449&ref=nelson-dayan.ghost.io)), enable revocation checking where the stack supports it, and restrict outbound TLS to known endpoints. Removing AAA Certificate Services outright can break legitimate services, so test first.
4. **Hunt for misuse since April 30, 2025.** Search TLS-inspection, proxy and EDR logs for any certificate or signed binary whose issuer is one of the eight intermediates. Weight Windows code-signing telemetry highest, since nothing there is CT-logged.

**Find your own G3 certificates before October 27.** Anything you serve that chains to emSign ECC Root CA - G3 breaks in Chrome once v43 lands. Check what each endpoint presents:

```
openssl s_client -connect example.com:443 -showcerts </dev/null 2>/dev/null \
  | grep -E '^ *(s|i):' 

```

InCommon customers are most exposed: per Chrome's CT analysis, 30,791 of about 30,800 unexpired G3 precertificates came from InCommon's OVG3C and DVG3C subordinate CAs.

**Test your clients against the canary hosts.** The disclosure site runs 12 test hosts that serve chains through the compromised intermediates, including Sectigo-path variants. A certificate error means the client is safe; a successful connection means it still trusts the keys.

```
curl -sS https://dv-g3b-emudhra.we-have-a-problem.com/      # emSign path
curl -sS https://dv-g3b-aaa-emudhra.we-have-a-problem.com/  # Sectigo AAA path

```

Run them from CI runners, API gateways, proxies, containers and appliances, not just laptops.

## Bonus: Understanding the Exploit

I believe that if you want to fix something, you first need to understand it from an attacker’s perspective. At a high level, we’ve seen that a private key could be recovered from a public certificate (more in [eMudhra Private Key Retrieval](https://github.com/NelsonDayan/eMudhra-Private-Key-Retrieval?ref=nelson-dayan.ghost.io) ) and then used to sign new certificates. That raises more questions:

**How would an attacker use this in the real world?** 
**How do they complete the chain of trust?** 
**How do you properly mitigate it?** 
**...**

### How certificate trust works (the short version)

**Digital signatures.** A certificate’s signature is a digital signature computed over a hash of the certificate body. Only the holder of the CA’s private key can produce a valid one. So the private key **is** the authority. Anyone who has it can create signatures that are indistinguishable from the CA’s own.

**Leaf certificates.** A leaf, or end-entity, certificate sits at the bottom of the chain. It’s the certificate issued to the actual website: it carries the hostnames and can’t sign other certificates.

**The certificate request (CSR).** The subscriber generates a key pair locally. They build a `CertificationRequestInfo` containing the subject, the public key, and any requested extensions, then sign it with their own private key. This self-signature is a proof of possession: it shows the requester holds the private key. The CA then checks that the requester actually controls the domain before it signs anything. Keep this step in mind, because the attack skips it entirely.

**Certificate Transparency (CT).** Chrome and Safari only accept a certificate if there’s proof it was publicly logged. CT doesn’t prevent mis-issuance. It makes mis-issuance visible, so it can be detected and acted on.

**The hierarchy: roots, intermediates, and cross-signing.**

- **Root CA**: a self-signed certificate. Its trust comes from being included in a root store (Mozilla NSS, Microsoft, Apple, the Chrome Root Store), not from its signature. Root keys are kept offline in HSMs in physically secured facilities. They’re used only in scripted, witnessed, audited key ceremonies, mainly to sign intermediate CA certificates.
- **Intermediate (issuing) CA**: kept online inside HSMs, and signs leaf certificates. If one is compromised, it can be revoked without touching the root.
- **Cross-signing**: the same intermediate or root key is certified by two different issuers. This creates more than one valid path to a trusted root. The well-known example is Let’s Encrypt’s ISRG Root X1, which was cross-signed by IdenTrust’s DST Root CA X3\. Cross-signing matters in this incident.

**Verification on the client.** In TLS 1.3, the server sends its leaf and intermediate certificates; the root is usually left out because the client already has it. The client then builds a path from the leaf up to a root it trusts. At each link it checks signatures, name chaining, validity dates, CA constraints, the hostname. Depending on the client, it may also check revocation or CT.

Notice what is not on that list: the client never checks how a certificate was issued. It only checks that the signatures are valid. That gap is the whole exploit.

**The Exploit**  
In the Low Byte incident the keys that we're leaked were of a intermediate CA, An intermediate CA key is the authority to issue certificates. With one of these keys, an attacker can sign a leaf certificate for any domain they choose, without going through the CA’s domain-ownership checks. Software that trusts the root will accept that certificate.

Each of the eight also exists as a second certificate with the same public key, cross-signed by Sectigo under its AAA Certificate Services root. That makes 16 compromised intermediate certificates, but still only 8 keys, and two separate paths to a trusted root.

### Completing the chain of trust

A forged leaf on its own isn’t enough. The client also needs the intermediate certificate to build a path to a root it trusts. Here the attacker needs nothing secret, because intermediate certificates are public by design. They’re published in CT logs and searchable on sites like crt.sh, and in this case they were also attached to the original bug report.

The attack looks like this:

1. Download one of the compromised intermediate certificates.
2. Recover its private key by trying all 256 possible values.
3. Use that key to sign a forged leaf certificate for the target domain.
4. Serve the forged leaf along with the intermediate. The client walks leaf - intermediate - trusted root, every signature checks out, and the connection looks completely legitimate.

I have created a tool that does all this for you. If interested check out [eMudhra Certificate Generator](https://github.com/NelsonDayan/eMudhra-Certificate-Generator?ref=nelson-dayan.ghost.io#emudhra-certificate-generator).

  
The weak certificates never went through the certificate transparency process and the response on browsers was very quick, so some browsers like Chrome and Safari were safe.

> **However the concern isn't about the browsers. It's about everything else.**Said by someone on twitter that I can't find T-T

As discussed in the "Who is still exposed" section. There is still a lot of technologies that have been affected and we will need to keep on the look out for vulnerabilities that arrives from this till 2039 because that's when the root certificates are going to expire.

For eMudhra the consequences are already pretty concrete, but still has a lot of questions to be answered.

## Sources

- [Mozilla Bug 2083449: eMudhra private key compromise of intermediate certificates](https://bugzilla.mozilla.org/show%5Fbug.cgi?id=2083449&ref=nelson-dayan.ghost.io)
- [Scott Helme, "Eight Bits of Trust"](https://scotthelme.co.uk/eight-bits-of-trust-emudhras-ca-keys-cracked-in-milliseconds/?ref=nelson-dayan.ghost.io)
- [The Hacker News: Eight eMudhra CA keys compromised](https://thehackernews.com/2026/10/eight-emudhra-ca-keys-compromised.html?ref=nelson-dayan.ghost.io)
- [SOCRadar: eMudhra CA key compromise FAQ](https://socradar.io/blog/emudhra-ca-key-compromise-weak-keys-risks-and-fixes/?ref=nelson-dayan.ghost.io)
- [BleepingComputer: Mozilla, Google, Apple block compromised eMudhra CA certificates](https://www.bleepingcomputer.com/news/security/mozilla-google-apple-block-compromised-emudhra-ca-certificates/?ref=nelson-dayan.ghost.io)
- [Red Hat RHSB-2026-012](https://access.redhat.com/security/vulnerabilities/RHSB-2026-012?ref=nelson-dayan.ghost.io)
- [eMudhra BSE filing, October 21, 2026](https://www.bseindia.com/xml-data/corpfiling/AttachLive/6be0c423-b335-494b-86f3-54c561c3a5f9.pdf?ref=nelson-dayan.ghost.io)
- [Disclosure and tracking site by Dennis Jackson](https://emudhra.we-have-a-problem.com/?ref=nelson-dayan.ghost.io)