Fuzzing para encontrar falhas

Fuzzing consiste em enviar entradas malformadas ou grandes demais a um programa para provocar um comportamento inesperado, especialmente falhas. Uma falha frequentemente indica um erro de corrupção de memória.

Em estouros de buffer, o primeiro objetivo é fazer o alvo falhar, para sabermos que existe um estouro.

O fluxo de trabalho clássico de exploração é:

• Testar por mutação até fazer o programa falhar.
• Encontrar o deslocamento exato até o endereço de retorno.
• Controlar o EIP.
• Redirecionar para o código de shell.

Esta lição aborda as duas primeiras etapas.

Para observar as falhas, anexe um depurador (como o Immunity Debugger ou o x64dbg no Windows, ou o GDB no Linux) ao alvo.

Quando o programa falha, o depurador mostra o estado dos registradores, especialmente o EIP, revelando se sobrescrevemos o endereço de retorno.

Um testador simples envia strings cada vez maiores até o programa falhar. Um ponto de partida comum é enviar muitos caracteres «A» (0x41).

Se o EIP mostrar 41414141 depois da falha, você confirmou o controle sobre o endereço de retorno.

Quando o aplicativo falha e o EIP é igual a 41414141, o estouro alcançou o endereço de retorno salvo.

Mas você ainda não sabe exatamente quantos bytes precedem o EIP. Enviar sempre o mesmo byte informa que o EIP é controlável, não onde ele está localizado.

Para encontrar o deslocamento preciso, envie um padrão exclusivo e não repetitivo em vez de usar apenas «A». Cada janela de 4 bytes é distinta, portanto o valor que chega ao EIP identifica o deslocamento.

O Metasploit fornece pattern_create.rb para isso.

Depois da falha com o padrão, anote o valor no EIP. Passe-o para pattern_offset.rb, que retornará o número exato de bytes antes do EIP.

Esse deslocamento corresponde ao tamanho do preenchimento antes dos bytes do endereço de retorno.

Verifique sempre. Crie uma entrada com offset bytes «A», seguidos de quatro bytes «B» (0x42). Se o EIP se tornar 42424242, o deslocamento está correto.

Essa confirmação evita horas desperdiçadas depurando mais tarde um erro de poucos bytes.

Depois de controlar o EIP, observe também para onde o ESP aponta no momento da falha. Normalmente, o ESP aponta para logo depois do endereço de retorno sobrescrito, dentro do restante do seu buffer.

É nesse espaço que você colocará posteriormente o código de shell.

Entre as ferramentas úteis para fuzzing e padrões estão:

• Spike e boofuzz: testadores de protocolos de rede.
• pattern_create / pattern_offset: localizam o deslocamento do EIP.
• mona.py no Immunity: automatiza tarefas de padrão, deslocamento e caracteres inválidos.

Uma falha útil precisa ser reprodutível. Salve a entrada exata que a provoca e execute-a novamente a partir de um estado limpo para confirmar que o deslocamento é estável.

Falhas inconsistentes geralmente significam que o erro não é um estouro de pilha limpo ou que alguma condição (tempo, tamanho, conteúdo) varia entre as execuções.

Lembre-se de por que um padrão cíclico é melhor do que uma string de bytes idênticos.

Agora você sabe como encontrar o deslocamento da falha:

• Teste por mutação com uma entrada crescente para provocar uma falha; confirme com 41414141 no EIP.
• Use um padrão cíclico com pattern_create / pattern_offset para encontrar o deslocamento exato.
• Verifique usando preenchimento + quatro bytes «B» (42424242).
• Observe para onde o ESP aponta para posicionar posteriormente o código de shell.

Em seguida, você controlará totalmente o EIP e redirecionará a execução.