Fundamentos de engenharia reversa e exploração de binários

Duas categorias de CTF estreitamente relacionadas lidam com programas compilados:

• Engenharia reversa (rev) — você analisa um binário para entender o que ele faz, geralmente para recuperar uma verificação de senha ou uma lógica oculta que exibe a bandeira.
• Exploração binária — você encontra um erro de segurança de memória em um binário em execução e o explora para sequestrar a execução, frequentemente para iniciar um interpretador de comandos em um serviço remoto que armazena a bandeira.

Engenharia reversa trata de entender; exploração binária trata de quebrar. Ambas exigem familiaridade com conceitos de baixo nível.

Nunca abra um binário às cegas em um desmontador. Faça primeiro uma triagem com ferramentas rápidas de linha de comando para descobrir seu tipo, sua arquitetura e quaisquer cadeias de caracteres óbvias.

Você analisa binários de duas formas complementares:

• Análise estática — leia o código sem executá-lo, usando um desmontador ou descompilador como o Ghidra ou uma visualização de desmontagem. Você vê todo o fluxo de controle, mas precisa inferir os valores em tempo de execução.
• Análise dinâmica — execute o programa sob um depurador como o GDB e observe os valores reais nos registradores e na memória. Você vê exatamente o que acontece, mas apenas ao longo do caminho que executa.

Participantes experientes alternam entre as duas: leem estaticamente para formular uma teoria e confirmam dinamicamente avançando passo a passo.

Para fazer engenharia reversa, você lê código de montagem. Não é necessário escrevê-lo com fluência, mas você precisa reconhecer padrões:

• cmp / test seguidos de um salto (je, jne) formam uma comparação e um desvio — geralmente a verificação da senha.
• call invoca uma função; os argumentos foram colocados nos registradores ou na pilha imediatamente antes.
• mov move dados entre registradores, memória e constantes.

Quando encontrar um cmp comparando sua entrada, seguido de um desvio para uma mensagem de sucesso, você terá encontrado a verificação. Agora recupere ou contorne o valor esperado.

Descompiladores modernos transformam o código de montagem novamente em C aproximado, que é muito mais rápido de ler do que as instruções brutas. Uma verificação de senha descompilada poderia ter esta aparência:

Desafios de exploração binária exploram programas que leem a entrada em uma área de memória de tamanho fixo sem verificar seu comprimento. A pilha armazena variáveis locais e o endereço de retorno salvo, que informa à CPU para onde ir quando uma função termina.

Se a entrada exceder uma área de memória local, ela poderá sobrescrever esse endereço de retorno salvo. Quem controla o endereço de retorno controla para onde a execução seguirá.

A exploração mais simples consiste em sobrescrever o endereço de retorno para saltar para uma função que o programa nunca pretendeu chamar — uma função win() oculta que exibe a bandeira.

As etapas:

• Encontre o deslocamento exato do início da área de memória até o endereço de retorno; uma ferramenta de padrão cíclico faz isso rapidamente.
• Encontre o endereço da função-alvo.
• Envie preenchimento até o deslocamento e depois sobrescreva o endereço de retorno com o alvo.

Binários reais ativam defesas que bloqueiam estouros ingênuos. Você precisa reconhecê-las com checksec:

• Canários da pilha — um valor secreto colocado antes do endereço de retorno; se ele mudar, o programa é encerrado. Primeiro, você precisa obtê-lo.
• NX (Não-eXecute) — a pilha não é executável, portanto você não pode executar código de shell colocado nela.
• ASLR / PIE — os endereços são aleatorizados a cada execução, então você precisa obter um vazamento de endereço antes de poder apontar para ele.
• RELRO — protege a tabela de deslocamentos globais contra sobrescritas.

Cada proteção direciona você para técnicas mais avançadas.

Quando o NX impede que você execute seu próprio código, a programação orientada a retornos reutiliza código que já está no binário.

Você encadeia pequenas sequências de instruções chamadas trechos, cada uma terminando em ret, para realizar ações passo a passo — por exemplo, carregar um registrador e chamar uma função de biblioteca para iniciar um interpretador de comandos. Você constrói a cadeia na pilha para que cada ret salte para o próximo trecho.

ROP é a ponte entre os estouros para iniciantes e a exploração real, na qual o código do invasor raramente pode ser executado diretamente.

Outra primitiva clássica de exploração é a vulnerabilidade em cadeia de formato, na qual a entrada do usuário é passada diretamente como argumento de formato para uma função de impressão.

Você aprende a explorar erros de memória com precisão justamente para poder evitá-los. As conclusões defensivas são concretas:

• Nunca use funções de entrada sem limite, como gets ou strcpy; use equivalentes que verifiquem o comprimento.
• Mantenha as proteções ativadas: canários, NX, ASLR/PIE completo e RELRO completo por padrão.
• Prefira linguagens seguras para a memória quando o modelo de ameaça permitir.
• Trate qualquer valor controlado pelo usuário que alcance uma cadeia de formato ou uma cópia de área de memória como uma descoberta grave na revisão de código.

Agora você tem um mapa da engenharia reversa e da exploração binária:

• Faça a triagem de todo binário com file, strings e checksec antes da análise aprofundada.
• Combine a análise estática (desmontador/descompilador) e dinâmica (depurador) para entender a lógica.
• A exploração binária começa com o estouro de uma área de memória da pilha, sobrescrevendo um endereço de retorno; as proteções (canários, NX, ASLR/PIE, RELRO) elevam o nível de dificuldade.
• ROP contorna o NX reutilizando trechos existentes; falhas em cadeias de formato surgem de argumentos de formato não confiáveis.
• Cada técnica também serve como lição defensiva para escrever e revisar códigos mais seguros.

Em seguida, você montará um conjunto de ferramentas e aprenderá a documentar suas soluções.