Nov 20, 2026·8 min read·2 visits
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.
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.
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.
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.
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:
HttpObjectAggregator or chunk limits).LastHttpContent chunk so the server finishes parsing the OHTTP payload and destroys the inner OHttpRequestResponseContext.The vulnerability mechanics are demonstrated by the diagnostic test OHttpCumulationBufferRetentionTest included in the research context:
./mvnw -pl codec-ohttp -Dtest=OHttpCumulationBufferRetentionTest -DfailIfNoTests=false testWhen 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=0As 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.
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.
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:
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.PooledByteBufAllocatorMetric.usedDirectMemory() and numActiveAllocations() via JMX or application telemetry to detect divergent spikes between active request throughput and allocated off-heap memory.CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L| Product | Affected Versions | Fixed Version |
|---|---|---|
netty-incubator-codec-ohttp Netty Project (io.netty.incubator) | >= 0.0.20.Final, < 0.0.27.Final | 0.0.27.Final |
| Attribute | Detail |
|---|---|
| CVE / GHSA ID | CVE-2026-69133 / GHSA-cg26-4c6j-2x8h |
| Weakness Class | CWE-772: Missing Release of Resource after Effective Lifetime |
| CVSS v3.1 Score | 5.3 Medium (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L) |
| EPSS Score | 0.30% (23.82nd Percentile) |
| Attack Vector | Network (Unauthenticated HTTP Keep-Alive Connections) |
| Impact | Direct/Pooled Memory Exhaustion (Endpoint Denial of Service) |
| Exploit Status | Proof-of-Concept (Unit Test Reproduction) |
| Patched Version | 0.0.27.Final |
The product does not release a resource after its effective lifetime has ended, which can allow an attacker to exhaust the available resource pool.
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.
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.
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.
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.
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.
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.