CVE-2026-59383
Patch Available.
This Vulnerability has been fixed in the Never-Ending Support (NES) version offered by HeroDevs.
Overview
Spring Integration extends the Spring programming model to support Enterprise Integration Patterns, providing lightweight messaging within Spring-based applications and integration with external systems through declarative adapters. Its JDBC module persists messages in relational database tables through message stores such as JdbcMessageStore.
A remote code execution vulnerability (CVE-2026-59383) has been identified in the JdbcMessageStore of Spring Integration, which allows attackers who can write to the message store table to have arbitrary classes deserialized despite a configured allow-list of trusted types. Deserializing attacker-chosen classes can be used to run arbitrary code through gadget chains available on the application classpath.
Per OWASP: Data which is untrusted cannot be trusted to be well formed. Malformed data or unexpected data could be used to abuse application logic, deny service, or execute arbitrary code, when deserialized.
This issue affects multiple versions of Spring Integration.
Details
Module Info
- Product: Spring Integration
- Affected packages:
org.springframework.integration:spring-integration-jdbc - Affected versions: >=6.4.0 <=6.4.13, >=6.5.0 <=6.5.11, >=7.0.0 <=7.0.7, >=7.1.0 <=7.1.2
- GitHub repository: https://github.com/spring-projects/spring-integration
- Published packages: https://central.sonatype.com/artifact/org.springframework.integration/spring-integration-jdbc
- Package manager: Maven
- Fixed in:
- OSS Spring Integration 7.0.8, 7.1.3
- NES for Spring Integration
Vulnerability Info
This High-severity vulnerability is found in the org.springframework.integration:spring-integration-jdbc package in multiple versions of Spring Integration. JdbcMessageStore deserializes stored messages through an AllowListDeserializingConverter, and applications restrict which classes may be deserialized by calling addAllowedPatterns(). Those patterns are added to whichever converter instance the store holds at that moment:
public void addAllowedPatterns(String... patterns) {
this.deserializer.addAllowedPatterns(patterns);
}
The store is also BeanClassLoaderAware. When it is declared as a <bean> or through @Bean, the Spring container populates its properties, including the allowed patterns, before invoking the class loader callback. Unless a deserializer was set explicitly, setBeanClassLoader() then replaces the converter with a new, empty one and rebinds the message row mapper to it:
public void setBeanClassLoader(ClassLoader classLoader) {
if (!this.deserializerExplicitlySet) {
this.deserializer = new AllowListDeserializingConverter(classLoader);
this.mapper = new MessageRowMapper(this.deserializer);
}
}
The previously registered patterns stay on the discarded converter. When messages are read back, the row mapper converts the stored message bytes with the new converter:
public Message<?> mapRow(ResultSet rs, int rowNum) throws SQLException {
byte[] blobAsBytes = rs.getBytes("MESSAGE_CONTENT");
return (Message<?>) this.deserializer.convert(Objects.requireNonNull(blobAsBytes));
}
An empty allow-list does not reject anything; AllowListDeserializingConverter treats it as permitting every type:
protected void checkAllowList(Class<?> clazz) {
if (this.allowedPatterns.isEmpty()) {
return;
}
...
}
As a result, the allow-list the operator configured is silently ignored, and the store passes any serialized object found in the message table to Java deserialization. An attacker able to write rows to the message store table can store a crafted payload using any class present on the classpath, and it is deserialized when the application retrieves the message, which can lead to arbitrary code execution through available gadget classes.
Mitigation
Only recent versions of Spring Integration receive community support. Older lines are End-of-Life and will not receive public updates to address this issue.
As a workaround, configure the JdbcMessageStore with an explicit deserializer through setDeserializer() before adding the allowed patterns, so that setBeanClassLoader() does not replace the converter that holds them, and restrict write access to the message store tables to the application only.
Users of the affected components should apply one of the following mitigations:
- Upgrade to a currently supported version of Spring Integration.
- Leverage a commercial support partner like HeroDevs for post-EOL security support.
Credits
- Scott Frederick from HeroDevs (finder)