CVE-2026-50560: Netty HTTP/2 Header Size DoS Vulnerability
Netty, a widely-used Java framework for building network servers and clients, has a flaw in how it handles HTTP/2 header size limits. When a client specifies a maximum header list size via the HTTP/2 SETTINGS_MAX_HEADER_LIST_SIZE parameter, Netty can be forced into a state where it crashes while attempting to send response headers back to the client. An attacker can exploit this to repeatedly trigger these crashes, effectively denying service to legitimate users—similar in impact to the HTTP/2 Rapid Reset attack but using different network-level mechanics. The vulnerability affects Netty versions before 4.1.135.Final and 4.2.15.Final.
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-770
- 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, Netty HTTP/2 max header size handling produces an attack similar to HTTP/2 Rapid Reset. There is a setting in the http2 specification called `SETTINGS_MAX_HEADER_LIST_SIZE`. When a client sends that setting to Netty, it appears that Netty will behave as follows: read the request; proxy the request to the origin; attempt to produce a response; and create an exception while writing the headers for the response. Functionally, this should be similar to the http2 reset attack, but with a different on-the-wire signature. Versions 4.1.135.Final and 4.2.15.Final patch the issue.
4 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
The vulnerability resides in Netty's HTTP/2 implementation, specifically in the handling of the SETTINGS_MAX_HEADER_LIST_SIZE setting. When a client sends this setting, Netty processes the inbound request and forwards it to an origin server. However, when constructing the outbound response headers, Netty fails to properly validate or handle header sizes against the negotiated limit, leading to an exception during header serialization. This exception can be triggered repeatedly by an attacker sending crafted HTTP/2 frames, creating a denial-of-service condition. The root cause maps to CWE-770 (Allocation of Resources Without Limits or Throttling), as Netty does not adequately throttle or limit resource consumption during header processing.
Business impact
Applications and proxies built on Netty—including API gateways, load balancers, reverse proxies, and microservice frameworks—become susceptible to availability attacks. An attacker with network access can send a low volume of HTTP/2 requests with specifically crafted SETTINGS_MAX_HEADER_LIST_SIZE values to crash or exhaust resources in the Netty process, rendering the service unavailable to legitimate traffic. This is particularly concerning for critical infrastructure, financial systems, and any internet-facing service relying on Netty. The attack requires no authentication or special privileges, making it accessible to any network-adjacent threat actor.
Affected systems
Netty versions 4.1.x prior to 4.1.135.Final and 4.2.x prior to 4.2.15.Final are affected. Any application or service using these versions and exposing HTTP/2 endpoints is at risk. This includes but is not limited to Spring Cloud Gateway, gRPC-Java (which uses Netty), Project Reactor Netty, and custom protocol implementations built directly on Netty. Organizations should inventory all services using Netty and cross-reference against the fixed versions.
Exploitability
This vulnerability is readily exploitable. No authentication, user interaction, or special network privileges are required. An attacker with basic network access to an affected Netty HTTP/2 service can trigger the flaw by sending standard HTTP/2 frames with a low SETTINGS_MAX_HEADER_LIST_SIZE value, causing immediate denial of service. The attack surface is broad for any internet-facing HTTP/2 service. However, the vulnerability is not currently listed on CISA's Known Exploited Vulnerabilities (KEV) catalog, suggesting active exploitation in the wild has not yet been officially confirmed at publication time.
Remediation
Upgrade Netty to version 4.1.135.Final or later for the 4.1.x branch, or to version 4.2.15.Final or later for the 4.2.x branch. These versions include fixes that properly validate and enforce the SETTINGS_MAX_HEADER_LIST_SIZE limit, preventing the header serialization exception. For applications using Netty indirectly through frameworks like Spring Cloud Gateway or Project Reactor Netty, ensure those frameworks have released and deployed updates incorporating the patched Netty version.
Patch guidance
1. Identify all services running Netty by checking dependency manifests (pom.xml for Maven, build.gradle for Gradle, etc.) or runtime introspection. 2. For 4.1.x users, upgrade to 4.1.135.Final; for 4.2.x users, upgrade to 4.2.15.Final. Check the Netty release notes to confirm no breaking changes affect your implementation. 3. For transitive Netty dependencies, update parent frameworks (e.g., Spring Boot, Spring Cloud Gateway, gRPC-Java) to versions that include the patched Netty. 4. Test thoroughly in a staging environment, especially HTTP/2 workloads, before production rollout. 5. Schedule upgrades promptly given the ease of exploitation.
Detection guidance
Monitor for HTTP/2 SETTINGS frames with unusually small or crafted SETTINGS_MAX_HEADER_LIST_SIZE values originating from external or suspicious sources. Watch application logs for repeated 'header serialization' or 'header size limit' exceptions correlated with HTTP/2 traffic spikes. Network-level detection could flag repeated SETTINGS_MAX_HEADER_LIST_SIZE changes from the same source within a short time window. Consider deploying WAF or reverse-proxy rules to rate-limit or block HTTP/2 SETTINGS frames that appear anomalous. Correlation of these signals with service availability degradation may indicate active exploitation.
Why prioritize this
Although the CVSS score of 5.3 (MEDIUM) reflects limited confidentiality and integrity impact, the availability attack is trivial to execute and affects core infrastructure layers. HTTP/2 is increasingly common; many organizations do not yet inventory Netty adoption. The lack of KEV designation should not delay patching—it may simply reflect a publication lag. Organizations running internet-facing Netty HTTP/2 services should treat this as a high-priority patch due to ease of exploitation and broad potential blast radius.
Risk score, explained
The CVSS 3.1 score of 5.3 reflects a network-accessible vulnerability (AV:N) with low complexity (AC:L), requiring no privileges (PR:N) or user interaction (UI:N), and causing low availability impact (A:L) in an unchanged scope (S:U). There is no confidentiality (C:N) or integrity (I:N) impact. However, this score underweights the practical threat: the attack is trivial, repeatable, and can be launched at scale. In operational risk terms, the ease of exploitation and the criticality of availability for many services warrant treating this above the MEDIUM baseline.
Frequently asked questions
Does this vulnerability allow an attacker to read or modify data on the server?
No. The vulnerability is purely a denial-of-service flaw. It causes Netty to crash or reject HTTP/2 requests when processing crafted SETTINGS_MAX_HEADER_LIST_SIZE values. There is no confidentiality or integrity breach; the attacker cannot read sensitive data or alter server state. The impact is limited to service availability.
Is this vulnerability similar to HTTP/2 Rapid Reset (CVE-2023-44487)?
Both vulnerabilities exploit weaknesses in HTTP/2 reset handling and can cause denial of service through resource exhaustion. However, they are distinct: Rapid Reset uses RST_STREAM frames to trigger resets, while this vulnerability leverages SETTINGS_MAX_HEADER_LIST_SIZE to cause header serialization exceptions. The on-the-wire signatures and attack patterns differ, but the practical impact—service unavailability—is similar.
Do I need to patch if I don't use HTTP/2?
No. If your application only handles HTTP/1.x traffic, this vulnerability does not affect you. However, if you are unsure whether HTTP/2 is enabled, check your Netty configuration and framework settings. Many modern applications enable HTTP/2 by default, so verification is recommended.
What if I cannot upgrade immediately?
Implement compensating controls: restrict HTTP/2 SETTINGS frames at the firewall or WAF level, rate-limit inbound HTTP/2 connections, and monitor for the exception patterns mentioned in detection guidance. These measures reduce but do not eliminate risk. Prioritize upgrading as soon as possible.
This analysis is provided for informational purposes to assist security professionals in risk assessment and remediation planning. No guarantee of completeness or accuracy is offered. Organizations should verify all patch versions, affected product versions, and remediation steps against official vendor advisories and their own systems before taking action. SEC.co does not assume liability for decisions made based on this intelligence. Always test patches in non-production environments before deployment. Source: NVD (public-domain), retrieved 2026-07-20. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-44250HIGHNetty Redis Codec Denial-of-Service via Nested Array Memory Exhaustion
- CVE-2026-44890HIGHNetty Redis Codec Memory Exhaustion Denial of Service
- CVE-2026-45416HIGHNetty TLS Memory Exhaustion Denial of Service
- CVE-2026-46340HIGHNetty SCTP Memory Exhaustion Denial of Service
- CVE-2026-48748HIGHNetty HTTP/3 Memory Exhaustion Vulnerability – Patch to 4.2.15.Final
- CVE-2026-50011HIGHNetty Redis Memory Exhaustion Denial of Service
- CVE-2026-10533MEDIUMOpenShift ResourceQuota Bypass Leads to API Server DoS
- CVE-2026-10740MEDIUMs2n-quic Memory Allocation DoS – QUIC CRYPTO Frame Reassembler