Description

Improper neutralization of directives in dynamically evaluated code ('eval injection') vulnerability in Apache Camel K. An improper neutralization of directives in dynamically evaluated Maven configuration allows tenant-controlled repository content to influence code execution within the operator pod, potentially enabling tenants to execute arbitrary code with the privileges of the operator. This issue affects Apache Camel K: from 2.0.0 before 2.9.3, from 2.10.1 before 2.10.2. Users are recommended to upgrade to version 2.9.3, 2.10.2 or 2.11.0, which fixes the issue.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.8",
  "pubDate": "2026-09-10T08:16:58.947Z",
  "pubdate": "2026-09-10T08:16:58.947Z",
  "executiveSummary": "An improper neutralization of directives vulnerability exists in Apache Camel K, classified as an eval injection flaw. This vulnerability arises from the insecure handling of dynamically evaluated Maven configurations.\nThe flaw allows a tenant with the ability to influence repository content to trigger arbitrary code execution within the context of the operator pod. Since the operator runs with elevated privileges in the Kubernetes cluster, this constitutes a critical security risk.\nAffected versions include Apache Camel K 2.0.0 through 2.9.2 and 2.10.1. Attackers require the capability to control or influence the repository content that the Camel K operator interacts with during the build or deployment process.\nSuccessful exploitation grants the attacker the ability to execute arbitrary commands under the service account privileges of the operator, potentially leading to a full compromise of the integration workloads or the underlying Kubernetes namespace.",
  "technicalDetails": "The vulnerability resides within the Apache Camel K operator's Maven configuration processing logic. The operator dynamically evaluates configuration files, specifically those governing repository settings, without sufficient sanitization or neutralization of directives.\nThe root cause is the failure to isolate or validate external repository metadata, allowing untrusted input to be interpreted as executable instructions during the Maven build phase managed by the operator.\nIn a multi-tenant environment, if a user can manipulate a repository configuration, they can inject malicious directives into the build pipeline. When the operator pod processes these configurations to pull dependencies or resolve build settings, the injected directives are evaluated by the underlying runtime environment.\nThe attack flow begins when a tenant provides a malicious Maven configuration via a Camel K resource (e.g., Integration or Build). The operator retrieves this configuration and passes it to the Maven execution context. Because the input is improperly neutralized, the execution engine interprets the injected directives as part of the build command or configuration set.\nThis behavior results in arbitrary code execution (ACE) within the operator pod. Given that the operator pod typically requires broad permissions to orchestrate resources within the cluster, the attacker inherits the operator's service account permissions. This enables further post-exploitation activities, such as lateral movement, unauthorized access to cluster secrets, or the deployment of additional malicious pods.\nThe vulnerability affects Apache Camel K versions 2.0.0 up to (but not including) 2.9.3, and version 2.10.1 (not including 2.10.2). No specific authentication is required if the attacker already has sufficient permissions to define Integration or Build resources within the cluster, making this a significant escalation of privilege vulnerability."
}