The eMudhra certificate authority incident: Are your medical devices still vulnerable?

Alan ParkinsonAlan Parkinson

On 17th October 2026 a security researcher discovered that 8 of the eMudhra intermediate CA private keys were so weak that they could be recovered from their public certificates in under a second. Six of the keys could be used to issue TLS certificates (enabling an attacker to effectively impersonate any website or cloud service). The other two were for code signing.

Chrome and Firefox blocked the affected certs within hours. The other software vendors and OSes then issued their patches in the days that followed. But what about medical devices that are already in hospitals? Some have certificate trust stores baked into the firmware, no mechanism at all for automatic updates, and an expected lifespan of years.

A CA can revoke the certificate, but that alone doesn't prevent the device from trusting it. Devices that continue to accept the affected certificate chains will remain vulnerable until they receive an update (or another security control) that stops the attack.

For medical device manufacturers, the question is straightforward: can you identify which of your devices or versions of your devices are unaffected, and can you provide evidence to support that?

What happened at eMudhra?

When the device connects to the cloud service over HTTPS, the server will present a digital certificate. The device will then validate that the certificate is valid for that hostname and that it chains back to a CA that it trusts.

Most devices that use public TLS certificates will be using a trust store which contains the root certificates of various CAs. An intermediate CA sits between the trusted root and the server certificate, allowing certificates to be issued without the root CA needing to use its private key at all. If an attacker obtains the private key of an intermediate CA, they could in principle go on to issue fraudulent certificates which clients trusting that chain would accept.

The private keys weren't stolen from eMudhra's infrastructure. They could be derived from information that was already publicly available. In April 2025 eMudhra (emSign) generated new intermediate CA keys and certs.

According to eMudhra’s investigation, a scripting error during the key generation process resulted in an additional set of exceptionally weak private keys. Eight intermediate certificates were mistakenly created using those keys. The weakness was remarkable; rather than breaking the underlying crypto, an attacker could simply try a few hundred possible key values and see which one(s) match the public certificates.

eMudhra revoked the affected intermediate certificates on 18th October. The company states that the intermediate certificates had not been used to issue any publicly trusted end-entity certificates prior to the issue being discovered and that its CA infrastructure had not been compromised.

That in no way rules out future exploitation. The weak private keys are still recoverable, and a client that continues to accept certificates issued with those keys will remain at risk.

Why Sectigo’s cross-signing matters

The affected intermediate CAs had also been cross-signed by Sectigo.

Cross-signing allows the same CA public key to be present in certificates issued via different trust chains. In this case, the compromised intermediate keys could form certificate chains via eMudhra's roots or via Sectigo's AAA Certificate Services hierarchy.

AAA Certificate Services has been distributed with a wide variety of operating systems and software libraries in the past, including those used in embedded Linux devices and application runtimes.

Although some browser trust programmes have already removed this root, older systems and independently maintained trust stores may still contain it. This means a medical device manufacturer that has not purchased an eMudhra certificate could find their device still accepts a fraudulent eMudhra certificate issued with one of the compromised keys.

Sectigo revoked the cross-signed certs on the 19th October and has confirmed that their own CA infrastructure and private keys were not compromised. That distinction is important as simply checking for eMudhra root certs isn't sufficient. You have to establish that the medical device will accept the compromised intermediate keys via some trusted certification path.

Why the industry response may not reach medical devices

Browser vendors were able to act quite rapidly as they can issue certificate distrust decisions independently of their normal software releases:

  • Google used Chrome's CRLSet to block the six affected TLS intermediate public keys on the 17th October, just under two hours after the report had come in.
  • Mozilla utilised Firefox's OneCRL mechanism and had the update distributed to users with standard configs in under 3 hours. No protection required users to upgrade their browser.
  • Other vendors (Apple, Microsoft, the various Linux distros and the maintainers of the TLS libraries) have also introduced their own protections.

These mechanisms are not necessarily available to embedded medical devices.

Revocation only works if the client enforces it.

Certificate authorities publish their revocation information via Certificate Revocation Lists (CRLs) or the Online Certificate Status Protocol (OCSP).

However, many embedded TLS clients don't perform certificate revocation checks by default, and in those that do, it may well be dependent on network access to the CA's revocation infrastructure. Hospital network restrictions can prevent that access, and some TLS implementations will accept the connection if the revocation check fails.

For a client that does not enforce revocation, the fact that eMudhra or Sectigo have revoked the affected certificates makes no practical difference.

One device can have more than one trust store.

Medical devices can contain multiple software items, each with its own TLS client and trust store.

Software

Potential trust source

Embedded Linux

Operating system CA bundle

OpenSSL application

System bundle or application-specific CA file

Java application

Bundled JRE cacerts or custom keystore

Embedded browser or WebView

Platform or browser-managed trust store

Proprietary TLS implementation

Certificates or keys embedded in firmware

An OS CA bundle update doesn't necessarily update an application's trust store. The same applies to a device that may have a primary app that uses the system certificate store and a separate telemetry service, update mechanism, or companion app that uses its own TLS implementation.

The update mechanism is just as important as the trust configuration. Some trust stores can be updated via OS packages or application updates. Others will require a full firmware release (verification and release activities).

A manufacturer needs to determine which arrangements are in each software item within their device.

How to assess whether your medical device is affected

An SBOM or vulnerability scan may identify the software that's affected, but it doesn't necessarily indicate the level of exposure. You need more information to work out the exposure.

Think of a device talking to a cloud service over HTTPS. Its TLS client is using the OS CA bundle and doing the standard certificate chain and hostname validation. To assess the eMudhra incident, the manufacturer has to determine whether the client would have accepted a fraudulent cert issued by one of the compromised intermediaries.

A useful assessment starts with four questions.

1. What does the TLS client trust?

Identify the actual trust store that the software item uses.

Does it contain a root that could form a valid chain via an affected intermediate? Does the implementation support alternative certificate paths (including Sectigo's cross-signed certs)?

Finding a trusted root on its own doesn't establish vulnerability. It just identifies a potential trust path which would then need to be investigated. The TLS implementation might already be rejecting invalid keys or enforcing additional controls.

2. How does it validate certificates?

Does the client perform hostname validation? Does it check certificate validity and constraints? Does it enforce revocation or reject explicitly distrusted certificates?

Check the configuration that the released software actually uses rather than just the capabilities that the TLS library docs claim. For example, a library might support CRL checking without the application actually enabling it, but without network access, the certificate revocation will not work.

3. Are there independent authentication controls?

A device may use public key pinning or may restrict the accepted trust anchors to a manufacturer-controlled private CA.

It may also be capable of independently authenticating application messages irrespective of TLS. These controls can prevent certain consequences of endpoint impersonation even in the case where a wider public CA trust relationship does exist.

The assessment must determine whether the controls in fact apply to the connection under investigation.

4. What could an attacker achieve?

The existence of a vulnerable trust relationship does not in itself mean there's a patient safety implication.

What information is being transmitted via the connection and what level of authority does the remote service have over the device? A link used solely for retrieving public documentation has quite different potential implications from one used to transmit treatment parameters, device configuration or firmware updates. Both might need remediation, but the risk assessment should be based on what an attacker can actually achieve.

Verification is more important than assumption.

A manufacturer's assessment should be underpinned by evidence of the device's actual behaviour.

Suppose a device has a security requirement to authenticate its cloud endpoint via public key pinning. The manufacturer's verification evidence should show that the TLS client will reject a server which presents an otherwise valid certificate for the expected hostname if the server public key does not match an authorised pin.

For eMudhra, a useful negative test is to see whether the relevant TLS implementation would reject a certificate chain which contains one of the compromised intermediate keys. In a controlled, authorised test environment, the manufacturer can exercise the TLS client with appropriate certificate chains and record the results.

For example:

Verification scenario

Expected result

Legitimate server certificate with authorised key

Connection accepted

Certificate signed by an untrusted CA

Connection rejected

Certificate using an affected intermediate key

Connection rejected

Alternative cross-signed path using the same compromised key

Connection rejected

Certificate for the correct hostname but an unauthorised server key, where pinning is required

Connection rejected

The exact tests will depend on the selected security controls and the TLS implementation. They should use the actual software configuration of the device as released, or a representative environment whose equivalence is justified.

This is actually more than just the removal of a root cert from a trust store. It also illustrates why traceability is important.

The threat model identifies endpoint impersonation via a compromised CA. The security requirements specify the selected controls. Implementation and verification show how those controls actually work. It should be fully traceable in your QMS; from threat to mitigating control, and right through to verification.

When a vulnerability report comes in, the manufacturer can assess it against the existing design and verification evidence rather than having to go back and re-establish the entire security argument.

Firmware signing and the consequences of a compromised TLS connection

One potentially quite serious consequence of cloud endpoint impersonation is the interference with software and firmware updates.

Consider a device which downloads its firmware from the manufacturer's cloud service over HTTPS.

An attacker who successfully impersonated that service could supply a modified firmware image or alter the update metadata. If the device treats the HTTPS connection as sufficient proof that the firmware is genuine, then the attacker may be able to install unauthorised software.

This is why firmware update authentication shouldn't be based purely on HTTPS/TLS.

Independent firmware signature verification

A secure firmware update process should independently verify the authenticity and integrity of the update using a manufacturer-controlled signing key.

The device should establish that:

  • The manufacturer signed the firmware (or some other explicitly trusted signing authority).
  • The firmware and the associated update metadata have not been modified.
  • The update is for the correct device model and hardware configuration.
  • The update is compliant with the device version and rollback restrictions.
  • The trusted firmware verification key must be protected against unauthorised modification.

Most importantly in this instance, the firmware verification mechanism must not be reliant on the same public CA trust chain that could be compromised.

If the device independently verifies the firmware using a protected, manufacturer-controlled public key, then an attacker impersonating the update server would still be unable to install the modified firmware without a valid signature.

This doesn't remove all the risk, though. An attacker could still interrupt the update and try to install an older, legitimately signed firmware version if there's no rollback protection.

Secure Boot can add an extra layer of protection by checking the software is genuine and hasn't been tampered with before it runs. Firmware signature verification, secure boot and rollback protection are all separate controls. Their effectiveness depends entirely on implementation and how the keys are managed.

The two compromised code signing intermediates.

The eMudhra incident also impacted two of the intermediate CAs for code signing. These present a different concern from TLS certificate issuance.

An attacker with a compromised code-signing key could, in principle, produce software that would be signed in a way that would be accepted by a system that trusts the compromised public code-signing hierarchy.

This is relevant to Windows-based medical devices, desktop apps, installers and the associated support software. Microsoft issued protections for the affected code-signing certificates on 20 October. Manufacturers should assess whether these protections were in fact applied to their deployed Windows systems, especially those that are running with restricted or infrequent updates.

They should also establish how their devices verify software and firmware signatures. A device which independently verifies the firmware against a protected manufacturer-controlled key is not necessarily vulnerable to the installation of malicious firmware even in the event of a public code signing CA being compromised.

However, if the firmware update mechanism accepts software signed with a publicly trusted code-signing certificate chain, then that trust relationship needs to be examined.

Managing the risk

The right response will of course depend on the device architecture and the assessment results.

For this incident, the manufacturers should be looking at applying the relevant vendor updates or configuring their TLS implementations to distrust the compromised intermediate keys.

Where an implementation allows for the blocking of individual intermediate public keys, this could prevent the acceptance of both the eMudhra-issued and the Sectigo cross-signed certificates without unnecessarily removing other unrelated trust relationships.

Removing a root CA may also be the right thing to do, though the manufacturer should be fully aware of the implications for legitimate connections prior to doing so.

Long-term security controls include the following.

Public key pinning: limit the server public keys that the client will accept. This reduces the need to rely on the wider public CA ecosystem, but again does require a robust key rotation and key recovery process.

Private Certificate Authorities: in the case of communication purely with manufacturer-controlled services, you can use a private CA to get rid of the need for a public CA issue. The manufacturer then takes on the responsibility of running and maintaining the certificate hierarchy.

Constrained public CA trust: in cases where public CAs are still required, the manufacturer can limit the set of accepted trust anchors and have a mechanism in place to distribute trust changes to the deployed devices.

Revocation checking: revocation checking can provide an extra layer of protection, as long as the device is capable of obtaining the relevant information and can do so in a secure manner (i.e. it can cope with failure scenarios). This may need documentation in the device's label, particularly for user groups such as hospital and clinic network teams to avoid accidental blocking.

Independent message and update authentication: Cryptographic signatures or other appropriate authentication mechanisms can be used to protect safety relevant messages and software updates even in the event that the underlying TLS connection is compromised.

These controls are not interchangeable and the manufacturers may require several of them.

The aim is to identify and manage the relevant risks via the current threat modelling and cybersecurity risk management processes.

What your SBOM will and won’t tell you

An SBOM can help identify software components that may need investigation following this incident.

Several vendors have published product-specific vulnerability identifiers or advisories associated with the compromised eMudhra certificates.

Examples include:

Vulnerability

Software

CVE-2026-91403

Oracle Java SE and GraalVM

CVE-2026-111943

Go standard library

CVE-2026-113470

Firefox and Thunderbird

A vulnerability management tool can identify the affected component versions in an SBOM, which in turn can help the manufacturer to prioritise which products and which software items to look at. But the presence of a potentially affected component does not necessarily establish that a device is vulnerable.

A useful exercise for this week

If you manufacture a connected medical device, there are three practical activities worth completing.

1. Check the trust relationships in your deployed products.

Which software items establish TLS connections and what each of them trusts? OS bundles, application-specific trust stores, proprietary TLS implementations and companion apps.

2. Establish whether the affected certificate chains would be rejected.

Check the deployed configuration and the evidence behind any controls you're relying on. Where appropriate, carry out the relevant verification testing in a controlled environment. Don't assume that a vendor security update has reached every software item or every deployed version.

3. Review the threat model and the supporting evidence.

Does your threat model consider an attacker impersonating a trusted cloud endpoint through a compromised CA? Can you trace the selected controls through requirements, implementation and verification?

If you can't answer those questions, then you've got a gap you need to address irrespective of whether that particular incident has any bearing on the device.

The bigger lesson

The eMudhra case is quite unusual in terms of the private key strength. Recovery of a P-384 private key should be computationally infeasible. It shouldn't be something that you could just do by trying a few hundred values. But a CA issuing fraudulent certificates is a well-known cybersecurity threat.

Medical device manufacturers aren't expected to be able to predict which CA is going to fail next. What they are expected to do is understand the trust chains that their devices are reliant upon, be able to identify the credible threats and then have the ability to make a decision as to how they manage the associated risks.

A threat model that considers compromised CAs, supported by security requirements and verification evidence, should make an incident like this substantially easier to assess.

The manufacturer can identify which of the deployed devices are reliant on the affected trust relationships, determine whether the current controls are still effective and document any required remediation.

Without that information, even a relatively straightforward certificate incident can become a lengthy investigation across multiple products and software versions.

Revocation is a decision made by a certificate authority. Protection depends on whether the device enforces that decision.

The next time a CA is compromised, manufacturers should be able to establish whether their devices are protected using evidence they already have.

Newsletter

Never miss an insight.
Subscribe to The Detective’s Notebook.

Practical cybersecurity regulatory insights and guides for medical device teams. Free, no spam, unsubscribe anytime.