Description

DefaultExecutionContextSerializer, used by default in Spring Batch's JDBC job repository, passes Base64-decoded bytes directly to ObjectInputStream.readObject() without an ObjectInputFilter that restricts types to a trusted class allowlist. Spring Batch 6.0.0 - 6.0.4 Spring Batch 5.2.6 and earlier

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "5.6",
  "pubDate": "2026-08-27T06:17:17.640Z",
  "pubdate": "2026-08-27T06:17:17.640Z",
  "executiveSummary": "This vulnerability is an instance of insecure deserialization within the DefaultExecutionContextSerializer component of Spring Batch. The flaw exists because the library processes Base64-encoded data and passes the resulting byte stream directly to ObjectInputStream.readObject() without implementing a strict ObjectInputFilter or a deserialization allowlist.\nThe vulnerability affects Spring Batch versions 6.0.0 through 6.0.4 and 5.2.6 and earlier. By providing a maliciously crafted serialized object, an attacker can trigger arbitrary code execution (ACE) within the context of the application server. This poses a critical risk to the confidentiality, integrity, and availability of the underlying system.\nSuccessful exploitation allows an unauthenticated or authenticated attacker (depending on the exposure of the job repository) to achieve remote code execution. Because the application fails to validate the class types during the reconstruction of objects, the Java Virtual Machine (JVM) will attempt to instantiate any gadget classes present on the classpath. Organizations utilizing affected versions are at significant risk if the job repository is accessible to untrusted inputs, as this vulnerability provides a direct vector for total system compromise.",
  "technicalDetails": "The vulnerability resides in the DefaultExecutionContextSerializer class, which is the default implementation for serializing and deserializing the execution context within Spring Batch's JDBC job repository. The class functionality involves taking stored binary data from the database, performing a Base64 decoding operation, and subsequently invoking readObject() on an ObjectInputStream to hydrate the Java object.\nThe root cause is the absence of a restrictive ObjectInputFilter (introduced in Java 9+ and backported to older versions) or any form of application-level validation to restrict the types of objects that the deserializer is permitted to process. In Java deserialization, the readObject() method effectively acts as a sink; when the JVM deserializes the stream, it automatically triggers methods within the classes being reconstructed. If an attacker identifies 'gadget chains'—classes already present on the application's classpath that perform dangerous operations (such as executing shell commands or writing files) during their readObject() or finalize() cycles—they can force the application to execute arbitrary code.\nThe attack flow follows a predictable sequence: First, the attacker identifies the storage mechanism for the Spring Batch execution context, typically a database table defined in the JDBC job repository. Second, the attacker constructs a malicious payload using tools like Ysoserial to generate a serialized object graph that triggers a gadget chain upon deserialization. Third, the attacker injects this Base64-encoded payload into the database record that Spring Batch is configured to read. When the application service polls the job repository or triggers a job execution, the DefaultExecutionContextSerializer invokes the vulnerable readObject() method on the malicious payload.\nBecause the deserialization process is executed server-side, the resulting payload executes with the privileges of the application process. This bypasses typical authentication barriers if the malicious payload is placed into the repository through secondary means, such as an application feature that allows updating job context data. The lack of an allowlist-based filtering mechanism means that the application effectively trusts any serialized object presented to it, rendering the entire JVM process vulnerable to malicious class instantiation."
}