CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-69133

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 20, 2026·8 min read·2 visits

Executive Summary (TL;DR)

Netty OHTTP client and server codecs fail to release or reset the outer cumulation buffer upon completing an OHTTP exchange. Remote peers can complete a large exchange and keep the connection idle via HTTP keep-alive to pin direct memory and exhaust JVM buffer pools. Upgrade to version 0.0.27.Final to resolve the flaw.

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Vulnerability Overview

The io.netty.incubator:netty-incubator-codec-ohttp library provides Netty channel handlers that implement Oblivious HTTP (OHTTP) as defined in RFC 9458. OHTTP is an architecture designed to decouple client network identities from encrypted application requests by routing encapsulated Binary HTTP messages through an untrusted relay to a target gateway. Within a Netty pipeline, OHttpClientCodec and OHttpServerCodec process the outer HTTP transport frames, manage cryptographic context state, and delegate inner payload decoding to OHttpRequestResponseContext.

In versions 0.0.20.Final through 0.0.26.Final, both OHttpClientCodec and OHttpServerCodec contain a resource lifecycle flaw classified under CWE-772 (Missing Release of Resource after Effective Lifetime). During the reception of an OHTTP message, incoming HttpContent chunks are aggregated into a handler-scoped ByteBuf field named cumulationBuffer. While the codec destroys the inner OHttpRequestResponseContext upon receiving and processing the final LastHttpContent frame, it fails to deallocate or reset the outer cumulationBuffer.

Because the outer cumulationBuffer remains allocated and referenced by the handler instance, its backing memory chunk stays pinned at the highest capacity reached during the message exchange. On connections that remain open via HTTP keep-alive, this memory is not returned to the ByteBufAllocator until a subsequent inbound message triggers reallocation or the underlying TCP channel closes. An unauthenticated peer can exploit this behavior by completing a single large OHTTP transaction on multiple persistent connections and leaving them idle, exhausting JVM direct memory or Netty buffer pools.

Root Cause Analysis

Netty relies on explicit reference counting (ReferenceCounted) to manage off-heap direct memory and pooled buffer allocations. When a codec accumulates fragmented network frames into a composite or dynamic ByteBuf, it must ensure that the buffer is released when framing completes or the channel tears down. In netty-incubator-codec-ohttp, inbound outer HTTP body chunks are appended to cumulationBuffer inside the decode method of OHttpClientCodec and OHttpServerCodec before being passed to oHttpContext.parse(...).

As oHttpContext.parse decapsulates the outer OHTTP payload, it advances the readerIndex of cumulationBuffer until all available ciphertext bytes are consumed (readableBytes() == 0). When the isLast flag is true (indicating LastHttpContent) and parsing finishes, the codec tears down the exchange state by calling h.destroy() in the client codec or destroyContext() in the server codec. This teardown routine invokes OHttpRequestResponseContext.destroy(), which releases the inner Binary HTTP cumulation buffer.

The root cause of CVE-2026-69133 is that the outer cumulationBuffer owned directly by OHttpClientCodec and OHttpServerCodec is omitted from this post-exchange cleanup. The only code path that unconditionally calls cumulationBuffer.release() in vulnerable versions is handlerRemoved(ChannelHandlerContext ctx). Consequently, after an exchange finishes on an active channel, cumulationBuffer remains attached to the handler with refCnt=1 and readableBytes=0, holding onto the full capacity expanded to accommodate the previous payload.

It is important to distinguish this bug from an unbounded memory leak on a single channel. If a second OHTTP exchange occurs on the same keep-alive connection, the existing cumulationBuffer capacity is reused rather than leaked. However, if the peer ceases transmitting data after a large exchange, the expanded buffer remains pinned indefinitely for the duration of the idle TCP session.

Code Analysis

The vulnerability was resolved in commit a82cd85099c1a1fb78b73b068c77c8c902fc32ce by modifying the completion blocks in both OHttpClientCodec.java and OHttpServerCodec.java. In the vulnerable implementation, the codecs destroyed the inner request/response context immediately upon processing the last HTTP content chunk without checking the state of cumulationBuffer.

diff --git a/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpClientCodec.java b/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpClientCodec.java
index c738cc8..0faeb2d 100644
--- a/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpClientCodec.java
+++ b/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpClientCodec.java
@@ -245,6 +245,14 @@ protected void decode(ChannelHandlerContext ctx, HttpObject msg, List<Object> ou
                 out.add(ReferenceCountUtil.retain(msg));
             }
             if (isLast) {
+                // Check if we can either free up some memory or release it all together.
+                if (cumulationBuffer.isReadable()) {
+                    cumulationBuffer.discardSomeReadBytes();
+                } else {
+                    cumulationBuffer.release();
+                    cumulationBuffer = Unpooled.EMPTY_BUFFER;
+                }
+
                 OHttpRequestResponseContextHolder h = contextHolders.pollFirst();
                 assert h != null;
                 h.destroy();
diff --git a/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpServerCodec.java b/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpServerCodec.java
index 23b88d6..b91b66b 100644
--- a/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpServerCodec.java
+++ b/codec-ohttp/src/main/java/io/netty/incubator/codec/ohttp/OHttpServerCodec.java
@@ -188,6 +188,13 @@ protected final void decode(ChannelHandlerContext ctx, HttpObject msg, List<Obje
                         oHttpContext.parse(ctx.alloc(), cumulationBuffer, isLast, out);
                     } finally {
                         if (isLast && oHttpContext.receivedLastHttpContent()) {
+                            // Check if we can either free up some memory or release it all together.
+                            if (cumulationBuffer.isReadable()) {
+                                cumulationBuffer.discardSomeReadBytes();
+                            } else {
+                                cumulationBuffer.release();
+                                cumulationBuffer = Unpooled.EMPTY_BUFFER;
+                            }
                             destroyContext();
                         }
                     }

The patch introduces a conditional check when isLast is reached. In the standard case where the entire outer payload has been consumed by oHttpContext.parse, cumulationBuffer.isReadable() returns false. The patched code invokes cumulationBuffer.release() to decrement the reference count and return the memory chunk to the allocator, then resets the reference to Unpooled.EMPTY_BUFFER.

> [!NOTE] > Fix Completeness & Residual Risk Assessment: If cumulationBuffer.isReadable() evaluates to true when isLast is processed (for example, if unconsumed bytes remain in the buffer), the patch invokes cumulationBuffer.discardSomeReadBytes(). In Netty's AbstractByteBuf implementation, discardSomeReadBytes() shifts unread bytes to index 0 to reclaim writable space within the existing buffer, but it does not shrink or deallocate the underlying pooled memory chunk. Consequently, if a peer were able to leave trailing unread bytes in cumulationBuffer across an exchange boundary, the allocated capacity would remain pinned until those bytes are drained or the channel closes.

Exploitation

Exploiting CVE-2026-69133 does not require authentication, cryptographic key compromise, or malformed protocol packets. Because both OHttpServerCodec and OHttpClientCodec are affected, the attack surface exists in two directions: an external client targeting an OHTTP gateway/server, or a malicious OHTTP gateway/relay targeting a connecting Netty OHTTP client.

To execute a memory pinning attack against an OHTTP server, an adversary follows a multi-step sequence:

  1. Establish numerous concurrent TCP/TLS connections to the target OHTTP endpoint with HTTP keep-alive enabled (the default in HTTP/1.1 and persistent streams).
  2. On each connection, transmit a valid, maximum-sized OHTTP request (e.g., 256 KB to several megabytes, depending on the upstream HttpObjectAggregator or chunk limits).
  3. Transmit the final LastHttpContent chunk so the server finishes parsing the OHTTP payload and destroys the inner OHttpRequestResponseContext.
  4. Hold the connection open in an idle state without sending subsequent HTTP requests, periodically sending TCP keep-alives or minimal transport-level frames if necessary to bypass load balancer idle timers.

The vulnerability mechanics are demonstrated by the diagnostic test OHttpCumulationBufferRetentionTest included in the research context:

./mvnw -pl codec-ohttp -Dtest=OHttpCumulationBufferRetentionTest -DfailIfNoTests=false test

When executed against vulnerable versions (0.0.20.Final through 0.0.26.Final), inspecting the internal buffer state immediately after exchange completion produces the following metrics:

small client after completion: refCnt=1 capacity=1064 readerIndex=1064 writerIndex=1064 readableBytes=0
small server after completion: refCnt=1 capacity=1110 readerIndex=1110 writerIndex=1110 readableBytes=0
large client after completion: refCnt=1 capacity=262144 readerIndex=131114 writerIndex=131114 readableBytes=0
large server after completion: refCnt=1 capacity=262144 readerIndex=131160 writerIndex=131160 readableBytes=0
small after close: clientOldRefCnt=0 serverOldRefCnt=0
large after close: clientOldRefCnt=0 serverOldRefCnt=0

As shown in the diagnostic output, a payload of ~131 KB causes Netty's allocator to expand cumulationBuffer to a power-of-two capacity of 262144 bytes (256 KB). Even though readerIndex equals writerIndex (131160) and readableBytes is 0, refCnt remains 1 until the connection is explicitly closed (clientOldRefCnt=0 serverOldRefCnt=0). Across 10,000 idle connections, a 256 KB buffer per channel pins 2.56 GB of direct memory without generating active CPU load or anomalous error logs.

Impact Assessment

CVE-2026-69133 is rated Medium severity with a CVSS v3.1 score of 5.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L). The attack vector is Network (AV:N), attack complexity is Low (AC:L), and neither privileges (PR:N) nor user interaction (UI:N) are required. There is no impact to confidentiality (C:N) or integrity (I:N), as the retained buffer bytes cannot be read cross-connection.

The availability impact is scored as Low (A:L) because memory growth on any single connection is strictly bounded by the largest individual OHTTP message processed on that channel; repeated exchanges on the same connection reuse the buffer rather than leaking new allocations. However, in high-concurrency deployments where an attacker can establish thousands of parallel keep-alive sessions, the cumulative pinned memory can exhaust the JVM's maximum direct memory (-XX:MaxDirectMemorySize) or Netty's PooledByteBufAllocator arenas.

When direct memory exhaustion occurs, the Netty event loop fails to allocate buffers for new inbound socket reads or outbound writes, throwing java.lang.OutOfMemoryError: Direct buffer memory or io.netty.util.internal.OutOfDirectMemoryError. This degrades service capacity and drops legitimate client connections. As of disclosure, the vulnerability has an EPSS score of 0.00304 (23.82nd percentile) and is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.

Remediation

Development teams using io.netty.incubator:netty-incubator-codec-ohttp should upgrade to version 0.0.27.Final or later. This release incorporates commit a82cd85099c1a1fb78b73b068c77c8c902fc32ce, which ensures cumulationBuffer is released and replaced with Unpooled.EMPTY_BUFFER immediately upon completing an OHTTP message exchange.

To update the dependency in a Maven pom.xml configuration:

<dependency>
    <groupId>io.netty.incubator</groupId>
    <artifactId>netty-incubator-codec-ohttp</artifactId>
    <version>0.0.27.Final</version>
</dependency>

For environments where an immediate library upgrade is not feasible, operators can reduce the attack window by applying defensive channel pipeline and reverse-proxy configurations:

  • Enforce Aggressive Idle Timeouts: Add a Netty IdleStateHandler before the OHTTP codec in the ChannelPipeline with a short readerIdleTime (e.g., 5 to 15 seconds) and close channels upon receiving an IdleStateEvent. This forces handlerRemoved to execute and frees the retained cumulationBuffer.
  • Restrict Concurrent Connections and Keep-Alive: Configure upstream reverse proxies or load balancers to cap the maximum number of concurrent keep-alive connections per source IP address and enforce maximum request payload size limits.
  • Monitor Allocator Metrics: Track PooledByteBufAllocatorMetric.usedDirectMemory() and numActiveAllocations() via JMX or application telemetry to detect divergent spikes between active request throughput and allocated off-heap memory.

Official Patches

Netty ProjectOfficial patch commit releasing cumulationBuffer upon exchange completion
Netty ProjectRelease 0.0.27.Final containing the fix for CVE-2026-69133
GitHub Security AdvisoryGHSA-cg26-4c6j-2x8h advisory and remediation guidance

Fix Analysis (1)

Technical Appendix

CVSS Score
5.3/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
EPSS Probability
0.30%
Top 76% most exploited

Affected Systems

io.netty.incubator:netty-incubator-codec-ohttp (0.0.20.Final through 0.0.26.Final)

Affected Versions Detail

Product
Affected Versions
Fixed Version
netty-incubator-codec-ohttp
Netty Project (io.netty.incubator)
>= 0.0.20.Final, < 0.0.27.Final0.0.27.Final
AttributeDetail
CVE / GHSA IDCVE-2026-69133 / GHSA-cg26-4c6j-2x8h
Weakness ClassCWE-772: Missing Release of Resource after Effective Lifetime
CVSS v3.1 Score5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L)
EPSS Score0.30% (23.82nd Percentile)
Attack VectorNetwork (Unauthenticated HTTP Keep-Alive Connections)
ImpactDirect/Pooled Memory Exhaustion (Endpoint Denial of Service)
Exploit StatusProof-of-Concept (Unit Test Reproduction)
Patched Version0.0.27.Final

MITRE ATT&CK Mapping

T1499.003Endpoint Denial of Service: Resource Exhaustion
Impact
T1499.002Endpoint Denial of Service: Service Exhaustion
Impact
CWE-772
Missing Release of Resource after Effective Lifetime

The product does not release a resource after its effective lifetime has ended, which can allow an attacker to exhaust the available resource pool.

Known Exploits & Detection

GitHubOfficial GitHub Security Advisory detailing the cumulationBuffer retention mechanics in OHttpClientCodec and OHttpServerCodec.

Vulnerability Timeline

CVE-2026-69133 reserved by GitHub_M.
2026-08-03
Fix commit a82cd85099c1a1fb78b73b068c77c8c902fc32ce authored and committed by Norman Maurer.
2026-08-04
Initial GitHub Security Advisory recorded in repository tracking (GHSA-cg26-4c6j-2x8h).
2026-09-01
Official public disclosure of CVE-2026-69133, GHSA-cg26-4c6j-2x8h, and NVD record publication.
2026-11-19
CISA ADP attached SSVC decision tree metrics and NVD updated vulnerability associations.
2026-11-20

References & Sources

  • [1]GitHub Security Advisory GHSA-cg26-4c6j-2x8h
  • [2]Fix Commit a82cd85099c1a1fb78b73b068c77c8c902fc32ce
  • [3]Netty Incubator Codec OHTTP 0.0.27.Final Release
  • [4]NVD - CVE-2026-69133 Detail
  • [5]CVE.org Record - CVE-2026-69133
  • [6]CVEListV5 JSON Record - CVE-2026-69133

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•15 minutes ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 2 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
2 views•9 min read
•about 3 hours ago•CVE-2026-35374
6.3

CVE-2026-35374: Arbitrary File Truncation via TOCTOU Race Condition in uutils coreutils split

CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 4 hours ago•CVE-2026-35377
3.3

CVE-2026-35377: Local Denial of Service via Improper Single-Quote Backslash Parsing in uutils coreutils env

CVE-2026-35377 is an improper input validation vulnerability (CWE-20) in the env utility of uutils coreutils, the Rust-based reimplementation of GNU coreutils. When processing command-line arguments with the -S (--split-string) option, the uutils split-string tokenizer erroneously validates backslash sequences enclosed within single quotes against a fixed table of known escape characters. Under standard GNU env behavior, backslashes inside single quotes are treated literally (except for \\ and \'). Because uutils rejects unrecognized sequences such as \a, \x, or \| with exit code 125, automated scripts, shebang invocations, and administrative workflows relying on POSIX/GNU compatibility fail to execute, resulting in a local denial of service.

Alon Barad
Alon Barad
2 views•9 min read
•about 5 hours ago•CVE-2026-35376
4.5

CVE-2026-35376: Time-of-Check Time-of-Use (TOCTOU) Race Condition in uutils coreutils chcon

A Time-of-Check to Time-of-Use (TOCTOU) race condition in the chcon utility of uutils coreutils prior to version 0.8.0 allows a local attacker with write access to a directory tree undergoing recursive SELinux context relabeling to redirect extended attribute modifications to arbitrary system files.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 6 hours ago•CVE-2026-105802
8.6

CVE-2026-105802: Arbitrary Command Execution via Submodule Configuration Injection in Git LFS

A line delimiter injection vulnerability in Git Large File Storage (Git LFS) versions 0.6.0 through 3.8.0 allows remote attackers to execute arbitrary commands via crafted Git submodule URLs containing embedded line feed characters.

Alon Barad
Alon Barad
2 views•12 min read