CVE-2026-59431
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, data access, web and messaging support, and the Spring Expression Language (SpEL) used to query and manipulate objects at runtime.
A denial of service vulnerability (CVE-2026-59431) has been identified in the Spring Expression Language, which allows attackers who can supply SpEL expressions to use the collection selection operators to perform significantly more work than the configured maximum number of operations permits. This can lead to excessive CPU consumption.
Per OWASP: The Denial of Service (DoS) attack is focused on making a resource (site, application, server) unavailable for the purpose it was designed.
This issue affects multiple versions of Spring Framework.
Details
Module Info
- Product: Spring Framework
- Affected packages:
org.springframework:spring-expression - Affected versions: >=7.0.0 <=7.0.10, >=6.2.0 <=6.2.20, >=6.1.0 <=6.1.29, >=6.0.0 <=6.0.32, >=5.3.0 <=5.3.50, <=5.2.26.RELEASE
- GitHub repository: https://github.com/spring-projects/spring-framework
- Published packages: https://central.sonatype.com/artifact/org.springframework/spring-expression
- 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-expression package in multiple versions of Spring Framework. Applications are vulnerable when they accept and evaluate untrusted or user-controlled SpEL expressions.
SpEL limits the number of operations an expression may perform during evaluation (maxOperations, 10,000 by default), so that an untrusted expression cannot consume unbounded resources. SpEL AST nodes report their work by calling ExpressionState.trackOperation(), and evaluation fails with SpelEvaluationException (EL1085E) once the limit is reached.
The collection selection operators (?[...] for all matches, ^[...] for the first match and $[...] for the last match) are implemented in Selection.getValueRef(). The operator evaluates the selection criteria against every entry of a map, or every element of a list or array, but it tracks an operation only for the selection itself and for each element that matches the criteria:
state.trackOperation();
List<Object> result = new ArrayList<>();
for (Object element : data) {
try {
state.pushActiveContextObject(new TypedValue(element));
state.enterScope();
Object val = selectionCriteria.getValueInternal(state).getValue();
if (val instanceof Boolean b) {
if (b) {
if (this.variant == FIRST) {
return new ValueRef.TypedValueHolderValueRef(new TypedValue(element), this);
}
state.trackOperation();
result.add(element);
}
}
// ...The map branch follows the same pattern. Elements for which the criteria evaluate to false are not counted by the selection, so a selection whose criteria rarely or never match can process every element of a large collection while counting far fewer operations than it performs. An attacker can therefore make an expression perform significantly more work than the maxOperations limit is meant to permit, which can lead to excessive CPU consumption.
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
YLChen-007 (finder)