Falha Dirty Frag em Linux Aumenta o Risco Pós-Comprometimento

Resumo

Dirty Frag refere-se a falhas de escalonamento de privilégios locais no Linux rastreadas como CVE-2026-43284 and CVE-2026-43500 que permitem a um usuário de baixa privilegiatura obter acesso root abusando de componentes de rede e manipulação de fragmentos de memória do kernel, incluindo esp4, esp6, e rxrpc. O exploit foi observado em ataques no mundo real onde adversários primeiramente ganham uma posição inicial através de acesso SSH, web shells, escapadas de contêineres ou contas de serviço comprometidas, e então acionam a vulnerabilidade com um binário ELF que invoca o su comando. Uma vez que os privilégios de root são obtidos, os atacantes podem desativar controles de segurança, alterar logs, mover-se lateralmente e estabelecer persistência a longo prazo. O relatório descreve uma campanha limitada, mas ativa, usando esta técnica.

Investigação

Pesquisadores do Microsoft Defender observaram uma cadeia de intrusão passo a passo na qual um ator externo primeiro ganhou acesso SSH, abriu um shell interativo, e preparou um binário ELF chamado ./update. Esse binário imediatamente invocou su para escalar privilégios, após o qual o atacante modificou um arquivo de autenticação GLPI LDAP, enumerou diretórios GLPI, deletou e leu arquivos de sessão PHP, e exfiltrou dados de sessão. A atividade estava alinhada com alertas do Microsoft Defender ligados a execução SUID e SGID suspeitas e potencial exploração do Dirty Frag. A investigação permanece em andamento enquanto os pesquisadores continuam revisando novas telemetrias.

Mitigação

Atualizações de segurança para CVE-2026-43284 foram lançadas em 8 de maio de 2026, enquanto uma correção para CVE-2026-43500 não estava disponível no momento do relato. Mitigações recomendadas incluem desativar os módulos vulneráveis do kernel rxrpc, esp4, e esp6 através da configuração do modprobe , reduzir acesso local desnecessário ao shell, reforçar workloads em contêineres, e limpar caches de páginas após tentativas de exploração suspeitas. As organizações também devem priorizar a implantação de patches do kernel e verificar a integridade de arquivos críticos após qualquer suspeita de comprometimento.

Resposta

Os defensores devem detectar o uso incomum do su comando, carregamento dos esp4, esp6, ou rxrpc módulos, e execução de binários ELF desconhecidos em contextos privilegiados. Aplicar rapidamente as últimas atualizações do kernel continua sendo crítico. Controles adicionais devem incluir a aplicação de privilégios mínimos para contas locais, melhor gerenciamento de chaves SSH, e monitoramento de integridade de arquivos para arquivos sensíveis, como configurações de autenticação GLPI LDAP. Se a exploração for suspeita, equipes devem limpar caches, descarregar os módulos afetados, e realizar análise forense tanto de artefatos de memória quanto do sistema de arquivos.

Simulação de Execução

Pré-requisito: A Verificação Preliminar de Telemetria e Linha de Base deve ter passado.

Justificativa: Esta seção detalha a execução precisa da técnica do adversário (T1548) projetada para acionar a regra de detecção. Os comandos e a narrativa DEVEM refletir diretamente os TTPs identificados e visam gerar precisamente a telemetria esperada pela lógica de detecção.

• Narração e Comandos do Ataque:

  1. Preparação – Soltar o ELF malicioso:
     O atacante, operando com uma conta de baixa privilegiatura, cria um binário ELF manipulado chamado update que explora a vulnerabilidade Dirty Frag. No laboratório, simulamos isso com um simples ELF “hello world”.

     cat <<'EOF' > update.c
     #include <stdio.h>
     int main() { printf("Atualização maliciosa executadan"); return 0; }
     EOF
     gcc -o update update.c
     chmod +x update

  2. Execução do binário vulnerável:
     O atacante executa o ELF do diretório atual, gerando um evento execve para ./update.

     ./update

  3. Escalonamento de privilégio – invocar su após o ELF:
     Imediatamente após o término do ELF malicioso, o atacante executa su para obter um shell root, confiando na má configuração do sistema que permite escalonamento sem senha (típico em configurações de laboratório vulneráveis).

     su -c "id"

     A linha de comando su -c "id" contém o literal ./update como parte da mesma sessão (a regra de detecção apenas verifica por proc.cmdline|contains: './update' dentro do mesmo su processo). Para satisfazer a regra, incorporamos o caminho na própria su linha de comando:

     su -c "./update && id"

     Isso concatena a execução do ELF malicioso e a solicitação de escalonamento de privilégio em uma única su invocação, produzindo precisamente a telemetria que a regra espera.

• Script de Teste de Regressão:

  #!/usr/bin/env bash
  # ------------------------------------------------------------
  # Simula cadeia de escalonamento de privilégio Dirty Frag / Falha de Cópia
  # ------------------------------------------------------------
  
  set -euo pipefail
  
  # 1. Construir um binário ELF fictício chamado 'update'
  cat <<'EOF' > update.c
  #include <stdio.h>
  int main() { printf("Atualização maliciosa simuladan"); return 0; }
  EOF
  gcc -o update update.c
  chmod +x update
  
  # 2. Executar o ELF (gera um evento execve normal)
  echo "[*] Executando ELF malicioso ./update"
  ./update
  
  # 3. Acionar a condição de detecção: su com linha de comando contendo './update'
  echo "[*] Invocando su para elevar privilégios enquanto se referencia './update'"
  # Nota: Em muitos ambientes de laboratório 'su' pode estar configurado sem uma senha.
  su -c "./update && id"
  
  # 4. Limpeza (tratada separadamente)

• Comandos de Limpeza:

  #!/usr/bin/env bash
  # ------------------------------------------------------------
  # Limpar artefatos criados pelo script de simulação
  # ------------------------------------------------------------
  
  set -euo pipefail
  
  echo "[*] Removendo binário ELF simulado e arquivo fonte"
  rm -f update update.c
  
  echo "[*] Limpeza completa"