Integer Overflow

Desconsiderar o estouro de inteiros pode resultar em erros de lógica ou buffer overflow.

Erros de estouro de inteiros ocorrem quando um programa não considera o fato de que uma operação aritmética pode resultar em uma quantidade maior do que o valor máximo de um tipo de dados ou menor do que seu valor mínimo. Esses erros costumam causar problemas em funções de alocação de memória, nas quais a entrada do usuário passa por conversões implícitas entre valores signed e unsigned. Se um invasor puder fazer com que o programa aloque menos memória do que o necessário ou interprete um valor signed como unsigned em uma operação de memória, o programa poderá estar vulnerável ao estouro de buffer.

Exemplo 1: O seguinte trecho de código do OpenSSH 3.3 demonstra um caso clássico de estouro de inteiros:

nresp = packet_get_int();
if (nresp > 0) {
 response = xmalloc(nresp*sizeof(char*));
 for (i = 0; i < nresp; i++)
  response[i] = packet_get_string(NULL);
}

Se nresp tiver o valor 1073741824 e sizeof(char*) tiver seu valor típico de 4, ocorrerá o estouro do resultado da operação nresp*sizeof(char*), e o argumento para xmalloc() será 0. A maioria das implementações de malloc() permitirá a alocação de um buffer de 0 byte, fazendo com que as iterações de loop subsequentes estourem o buffer de heap response.

Exemplo 2: Esse exemplo processa a entrada do usuário formada por uma série de estruturas de comprimento variável. Os dois primeiros bytes de entrada determinam o tamanho da estrutura a ser processada.

 char* processNext(char* strm) {
 char buf[512];
 short len = *(short*) strm;
 strm += sizeof(len);
 if (len <= 512) {
  memcpy(buf, strm, len);
  process(buf);
  return strm + len;
 } else {
  return -1;
 }
}

O programador definiu um limite superior no tamanho da estrutura: se ele for maior que 512, a entrada não será processada. O problema é que len é um inteiro com sinal e, portanto, a verificação do comprimento máximo da estrutura é feita com inteiros com sinal, mas len é convertido em um inteiro sem sinal na chamada para memcpy(). Se len for negativo, parecerá que a estrutura tem um tamanho apropriado (a ramificação if será usada), mas a quantidade de memória copiada por memcpy() será muito grande, e o invasor será capaz de estourar a pilha com dados em strm.