Delinea Blog > Node2Shell and eMudhra: Can two unrelated vulnerabilities become one attack chain?

Node2Shell and eMudhra: Can two unrelated vulnerabilities become one attack chain?

Published November 2026
Read time 6 minutes
What you will learn
How a forged eMudhra certificate could deliver a malicious Brotli response, which conditions must hold, why simpler paths to the decoder exist and how code execution would put application credentials at risk. 

Part 2: Following the attack path

In the first part of this series, we looked at two unrelated security incidents: Node2Shell, a memory corruption vulnerability in Google's Brotli decoder, and the eMudhra certificate authority compromise, which exposed private keys that should never have been recoverable.

The question is what happens when we put them together.

Node2Shell allows specially crafted compressed data to corrupt memory when an affected application decompresses it. The eMudhra compromise could allow an attacker to impersonate a trusted HTTPS service if the client still accepts certificates issued through the compromised keys.

One vulnerability affects how an application processes data. The other effects how it decides who to trust. Could the second provide a way to deliver the first?

It's technically plausible under specific conditions, but there's no public demonstration of the combined attack and the forged certificate may not even be necessary.

From a trusted connection to a vulnerable decoder

Consider a Node.js application that connects to an external API using the built-in fetch() function. The application establishes an HTTPS connection, validates the server certificate and automatically decompresses Brotli-compressed responses.

Now consider an attacker who can redirect that connection and recover one of the compromised eMudhra intermediate CA keys. If the client still accepts a certificate chain involving that key, the attacker could impersonate the external service.

The application might complete the TLS handshake without detecting the substitution. But the response would now be controlled by the attacker.

Instead of ordinary API data, the impersonated server could return a malicious Brotli-compressed response. When fetch() decompresses it, the vulnerable decoder could encounter the same memory corruption issue demonstrated by Imperva.

The malicious input would arrive through an outbound connection the application already makes, without the attacker needing to exploit its authentication mechanism.

eMudhra and Node2Shell - a possible attack chainHypothetical attack chain combining eMudhra certificate impersonation with Node2Shell. Each stage requires specific conditions, and no combined attack has been publicly demonstrated.

Would the attack actually work?

Several conditions would need to be met.

  1. The attacker needs control over the connection path or another way to redirect the request. Recovering a CA private key alone doesn't provide that control.

  2. The client must still trust the forged certificate. Browser protections don't necessarily apply to server-side applications, but Node.js and other runtimes have already introduced changes to certificate validation.

  3. The application must process the response using an affected Brotli decoder. Node.js fetch() provides one entry point, but not every HTTP client handles compressed responses the same way.

The second and third conditions can overlap. The October 21 Node.js release addressed both the decoder and certificate trust issues, so older runtimes may still have both problems, depending on their certificate configuration.

Reaching the decoder also doesn’t guarantee remote code execution. Imperva demonstrated RCE on Node.js 24.22.0 running on Linux arm64, but it required multiple attempts. Public exploit code now exists and CISA lists the flaw as exploited, but whether the result is a crash or successful code execution still depends on the build, architecture, runtime protections, and application behavior.

The individual mechanisms are documented, but we haven't tested the combined chain, and there's no public evidence that the compromised eMudhra keys have been used to deliver Node2Shell.

Does the attack even need the certificate?

Often, no. Node2Shell doesn't depend on the eMudhra keys. Applications accepting Brotli-compressed request bodies may expose the decoder directly to external clients. Applications fetching data from attacker-controlled servers or compromised upstream APIs could also receive malicious responses without a forged certificate.

PowerShell 7 provides another example. Microsoft's guidance confirms that Invoke-WebRequest and Invoke-RestMethod automatically decompress HTTP responses by default. This creates a potential entry point when the commands process Brotli-compressed responses from an attacker-controlled or compromised server.

The forged certificate adds value in a more specific situation.When the attacker needs to impersonate a trusted HTTPS service, can redirect the connection and the client still accepts a certificate issued through the compromised keys.

It's a possible delivery path, but not the only one, and not necessarily the simplest.

The problem is bigger than Node.js

CVE-2026-111497 affects Google's Brotli decoder, which is used across multiple runtimes, libraries and applications. Microsoft released fixes for .NET, PowerShell 7 and Visual Studio in late October. Python's brotli and brotlicffi packages also required updates, while Java applications using brotli4j and products built on Envoy and Istio have been identified as affected.

The exposure differs between products. In .NET, for example, automatic Brotli decompression isn't enabled by default for ASP.NET Core requests or HttpClient responses. An application must enable those paths or explicitly use the Brotli APIs.

An application accepting compressed requests may expose the decoder to unauthenticated clients. An HTTP client that decompresses responses requires the attacker to control the server or the response. The important question isn't just whether a vulnerable library is present, but where it's called and who controls the input.

Patching also depends on how the library is packaged. Some applications use the operating system's Brotli library, while others bundle or compile their own copy. Java's brotli4j includes native Brotli code, and self-contained .NET applications or containers may need to be rebuilt.

Updating the system library won't necessarily fix every application using it.

What does this mean for identity security?

If the combined attack worked, the result wouldn't stop at impersonating a trusted service. It could also lead to code execution inside the application.

A forged certificate doesn't automatically expose application credentials. It may allow service impersonation or interception of information sent over the connection. But if malicious content delivered through that connection leads to code execution, the attacker could potentially access API tokens, service-account credentials and other secrets available inside the process.

Whether the malicious data arrives through a forged certificate, an HTTP request or a compromised upstream server, successful code execution puts the identities available to that application at risk.

The next target could be the access the application already has. There's still no demonstrated attack combining the eMudhra keys with Node2Shell. But the analysis shows that an attacker may have simpler ways to reach the vulnerable decoder without relying on certificate impersonation.

eBook - Identity Visibility

FREE EBOOK
Move from identity blind spots to total visibility

Discovery is key to reducing risk. The CISOs guide to identity risk explains why and how.