Memória e pilha

Quando um programa é executado, o sistema operacional fornece a ele um layout de memória com regiões distintas: o texto (código), os dados/BSS (globais), o heap (alocação dinâmica) e a pilha.

Os estouros de buffer exploram com mais frequência a pilha, portanto compreendê-la é essencial.

A pilha é uma região da memória usada para chamadas de funções. Ela armazena variáveis locais, argumentos de funções e endereços de retorno.

Em x86, ela cresce para baixo: inserir dados move o ponteiro da pilha em direção a endereços menores. Essa direção é importante quando ocorre um estouro.

Cada chamada de função cria um quadro da pilha. Normalmente, um quadro contém variáveis locais, o ponteiro base salvo (EBP) e o endereço de retorno (EIP salvo).

O endereço de retorno informa à CPU onde continuar quando a função terminar. Controlá-lo é o elemento central da exploração de um estouro de pilha.

Em x86 de 32 bits, os registradores importantes são:

• ESP: ponteiro da pilha, topo da pilha.
• EBP: ponteiro base, âncora do quadro atual.
• EIP: ponteiro de instrução, endereço da próxima instrução.

Se você controlar o EIP, controlará o fluxo de execução.

Um buffer é um bloco de memória de tamanho fixo, como uma matriz de caracteres local. O programa espera que os dados caibam nele.

Se o programa copiar mais dados do que o buffer comporta sem verificar o comprimento, o excesso transbordará para a memória adjacente.

Um estouro de buffer ocorre quando a entrada excede o tamanho do buffer e sobrescreve dados vizinhos na pilha.

Como o EBP salvo e o endereço de retorno ficam logo depois dos buffers locais, uma entrada suficientemente grande pode sobrescrever o endereço de retorno, assumindo o controle do fluxo de execução.

Os estouros geralmente resultam de funções C inseguras que não verificam o tamanho:

• strcpy, strcat, sprintf, gets.

Alternativas mais seguras, como strncpy ou snprintf, aceitam um limite de tamanho, mas o código legado está repleto das funções perigosas.

Quando a função vulnerável retorna, a CPU remove o endereço de retorno (agora controlado pelo invasor), coloca-o no EIP e salta para esse endereço.

Se apontar o EIP para o seu próprio código de máquina injetado (código de shell), a CPU o executará com os privilégios do programa.

x86 usa o formato little-endian: os valores de vários bytes são armazenados começando pelo byte menos significativo. Para sobrescrever o endereço de retorno com 0x080414C3, escreva os bytes na ordem inversa.

Usar a ordem de bytes errada é um erro comum entre iniciantes e faz os exploits falharem silenciosamente.

Os sistemas modernos adicionam defesas que dificultam a exploração:

• DEP/NX: marca a pilha como não executável.
• ASLR: randomiza os endereços de memória.
• Canários da pilha: detectam sobrescritas antes do retorno.

Este curso concentra-se no caso clássico (com as proteções desativadas) para ensinar os fundamentos.

Embora as defesas modernas tornem mais difíceis os estouros clássicos de pilha, os fundamentos continuam essenciais. Sistemas embarcados, dispositivos IoT e softwares legados frequentemente não têm essas proteções.

Dominar o caso básico também é um pré-requisito para técnicas avançadas, como ROP, que contornam as mitigações modernas.

Lembre-se de qual valor o invasor finalmente quer controlar.

Agora você entende os fundamentos:

• A pilha armazena variáveis locais, o EBP salvo e o endereço de retorno, e cresce para baixo.
• ESP, EBP, EIP são os principais registradores x86; controlar o EIP significa controlar a execução.
• Funções inseguras, como strcpy e gets, causam estouros.
• x86 usa o formato little-endian; as defesas modernas são DEP, ASLR e canários.

Em seguida, você testará um programa para encontrar o deslocamento da falha.