In one of the most technically revealing post-incident disclosures in recent WebPKI history, global Certifying Authority eMudhra has published its comprehensive investigation report on Mozilla's Bugzilla security portal, detailing the exact root cause behind the revocation of multiple root and intermediate Certificate Authority (CA) certificates across global trust stores. The investigation reveals that the cryptographic compromise was not caused by a hardware failure or firmware zero-day within its Hardware Security Modules (HSMs), but by a critical software defect in a custom, host-side Python script executed during an off-line key migration ceremony.
The flawed Python script—engineered to parse, transport, and unwrap key objects between HSM appliances across facilities—contained a read-back calculation bug that truncated the scalar value and entropy of Elliptic Curve Cryptography (ECDSA) private keys. Astonishingly, the resulting weakened keys still yielded mathematically valid cryptographic signatures, enabling the compromised certificates to survive two full WebTrust compliance audit cycles without detection. Furthermore, eMudhra acknowledged that the HSM's strict FIPS-approved operational mode had been disabled during practice ceremony runs, allowing sensitive private key attributes to exist in the volatile memory of an unshielded host operating system.
The Technical Root Cause: Flawed Python Read-Back Logic
The incident traces its origins to an April 30, 2025 key generation ceremony conducted at eMudhra's WebTrust-audited data center in India. The ceremony aimed to generate "Series B" and "Series C" intermediate CA key pairs slated for deployment in eMudhra's planned European Union and United States hosting facilities. Due to global hardware supply chain delays in early 2025 and impending CA/Browser Forum root store policy deadlines mandating dedicated TLS server authentication sub-CAs, eMudhra elected to generate the keys locally and migrate them via cryptographic key-wrapping to destination HSMs.
To facilitate this migration, engineers executed a custom Python utility on an isolated host workstation connected to the HSM via PKCS#11 interfaces.
Anatomy of the Python Key-Truncation Defect
When an asymmetric key pair is exported under secure key-wrapping specifications (such as PKCS#11 C_WrapKey / C_UnwrapKey or AES-KWP), the private key components must be deserialized and verified against their corresponding public key parameters. The custom Python script contained an error in how it processed variable-length byte arrays representing the private key scalar d for NIST curves (P-256 and P-384).
- Improper Buffer Slicing: The read-back function miscalculated leading zero bytes, truncating the significant byte length of the private key integer during conversion between big-endian byte arrays and internal numeric representations.
- Entropy Collapse: Rather than occupying the full 256-bit or 384-bit field, the effective cryptographic security of the unwrapped private key was reduced by orders of magnitude, making it vulnerable to discrete logarithm lattice attacks.
- Mathematical Validity Paradox: In elliptic curve cryptography, a truncated scalar
d'remains a valid point multiplication factor on the curve:Q' = d' * G. Because the public key was simultaneously updated to reflect the corrupted scalar, signing operations executed normally without throwing assertion faults.
HSM Boundary Violations & FIPS Disabling
The core security value proposition of a certified Hardware Security Module (FIPS 140-2 Level 3) is that private key material never exists in plaintext outside the physical, tamper-evident cryptographic boundary. If private keys must move between HSMs, they must do so encrypted under a trusted Key Encryption Key (KEK) using direct HSM-to-HSM transport mechanisms.
In its formal report, eMudhra conceded a grave procedural breakdown:
"The HSM's FIPS-approved mode was switched off for the practice run... Additionally, the custom script was run on an isolated host and was not a function of the emCA software."
By disabling FIPS mode during testing and executing host-side Python unwrapping, the private key attributes resided in the volatile RAM of the Python runtime process on the host workstation. While the host was physically isolated, this procedure violated the fundamental tenet of root key custody: private key material must never touch general-purpose CPU registers or operating system memory unencrypted.
Revocation of Eight Additional RSA Key Pairs
While initial investigations focused on the corrupted ECDSA intermediate (which issued 130 end-entity TLS certificates under the EM DV TLS CA – G2C hierarchy covering universities and enterprises), eMudhra disclosed for the first time that it had to revoke eight additional RSA key pairs on November 7, 2026.
Unlike the elliptic curve keys, the Python script did not mathematically truncate the RSA key values. However, because those eight RSA keys passed through the identical defective read-back procedure, their private components also sat in the volatile memory of the host workstation. Because eMudhra could not cryptographically verify that the RSA keys had remained untampered and unexposed throughout subsequent re-import attempts, industry trust store operators (including Mozilla, Google, and Apple) mandated complete revocation under baseline CA requirements.
| Certificate Hierarchy | Algorithm / Key Size | Technical Defect | Revocation Status |
|---|---|---|---|
| EM DV TLS CA – G2C | ECDSA P-384 | Scalar truncation via Python read-back logic; weakened entropy. | Revoked (Compromised) |
| eMudhra Intermediate Series B (4 CAs) | RSA 3072 / 4096 | Host RAM exposure; inability to verify zero-leakage HSM transfer. | Revoked (Cessation of Operation) |
| eMudhra Intermediate Series C (4 CAs) | RSA 3072 / 4096 | Host RAM exposure; identical object label collision. | Revoked (Cessation of Operation) |
Audit Failures and the Label Collision Blind Spot
One of the most concerning findings for the global WebPKI ecosystem is that these compromised and weakened intermediate CAs survived two consecutive annual WebTrust compliance audits without being detected.
The post-incident report revealed that during the key generation ceremony:
- No Cryptographic Public Key Cross-Check: The ceremony script never compared the newly certified public keys against the original mathematical key pairs generated within the primary HSM.
- No Key Strength Assertion: No automated entropy or bit-length validation was executed on generated objects prior to signing.
- Identical Key Labels: The corrupted key object rebuilt by the Python script carried a PKCS#11 label virtually identical to the original key object. When the certificate signing request (CSR) was submitted to the root CA, the operator inadvertently selected the defective, corrupted key object for signing.
Independent audit firm KPMG has been retained by eMudhra to conduct an end-to-end forensic investigation into the CA's key management controls, with final audit findings scheduled for submission to root store governance bodies by December 4, 2026.
Lessons for PKI Architects & Key Ceremonies
The eMudhra incident provides critical architectural lessons for enterprise security officers, certificate authorities, and internal PKI operators:
- Enforce Zero-Host-Memory Key Policies: Never allow private key deserialization on general-purpose compute operating systems. Utilize direct HSM-to-HSM encrypted cloning (e.g., Thales payShield or Luna HSM peer-to-peer transport) where keys remain in tamper-proof silicon.
- Mandatory FIPS Lockout: Hard-code operational policies so that key generation or unwrapping operations instantly abort if the cryptographic module is not running in strict FIPS 140-2 Level 3 approved mode.
- Automated Pre-Flight Mathematical Integrity Checks: Before submitting any intermediate key for root signature, execute automated mathematical verification comparing the unwrap result against the original generation seed.
The eMudhra post-incident report confirms that even in highly regulated, audited cryptographic environments, bespoke administrative scripts can bypass hardware-grade protections if strict physical and procedural boundaries are compromised.



