Skip to main content

Netty CVE-2026-42583

HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-05-07 https://github.com/netty/netty GHSA-mj4r-2hfc-f8p6
7.5
CVSS 3.1 · Vendor: https://github.com/netty/netty
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Open TCP connection
  2. Delivery
    Send 22-byte crafted LZ4 header
  3. Exploit
    Trigger 32MB ByteBuf allocation
  4. Execution
    Repeat across many connections
  5. Persist
    Exhaust server memory
  6. Impact
    Cause OutOfMemoryError or service crash

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the target application to use Netty's Lz4FrameDecoder in a server-side ChannelPipeline that processes data from untrusted network sources. Specifically, the application must accept LZ4-compressed frames over TCP or UDP and instantiate the Lz4FrameDecoder handler to decompress incoming data. Most critical for services explicitly designed to handle LZ4-compressed protocols (custom binary APIs, gaming servers, distributed systems using LZ4 for wire compression). Exploitation is limited if: (a) the application uses Netty but does not employ LZ4 compression handlers, (b) LZ4 decoding is restricted to authenticated users or internal-only channels, (c) per-channel or aggregate memory quotas are enforced via Netty configuration or JVM heap limits, or (d) network infrastructure enforces connection rate limits or payload inspection that discards malformed LZ4 frames. No user interaction required - remote unauthenticated exploitation against default configurations of Netty applications exposing Lz4FrameDecoder to untrusted inputs.

Impact

Real-world risk is moderate to high for exposed applications but not universally critical. CVSS vector AV:N/AC:L/PR:N/UI:N indicates straightforward remote exploitation without authentication - a single unauthenticated attacker can exhaust server memory by opening concurrent connections and sending 22-byte frames repeatedly. EPSS data not provided, but the low attack complexity and network vector suggest high exploitation feasibility once attackers identify vulnerable endpoints. No CISA KEV listing indicates this is not yet widely exploited in the wild, but the published PoC in GitHub advisory GHSA-mj4r-2hfc-f8p6 lowers the skill barrier to opportunistic attacks. Key risk mitigators: this specifically affects applications that (1) use Netty's Lz4FrameDecoder in server-side pipelines and (2) accept LZ4-compressed data from untrusted network sources. Many Netty deployments use HTTP/2 or custom protocols without LZ4 compression, reducing the attack surface. Applications with per-connection memory limits, rate limiting, or Web Application Firewalls may already have compensating controls. Priority is highest for public-facing services explicitly advertising LZ4 compression support (e.g., custom binary protocols, game servers, IoT gateways) without aggregate memory caps.

Exploit ScenarioDerived

An attacker identifies a Java service exposing a Netty-based binary protocol endpoint on TCP port 8080 that accepts LZ4-compressed payloads. The attacker crafts a minimal 22-byte LZ4 frame with a valid magic number, BLOCK_TYPE_COMPRESSED flag, compressedLength of 1 byte, and decompressedLength set to the maximum 32MB (1 << 25). Opening 1,000 concurrent connections and sending this crafted frame on each connection forces the server to allocate 32GB of heap memory (1,000 * 32MB) within seconds, exhausting available RAM and triggering OutOfMemoryError. Publicly available exploit code exists in GitHub advisory GHSA-mj4r-2hfc-f8p6, lowering the barrier to replication.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.0% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – May 07, 2026

Memory exhaustion in Netty's Lz4FrameDecoder allows remote unauthenticated attackers to cause denial of service by sending minimal malicious data that triggers disproportionate server-side memory allocation. A 22-byte crafted LZ4 frame forces the decoder to allocate up to 32MB of heap memory per request, enabling resource exhaustion attacks against Java applications using Netty's compression codec. Publicly available exploit code exists (PoC published in GitHub advisory GHSA-mj4r-2hfc-f8p6). CVSS 7.5 indicates network-exploitable high-availability impact with no authentication or complexity barriers, though real-world risk depends on whether LZ4 decompression is exposed to untrusted network inputs.

RemediationAI

Upgrade to patched Netty versions: netty-codec-compression 4.2.13.Final or later, and netty-codec 4.1.133.Final or later, as confirmed in GitHub advisory GHSA-mj4r-2hfc-f8p6. Update Maven/Gradle dependencies to reference the fixed versions and redeploy affected services. If immediate patching is not feasible, implement compensating controls: (1) Configure per-channel memory limits using Netty's ChannelConfig maxMessagesPerRead and writeBufferWaterMark settings to cap buffer growth - note this may degrade throughput for legitimate high-volume clients. (2) Deploy connection-level rate limiting to restrict new connection attempts per source IP (e.g., iptables connlimit or application-layer throttling) - be aware this impacts legitimate users behind NAT. (3) Add aggregate memory quotas using JVM flags -Xmx to limit total heap size and -XX:MaxDirectMemorySize for off-heap buffers, ensuring OOM conditions trigger graceful degradation rather than full crashes - understand this creates a ceiling on concurrent users. (4) Remove Lz4FrameDecoder from ChannelPipeline if LZ4 decompression is not required, or restrict its use to trusted internal channels only. Vendor advisory URLs: https://github.com/netty/netty/security/advisories/GHSA-mj4r-2hfc-f8p6.

Affected Packages

maven io.netty:netty-codec fix: 4.1.133.Final
maven io.netty:netty-codec-compression fix: 4.2.13.Final

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in maven

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Netty is a widely-used asynchronous event-driven network application framework for Java. The Lz4FrameDecoder component in the netty-codec-compression library implements LZ4 frame decompression for network streams. The vulnerability stems from CWE-400 (Uncontrolled Resource Consumption) where the decoder trusts user-supplied header fields - specifically the 'decompressedLength' field in the LZ4 frame header - to pre-allocate ByteBuf objects before validating the actual compressed payload. The decoder calls ctx.alloc().buffer(decompressedLength, decompressedLength) immediately after reading the header, allowing an attacker to specify a maximum block size (32MB per LZ4 specification) with only 22 bytes of network traffic. This creates an amplification factor of approximately 1.5 million to one. Affected packages per CPE data: maven/io.netty:netty-codec-compression and maven/io.netty:netty-codec, impacting any Java application using Netty's LZ4 frame decoding in network-facing channels without external rate limiting or memory quotas.

Know when Java gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (https://github.com/netty/netty) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
SUSE HIGH
Red Hat 7.5 HIGH

Primary rating from Vendor (https://github.com/netty/netty).

CVSS VectorVendor: https://github.com/netty/netty

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

DescriptionCVE.org

Summary

Lz4FrameDecoder allocates a ByteBuf of size decompressedLength (up to 32 MB per block) before LZ4 runs. A peer only needs a 21-byte header plus compressedLength payload bytes - 22 bytes if compressedLength == 1 - to force that allocation.

Details

io.netty.handler.codec.compression.Lz4FrameDecoder#decode Header fields are trusted for sizing. On the compressed path, after readableBytes >= compressedLength, the decoder does ctx.alloc().buffer(decompressedLength, decompressedLength) then decompresses.

PoC

The test below demonstrates how an attacker sending 22 bytes will force the server to allocate 32MB

java
    @Test
    void test() throws Exception {
        EventLoopGroup workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
        try {
            AtomicReference<Throwable> serverError = new AtomicReference<>();
            CountDownLatch latch = new CountDownLatch(1);

            ServerBootstrap server = new ServerBootstrap()
                    .group(workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline()
                                    .addLast(new Lz4FrameDecoder())
                                    .addLast(new ChannelInboundHandlerAdapter() {
                                        @Override
                                        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
                                            if (cause instanceof DecoderException) {
                                                serverError.set(cause.getCause());
                                            } else {
                                                serverError.set(cause);
                                            }
                                            latch.countDown();
                                        }
                                    });
                        }
                    });

            ChannelFuture serverChannel = server.bind(0).sync();

            Bootstrap client = new Bootstrap()
                    .group(workerGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ByteBuf buf = ctx.alloc().buffer(22, 22);
                            buf.writeLong(MAGIC_NUMBER);
                            buf.writeByte(BLOCK_TYPE_COMPRESSED | 0x0F);
                            buf.writeIntLE(1);
                            buf.writeIntLE(1 << 25);
                            buf.writeIntLE(0);
                            buf.writeByte(0);

                            ctx.writeAndFlush(buf);

                            ctx.fireChannelActive();
                        }
                    });

            ChannelFuture clientChannel = client.connect(serverChannel.channel().localAddress()).sync();

            assertTrue(latch.await(10, TimeUnit.SECONDS));

            assertInstanceOf(IndexOutOfBoundsException.class, serverError.get());

            clientChannel.channel().close();
            serverChannel.channel().close();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }

Impact

Untrusted senders without per-channel / aggregate limits can stress memory with many small requests.

Executive ViewAI

Why It Matters

Netty's Lz4FrameDecoder contains a memory exhaustion vulnerability (CVE-2026-42583) that allows remote attackers to trigger disproportionate heap allocation-22 bytes of malicious data can force 32MB allocation per request-creating a denial-of-service risk for any Java application processing LZ4-compressed data from untrusted sources. Organizations running Netty-based services exposed to external network traffic face potential service unavailability without immediate mitigation, as no vendor patch is currently available.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Disable Lz4FrameDecoder if not functionally required; (2) Restrict LZ4 decompression to authenticated connections or internal-only network segments; (3) Implement upstream request-size limits and rate limiting to prevent high-volume frame submission; (4) Configure JVM heap limits and memory-pressure alarms to detect exploitation attempts; (5) Monitor for GHSA-mj4r-2hfc-f8p6 patch availability and apply immediately upon release.

Threat Intelligence Overview

EPSS Score
0.0%
Top 88% exploitable
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
NVD CVE.org EPSS GHSA Vendor GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Affected Products (CPE)CVE.org

pkg:maven/io.netty:netty-codec-compression
pkg:maven/io.netty:netty-codec

More in Java

View all
CVE-2012-4681 CRITICAL POC
9.8 Aug 28

Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m

CVE-2015-7450 CRITICAL POC
9.8 Jan 02

Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti

CVE-2013-2465 CRITICAL POC
9.8 Jun 18

Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent

CVE-2011-3544 CRITICAL POC
9.8 Oct 19

Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug

CVE-2010-1871 HIGH POC
8.8 Aug 05

JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to

CVE-2012-1723 CRITICAL POC
9.8 Jun 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up

CVE-2013-0422 CRITICAL POC
9.8 Jan 10

Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using

CVE-2012-0507 CRITICAL POC
9.8 Jun 07

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up

CVE-2015-4852 CRITICAL POC
9.8 Nov 18

The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers

CVE-2012-5076 CRITICAL POC
9.8 Oct 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow

CVE-2017-3066 CRITICAL POC
9.8 Apr 27

Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla

CVE-2012-0391 CRITICAL POC
9.8 Jan 08

The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during

Vendor StatusVendor

SUSE

Severity: High
Product Status
openSUSE Tumbleweed Fixed
SUSE Linux Enterprise High Performance Computing 15 SP4-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP4-LTSS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-ESPOS Affected
SUSE Linux Enterprise High Performance Computing 15 SP5-LTSS Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy