Description

Applications that evaluate Spring Expression Language (SpEL) expressions using SimpleEvaluationContext may be vulnerable to a safety guard bypass when the SpEL expression compiler is active. Spring Framework 7.0.0 - 7.0.8 Spring Framework 6.2.0 - 6.2.19 Spring Framework 6.1.0 - 6.1.28 Spring Framework 6.0.0 - 6.0.30 Spring Framework 5.3.0 - 5.3.49 Spring Framework 5.2.25.RELEASE and earlier

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.1",
  "pubDate": "2026-08-27T20:17:54.470Z",
  "pubdate": "2026-08-27T20:17:54.470Z",
  "executiveSummary": "A security vulnerability exists in the Spring Framework's Expression Language (SpEL) evaluation mechanism when utilizing SimpleEvaluationContext. The vulnerability manifests as a bypass of established safety guards, specifically triggered when the SpEL expression compiler is enabled.\nThis flaw allows an attacker to execute arbitrary expressions that should otherwise be restricted by the context's security constraints. By manipulating the compiled bytecode, an attacker may transcend intended limitations on object property access or method invocation.\nThe affected versions encompass a wide range of the Spring Framework, including 5.2.25.RELEASE and earlier, 5.3.0 - 5.3.49, 6.0.0 - 6.0.30, 6.1.0 - 6.1.28, 6.2.0 - 6.2.19, and 7.0.0 - 7.0.8.\nSuccessful exploitation could lead to unauthorized data access, sensitive information disclosure, or potential remote code execution depending on the application's configuration and the presence of reachable gadgets within the classpath. This requires an attacker to provide input that is subsequently processed by an insecurely configured SpEL evaluation engine.",
  "technicalDetails": "The vulnerability resides within the interaction between the SpEL expression compiler and the SimpleEvaluationContext. In a secure implementation, SimpleEvaluationContext is designed to restrict SpEL expressions to a subset of the language, explicitly forbidding access to sensitive components such as the ClassLoader, System properties, or arbitrary method execution on restricted types.\nThe root cause of this vulnerability is an improper synchronization between the interpretation phase and the compilation phase of SpEL expressions. When the SpEL compiler is active, it attempts to optimize expression evaluation by generating bytecode at runtime. If the compiler does not properly inherit or enforce the safety restrictions defined within the SimpleEvaluationContext, the resulting bytecode may execute operations that were meant to be blocked by the context's access policy.\nThe attack flow typically follows this sequence: 1) The application uses an instance of SimpleEvaluationContext to evaluate user-supplied expressions; 2) The SpEL compiler, if enabled, intercepts the expression to optimize it into bytecode; 3) Due to the vulnerability, the generated bytecode fails to account for the constraints (e.g., access to properties or methods) defined in the evaluation context; 4) The compiled bytecode is executed by the JVM, effectively ignoring the security boundary intended by the framework.\nThis bypass allows for unintended traversal of object graphs or interaction with protected framework components. By carefully crafting an expression that triggers the compiler, an attacker can bypass property or method access restrictions. If the application environment allows for the invocation of sensitive classes or methods through the SpEL engine, an attacker may achieve arbitrary code execution or disclose configuration data that is typically shielded by the sandbox.\nThe vulnerability is primarily dependent on the application having the SpEL compiler feature enabled. While SimpleEvaluationContext is intended for security-sensitive contexts, the compiler integration creates a secondary path for expression execution that bypasses the restrictive validation logic that the interpreted engine applies. The impact is significant in environments where user input is passed directly to the expression evaluation engine without adequate sanitization or strict allow-listing, as it essentially nullifies the protection provided by the framework's intended security architecture."
}