Ataques
Contornar o DEP com ROP: executar instruções por referência


VP of Hacking
Updated
5 min
Na última publicação do blog, apresentamos o que é o DEP (Data Execution Prevention) e como ele afeta os exploits comuns de buffer overflow.
Neste post, vamos mostrar uma forma de contornar o DEP usando Return-Oriented Programming (ROP).
ROP
Quando escrevemos um exploit para uma vulnerabilidade de buffer overflow em uma aplicação sem DEP, sobrescrevemos o ponteiro de instrução salvo no stack frame da função afetada com um ponteiro para algo como JMP ESP (ou para qualquer outro registrador que aponte para o nosso shellcode). Em seguida, colocamos um shellcode na pilha, que é finalmente executado quando o JMP ESP acontece.
Quando executamos um JMP ESP (ou com qualquer outro registrador de uso geral), o programa espera encontrar instruções no endereço apontado por ESP. Com o DEP, não podemos executar instruções na pilha, mas continuamos controlando o fluxo de execução.
O que aconteceria se, em vez de sobrescrever o Saved EIP com um ponteiro para JMP ESP, o sobrescrevêssemos com um ponteiro para uma instrução RETN? A instrução RETN é comum nos epílogos de funções e faz uma única coisa: retira (pop) o valor apontado por ESP e o usa como o próximo ponteiro de instrução, ou EIP. Em outras palavras, RETN espera encontrar, no endereço apontado por ESP, um ponteiro para uma instrução, e não a instrução em si.
Como controlamos o fluxo de execução e escrevemos na pilha, podemos fazer o que quisermos. Vamos procurar uma instrução RETN:
Isso faz o mona procurar até 10 instruções RETN. O resultado é:

Vamos pegar a primeira, em 62501022, e atualizar o exploit do post anterior. Desta vez, queremos que EAX tenha o valor 0xdeadbeef:
E vamos ver o que acontece:

Veja o que aconteceu:
Colocamos um breakpoint no endereço da instrução
RETN.Executamos o exploit.
O programa parou no breakpoint.
Nesse momento, observe o valor apontado por
ESP:EE05C031.Esse valor faz parte do shellcode injetado:
xor eax,eax→\x31\xc0add eax,0xdeadbeee→\x05\xee\xbe\xad\xde(os dois primeiros bytes)
Quando a instrução
RETNé executada, esse valorEE05C031é armazenado emEIP.
Isso significa que podemos substituir os bytes EE05C031 por um ponteiro arbitrário, que vai se tornar a próxima instrução a ser executada!
No nosso exploit, queremos fazer EAX = 0xdeadbeef usando três instruções: xor eax,eax, add eax,0xdeadbeee e inc eax. Vamos verificar se encontramos, no ambiente de execução, um ponteiro que realize a primeira operação (xor eax,eax):

Encontramos um em 62501162 que aponta para um xor eax,eax. Vamos atualizar o exploit e colocar esse endereço no lugar da instrução xor eax,eax:
Vamos executá-lo:

Excelente! Veja o que aconteceu:
O ponteiro para a instrução
RETNfoi alcançado.Quando o
RETNfoi executado, ele recuperou o valor apontado porESPe atualizouEIPcom esse valor.No nosso caso, esse valor era um ponteiro para uma instrução
xor eax,eax.Com isso, o
xor eax,eaxfoi executado com sucesso! Contornamos o DEP!
No entanto, há um problema. Se você observar a animação, o fluxo de execução foi desviado para onde estava a instrução xor eax,eax, mas depois perdemos o controle.
Precisamos fazer EAX = 0xdeadbeee. Há várias formas de fazer isso. Tentamos com xor eax,eax → add eax,0xdeadbeee, mas outra forma é colocar o valor 0xdeadbeee no topo da pilha e depois executar um pop eax. Também precisamos recuperar o controle do fluxo de execução. Podemos fazer isso voltando para a pilha, para executar a última instrução do nosso shellcode, inc eax, e fazer EAX = 0xdeadbeef. Ou seja, precisamos encontrar o endereço de uma instrução pop eax seguida de um retn.

Encontramos em 625011B4! Agora dá para ver por que isso se chama ROP? Porque sempre precisamos retornar (return) à pilha para buscar o próximo ponteiro para a próxima instrução desejada. Só para constar, em termos de ROP, qualquer instrução ou conjunto de instruções seguido de um retn é chamado de gadget.
Nosso gadget pop eax # retn depende de a pilha ter o valor 0xdeadbeee no topo. Vamos atualizar o exploit:
Confira:

Conseguimos fazer EAX = 0xdeadbeee usando ROP. Agora, o último passo é encontrar um ponteiro para inc eax e fazer EAX = 0xdeadbeef.

Encontramos um em 00402139. Como esta é a última instrução do nosso shellcode, o byte NULL não vai afetar o exploit. Vamos atualizar o código:
Confira:

Conseguimos fazer EAX = 0xdeadbeef sem executar uma única instrução na pilha! Contornamos o DEP!
Como usar o mona para encontrar gadgets
A esta altura, você já deve ter percebido que encontrar gadgets úteis pode se tornar algo bem tedioso. Felizmente, o mona facilita essa tarefa. Basta executar o seguinte:
And wait for mona to do the hard work:

Com isso, o mona vai encontrar gadgets utilizáveis no ambiente de execução. Um arquivo chamado rop.txt, com todos os gadgets encontrados, é criado no diretório do mona da aplicação depurada. O mona também gera uma proposta de algo chamado cadeias ROP (ROP chains), que nada mais são do que um conjunto de gadgets ROP encadeados para realizar algo mais complexo. Não vou dar spoiler do próximo post, mas as cadeias ROP serão usadas mais adiante em uma exploração mais séria.
Conclusões
Aqui vimos uma forma de contornar o Data Execution Prevention em um sistema Windows moderno. No entanto, o shellcode usado era muito básico e só demonstrou que é possível contornar o DEP. No próximo post, vamos usar ROP para criar algo mais complexo.
Comece agora com a solução de segurança de aplicações da Fluid Attacks
Tags:
treinamento
exploit
Assine nossa newsletter
Mantenha-se atualizado sobre nossos próximos eventos e os últimos posts do blog, advisories e outros recursos interessantes.
Outros posts























