====== Buffer overflow ======

Esta atividade consiste em desenvolver o experimento {{:sas:seed-buffer-overflow.pdf|Buffer overflow vulnerability}} do [[http://www.cis.syr.edu/~wedu/seed|SEED Project]].

Antes de desenvolver esse experimento, recomenda-se estudar a seguintes leituras preparatórias: 

  * [[http://www.phrack.org/issues/49/14.html#article|Smashing the Stack for Fun and Profit]], Aleph One, 1996 ([[http://www-inst.eecs.berkeley.edu/~cs161/fa08/papers/stack_smashing.pdf|versão PDF]])
  * [[http://www.mgraziano.info/docs/stsi2010.pdf|Smashing the Stack in 2010]], Graziano & Cugliari, 2010
  * [[http://paulmakowski.wordpress.com/2011/01/25/smashing-the-stack-in-2011|Smashing the Stack in 2011]], Makowski, 2011

No relatório, descreva as atividades efetuadas e explique como funcionam os seguintes mecanismos de proteção:

  * Técnica ASLR (//Address Space Layout Randomization//)
  * Bit NX (//No eXecute bit//)
  * Proteção de pilha oferecida pelo compilador GCC
  * Proteção de execução SUID oferecida pelo shell ''bash''
  * Proteção de execução SUID oferecida pela montagem de partições (comando ''mount'')

==== Roteiro sugerido ====

Este roteiro foi baseado no experimento de [[http://www.cis.syr.edu/~wedu/seed/Labs/Vulnerability/Buffer_Overflow/|buffer overflow]] do Seed Project. Os comandos abaixo foram testados em plataforma Ubuntu 13.04 32 e 64 bits.

<note warning>
Deve ser usado como informação complementar, não como substituto ao roteiro original!
</note>


Desligar a proteção ASLR (//Adress Space Layout Randomization//) do //kernel//:

<code>
sudo sysctl -w kernel.randomize_va_space=0
</code>

Compilar ''stack.c'' sem a proteção de pilha do compilador:

<code>
cc stack.c -o stack -fno-stack-protector -g
</code>

Desligar o flag NX (No Executable Stack) no cabecalho do executável ELF:

<code>
sudo apt-get install execstack
execstack stack
execstack -s stack
execstack stack
</code>

Ajustar usuário e permissões do executável ''stack'':

<code>
sudo chown root.root stack
sudo chmod 4755 stack
</code>

Gerar um ''badfile'' qualquer para poder executar ''stack'' (sem //overflow//):

<code>
echo "um teste..." > badfile
</code>

Depurar ''stack'' para descobrir o endereço do ponteiro ''str'':

<code>
gdb stack
   br 13           // insere breakpoint na linha 13 (strcpy)
   run             // inicia a execução
   print /x str    // obtém o valor do ponteiro str
   quit            // encerra o debugger
</code>

Usar o valor obtido do ponteiro ''str'' para ajustar ''exploit.c'':

  * compreenda a estrutura da pilha do programa ''stack.c'' dentro da chamada a ''bof()''
  * descubra que posição da variável ''buffer'' corresponde ao endereço de retorno da função ''bof''
  * escreva o código necessário em ''exploit.c'' para produzir um arquivo ''badfile'' que carregue o //shellcode// na memória do alvo e sobrescreva o endereço de retorno da função ''bof'' com o endereço do //shellcode//
  * Para ver o conteúdo de ''badfile'' use o comando ''hd'' (//hex dump//)

Compilar e executar ''exploit.c'' para gerar o arquivo ''badfile'' malicioso:

<code>
cc exploit.c -o exploit
./exploit
</code>

Usar o ''badfile'' malicioso para explorar a vulnerabilidade de ''stack'':

<code>
./stack
whoami
</code>

Se tudo estiver certo, o último comando deve retornar um //prompt// de root (#) e o comando ''whoami'' deve informar ''root''. Se não funcionar, verificar:

  * se estiver em uma partição de disco montada com o flag ''nosuid'' (verificar isso com o comando ''mount''), mover os arquivos ''stack'' e ''badfile'' para ''/tmp''
  * se a arquitetura do //shellcode// está correta (32 ou 64 bits).

No caso de arquiteturas de 64 bits, [[http://blog.markloiseau.com/2012/06/64-bit-linux-shellcode|este site]] explica com detalhes a construção de um //shellcode// para processadores de 64 bits no padrão x86_64 (Intel/AMD). Outros //shellcodes// podem ser encontrados [[http://shell-storm.org/shellcode/|aqui]].

=== Contornar a proteção ASLR ===

Religar a proteção ASLR do kernel:

<code>
sudo sysctl -w kernel.randomize_va_space=2
</code>

Executar o ataque continuamente, para tentar contornar a proteção ASLR (pode demorar muito!):

<code>
while true ; do ./stack ; done
</code>