CVE-2026-59418

Denial of Service
Affects
Spring Framework
in
Spring
No items found.
Versions
>=6.1.0 <=6.1.29, >=6.2.0 <=6.2.20, >=7.0.0 <=7.0.10

Patch Available.

Exclamation circle icon
Patch Available

This Vulnerability has been fixed in the Never-Ending Support (NES) version offered by HeroDevs.

Overview

Spring Framework is the foundational Java application framework of the Spring portfolio, providing dependency injection, transaction management, and the Spring MVC and Spring WebFlux web frameworks for building servlet-based and reactive applications.

A denial of service vulnerability (CVE-2026-59418) has been identified in the streaming text decoder of Spring Framework's spring-core module, which allows attackers to make a Spring WebFlux application running on Reactor Netty leak pooled memory by sending request bodies that exceed the configured maxInMemorySize codec limit. Repeated requests can exhaust the server's memory and make the application unavailable.

Per OWASP: The Denial of Service (DoS) attack is focused on making a resource (site, application, server) unavailable for the purpose it was designed. There are many ways to make a service unavailable for legitimate users by manipulating network packets, programming, logical, or resources handling vulnerabilities, among others.

This issue affects multiple versions of Spring Framework.

Details

Module Info

Vulnerability Info

This Medium-severity vulnerability is found in the org.springframework:spring-core package in multiple versions of Spring Framework. StringDecoder, through its base class AbstractCharSequenceDecoder, decodes a stream of incoming data buffers into a Flux<String>, splitting the input on line delimiters. Partial lines are held in a LimitedDataBufferList bounded by the codec's maxInMemorySize, which throws DataBufferLimitException once the limit is exceeded.

An application is exposed when it runs Spring WebFlux on Reactor Netty, decodes request bodies as a stream of String values (for example with bodyToFlux(String.class) or a Flux<String> request body), and configures a maxInMemorySize lower than the size of the buffers the server produces (8KB by default with HTTP/1.1). Applications using the default maxInMemorySize of 256KB with default server settings are not affected.

Each incoming buffer is processed by processDataBuffer:

private Collection<DataBuffer> processDataBuffer(DataBuffer buffer, DataBufferUtils.Matcher matcher,
                LimitedDataBufferList chunks) {

        boolean release = true;
        try {
                List<DataBuffer> result = null;
                do {
                        int endIndex = matcher.match(buffer);
                        if (endIndex == -1) {
                                chunks.add(buffer);
                                release = false;
                                break;
                        }
                        DataBuffer split = buffer.split(endIndex + 1);
                        if (result == null) {
                                result = new ArrayList<>();
                        }
                        int delimiterLength = matcher.delimiter().length;
                        if (chunks.isEmpty()) {
                                if (this.stripDelimiter) {
                                        split.writePosition(split.writePosition() - delimiterLength);
                                }
                                result.add(split);
                        }
                        else {
                                chunks.add(split);
                                DataBuffer joined = buffer.factory().join(chunks);
                                if (this.stripDelimiter) {
                                        joined.writePosition(joined.writePosition() - delimiterLength);
                                }
                                result.add(joined);
                                chunks.clear();
                        }
                }
                while (buffer.readableByteCount() > 0);
                return (result != null ? result : Collections.emptyList());
        }
        finally {
                if (release) {
                        DataBufferUtils.release(buffer);
                }
        }
}

The buffers returned by buffer.split(...) are pooled buffers carved out of the input that each hold their own reference to its memory. When chunks.add(...) throws DataBufferLimitException after one or more lines have already been split off, the split buffers held in the local result list (and the split buffer being added) are never handed downstream and are never released. At the same time, the finally block releases the input buffer, which the concatMapIterable operator also releases through the doOnDiscard(DataBuffer.class, DataBufferUtils::release) hook when the error propagates, so the reference counting of the pooled input is unbalanced as well. An unauthenticated attacker who sends request bodies containing a few short lines followed by data longer than the configured limit can repeat this on every request, steadily leaking Reactor Netty's pooled memory until the application can no longer allocate buffers and stops serving requests.

Mitigation

Only recent versions of Spring Framework receive community support. Older lines are End-of-Life and will not receive public updates to address this issue.

Users of the affected components should apply one of the following mitigations:

  • Upgrade to a currently supported version of Spring Framework.
  • Leverage a commercial support partner like HeroDevs for post-EOL security support.

Credits

Vulnerability Details
Severity
Level
CVSS Assessment
Low
>=0 <4
Medium
>=4 <6
High
>=6 <8
Critical
>=8 <10
Medium
ID
CVE-2026-59418
PROJECT Affected
Spring Framework
Versions Affected
>=6.1.0 <=6.1.29, >=6.2.0 <=6.2.20, >=7.0.0 <=7.0.10
NES Versions Affected
Published date
November 20, 2026
≈ Fix date
Category
Denial of Service
Vex Document
Download VEXHow do I use it?
Sign up for the latest vulnerability alerts fixed in
NES for Spring
Rss feed icon
Subscribe via RSS
or

By submitting the form I acknowledge receipt of our Privacy Policy.

Thanks for signing up for our Newsletter! We look forward to connecting with you.
Oops! Something went wrong while submitting the form.