CVE-2026-59374
Patch Available.
This Vulnerability has been fixed in the Never-Ending Support (NES) version offered by HeroDevs.
Overview
Spring Framework is the foundational open-source application framework for Java, providing dependency injection, data binding, transaction management and the Spring MVC and WebFlux web frameworks on which most Spring applications are built.
An authorization bypass vulnerability (CVE-2026-59374) has been identified in the property path parsing of Spring Framework's spring-beans module, which allows attackers to write to map-keyed and list-indexed properties that an application has explicitly excluded from data binding with disallowedFields or allowedFields. An attacker only needs to append extra characters after the closing bracket of a protected property path in a submitted form field.
Per OWASP: Software frameworks sometimes allow developers to automatically bind HTTP request parameters into program code variables or objects to make using that framework easier on developers. This can sometimes cause harm. Attackers can sometimes use this methodology to create new parameters that the developer never intended which in turn creates or overwrites new variable or objects in program code that was not intended. This is called a Mass Assignment vulnerability.
This issue affects multiple versions of Spring Framework.
Details
Module Info
- Product: Spring Framework
- Affected packages:
org.springframework:spring-beans - Affected versions: <=5.2.26.RELEASE, >=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-beans
- Package manager: Maven
- Fixed in:
- OSS Spring Framework 7.0.11
- NES for Spring Framework v4.3.42, v5.3.55, v6.1.31, v6.2.22
Vulnerability Info
This High-severity vulnerability is found in the org.springframework:spring-beans package in multiple versions of Spring Framework. Applications use DataBinder's setDisallowedFields and setAllowedFields to keep user-supplied request parameters away from sensitive properties. Before binding, DataBinder.checkAllowedFields() converts each submitted parameter name to its canonical form and matches that string against the configured patterns. The parameter that survives the check is then resolved by AbstractNestablePropertyAccessor, whose getPropertyNameTokens() method splits a path such as settings[role] into the property name settings and the key role:
private PropertyTokenHolder getPropertyNameTokens(String propertyName) {
String actualName = null;
List<String> keys = new ArrayList<>(2);
int searchIndex = 0;
while (searchIndex != -1) {
int keyStart = propertyName.indexOf(PROPERTY_KEY_PREFIX, searchIndex);
searchIndex = -1;
if (keyStart != -1) {
int keyEnd = getPropertyNameKeyEnd(propertyName, keyStart + PROPERTY_KEY_PREFIX.length());
if (keyEnd != -1) {
if (actualName == null) {
actualName = propertyName.substring(0, keyStart);
}
String key = propertyName.substring(keyStart + PROPERTY_KEY_PREFIX.length(), keyEnd);
...
keys.add(key);
searchIndex = keyEnd + PROPERTY_KEY_SUFFIX.length();
}
}
}
PropertyTokenHolder tokens = new PropertyTokenHolder(actualName != null ? actualName : propertyName);
...
}The loop only looks for the next [ after each closing ]. It never checks that a key starts exactly where the previous one ended, and it never checks that the whole path was consumed. Any text after the last ] is silently dropped, so settings[role]x is resolved as settings[role] and array[0]name as array[0]. The field check, however, compares the full submitted string, and settings[role]x does not match an exact disallowedFields pattern of settings[role]. The parameter therefore passes the binding restrictions and is then written to the very map entry or list element the application meant to protect. Applications are exposed when they bind request parameters onto objects, protect nested, map-keyed or list-indexed properties with exact disallowedFields patterns or restrictive allowedFields patterns, and do not also use a wildcard disallowedFields pattern that covers the suffixed form.
Steps to Reproduce
- Add
spring-contextandspring-beansfrom an affected Spring Framework version (for example 6.2.19) to the classpath. - Compile and run the class below. It disallows binding to the
settings[role]map entry and then submits the parametersettings[role]x.
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.validation.DataBinder;
public class Repro {
public static class Account {
private Map<String, String> settings = new HashMap<>();
public Map<String, String> getSettings() { return this.settings; }
public void setSettings(Map<String, String> settings) { this.settings = settings; }
}
public static void main(String[] args) {
Account account = new Account();
DataBinder binder = new DataBinder(account);
binder.setDisallowedFields("settings[role]");
MutablePropertyValues values = new MutablePropertyValues();
values.add("settings[role]x", "admin");
binder.bind(values);
System.out.println(account.getSettings());
}
}- On an affected version the program prints
{role=admin}: the disallowed entry was written. Submittingsettings[role]instead prints{}, because the exact path is blocked.
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
Xint (finder)