C Segurança (Buffer Overflow)

O C deixa você escrever direto na memória, byte a byte, e não confere se você está dentro dos limites. Se um array tem lugar para 8 letras e o programa escreve 12, o C escreve mesmo: passa por cima do que estava na memória ao lado. Isso é um estouro de buffer (buffer overflow), a falha mais famosa — e mais perigosa — da história do C. Ela derruba o programa, estraga dados sem avisar e é a porta por onde muitos ataques entram. Nesta aula você vai ver o estouro acontecer de verdade, entender por que ele passa calado, e aprender as funções e as opções de compilação que o pegam.

Todas as saídas desta aula são reais, feitas com o gcc 15 na máquina fictícia da Ana, na pasta ~/c/seg. Esta é uma aula sobre defender o seu próprio programa dos seus próprios enganos: nada aqui serve para atacar o programa de outra pessoa.

A ideia: a prateleira que invade a vizinha

Pense num array como uma prateleira com um número fixo de espaços — digamos, 8. Você pode guardar coisas no espaço 0 até o espaço 7. Em quase toda linguagem, se você tentar pôr algo no espaço 8, a linguagem reclama na hora. No C, não: ele simplesmente coloca a coisa no lugar onde o espaço 8 estaria, que já é a prateleira do vizinho. O vizinho pode ser outra variável, um valor de controle do programa ou uma peça interna que faz o programa voltar das funções. Escrever ali é o estouro de buffer.

O nome vem do inglês buffer ("pulmão", um espaço reservado de memória) e overflow ("transbordar"): o dado transbordou do espaço reservado. Três coisas podem acontecer:

• O programa morre com *** stack smashing detected *** — às vezes. É o melhor caso, porque você percebe.
• O programa continua e entrega um resultado errado, porque estragou uma variável ao lado. Pior, porque parece que funcionou.
• Alguém de fora controla o estrago e faz o programa rodar o que quiser. É assim que muitos vírus e invasões começam.

A origem do transbordo é quase sempre a mesma: uma função que copia texto sem saber o tamanho do destino. Veja a lista das perigosas e o que usar no lugar:

Repare no padrão: toda versão segura recebe o tamanho do destino. A regra de ouro desta aula é uma só: nunca copie texto para um array sem dizer à função quanto cabe nele.

1. O clássico: scanf("%s") sem limite

A Ana quer ler o nome de uma pessoa. O array tem 8 bytes. Veja o %s "pelado", sem número:

#include <stdio.h>

int main(void) {
    char nome[8];
    printf("Nome: ");
    if (scanf("%s", nome) != 1) {
        return 1;
    }
    printf("Olá, %s!\n", nome);
    return 0;
}

Compila sem um aviso sequer. Com um nome curto, funciona. Com um nome de 11 letras num array de 8:

$ gcc -std=c23 -Wall -Wextra nome.c -o nome
$ echo Ana | ./nome
Nome: Olá, Ana!
$ echo Maximiliano | ./nome
Nome: *** stack smashing detected ***: terminated
Abortado                   (imagem do núcleo gravada) ./nome
$ echo $?
134

nenhum aviso na compilação

O compilador não tem como saber, enquanto compila, que a pessoa vai digitar 11 letras. O tamanho só existe na hora de rodar.

*** stack smashing detected ***

"Esmagamento da pilha detectado". O scanf escreveu Maximiliano\0 (12 bytes) num array de 8 e passou por cima de uma trava que o gcc coloca na pilha (o stack protector). No fim do main, o programa viu a trava quebrada e se abortou.

Abortado … 134

O programa foi encerrado à força. O código 134 é o "abortado" do Linux (veja exit).

O conserto: diga o tamanho ao scanf

O %s aceita um número antes do s: a quantidade máxima de caracteres que ele pode ler. Para um char nome[8], use %7s: 7 letras mais o '\0' do fim cabem exatos nos 8 bytes (veja Strings). O que passar disso fica na entrada, sem estourar nada:

$ echo Maximiliano | ./nome      « agora com scanf("%7s", nome)
Nome: Olá, Maximil!

No editor do guia, o mesmo %7s corta o nome igualzinho (o resto, iano, fica na entrada):

$ clang -std=c23 -Wall -Wextra nome.c -o nome
$ ./nome
Nome: Maximiliano
Olá, Maximil!
[código de saída: 0]

#include <stdio.h>

int main(void) {
    char nome[8];
    printf("Nome: ");
    if (scanf("%s", nome) != 1) {
        return 1;
    }
    printf("Olá, %s!\n", nome);
    return 0;
}

#include <stdio.h>

int main(void) {
    char nome[8];
    printf("Nome: ");
    if (scanf("%7s", nome) != 1) {
        return 1;
    }
    printf("Olá, %s!\n", nome);
    return 0;
}

2. O estouro silencioso que vira "administrador"

Até aqui o estouro derrubou o programa. Agora o caso que assusta de verdade: um estouro que não derruba nada e troca o valor de outra variável. A Ana escreveu um login de brincadeira. A struct guarda o nome (8 bytes) e um campo admin, que vale 0 para uma pessoa comum:

#include <stdio.h>
#include <string.h>

struct Usuario {
    char nome[8];
    int admin;
};

int main(void) {
    struct Usuario u = {.nome = "", .admin = 0};
    char entrada[100];

    printf("Nome: ");
    if (scanf("%99s", entrada) != 1) {
        return 1;
    }
    strcpy(u.nome, entrada);

    printf("Olá, %s!\n", u.nome);
    if (u.admin) {
        printf("Acesso de ADMINISTRADOR liberado (admin = %d).\n", u.admin);
    } else {
        printf("Acesso comum.\n");
    }
    return 0;
}

O scanf("%99s", entrada) está correto: lê com limite, para um array de 100. O erro está no strcpy(u.nome, entrada), que copia sem limite para o u.nome, que só tem 8 bytes. Veja o que acontece com um nome comprido:

$ gcc -std=c23 -Wall -Wextra login.c -o login
$ echo Ana | ./login
Nome: Olá, Ana!
Acesso comum.
$ echo Maximiliano | ./login
Nome: Olá, Maximiliano!
Acesso de ADMINISTRADOR liberado (admin = 7302753).
$ echo $?
0

Ninguém mexeu em admin, e ele virou 7302753: deixou de ser zero e o acesso de administrador foi liberado. O que aconteceu? Na memória, o campo admin vem logo depois dos 8 bytes de nome. "Maximiliano" tem 11 letras + o '\0' = 12 bytes. Os 8 primeiros encheram nome; os 4 que sobraram (a, n, o e o '\0') foram escritos bem em cima de admin. O programa não morreu, não avisou, e passou a dar acesso que não devia. É o estouro de buffer na sua forma mais traiçoeira.

E o AddressSanitizer, que pega estouros tão bem? Aqui ele fica calado: o estouro ficou dentro da mesma struct (de nome para admin), e para o ASan a struct inteira é uma região válida. Ele vigia as bordas de cada variável, não as fronteiras entre os campos de uma struct. Quem pega este caso é o outro fiscal, o FORTIFY (seção 5). No editor do guia, o estouro também passa calado e imprime o mesmo admin = 7302753.

3. strcpy e o "+1" esquecido

O strcpy ("string copy", copiar string) copia da origem até o '\0', caiba ou não no destino. Veja um programa que copia o que veio na linha de comando para um array de 8 bytes:

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    char item[8];
    if (argc < 2) {
        return 1;
    }
    strcpy(item, argv[1]);
    printf("Item: %s\n", item);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra copia.c -o copia
$ ./copia biscoito
Item: biscoito
$ ./copia "biscoito recheado"
*** stack smashing detected ***: terminated
Abortado                   (imagem do núcleo gravada) ./copia "biscoito recheado"
$ echo $?
134

Repare numa armadilha fina: ./copia biscoito pareceu funcionar. Mas "biscoito" tem 8 letras; com o '\0', são 9 bytes num array de 8. O nono byte foi escrito fora do array, só que caiu num canto que não disparou a trava da pilha. É o pior caso: o programa escreveu onde não devia e tudo parece certo. Esse é o clássico erro do "+1" esquecido — o espaço do '\0' que ninguém somou.

O conserto é o snprintf ("string print, com N"), que escreve no máximo o tamanho do destino e sempre termina a string com '\0':

    char item[8];
    if (argc < 2) {
        return 1;
    }
    snprintf(item, sizeof item, "%s", argv[1]);   // nunca passa de 8 bytes
    printf("Item: %s\n", item);

Agora ./copia "biscoito recheado" guarda só biscoit (7 letras + o '\0') e não estoura nada. Perder o fim do texto é chato, mas é muito melhor que estragar a memória. Em um programa de verdade, você daria ao array um tamanho folgado e ainda avisaria quando o texto não coube.

4. gets: a função banida

A função mais perigosa de todas foi a gets ("get string"), que lia uma linha inteira sem limite nenhum — não havia nem como dizer o tamanho. Ela foi tão fonte de desastres que o C a marcou como obsoleta no C99 e a removeu da linguagem no C11: é a única função da biblioteca padrão que já foi apagada. No gcc 15, usá-la nem compila em C23:

$ gcc -std=c23 -Wall -Wextra gets.c -o gets
gets.c: In function ‘main’:
gets.c:6:5: error: implicit declaration of function ‘gets’; did you mean ‘fgets’? [-Wimplicit-function-declaration]
    6 |     gets(nome);
      |     ^~~~
      |     fgets

A aula Ler uma Linha (fgets) conta essa história em detalhe e mostra o fgets, a substituta segura que recebe o tamanho do array. Se você ver gets em um código ou livro antigo, troque por fgets na hora.

5. Os dois fiscais: ASan e FORTIFY

Você não vai achar os estouros lendo o código com os olhos — eles passam calados. Precisa de ferramentas que conferem enquanto o programa roda. Duas são fáceis de ligar, e cada uma pega casos diferentes.

AddressSanitizer: o relatório completo

O -fsanitize=address coloca um fiscal em cada acesso à memória (é a mesma ferramenta da aula Sanitizers, vista aqui pelo lado da segurança). Recompile o nome.c da seção 1 com ele e com -g (para ter arquivo e linha):

$ gcc -std=c23 -Wall -Wextra -g -fsanitize=address nome.c -o nome-asan
$ echo Maximiliano | ./nome-asan
Nome: =================================================================
==415616==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7bed3aaf0028 at pc 0x7fed3d0b05dc bp 0x7fff8af96370 sp 0x7fff8af95af8
WRITE of size 12 at 0x7bed3aaf0028 thread T0
    #0 0x7fed3d0b05db in scanf_common ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors_format.inc:346
    #1 0x7fed3d0f0e4e in __isoc23_vscanf ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1586
    #2 0x7fed3d0f1634 in __isoc23_scanf ../../../../src/libsanitizer/sanitizer_common/sanitizer_common_interceptors.inc:1616
    #3 0x562116b362de in main /home/ana/c/seg/nome.c:6
«… a pilha da biblioteca e o mapa da memória …»
  This frame has 1 object(s):
    [32, 40) 'nome' (line 4) <== Memory access at offset 40 overflows this variable
SUMMARY: AddressSanitizer: stack-buffer-overflow /home/ana/c/seg/nome.c:6 in main
==415616==ABORTING

stack-buffer-overflow

"Estouro de buffer na pilha": um array local foi escrito fora dos limites.

WRITE of size 12

Uma escrita de 12 bytes (as 11 letras de "Maximiliano" + o '\0'). Quem escreveu foi o scanf.

#3 … in main /home/ana/c/seg/nome.c:6

A primeira linha com um arquivo seu: o scanf da linha 6.

[32, 40) 'nome' (line 4)

Qual variável foi estourada: o array nome, declarado na linha 4, de 8 bytes.

SUMMARY … nome.c:6

O resumo em uma linha. Se for ler só uma, leia esta.

Lembre da seção 2: o ASan é ótimo para estourar os limites de uma variável, mas não pega o estouro de um campo de struct para o vizinho. Para esse, entra o segundo fiscal.

FORTIFY_SOURCE: a conferência barata do compilador

O -D_FORTIFY_SOURCE=2 pede ao compilador que troque funções como strcpy, memcpy e sprintf por versões que, quando sabem o tamanho do destino, conferem antes de copiar. É quase de graça (não deixa o programa mais lento como o ASan), mas só funciona com otimização ligada (-O2). Volte ao login da seção 2:

$ gcc -std=c23 -Wall -Wextra -O2 -D_FORTIFY_SOURCE=2 login.c -o login-fort
$ echo Maximiliano | ./login-fort
Nome: *** buffer overflow detected ***: terminated
Abortado                   (imagem do núcleo gravada) ./login-fort
$ echo $?
134

O estouro que o ASan deixou passar e que o programa normal nem percebeu foi pego aqui: *** buffer overflow detected *** ("estouro de buffer detectado"), e o programa parou com código 134, antes de liberar o acesso de administrador. O FORTIFY conhece o tamanho de u.nome (8 bytes, escrito no código) e sabe que o strcpy de 12 bytes não cabe.

Mas o FORTIFY tem um limite: ele só confere as funções que recebem um destino de tamanho conhecido. O scanf("%s") da seção 1 não é uma dessas, então nem o FORTIFY o pega na hora da cópia — ali quem avisa é a trava da pilha (o stack smashing) ou o ASan. Por isso os dois fiscais se completam.

Qual usar: durante o desenvolvimento e nos testes, compile com -g -fsanitize=address; na versão que vai para os usuários, deixe -O2 -D_FORTIFY_SOURCE=2 (rápido e ainda protege). Os dois juntos cobrem quase tudo.

#include <stdio.h>
#include <string.h>

void guardar(char destino[], size_t tam, const char *origem) {
    (void) tam;
    strcpy(destino, origem);
}

int main(void) {
    char nome[8];
    char entrada[100];
    printf("Nome: ");
    if (scanf("%99s", entrada) != 1) {
        return 1;
    }
    guardar(nome, sizeof nome, entrada);
    printf("Guardado: %s\n", nome);
    return 0;
}

#include <stdio.h>
#include <string.h>

void guardar(char destino[], size_t tam, const char *origem) {
    snprintf(destino, tam, "%s", origem);
}

int main(void) {
    char nome[8];
    char entrada[100];
    printf("Nome: ");
    if (scanf("%99s", entrada) != 1) {
        return 1;
    }
    guardar(nome, sizeof nome, entrada);
    printf("Guardado: %s\n", nome);
    return 0;
}

Quando dá errado

$ echo Maximiliano | ./login
Nome: Olá, Maximiliano!
Acesso de ADMINISTRADOR liberado (admin = 7302753).

Referência rápida

Exercícios

Resumo

• Um estouro de buffer é escrever além do fim de um array. O C não impede, e o erro pode derrubar o programa, estragar um dado vizinho em silêncio ou abrir a porta para um ataque.
• A causa é quase sempre copiar texto sem o tamanho do destino: gets, strcpy, strcat, sprintf, scanf("%s").
• As versões seguras recebem o tamanho: %29s, snprintf(dest, sizeof dest, ...), fgets. O gets foi removido do C no C11.
• Um programa que "roda e dá certo" não prova nada: o estouro pode estar lá, calado.
• -g -fsanitize=address pega estouros de array com a linha exata; -O2 -D_FORTIFY_SOURCE=2 é barato e pega até estouro entre campos de struct. Use o ASan no desenvolvimento e o FORTIFY na versão final.
• No editor do guia, os dois fiscais não funcionam; rode-os no seu Linux.

Próxima aula: Boas Práticas.