Node.js patches HTTP/2 bugs that can crash servers or expose response data
Node.js shipped fixes for 16 security flaws, including two HTTP/2 issues that can crash servers or spill memory contents across connections. The unusual part is how little an attacker may need to do.
A patched Node.js release this week fixes a bug where an unauthenticated client can crash a server using the built-in HTTP/2 support on the 24.x and 26.x lines.
That is already bad enough. The unusual part is the second HTTP/2 fix: under some conditions, a server can send a client chunks of its own memory, including responses meant for other connections.
That is not just a glitch. It is the kind of bug that breaks the basic promise that one user's traffic stays separate from another's.
Why these two fixes matter more than the rest
Node.js fixed 16 security flaws in total, and the supported releases are now 22.23.5, 24.22.3, and 26.13.1.
Most security updates are about stopping code execution, privilege escalation, or denial of service. Those are familiar categories. These HTTP/2 issues are notable because they hit both availability and isolation.
One bug can knock a server over. The other can blur the line between connections.
Think of HTTP/2 like a courier van carrying multiple labeled parcels in one trip instead of sending a separate car for each package. That is efficient, and it is a big reason HTTP/2 exists. But if the sorting inside the van goes wrong, one customer can receive part of somebody else's parcel. That appears to be the kind of failure this second flaw risks.
And the first issue being reachable by an unauthenticated client means the attacker may not need an account, a session, or any special position. If the service accepts HTTP/2 traffic and is running an affected release line, the front door may be enough.
A quick plain-English version of the underlying problem
HTTP/2 is designed to handle many streams over one connection. That improves performance, but it also means the software has to keep track of a lot of state correctly: which bytes belong to which request, which response belongs to which stream, and what should happen if the conversation gets interrupted or malformed.
When that bookkeeping goes wrong, two broad things can happen:
- the program hits a bad state and crashes
- the program reads or writes the wrong memory and sends data where it does not belong
The second case is the nastier one.
If a server sends pieces of memory to a client, the exact content can vary. Sometimes it is junk. Sometimes it includes sensitive material that happened to be nearby in memory at that moment. In this case, the known detail says it can include responses intended for other connections, which is enough to treat it seriously even without a full public breakdown of every possible impact.
That is why memory disclosure bugs get attention. They turn a simple request into a peek behind the curtain.
Who should be paying attention
If you run Node.js services and use the runtime's built-in HTTP/2 support, this is for you.
The affected details provided so far are specific on one point: the unauthenticated crash bug affects the 24.x and 26.x release lines. Fixed versions were released across all three supported lines:
- 22.23.5
- 24.22.3
- 26.13.1
Even if your immediate concern is the crash issue, the data exposure angle should move this up the queue. Availability problems are visible fast. Data leaks can sit quietly unless you are looking for them.
If you are not sure whether your application uses HTTP/2, do not guess. Check the app configuration, reverse proxy setup, and deployment notes. Some teams terminate HTTP/2 at a proxy and speak plain HTTP internally. Others use Node's built-in support directly. That distinction matters here.
Practical steps to take now
If you are responsible for a Node.js deployment, keep this simple:
- Update supported installations to 22.23.5, 24.22.3, or 26.13.1, depending on your line.
- Identify any services using Node's built-in HTTP/2 support.
- Prioritize internet-facing systems first, especially ones that accept client traffic directly.
- Review crash logs and monitoring for unexpected process exits around HTTP/2 handling.
- Treat unusual response mix-ups or hard-to-explain client data exposure reports as potential security signals, not just random bugs.
- If you cannot patch immediately, consider reducing exposure by disabling the affected path where that is operationally possible.
Patching is the main fix.
For most readers, the practical read is straightforward: when a runtime update mentions both server crashes and cross-connection data leakage, do not file it under routine maintenance. This is core plumbing, and when plumbing fails, the mess spreads fast.