Buffer Overflow é uma das vulnerabilidades mais antigas e ainda assim mais exploradas na segurança da informação. Ela ocorre quando um programa tenta gravar mais dados em um espaço de memória (buffer) do que o tamanho reservado para ele. O excesso de dados “transborda” para áreas adjacentes da memória, podendo corromper variáveis, alterar o fluxo de execução do programa e até permitir a execução de código malicioso.
Para entender melhor, é preciso lembrar que um buffer nada mais é do que um espaço de memória temporário usado para armazenar dados durante a execução de um programa. Esses dados podem vir de diversas fontes: teclado, arquivos, rede ou até mesmo de outros programas. Ao criar um buffer, o programador define um tamanho fixo. Se o código não verificar adequadamente o tamanho da entrada recebida, qualquer dado maior que esse limite vai ultrapassar o espaço alocado.
Imagine que um programa define um buffer para armazenar o nome de um usuário com apenas 8 bytes: char nome[8];. Em C, strings precisam de um byte extra para o caractere nulo , ou seja, o limite de caracteres reais seria 7. Se o programador utilizar uma função insegura como gets(nome); ou strcpy(nome, entrada); sem validar o tamanho da entrada, um usuário mal-intencionado pode inserir, por exemplo, “Administrador123456”. Esse dado é maior do que o buffer suporta e, ao ser copiado, irá sobrescrever dados adjacentes na memória.
Esse “transbordamento” pode causar efeitos inesperados: alterar variáveis internas do programa, corromper ponteiros e até substituir o endereço de retorno armazenado na pilha de execução. Ao manipular esse endereço, um atacante pode fazer o programa “pular” para uma área de memória onde ele injetou código malicioso, como um shellcode, obtendo assim o controle do sistema. Essa técnica foi amplamente usada em ataques reais contra sistemas antigos e ainda é vista em softwares vulneráveis até hoje.
Por exemplo, em um servidor que recebe dados de clientes via rede, se houver uma função como:
char buffer[256];
recv(socket, buffer, 1024, 0);
o programa está pedindo para receber até 1024 bytes, mas o buffer só comporta 256. Se o atacante enviar uma mensagem com mais de 256 bytes, ocorrerá o estouro de buffer. Dependendo da arquitetura e das proteções, isso pode levar desde a interrupção do serviço (DoS) até a execução de código arbitrário.
Para mitigar riscos, desenvolvedores devem seguir algumas boas práticas:
Sempre validar e limitar o tamanho dos dados antes de armazená-los no buffer.
Utilizar funções seguras como fgets no lugar de gets, strncpy no lugar de strcpy e snprintf no lugar de sprintf.
Habilitar proteções no compilador, como Stack Canaries, que detectam alterações suspeitas na pilha.
Ativar mecanismos do sistema operacional como DEP (Data Execution Prevention), que impede execução de código em áreas de memória destinadas a dados, e ASLR (Address Space Layout Randomization), que randomiza endereços para dificultar previsões de onde o código está na memória.
Mesmo com todas essas proteções modernas, buffer overflow continua relevante, especialmente em sistemas legados, firmware de dispositivos embarcados e aplicações críticas que não foram atualizadas. Por isso, é fundamental que programadores, administradores de sistemas e profissionais de segurança compreendam como essa falha ocorre, quais são seus impactos e como preveni-la.
Se não tratada, essa vulnerabilidade não é apenas um problema técnico, mas uma porta de entrada para ataques graves, podendo comprometer dados, sistemas inteiros e até infraestruturas críticas. A prevenção começa no código e se estende até a configuração do ambiente onde o software será executado.
