Cluster-Chaos-Exploitation-de-CVE-2025-59359-pour-la-prise-de-contrôle-de-Kubernetes

Une procédure pas à pas médico-légale pratique de CVE-2025-59359, une faille critique d'injection de commandes OS dans Chaos-Mesh. Apprenez comment les attaquants détournent les clusters Kubernetes via des mutations GraphQL, et comment détecter, analyser et signaler la brèche en utilisant ELK.

Par Mark Mallia

Résumé exécutif

CVE-2025-59359 expose une faille critique d'injection de commandes OS dans le Controller Manager de Chaos-Mesh. Cette vulnérabilité permet aux attaquants d'exécuter des commandes shell arbitraires à travers les pods Kubernetes, pouvant mener à une compromission complète du cluster. Cet article simule l'exploit, cartographie son empreinte médico-légale et décrit les stratégies de détection et d'atténuation pertinentes pour les équipes techniques et les parties prenantes exécutives.

Pourquoi cette CVE se démarque

Dans le monde en constante évolution de la sécurité Kubernetes, CVE-2025-59359 se distingue comme un rappel frappant de la façon dont une seule entrée négligée peut défaire un cluster entier. Cette vulnérabilité critique (CVSS 9.8) affecte le Controller Manager de Chaos-Mesh, où les paramètres fournis par l'utilisateur sont imprudemment concaténés dans des commandes shell sans aucune vérification ni assainissement. Le résultat ? Un attaquant non authentifié à l'intérieur du cluster peut exécuter des commandes arbitraires sur les pods, obtenant un contrôle complet avec une facilité alarmante. C'est un cas d'école d'escalade de privilèges via l'injection de commandes, et un puissant exemple de pourquoi les commandements de codage sécurisé dans les environnements cloud-native sont importants.

Analyse technique

La faille existe dans la mutation cleanTcs. Cette mutation nettoie les paramètres de contrôle de trafic Linux (TC) après les expériences de chaos, et elle accepte des paramètres fournis par l'utilisateur à partir des spécifications d'expérience.
Lorsqu'un attaquant fournit une valeur modifiée pour ces paramètres, la commande shell résultante est construite par concaténation de chaînes. Aucune vérification défensive n'est effectuée avant que cette commande ne soit exécutée avec les privilèges du Controller Manager—ce qui signifie qu'un utilisateur non authentifié peut injecter des commandes arbitraires dans n'importe quel pod ou namespace contrôlé par le cluster.

Voici un extrait du code source de la mutation (montré dans le contexte de son implémentation Go).

// cleanTcsMutation.go
func executeCleanTcs(ctx context.Context, payload Payload) error {
    // Build command string using user input directly
    cmd := fmt.Sprintf(
        "tc qdisc add dev %s root handle 1: htb rate %s ceil %s",
        payload.Device,
        payload.Rate,
        payload.Ceil,
    )
    log.Debugf("Running command: %s", cmd)
    if err := ctx.RunCommand(cmd); err != nil {
        return fmt.Errorf("tc clean mutation failed: %w", err)
    }
    return nil
}

• La mutation accepte trois paramètres—Device, Rate et Ceil.
• Ceux-ci sont concaténés dans la chaîne de commande sans aucune étape d'assainissement.
• L'appel shell résultant est exécuté avec les privilèges du Chaos Controller Manager, qui a généralement accès à tous les pods dans chaque namespace.

Comment un attaquant peut l'exploiter

Imaginez un cluster Kubernetes exécutant Chaos-Mesh, où un attaquant conçoit une spécification d'expérience apparemment innocente. Mais au lieu de régler le contrôle de trafic, il glisse une charge utile comme ; rm -rf /tmp dans des champs comme Device, Rate ou Ceil. Une fois soumise via l'interface utilisateur ou l'API, la mutation construit et exécute aveuglément la commande—aucun assainissement, aucune barrière de sécurité. Et parce qu'elle s'exécute avec les privilèges du controller-manager, le code injecté se propage à travers les pods comme une traînée de poudre. Pire encore, si l'attaquant utilise également CVE-2025-59358 pour accéder au point de terminaison GraphQL sans authentification, il n'a même pas besoin d'identifiants.

Si elle est exploitée en production, CVE-2025-59359 pourrait permettre aux attaquants de perturber les services, d'accéder à des charges de travail sensibles et de pivoter entre les namespaces—posant un risque matériel pour la continuité des affaires et la conformité réglementaire. Les organisations utilisant Chaos-Mesh devraient prioriser le patching, l'application de RBAC et l'audit des points de terminaison GraphQL.

Cartographie MITRE ATT&CK

Stratégies de détection

• Action immédiate : Revoyez votre politique concernant le traitement des entrées utilisateur dans la mutation cleanTcs.
• Conseil d'atténuation : Ajoutez une étape d'assainissement avant de construire la chaîne de commande shell, ou passez à une requête paramétrée qui évite la concaténation.
• Plan à long terme : Envisagez de mettre en œuvre des contrôles d'accès basés sur les rôles pour le Chaos Controller Manager afin que seuls les utilisateurs autorisés puissent soumettre des spécifications d'expérience.

Configuration du pipeline Logstash

Créez un fichier logstash-tcs.conf dans votre répertoire de configuration Logstash.

input {
  beats {
    port => 5044
    codec => "json"
  }
}

filter {
  # The Python script will be referenced here.
  python {
    code => "/opt/elk/python/process_tcs.py"
    add_field => { "[tcs]" => "%{[message][device]}-%{[message][rate]}-%{[message][ceil]}" }
  }
}

output {
  elasticsearch {
    hosts => ["http://localhost:9200"]
    index => "chaos-tcs"
    document_type => "experiment"
    codec => "json"
  }
}

Script de filtrage Python – process_tcs.py

#!/usr/bin/python3

def process(event):
    """
    Transforms the raw event from Logstash into a JSON document suitable for Elasticsearch.
    Expected input format (example):

      {
        "message": {
          "device": "eth0",
          "rate":   "100mbit/s",
          "ceil":   "200mbit/s",
          "timestamp": "2025‑09‑18T14:33:00Z"
        }
      }

    The script extracts the three key values, normalises them and returns a dictionary.
    """
    # 1. Grab nested fields
    device = event.get("message", {}).get("device", "")
    rate   = event.get("message", {}).get("rate", "")
    ceil   = event.get("message", {}).get("ceil", "")

    # 2. Normalise numeric values – remove unit suffixes and cast to float.
    def strip_unit(val, unit):
        return float(val.replace(unit, "").strip())

    rate_val = strip_unit(rate, "mbit/s")
    ceil_val = strip_unit(ceil, "mbit/s")

    # 3. Build output dict
    result = {
        "device": device,
        "rate_mbit_s": rate_val,
        "ceil_mbit_s": ceil_val,
        "ts": event.get("message", {}).get("timestamp", ""),
        "tcs_id": f"{device}-{rate_val}-{ceil_val}"
    }

    # 4. Return the dict
    return result

Mapping d'index Elasticsearch

Créez un fichier de mapping chaos-tcs-mapping.json:

{
  "mappings": {
    "_doc": {
      "properties": {
        "device":      { "type": "keyword" },
        "rate_mbit_s":{ "type":"float"   },
        "ceil_mbit_s":{ "type":"float"   },
        "ts":          { "type":"date",  "format":"yyyy-MM-dd'T'HH:mm:ssZ"},
        "tcs_id":      { "type":"keyword" }
      }
    }
  }
}

Tableau de bord Kibana – “Command Injection Overview”

Pour visualiser l'impact de CVE-2025-59359 en temps réel, le tableau de bord offre trois panneaux clés qui transforment les données brutes d'expériences de chaos en informations exploitables. La série temporelle suit rate_mbit_s par pod, agrégée par namespace, aidant les équipes à repérer les anomalies dans la mise en forme du trafic à travers le cluster. L'histogramme montre le volume d'expériences par heure et déclenche des alertes lorsque le taux dépasse 1,5× la moyenne, révélant ainsi des abus potentiels ou des schémas d'attaque automatisés. Enfin, la table de filtrage liste chaque tcs_id avec son statut d'exécution et son indicateur de succès, permettant aux enquêteurs d'isoler rapidement les exécutions échouées ou suspectes. Ensemble, ces panneaux forment une lentille médico-légale sur la façon dont l'injection de commandes se déroule dans les environnements Kubernetes.

Ajoutez une règle d'alerte simple :

PUT /chaos-tcs/_settings
{
  "number_of_shards": 2,
  "number_of_replicas": 1
}

Créez un pipeline d'ingestion qui utilise le script Python ci-dessus, puis configurez une alerte Kibana pour qu'elle se déclenche lorsque rate_mbit_s s'écarte de plus de 15 % de sa moyenne mobile sur 24 heures.

Liste de contrôle de déploiement

Conclusion

CVE-2025-59359 n'est pas simplement une ligne de plus dans une base de données de vulnérabilités, c'est un exemple frappant de la façon dont une désinfection négligée des entrées peut compromettre la sécurité d'un cluster Kubernetes entier. En parcourant cet exploit, nous avons vu comment une simple mutation dans Chaos-Mesh peut devenir une passerelle vers l'exécution de code à distance, l'escalade de privilèges et la compromission complète des pods. Mais plus important encore, nous avons montré comment l'observabilité, les outils médico-légaux et une logique de détection réfléchie peuvent transformer le chaos en clarté.

Ce projet est destiné strictement à un usage éducatif et éthique. Toutes les démonstrations, simulations et procédures pas à pas médico-légales sont conçues pour sensibiliser aux vulnérabilités du monde réel et promouvoir un codage sécurisé, une divulgation responsable et des stratégies de défense proactives. En aucun cas, les techniques ou informations présentées ici ne doivent être utilisées pour compromettre, perturber ou exploiter des systèmes en production sans autorisation explicite.