Description

Composition lookup can potentially poison base function in Spring Cloud Function. Spring Cloud Function 5.0.0 - 5.0.3 Spring Cloud Function 4.3.0 - 4.3.4 Spring Cloud Function 4.2.0 - 4.2.7 Spring Cloud Function 3.2.16 and earlier

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "3.1",
  "pubDate": "2026-08-27T20:17:56.173Z",
  "pubdate": "2026-08-27T20:17:56.173Z",
  "executiveSummary": "A vulnerability exists in Spring Cloud Function where improper handling of composition lookups allows for the poisoning of base functions.\nThis vulnerability is categorized as an improper input validation or logic flaw during the function composition process, which can lead to unauthorized modification of the execution context.\nThe vulnerability affects multiple versions of Spring Cloud Function, specifically 5.0.0 - 5.0.3, 4.3.0 - 4.3.4, 4.2.0 - 4.2.7, and 3.2.16 and earlier.\nSuccessful exploitation allows an attacker to manipulate the function composition mechanism, potentially altering the behavior of the application by substituting or poisoning the intended base function logic.\nThe risk implication is significant as it can lead to arbitrary logic execution, data manipulation, or unauthorized processing within the application's workflow.\nThe attack typically requires the ability to influence the function composition parameters or definitions provided to the application, depending on the specific implementation context and exposed endpoints.",
  "technicalDetails": "The core of this vulnerability lies in the mechanism Spring Cloud Function uses to facilitate function composition, wherein multiple functions can be chained or combined to perform complex operations. The vulnerability occurs because the framework fails to adequately sanitize or validate the lookup process for these composed functions, allowing an attacker to inject or replace base function definitions.\nThe technical root cause is an insecure handling of function lookup requests when composing, which allows a maliciously crafted input to overwrite or redirect the intended reference to a base function. By poisoning the lookup, an attacker forces the application to execute a function different from the one originally configured or expected by the developer.\nThe attack flow generally involves the following steps: First, the attacker identifies an entry point where function composition is initiated, often exposed via HTTP headers or specific input parameters used by the Spring Cloud Function router or composition engine. Second, the attacker crafts a payload designed to target the lookup mechanism, injecting a reference to an unintended function or a modified version of a legitimate function. Third, the framework processes this composition request, and due to the flaw, updates the internal function registry or execution pipeline to include the attacker's supplied 'poisoned' function. Finally, subsequent calls to the affected composition trigger the attacker-supplied logic instead of the legitimate base function.\nThis vulnerability is particularly concerning in environments where user-supplied input is used to dynamically construct function chains. The vulnerability affects Spring Cloud Function versions 5.0.0 - 5.0.3, 4.3.0 - 4.3.4, 4.2.0 - 4.2.7, and 3.2.16 and earlier.\nThe post-exploitation impact includes the ability to redirect data flows, execute unauthorized code segments, or bypass business logic constraints by substituting sensitive functions with malicious equivalents. The degree of exposure is dependent on whether the composition endpoints are accessible over the network and whether authentication is required to initiate the composition process. By influencing the internal function registry, an attacker effectively gains control over the processing logic of the serverless function, leading to potential integrity and confidentiality compromises."
}