MEDIUM 5.3

CVE-2026-47244: Netty HTTP/2 Unlimited Stream Allocation DoS Vulnerability

Netty, a widely-used framework for building network applications and HTTP/2 servers, has a flaw in how it manages concurrent HTTP/2 streams. By default, Netty does not enforce a limit on the number of concurrent streams a client can open on a single connection, allowing an attacker to exhaust server resources by opening hundreds of thousands of stream objects. This vulnerability becomes especially dangerous when combined with Rapid-Reset-style attacks, where attackers can amplify their impact by rapidly opening and closing many streams.

Source data · NVD / CISA · public domain

CVSS
3.1 · 5.3 MEDIUM · CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
Weaknesses (CWE)
CWE-400
Affected products
1 configuration(s)
Published / Modified
2026-06-12 / 2026-06-17

NVD description (verbatim)

Netty is a network application framework for development of protocol servers and clients. Prior to versions 4.1.135.Final and 4.2.15.Final, DefaultHttp2Connection.DefaultEndpoint initialises maxActiveStreams/maxStreams to Integer.MAX_VALUE, and Http2Settings never inserts SETTINGS_MAX_CONCURRENT_STREAMS by default (Http2Settings.java:305-307 only clamps a user-supplied value). Unless the application explicitly calls initialSettings().maxConcurrentStreams(n), a Netty HTTP/2 server advertises no limit and enforces none locally. Each open stream allocates a DefaultStream object, PropertyMap slots, flow-controller state and IntObjectHashMap entry; with ~2^30 permissible odd stream IDs a single TCP connection can create hundreds of thousands of long-lived stream objects. This is also the precondition for CVE-2023-44487-style Rapid-Reset amplification, where the absence of a low concurrent cap multiplies backend work. Versions 4.1.135.Final and 4.2.15.Final patch the issue.

3 reference(s) · View on NVD →

SEC.co analysis · AI-assisted, reviewed against source

Technical summary

The vulnerability stems from DefaultHttp2Connection.DefaultEndpoint initializing maxActiveStreams and maxStreams to Integer.MAX_VALUE, and Http2Settings failing to set SETTINGS_MAX_CONCURRENT_STREAMS by default. Unless an application explicitly calls initialSettings().maxConcurrentStreams(n), the Netty HTTP/2 server advertises unlimited concurrent streams and enforces no local cap. Each stream allocates a DefaultStream object, PropertyMap slots, flow-controller state, and IntObjectHashMap entries. With ~2^30 permissible odd stream IDs per connection, a single client can create hundreds of thousands of long-lived stream objects, consuming memory and CPU. This configuration also establishes preconditions for CVE-2023-44487-style Rapid-Reset attacks, where the absence of a concurrent-stream ceiling multiplies backend computational load per attack packet.

Business impact

For organizations running Netty-based HTTP/2 servers—particularly API gateways, microservice frameworks, and reverse proxies—this vulnerability enables resource exhaustion attacks. An attacker can force a server to allocate and maintain massive numbers of stream objects with minimal bandwidth, leading to memory pressure, reduced throughput, and potential service degradation or outage. The risk is heightened for internet-facing services processing untrusted traffic. If an application does not enforce its own concurrent-stream limits upstream, it is fully exposed.

Affected systems

All Netty versions prior to 4.1.135.Final and 4.2.15.Final are affected. Any application using these older versions and deploying HTTP/2 without explicit maxConcurrentStreams configuration is vulnerable. This includes frameworks, libraries, and products that embed Netty, as well as direct users of the Netty library. Version 4.0 is not explicitly mentioned in the source data; verify vendor advisories for extended version coverage.

Exploitability

Exploitation requires only network access to an HTTP/2 endpoint; no authentication or user interaction is needed. An attacker can craft a series of HTTP/2 stream-opening requests to trigger the vulnerability. The attack is straightforward to execute—no complex exploitation techniques are required—and can be launched remotely. However, the CVSS score of 5.3 (Medium) reflects that the primary impact is availability, not confidentiality or integrity. Practical impact depends on the server's resource capacity and whether upstream network controls limit traffic.

Remediation

Upgrade to Netty version 4.1.135.Final or 4.2.15.Final, which patch the default stream-limit behavior. For applications unable to upgrade immediately, explicitly configure maxConcurrentStreams to a reasonable value (e.g., 100–1000, depending on workload) via initialSettings().maxConcurrentStreams(n). Additionally, enforce rate-limiting and connection-level controls at the load balancer or reverse proxy to reject excessive stream-open requests before they reach the application.

Patch guidance

1. Identify all services and dependencies using Netty. Check build artifacts (Maven, Gradle, etc.) and dependency trees for Netty versions. 2. Upgrade to 4.1.135.Final (for the 4.1.x line) or 4.2.15.Final (for the 4.2.x line) as soon as possible. 3. Review application initialization code to confirm that HTTP/2 settings are explicitly configured with a maxConcurrentStreams value if not relying solely on the patched defaults. 4. Test the patched version in a staging environment, particularly if the application relies on HTTP/2 stream multiplexing for legitimate high-concurrency workloads. 5. Monitor your supply chain: if your application embeds Netty indirectly through a framework (Spring, gRPC, etc.), verify that the framework or its dependencies have also been updated.

Detection guidance

Monitor HTTP/2 connection metrics for anomalies: rapid increases in the number of concurrent streams per connection, unusual memory growth tied to stream allocation, or CPU spikes during periods of low legitimate traffic. Log HTTP/2 SETTINGS frames and stream-open events to identify patterns of abuse. Network-level detection: watch for a single client source opening many streams in a short period. If your infrastructure includes a WAF or API gateway, configure rules to detect or throttle clients that exceed a reasonable stream-open rate (e.g., >100 streams/second). Application-level monitoring of DefaultStream object counts and PropertyMap allocations can reveal resource exhaustion in progress.

Why prioritize this

Although the CVSS score is Medium (5.3), this vulnerability merits prioritization because: (1) it is trivial to exploit remotely with no authentication; (2) it creates a vector for resource exhaustion and denial of service on internet-facing infrastructure; (3) when combined with Rapid-Reset techniques, it amplifies attacker impact; and (4) the fix is a simple version upgrade with minimal breaking changes. Organizations with Netty-based HTTP/2 endpoints should patch within their standard high-severity window (1–2 weeks for critical services).

Risk score, explained

CVSS 5.3 (Medium) reflects a network-accessible denial-of-service vulnerability with low attack complexity and no privileges or user interaction required. The impact is limited to availability (no confidentiality or integrity loss), justifying a score below 7.0. However, the practical risk may be higher in environments where (a) Netty servers are directly exposed to untrusted networks, (b) resource capacity is constrained, or (c) Rapid-Reset-style attacks are a known threat actor technique in your threat model.

Frequently asked questions

Do I need to patch if my application has its own stream-concurrency limits?

If your application explicitly sets maxConcurrentStreams via Netty's initialSettings() API, or if you enforce stream limits at a WAF or reverse proxy layer, the risk is mitigated. However, patching is still recommended to reduce the attack surface and ensure defense-in-depth. Do not rely solely on application-level controls without verifying they are always enforced.

Can this vulnerability be exploited without opening a large number of actual HTTP/2 requests?

Yes. The vulnerability allows a single TCP connection to create hundreds of thousands of stream objects with minimal network overhead. An attacker does not need to send full HTTP requests for each stream; opening a stream (via HTTP/2 HEADERS frames) is sufficient to allocate internal state. This makes the attack efficient and difficult to detect based on throughput alone.

How does this relate to CVE-2023-44487 (Rapid-Reset)?

CVE-2023-44487 exploited stream resets to amplify attack impact. This vulnerability creates a precondition by removing the server-side limit on concurrent streams. Combining the two flaws allows an attacker to create and reset thousands of streams more efficiently, multiplying backend work. Patching this CVE closes that amplification vector.

What versions of Netty are affected?

All versions prior to 4.1.135.Final and 4.2.15.Final. Version 4.0 is not explicitly listed in the advisory; verify with your Netty vendor or the official GitHub security advisory for extended coverage. If you use a framework (Spring Boot, gRPC, etc.), check that framework's Netty dependency constraints.

This analysis is provided for informational purposes and based on publicly available CVE data. No actual exploit code or weaponized proof-of-concept is provided. Organizations should verify all patch version numbers and affected product lists against official vendor advisories and their own dependency inventories before taking action. The CVSS score and severity assessment are as published by MITRE/NVD and reflect base-case assumptions; actual risk may differ based on your deployment architecture, network controls, and threat model. Always test patches in a non-production environment before production deployment. Source: NVD (public-domain), retrieved 2026-07-20. Analysis generated by SEC.co (claude-haiku-4-5).