mrk336/cluster-chaos-exploiting-cve-2025-59359-for-kubernetes-takeoverUma análise forense prática da CVE-2025-59359, uma falha crítica de injeção de comandos do sistema operacional no Chaos-Mesh. Aprenda como invasores sequestram clusters Kubernetes por meio de mutações GraphQL e como detectar, analisar e relatar a violação usando ELK.
Um guia forense prático da CVE-2025-59359, uma falha crítica de injeção de comandos do sistema operacional no Chaos-Mesh. Aprenda como atacantes sequestram clusters Kubernetes por meio de mutações GraphQL e como detectar, analisar e reportar a violação usando ELK.
Por Mark Mallia
A CVE-2025-59359 expõe uma falha crítica de injeção de comandos do sistema operacional no Controller Manager do Chaos-Mesh. Essa vulnerabilidade permite que atacantes executem comandos shell arbitrários nos pods do Kubernetes, o que pode levar ao comprometimento total do cluster. Este artigo simula o exploit, mapeia sua pegada forense e descreve estratégias de detecção e mitigação relevantes tanto para equipes técnicas quanto para stakeholders executivos.
No mundo em constante evolução da segurança do Kubernetes, a CVE-2025-59359 se destaca como um alerta contundente de como uma única entrada negligenciada pode desmoronar um cluster inteiro. Essa vulnerabilidade crítica (CVSS 9.8) afeta o Controller Manager do Chaos-Mesh, onde parâmetros fornecidos pelo usuário são concatenados de forma imprudente em comandos shell, sem verificações nem sanitização. O resultado? Um atacante não autenticado dentro do cluster pode executar comandos arbitrários nos pods, obtendo controle total com uma facilidade alarmante. É um caso clássico de escalada de privilégios por meio de injeção de comandos e um exemplo poderoso de por que os princípios de codificação segura em ambientes cloud-native são importantes.
A falha existe dentro da mutação cleanTcs. Essa mutação limpa as configurações de controle de tráfego (TC) do Linux após experimentos de caos e aceita parâmetros fornecidos pelo usuário nas especificações do experimento.
Quando um atacante fornece um valor malicioso para esses parâmetros, o comando shell resultante é construído por concatenação de strings. Nenhuma verificação defensiva é realizada antes de esse comando ser executado com privilégios do Controller Manager—o que significa que um usuário não autenticado pode injetar comandos arbitrários em qualquer pod ou namespace controlado pelo cluster.
Abaixo está um trecho do código-fonte da mutação (exibido no contexto de sua implementação em 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
}
Device, Rate e Ceil.Imagine um cluster Kubernetes executando o Chaos-Mesh, onde um atacante cria uma especificação de experimento aparentemente inofensiva. Mas, em vez de ajustar o controle de tráfego, ele insere um payload como ; rm -rf /tmp em campos como Device, Rate ou Ceil. Depois de enviado pela UI ou API, a mutação constrói e executa o comando às cegas—sem sanitização, sem salvaguardas. E, como é executado com privilégios do controller-manager, o código injetado se espalha pelos pods como fogo. Pior ainda: se o atacante também explorar a CVE-2025-59358 para acessar o endpoint GraphQL sem autenticação, ele nem precisa de credenciais.
Se explorada em produção, a CVE-2025-59359 pode permitir que atacantes interrompam serviços, acessem workloads sensíveis e façam pivot entre namespaces—representando um risco material para a continuidade dos negócios e a conformidade regulatória. Organizações que usam o Chaos-Mesh devem priorizar a aplicação de patches, a aplicação de RBAC e a auditoria do endpoint GraphQL.
| Tática | Técnica |
|---|---|
| Execução | T1059 – Command and Scripting Interpreter |
| Escalação de Privilégios | T1068 – Exploitation for Privilege Escalation |
| Movimento Lateral | T1021 – Remote Services |
| Impacto | T1499 – Endpoint Denial of Service |
cleanTcs.Crie um arquivo logstash-tcs.conf no diretório de configuração do 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"
}
}
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
Crie um arquivo de mapeamento 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" }
}
}
}
}