Description

Nuclio is a "Serverless" framework for Real-Time Events and Data Processing. Prior to version 1.16.5, Nuclio's Java runtime generates a build.gradle file during function builds using Go's text/template package. The template renders runtimeAttributes.repositories[] values with the {{ . }} action, which performs no escaping. An attacker can embed a closing brace (}) to break out of the repositories {} block and append arbitrary Groovy statements that execute unconditionally during the Gradle configuration phase. This issue has been patched in version 1.16.5.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.0",
  "pubDate": "2026-09-02T17:17:45.630Z",
  "pubdate": "2026-09-02T17:17:45.630Z",
  "executiveSummary": "Nuclio versions prior to 1.16.5 contain a critical template injection vulnerability within the Java runtime build process. The vulnerability stems from the insecure handling of user-supplied input when generating the build.gradle configuration file. By leveraging the Go text/template package, an attacker can supply malicious input that breaks out of the intended data structure, allowing for the execution of arbitrary Groovy code.\nThis vulnerability effectively grants an attacker the ability to achieve Remote Code Execution (RCE) during the function build phase. Because the Gradle configuration is executed with the privileges of the build process, successful exploitation allows for complete compromise of the build environment, potential access to sensitive environment variables, secrets, or the ability to manipulate the resulting function artifacts. The attack requires no authentication if the user-controlled input (specifically the repositories list) is reachable via the Nuclio API or function configuration interface. Users are advised to upgrade to version 1.16.5 or later immediately to mitigate this risk.",
  "technicalDetails": "The vulnerability is a classic Template Injection issue residing in the Nuclio Java runtime component. During the function build cycle, Nuclio programmatically constructs a build.gradle file to manage dependencies and repository configurations. This generation process utilizes the Go standard library package 'text/template'.\nThe root cause is the improper handling of the 'runtimeAttributes.repositories[]' configuration array. When rendering this template, the application injects the repository URLs directly into the output string using the Go template action '{{ . }}'. In the Go template engine, this syntax performs no automatic context-aware escaping or sanitization of the input content.\nAn attacker can exploit this by injecting a payload designed to prematurely terminate the 'repositories' block in the Gradle file. By supplying a string containing a closing brace (}) followed by malicious Groovy code, the attacker breaks the syntax intended by the template author. For example, injecting a string like 'some-url\" } \n [Arbitrary Groovy Code] \n repositories { \"placeholder' effectively escapes the intended configuration context.\nThe attack flow proceeds as follows: First, the attacker identifies an interface that allows defining 'runtimeAttributes' for a Java-based function. Second, the attacker submits a malicious configuration where the repository field includes a payload designed to escape the Gradle 'repositories' closure. Third, when the Nuclio controller triggers the function build process, the template engine renders the build.gradle file, incorporating the malicious Groovy statements into the configuration script.\nWhen the Gradle build process executes to compile the function, it parses the manipulated build.gradle file. Because the injected statements are part of the configuration phase, the build engine executes them with the privileges of the build worker container. This allows the attacker to execute shell commands, exfiltrate environment variables, or tamper with the build artifacts before they are deployed. The vulnerability is present in all versions prior to 1.16.5. There are no authentication requirements for an attacker if they have access to the function deployment configuration process, and the exploitation is independent of the network exposure of the target function itself, as the payload is executed during the build pipeline."
}