CVE-2026-59389
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.
An HTTP request smuggling vulnerability (CVE-2026-59389) has been identified in the Spring WebFlux multipart parser, which allows attackers to smuggle multipart parts or part headers past checks that an application performs on multipart content. When the application relays that multipart request to a downstream service, the downstream service can interpret it differently and act on content the application never inspected.
Per OWASP: HTTP Smuggling leverages the different ways that a particularly crafted HTTP message can be parsed and interpreted by different agents (browsers, web caches, application firewalls).
This issue affects multiple versions of Spring Framework.
Details
Module Info
- Product: Spring Framework
- Affected packages:
org.springframework:spring-web - Affected versions: >=5.3.0 <=5.3.50, >=6.0.0 <=6.0.32, >=6.1.0 <=6.1.29, >=6.2.0 <=6.2.20, >=7.0.0 <=7.0.10
- GitHub repository: https://github.com/spring-projects/spring-framework
- Published packages: https://central.sonatype.com/artifact/org.springframework/spring-web
- Package manager: Maven
- Fixed in:
- OSS Spring Framework 7.0.11
- NES for Spring Framework
Vulnerability Info
This Medium-severity vulnerability is found in the org.springframework:spring-web package in multiple versions of Spring Framework. It affects Spring WebFlux applications that receive multipart requests from untrusted sources, perform checks against the multipart content, and relay those requests to downstream services.
Spring WebFlux parses multipart request bodies with the reactive MultipartParser in org.springframework.http.codec.multipart, which DefaultPartHttpMessageReader uses to produce Part objects. The parser is lenient in two places, so the parts the application sees can differ from the parts a downstream service sees.
First, the headers of each part are split on CR LF only, and any line that does not contain a colon is silently skipped:
private static final String HEADER_ENTRY_SEPARATOR = "\\r\\n";
private HttpHeaders parseHeaders() {
// ...
String string = joined.toString(MultipartParser.this.headersCharset);
DataBufferUtils.release(joined);
String[] lines = string.split(HEADER_ENTRY_SEPARATOR);
HttpHeaders result = new HttpHeaders();
for (String line : lines) {
int idx = line.indexOf(':');
if (idx != -1) {
String name = line.substring(0, idx);
String value = line.substring(idx + 1);
while (value.startsWith(" ")) {
value = value.substring(1);
}
result.add(name, value);
}
}
return result;
}A bare LF or CR inside a header line is therefore kept as part of the header value. For example, the line Content-Disposition: form-data; name="a"\nContent-Type: text/plain is read by Spring as a single Content-Disposition header, while a downstream parser that accepts bare LF line endings sees two headers. Lines without a name/value separator are dropped instead of rejected, so malformed content passes through without an error.
Second, the boundary matchers in PreambleState and BodyState search for the delimiter alone and do not check what follows it:
public BodyState() {
byte[] delimiter = MultipartUtils.concat(CR_LF, TWO_HYPHENS, MultipartParser.this.boundary);
this.boundary = DataBufferUtils.matcher(delimiter);
this.boundaryLength = delimiter.length;
}RFC 2046 only allows a boundary delimiter to be followed by CR LF (another part) or -- (the close delimiter). Because any bytes are accepted after the delimiter, a body line such as --boundaryXline two ends the current part for Spring, while a compliant downstream parser treats it as ordinary body content. An attacker can use these differences to craft a multipart request whose parts, names or headers look harmless to the application's checks but are interpreted as different parts or headers by the downstream service that receives the relayed request.
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.