Exploração Detalhada de Cadeia de Exploração: CVE-2021-3156 (Baron Samedit)

Autor: IJ Baig
Data: 7 de julho de 2026

1. ID CVE, Versões Afetadas e Confirmação da Build

• ID CVE: CVE-2021-3156
• Tipo de Vulnerabilidade: Estouro de Buffer Baseado em Heap
• Faixa de Versões Afetadas: Versões legadas do Sudo 1.8.2 a 1.8.31p2, e versões estáveis 1.9.0 a 1.9.5p1.
• Versão Alvo Compilada: Sudo 1.9.5p1

1.1 Configuração do Ambiente

Para analisar esta vulnerabilidade com segurança, a versão vulnerável do Sudo foi compilada dentro de um ambiente isolado e não produtivo.

1.2 Compilação a Partir do Código Fonte

O código fonte do Sudo 1.9.5p1 foi baixado e compilado localmente usando utilitários make padrão. Foi tomado cuidado para executar isso a partir de um diretório local para que não sobrescrevesse o binário sudo nativo e corrigido do sistema host.

Confirmação da Build: Após a compilação, o binário personalizado foi executado para verificar se a versão correta e vulnerável foi compilada.

2. Análise da Causa Raiz

2.1 Localização do Código Vulnerável

• Arquivo: plugins/sudoers/sudoers.c
• Função: set_cmnd() (por volta da linha 864 na versão 1.9.5p1)

2.2 A Vulnerabilidade Explicada

Imagine que você tem um ajudante cujo trabalho é remover caracteres de escape (barras invertidas) de uma lista de palavras antes de colocá-las em uma caixa de armazenamento recém-alocada (um buffer de heap). O ajudante assume cegamente que toda barra invertida é sempre seguida por um caractere válido, então, sempre que vê uma barra invertida, a pula e copia o próximo caractere.

No entanto, existe uma falha na forma como o programa processa argumentos ao executar sudoedit -s. Isso permite que um usuário introduza uma palavra que termina exatamente com uma única barra invertida (\), que é imediatamente seguida pelo marcador invisível de fim de palavra (um terminador nulo, \0).

Quando o código do ajudante atinge essa barra invertida final, ele a pula e olha para o próximo caractere — o terminador nulo. Em vez de parar, a lógica da instrução if força o ajudante a pular também o terminador nulo. O loop continua, copiando qualquer memória arbitrária fora dos limites que venha a seguir para a caixa de armazenamento. Essa cópia contínua além do comprimento pretendido da palavra causa um estouro do buffer designado, levando a um grave estouro de buffer baseado em heap.

Trecho do Código Vulnerável:

/* Desescapar caracteres, pulando barras invertidas */
for (to = user_args, av = NewArgv + 1; (from = *av); av++) {
    while (*from) {
        // VULNERABILIDADE: Se from[0] for '\' e from[1] for '\0', 
        // o loop avalia como verdadeiro, incrementa 'from', pulando o terminador nulo.
        if (from[0] == '\\' && !isspace((unsigned char)from[1]))
            from++;
        *to++ = *from++; 
    }
    *to++ = ' ';
}
*--to = '\0';

2.3 Patch Oficial e Explicação da Correção

Os desenvolvedores do Sudo corrigiram esse erro lógico na versão 1.9.5p2 adicionando uma verificação rigorosa de limites. O código agora garante explicitamente que o caractere após a barra invertida não seja o terminador nulo antes de tentar desescapá-lo.

Diff do Patch:

- if (from[0] == '\\' && !isspace((unsigned char)from[1]))
+ if (from[0] == '\\' && from[1] != '\0' && !isspace((unsigned char)from[1]))

Por que isso corrige a causa raiz: A adição de from[1] != '\0' interrompe imediatamente a leitura fora dos limites. Agora, se o código encontrar uma barra invertida final no final da string (ou seja, from[1] é o terminador nulo), a instrução if será avaliada como falsa. O ponteiro não é incrementado prematuramente, o terminador nulo é processado corretamente como o fim da string, e o loop termina de forma segura sem estourar o heap.

3. Reprodução da Exploração

3.1 Prova de Conceito (PoC) Pública

Para esta reprodução, foi utilizado o exploit Python amplamente reconhecido desenvolvido pelo pesquisador de segurança Worawit (especificamente a variante exploit_nss.py).

3.2 Detalhamento da Execução do PoC

Antes de executar o PoC, é fundamental entender sua mecânica. O script não apenas trava o programa; ele orquestra uma manipulação altamente precisa da memória para obter execução de código.

Aqui está o detalhamento passo a passo das operações do PoC:

1. Geração do Payload: O script compila dinamicamente um payload C malicioso em um arquivo de objeto compartilhado (.so). Este payload é projetado para executar /bin/sh como root.
2. Feng Shui do Heap: O script define variáveis de ambiente específicas (como LC_ALL, LANG e TZ). Como o Sudo carrega variáveis de ambiente no heap na inicialização, o script calcula os tamanhos exatos necessários para organizar o heap em um layout previsível.
3. O Estouro: O script executa sudoedit -s e passa um argumento de linha de comando terminando com uma única barra invertida. Isso aciona a vulnerabilidade de um a menos (off-by-one) discutida na Seção 2, causando uma escrita fora dos limites.
4. Segmentação da Struct NSS: A escrita fora dos limites sobrescreve precisamente uma estrutura específica do glibc na memória do heap adjacente: a struct service_user. Esta struct é usada pelo Name Service Switch (NSS) para consultar informações do sistema.
5. Execução de Código: A struct service_user é corrompida para apontar para a biblioteca .so maliciosa compilada na Etapa 1. Quando o Sudo tenta consultar privilégios de usuário, ele carrega e executa cegamente a biblioteca do atacante, concedendo um shell root.

3.3 Acionando a Vulnerabilidade (Sudo 1.9.5p1)

Primeiro, um teste de crash básico foi realizado para provar que a vulnerabilidade existe sem armá-la.

Em seguida, o script completo exploit_nss.py do Worawit foi executado contra o binário vulnerável.

3.4 Verificando o Patch (Sudo 1.9.5p2)

Para verificar a correção oficial, o mesmo acionador do PoC foi executado contra o binário corrigido do Sudo.

sudoedit -s '\' 2>&1 | grep -q "sudoedit:" && echo "Vulnerável" || echo "Não vulnerável"

4. Resumo Não Técnico

O Sudo, um programa administrativo padrão usado em nossos servidores, contém uma falha crítica na forma como processa entradas de texto que contêm barras invertidas. Ao enviar cuidadosamente um comando malformado, um atacante com acesso básico de usuário pode enganar o sistema para escrever dados fora de sua área de memória designada. Esse erro permite que ele contorne completamente os controles de segurança e obtenha controle administrativo total e não autorizado sobre a máquina sem nunca precisar de uma senha.

5. Desafios Enfrentados e Lições Aprendidas

Desafios: Um dos principais desafios foi a fragilidade da manipulação do heap. Payloads de exploração direcionados a versões específicas de SO muitas vezes falham em outras porque a biblioteca C padrão subjacente (glibc) gerencia blocos de memória de forma diferente. Armar com sucesso esta vulnerabilidade exigiu um entendimento exato do alinhamento de memória e dos layouts de variáveis de ambiente (Feng Shui do Heap) específicos para o ambiente alvo.

Lições Aprendidas: Do ponto de vista defensivo e das operações de segurança, esta análise aprofundada reforçou vários conceitos críticos:

• O Valor dos Ambientes de Laboratório Controlados: A transição de ambientes guiados baseados na web (como TryHackMe) para compilar e explorar um binário vulnerável a partir do código fonte localmente proporciona um entendimento muito mais profundo de como os mecanismos subjacentes do SO determinam a viabilidade da exploração.
• A Engenharia de Detecção é Primordial: Confiar apenas na correção de binários SUID é insuficiente porque o ciclo de correção leva tempo. Explorar este exploit destacou a necessidade de regras robustas de detecção em SIEM. Monitorar a telemetria de execução de processos em busca de comandos sudoedit -s suspeitos terminando em caracteres de escape poderia permitir que uma equipe de SOC detectasse tentativas de exploração antes que um patch seja totalmente implantado na infraestrutura.
• Limites de Privilégios: O exercício ressaltou o imenso risco associado a binários SUID. Como o Sudo executa com privilégios de root desde sua primeira instrução, qualquer erro de lógica de análise na inicialização garante o comprometimento total do sistema.

6. Bônus: Vulnerabilidades Paralelas no Sudo

CVE Paralelo: CVE-2019-14287 (Bypass de Segurança do Sudo) Outra vulnerabilidade proeminente dentro do mesmo código base do Sudo compartilha um padrão de causa raiz semelhante: análise e validação inadequadas de entrada do usuário. No CVE-2019-14287, uma falha lógica na forma como o Sudo analisava o ID de usuário (UID) permitia que um atacante executasse comandos como root especificando o ID de usuário -1 ou 4294967295.

O Paralelo: Enquanto Baron Samedit (CVE-2021-3156) é uma falha de corrupção de memória e o CVE-2019-14287 é um bypass de autorização, a causa raiz em ambos os casos é uma falha na lógica inicial de análise de argumentos. Ambas as vulnerabilidades decorrem do Sudo confiar e manipular incorretamente argumentos de linha de comando em casos extremos (barras invertidas finais vs. wraparound inesperado de inteiros) antes de executar suas funções privilegiadas principais.

Declaração de Segurança e Ética: Toda exploração e teste demonstrados neste relatório foram conduzidos inteiramente dentro de uma máquina virtual local isolada e autorizada. Nenhum sistema de produção ou redes não autorizadas foram alvo ou interagiram durante este exercício.