HTTP2Shell: How a Supply-Chain Flaw Crossed Languages
Node2Shell is becoming HTTP2Shell. The exposure has spread from Node.js into Python packages and Brotli components. For teams building AI Agents and LLM applications, patching the CVE is not enough; they need to identify the dependencies that actually run inside each request path.The Vulnerability Moves from Node.js into Python
The original Node2Shell story focused on the Node.js ecosystem. Aikido Security used the term HTTP2Shell in the title and summary of its article. The exposure then spread along two paths:- Python packages indirectly pulled in a vulnerable Brotli component.
- HTTP/2 implementations were reused across languages, frameworks, and proxy services.
Why Brotli?
HTTP response compression does not necessarily mean Brotli compression. Servers usually announce the encoding with Content-Encoding: br, and clients decompress the response based on the negotiated encoding. The risk emerges while processing compressed content or related protocol state, rather than during ordinary static-file transfers.
Dependency boundaries do not naturally align with language boundaries.
A Python package may wrap a native extension, while a C or C++ compression library may be called by multiple HTTP stacks. An application may contain only a few relevant lines:
import brotli
payload = brotli.decompress(compressed_body)
What determines the actual scope of risk is which Brotli version the package depends on, how that version was compiled, where the input originates, and whether the call path is reachable.
Aikido Security's disclosure also covered multiple HTTP libraries and applications. Rather than framing the issue as “another vulnerability in Node.js,” it adopted the name HTTP2Shell to emphasize lateral propagation at the protocol and infrastructure layers.
The story reached the front page of Hacker News with 76 points and 36 comments. That generated substantial discussion, but the more consequential question is not the number of CVEs. It is how many ecosystem chains reuse the same underlying component.
What CVE-2026-111497 Actually Hits
CVE-2026-111497 is the central identifier in this disclosure. Aikido Security's article focuses on the vulnerability and lists affected Python packages, trigger conditions, and remediation details.
The “affected versions” listed in a security advisory provide only the first answer. At least four questions need to be separated:
- Does the vulnerability reside in Brotli, a native C extension, or HTTP/2 parsing logic?
- What inputs are required to trigger it, such as compressed data, a particular state, or an abnormal sequence?
- Which Python packages include the component directly or indirectly?
- Can the application actually receive and process attacker-controlled data?
This is why checking the language and framework alone is insufficient.
Network parsers often become a shared weak point. They must accept untrusted input while maintaining context across frames, streams, and compression states. The more complex the attacker-controlled bytes become, the harder it is for the application layer to contain every boundary condition.
From a defensive perspective, HTTP/2 introduces risks beyond a single implementation function. Connection reuse, stream concurrency, flow control, header processing, and compression negotiation can all influence the attack path.
If an upstream fix covers only one entry point while a downstream library retains the same parsing pattern, the vulnerability may return through another route.
Investigations must also distinguish between a dependency being present and the vulnerability being exploitable.
An affected version appearing in a service's lockfile does not mean the production service is necessarily exposed. A gateway may filter the input first, the service may not enable the relevant protocol, or the malicious data may never reach the dangerous branch.
Conversely, reviewing only an application's direct dependencies is not enough. The transport layer may come from an ASGI or WSGI server, a reverse proxy, or a component built into the runtime.
Why Patching Node.js May Not Be Enough
Upstream components, downstream libraries, and application code do not form a simple version chain. They can be divided into three layers:
- Underlying components: Brotli, HTTP/2 implementations, or parser libraries.
- Intermediate wrappers: Python packages, Node.js packages, and bindings for multiple languages.
- Top-level applications: web services, frameworks, proxies, and business systems.
Patching the original entry point usually guarantees only that one direct dependency chain no longer propagates the flaw downstream. If intermediate wrappers continue carrying the old version, upgrading a framework at the application layer may still leave the vulnerable underlying code in place.
Build methods can also affect the outcome.
The same Python package may publish a wheel or require local compilation of a native extension. A system-level Brotli installation, the Brotli embedded in a Python extension, and a separately installed Brotli in a container image may not be the same binary.
The final runtime environment determines whether a deployment is affected.
The same applies to Node.js services. Updating http2 calls in application code does not necessarily update the system OpenSSL, the proxy layer, or a shared HTTP/2 component used by another service.
As a result, “Node.js has been patched” is not a sufficient conclusion. Teams must also answer:
- Do Python and other language runtimes share any underlying libraries?
- Do images, virtual machines, or sidecars include outdated versions?
- Do lockfiles and the SBOM match the artifacts actually deployed?
- Does traffic pass through another proxy or gateway that parses it?
The most common mistake here is treating a dependency scanner's results as runtime facts.
Scanners are effective at identifying where an old version is declared, but they do not necessarily prove that an attacker can reach it.
Supply-Chain Remediation Requires a Dependency Graph
An effective investigation should not begin by upgrading every package and waiting for alerts to disappear.
First, Trace HTTP/2 and Brotli Call Paths
Work backward from the entry point:
- Is HTTP/2 enabled?
- Do request bodies or responses use
Content-Encoding: br? - Which library performs decompression?
- Which module parses HTTP/2 frames and stream state?
Then work forward through the dependency chain:
- Do affected Python packages directly depend on a vulnerable version?
- Is it introduced through a transitive dependency?
- Do native extensions statically link an outdated component?
Only the intersection of these two paths produces a meaningful reachable call graph.
Next, Verify Versions and Trigger Conditions
Compare version numbers against both the affected ranges and remediation details in Aikido Security's article. Do not infer a version from the package name, and do not inspect only the top-level lockfile.
At a minimum, preserve four types of evidence:
1. Top-level dependencies and lockfile
2. Complete SBOM
3. Actual versions in images or artifacts
4. Reachable HTTP/2 and Brotli call paths
If the deployment uses Python, installed packages and native extensions can be inspected in an isolated environment:
python -m pip list
python -m pip show <affected-package>
python -c "import importlib.metadata as m; print(m.version('<affected-package>'))"
Replace <affected-package> with the specific package names listed in Aikido's advisory. To determine which version a native extension ultimately links to, combine wheel contents, build manifests, or image scan results with the package inspection.
Finally, Verify Actual Reachability
Reachability takes priority over a blanket upgrade.
For internet-facing entry points, check whether HTTP/2 is enabled, whether Brotli is negotiated, and whether malformed compressed data can reach the parser. For internal services, determine whether they also handle public-facing proxy traffic, callbacks, or webhooks.
After remediation, add regression tests covering several cases. Normal Brotli content should continue to work; malformed compressed input should be rejected safely; and the service must not crash, consume abnormal amounts of resources, or enter an inconsistent state.
Original materials from Aikido Security are available here:
- Article: https://www.aikido.dev/blog/python-packages-vulnerable-node2shell-brotli-cve-2026-111497
- Hacker News discussion: https://news.ycombinator.com/item?id=50219177
The Broader Remediation Lesson
The importance of HTTP2Shell extends beyond one new CVE. Low-level protocol components are repeatedly wrapped by different languages and frameworks, making it difficult to apply fixes at the same pace. Advisories are published package by package, while attackers search for entry points along reachable paths. Focusing only on the Node.js packages where the flaw was first exposed can overlook bypasses through Python, proxy layers, and shared native libraries.
The next response will likely shift from counting upgraded packages to determining what versions actually run inside deployed artifacts. An SBOM still may not be enough because static linking, image layers, and proxy services can all cause the inventory to diverge from the deployment reality. Mapping entry points, protocols, call paths, and artifact versions is more reliable than patching one language at a time.
This case differs from vulnerabilities confined to a single library. HTTP/2 and compression components are cross-language infrastructure, so their boundaries naturally extend beyond any one package manager. The precise exposure still depends on deployment topology. A service that does not enable HTTP/2, or whose vulnerable call path is unreachable, should not be classified as compromised solely because an affected dependency name appears in its inventory.