Out-of-Bounds Read

O programa lê dados de fora dos limites da memória alocada.

O buffer overflow é provavelmente a forma mais conhecida de vulnerabilidade de segurança de software. A maioria dos desenvolvedores de software sabe o que é uma vulnerabilidade de buffer overflow, mas ataques de buffer overflow contra aplicativos legados e recém-desenvolvidos ainda são bastante comuns. Uma parte do problema deve-se à grande variedade de maneiras de como estouros de buffer podem ocorrer, enquanto outra parte deve-se às técnicas propensas a erros frequentemente utilizadas para impedir esses estouros.

Em uma exploração de buffer overflow clássica, o invasor envia dados a um programa, que ele armazena em um buffer de pilha de tamanho menor do que o normal. O resultado é que as informações na pilha de chamadas são substituídas, incluindo o apontador de retorno da função. Os dados definem o valor do apontador de retorno de forma que, quando a função é retornada, ela transfere o controle para o código mal-intencionado contido nos dados do invasor.

Embora esse tipo de buffer overflow de pilha ainda seja comum em algumas plataformas e comunidades de desenvolvimento, há vários outros tipos de buffer overflow, incluindo estouros de buffer de heap e erros "off-by-one", entre outros. Existem diversos livros excelentes que fornecem informações detalhadas sobre como ataques de buffer overflow funcionam, entre eles Building Secure Software [1], Writing Secure Code [2] e The Shellcoder's Handbook [3].

Em nível de código, vulnerabilidades de buffer overflow geralmente envolvem a violação das premissas do programador. Muitas funções de manipulação de memória em C e C++ não realizam verificações de limites e podem facilmente exceder os limites alocados dos buffers sob os quais elas operam. Até mesmo funções limitadas, como strncpy(), podem causar vulnerabilidades quando usadas incorretamente. A combinação entre manipulação de memória e suposições equivocadas sobre o tamanho ou a composição de um determinado dado é a causa raiz da maioria dos estouros de buffer.

Nesse caso, o programa lê de fora dos limites da memória alocada, o que pode permitir acesso a informações confidenciais, introduzir comportamentos incorretos ou fazer com que o programa trave.

Exemplo 1: No código a seguir, a chamada para memcpy() lê a memória de fora dos limites alocados de cArray, que contém elementos MAX do tipo char, enquanto iArray contém elementos MAX do tipo int.

void MemFuncs() {
   char array1[MAX];
   int  array2[MAX];
   memcpy(array2, array1, sizeof(array2));
}

Exemplo 2: O seguinte programa curto usa um argumento de linha de comando não confiável como buffer de pesquisa em uma chamada para memchr() com um número constante de bytes a serem analisados.

int main(int argc, char** argv) {
  char* ret = memchr(argv[0], 'x', MAX_PATH);
  printf("%s\n", ret);
}

O programa deve imprimir uma subcadeia de caracteres de argv[0] pesquisando os dados de argv[0] até um número constante de bytes. No entanto, como o número (constante) de bytes pode ser maior que os dados alocados para argv[0], a pesquisa pode continuar além dos dados alocados para argv[0]. Esse será o caso quando x não se encontrar em argv[0].