Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 04:33:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m

Browse source
This commit is contained in:
Translator 2024-07-17 18:07:32 +00:00
parent 7a66379787
commit 4a5a81842e
15 changed files with 345 additions and 309 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
binary-exploitation/libc-heap/bins-and-memory-allocations.md
View file

@ -8,7 +8,7 @@ Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* Otkrijte [**Porodičnu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
@ -16,24 +16,24 @@ Drugi načini podrške HackTricks-u:
## Osnovne informacije
Kako bi se poboljšala efikasnost čuvanja blokova, svaki blok nije samo u jednoj povezanoj listi, već postoji nekoliko tipova. To su binovi i postoji 5 tipova binova: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) mali binovi, 63 velika binova, 1 nesortirani bin, 10 brzih binova i 64 tcache binova po niti.
Da bi se poboljšala efikasnost načina na koji su čunjevi smešteni, svaki čunj nije samo u jednoj povezanoj listi, već postoji nekoliko tipova. To su čunjevi i postoji 5 vrsta čunjeva: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) mali čunjevi, 63 velika čunja, 1 nesortirani čunj, 10 brzih čunjeva i 64 tcache čunja po niti.
Početna adresa za svaki nesortirani, mali i veliki bin je unutar istog niza. Indeks 0 nije korišćen, 1 je nesortirani bin, binovi 2-64 su mali binovi, a binovi 65-127 su veliki binovi.
Početna adresa za svaki nesortirani, mali i veliki čunj je unutar istog niza. Indeks 0 nije korišćen, 1 je nesortirani čunj, čunjevi 2-64 su mali čunjevi, a čunjevi 65-127 su veliki čunjevi.
### Tcache (Keš po niti) Binovi
### Tcache (Keš po niti) Čunjevi
Iako niti pokušavaju da imaju svoj sopstveni hip (videti [Arenas](bins-and-memory-allocations.md#arenas) i [Pod-hipove](bins-and-memory-allocations.md#subheaps)), postoji mogućnost da će proces sa puno niti (kao što je veb server) **završiti deljenjem hipa sa drugim nitima**. U ovom slučaju, glavno rešenje je korišćenje **brava**, što može **znatno usporiti niti**.
Iako niti pokušavaju da imaju svoj sopstveni hip (videti [Arenas](bins-and-memory-allocations.md#arenas) i [Subheaps](bins-and-memory-allocations.md#subheaps)), postoji mogućnost da će proces sa puno niti (kao što je veb server) **završiti deljenjem hipa sa drugim nitima**. U ovom slučaju, glavno rešenje je korišćenje **brava**, koje mogu **znatno usporiti niti**.
Stoga, tcache je sličan brzom binu po niti na način da je to **jednostruko povezana lista** koja ne spaja blokove. Svaka nit ima **64 jednostruko povezana tcache binova**. Svaki bin može imati maksimalno [7 blokova iste veličine](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) u rasponu od [24 do 1032B na 64-bitnim sistemima i 12 do 516B na 32-bitnim sistemima](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
Stoga, tcache je sličan brzom čunju po niti na način da je to **jednostruko povezana lista** koja ne spaja čunjeve. Svaka nit ima **64 jednostruko povezana tcache čunja**. Svaki čunj može imati maksimalno [7 čunjeva iste veličine](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) u rasponu od [24 do 1032B na 64-bitnim sistemima i 12 do 516B na 32-bitnim sistemima](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
Kada nit oslobodi blok, ako nije prevelik da bi bio dodeljen u tcache i odgovarajući tcache bin **nije pun** (već 7 blokova), **biće dodeljen tamo**. Ako ne može ići u tcache, moraće da sačeka da se hip zaključa kako bi mogao da izvrši globalnu operaciju oslobađanja.
Kada nit oslobodi čunj, ako nije prevelik da bi bio alociran u tcache i odgovarajući tcache čunj **nije pun** (već 7 čunjeva), **biće alociran tamo**. Ako ne može ići u tcache, moraće da sačeka da se hip zaključa kako bi mogao da izvrši globalnu operaciju oslobađanja.
Kada se **blok dodeli**, ako postoji slobodan blok potrebne veličine u **Tcache-u, biće korišćen**, ako ne, moraće da sačeka da se hip zaključa kako bi mogao da pronađe jedan u globalnim binovima ili da napravi novi.\
Postoji i optimizacija, u ovom slučaju, dok ima zaključan hip, nit **će popuniti svoj Tcache hip blokovima (7) tražene veličine**, tako da ako zatreba više, naći će ih u Tcache-u.
Kada se **čunj alocira**, ako postoji slobodan čunj potrebne veličine u **Tcache-u, koristiće ga**, ako ne, moraće da sačeka da se hip zaključa kako bi mogao da pronađe jedan u globalnim čunjevima ili da napravi novi.\
Postoji i optimizacija, u ovom slučaju, dok ima zaključan hip, nit **će popuniti svoj Tcache hip čunjevima (7) tražene veličine**, tako da u slučaju potrebe za više njih, moći će da ih pronađe u Tcache-u.
<details>
<summary>Dodaj primer tcache bloka</summary>
<summary>Dodaj primer tcache čunja</summary>
```c
#include <stdlib.h>
#include <stdio.h>
@ -54,9 +54,9 @@ gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
Tcachebins[idx=0, size=0x20, count=1] ← Chunk(addr=0xaaaaaaac12a0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
```
#### Tcache Strukture i Funkcije
#### Strukture i funkcije Tcache
U sledećem kodu je moguće videti **maksimalne binove** i **delove po indeksu**, strukturu **`tcache_entry`** kreiranu da bi se izbeglo duplo oslobađanje i **`tcache_perthread_struct`**, strukturu koju svaka nit koristi da bi čuvala adrese za svaki indeks bin-a.
U sledećem kodu je moguće videti **maksimalne binove** i **delove po indeksu**, **`tcache_entry`** strukturu kreiranu da bi se izbeglo duplo oslobađanje i **`tcache_perthread_struct`**, strukturu koju svaka nit koristi da bi sačuvala adrese za svaki indeks bin-a.
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
@ -151,23 +151,23 @@ memset (tcache, 0, sizeof (tcache_perthread_struct));
#### Tcache Indeksi
Tcache ima nekoliko binova u zavisnosti od veličine, a početni pokazivači na **prvi chunk svakog indeksa i količina chunk-ova po indeksu se nalaze unutar chunk-a**. To znači da je moguće pronaći sve početne tačke tcache-a i količinu Tcache chunk-ova lociranjem chunk-a sa ovim informacijama (obično prvi).
Tcache ima nekoliko binova u zavisnosti od veličine, a početni pokazivači na **prvi blok svakog indeksa i količina blokova po indeksu se nalaze unutar bloka**. To znači da je moguće pronaći sve početne tačke tcache-a i količinu Tcache blokova lociranjem bloka sa ovim informacijama (obično prvi).
### Brzi binovi
Brzi binovi su dizajnirani da **ubrzaju dodelu memorije za male chunk-ove** čuvanjem nedavno oslobođenih chunk-ova u strukturi sa brzim pristupom. Ovi binovi koriste pristup poslednji unutra, prvi napolje (LIFO) pristup, što znači da je **najskorije oslobođeni chunk prvi** koji će biti ponovo korišćen kada postoji nova zahtev za alokacijom. Ovo ponašanje je korisno za brzinu, jer je brže ubaciti i ukloniti sa vrha steka (LIFO) u poređenju sa redom (FIFO).
Brzi binovi su dizajnirani da **ubrzaju dodelu memorije za male blokove** čuvanjem nedavno oslobođenih blokova u strukturi sa brzim pristupom. Ovi binovi koriste pristup poslednji unutra, prvi napolje (LIFO) pristup, što znači da je **najskorije oslobođeni blok prvi** koji će biti ponovo korišćen kada postoji nova zahtev za alokacijom. Ovo ponašanje je korisno za brzinu, jer je brže ubaciti i ukloniti sa vrha steka (LIFO) u poređenju sa redom (FIFO).
Dodatno, **brzi binovi koriste jednostruko povezane liste**, a ne dvostruko povezane, što dodatno poboljšava brzinu. Budući da se chunk-ovi u brzim binovima ne spajaju sa susedima, nema potrebe za složenom strukturom koja omogućava uklanjanje iz sredine. Jednostruko povezana lista je jednostavnija i brža za ove operacije.
Dodatno, **brzi binovi koriste jednostruko povezane liste**, a ne dvostruko povezane, što dodatno poboljšava brzinu. Pošto se blokovi u brzim binovima ne spajaju sa susedima, nema potrebe za složenom strukturom koja omogućava uklanjanje iz sredine. Jednostruko povezana lista je jednostavnija i brža za ove operacije.
U osnovi, ono što se dešava ovde je da je zaglavlje (pokazivač na prvi chunk koji treba proveriti) uvek usmereno ka poslednjem oslobođenom chunk-u te veličine. Dakle:
U osnovi, ono što se dešava ovde je da je zaglavlje (pokazivač na prvi blok koji treba proveriti) uvek usmereno ka poslednjem oslobođenom bloku te veličine. Dakle:
* Kada se alocira novi chunk te veličine, zaglavlje pokazuje na slobodan chunk za korišćenje. Pošto ovaj slobodan chunk pokazuje na sledeći koji treba koristiti, ova adresa se čuva u zaglavlju kako bi sledeća alokacija znala gde da dobije dostupan chunk.
* Kada se chunk oslobodi, slobodan chunk će sačuvati adresu trenutno dostupnog chunk-a, a adresa ovog novootvorenog chunk-a će biti stavljena u zaglavlje.
* Kada se alocira novi blok te veličine, zaglavlje pokazuje na slobodan blok za korišćenje. Pošto ovaj slobodan blok pokazuje na sledeći koji treba koristiti, ova adresa je sačuvana u zaglavlju tako da sledeća alokacija zna gde da dobije dostupan blok
* Kada se blok oslobodi, slobodan blok će sačuvati adresu trenutno dostupnog bloka i adresa ovog novootvorenog bloka će biti stavljena u zaglavlje
Maksimalna veličina povezane liste je `0x80` i organizovane su tako da će chunk veličine `0x20-0x2f` biti u indeksu `0`, chunk veličine `0x30-0x3f` bi bio u `idx` `1`...
Maksimalna veličina povezane liste je `0x80` i organizovane su tako da će blok veličine `0x20` biti u indeksu `0`, blok veličine `0x30` biće u indeksu `1`...
{% hint style="danger" %}
Chunk-ovi u brzim binovima nisu označeni kao dostupni, tako da se čuvaju kao chunk-ovi brzih binova neko vreme umesto da mogu da se spoje sa drugim slobodnim chunk-ovima koji ih okružuju.
Blokovi u brzim binovima nisu označeni kao dostupni tako da se čuvaju kao blokovi brzih binova neko vreme umesto što bi mogli da se spoje sa drugim slobodnim blokovima koji ih okružuju.
{% endhint %}
```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
@ -232,9 +232,9 @@ free(chunks[i]);
return 0;
}
```
Zabeležite kako alociramo i oslobađamo 8 blokova iste veličine tako da popune tcache, a osmi je smešten u brzom bloku.
Primetite kako alociramo i oslobađamo 8 blokova iste veličine tako da popunjavaju tcache, a osmi je smešten u brzom bloku.
Kompajlirajte ga i debagujte sa prekidnom tačkom u ret opcode-u glavne funkcije. Zatim, pomoću gef-a možete videti popunjavanje tcache bin-a i jedan blok u brzom binu:
Kompajlirajte i debagujte sa prekidnom tačkom u `ret` opcode-u iz `main` funkcije. Zatim, pomoću `gef` alata možete videti da je tcache bin pun i da je jedan blok u brzom binu:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -245,13 +245,13 @@ Fastbins[idx=1, size=0x30] 0x00
```
### Neuređena kanta
Neuređena kanta je **keš** koji koristi menadžer hipa kako bi ubrzao dodelu memorije. Evo kako funkcioniše: Kada program oslobodi komad, i ako taj komad ne može biti dodeljen u tcache ili brzoj kanti i ne sudara se sa vršnim komadom, menadžer hipa ga ne stavlja odmah u određenu malu ili veliku kantu. Umesto toga, prvo pokušava da ga **spoji sa bilo kojim susednim slobodnim komadima** kako bi stvorio veći blok slobodne memorije. Zatim, smešta ovaj novi komad u opštu kantu nazvanu "neuređena kanta".
Neuređena kanta je **keš** koji koristi menadžer hipa kako bi ubrzao dodelu memorije. Evo kako funkcioniše: Kada program oslobodi komad, i ako taj komad ne može biti dodeljen u tcache ili brzoj kanti i ne sudara se sa vršnom kantom, menadžer hipa ga ne stavlja odmah u određenu malu ili veliku kantu. Umesto toga, prvo pokušava da ga **spoji sa bilo kojim susednim slobodnim komadima** kako bi stvorio veći blok slobodne memorije. Zatim, smešta ovaj novi komad u opštu kantu nazvanu "neuređena kanta."
Kada program **zatraži memoriju**, menadžer hipa **proverava neuređenu kantu** da vidi da li postoji dovoljno veliki komad. Ako pronađe jedan, odmah ga koristi. Ako ne pronađe odgovarajući komad u neuređenoj kanti, premestiće sve komade sa ove liste u njihove odgovarajuće kante, bilo male ili velike, na osnovu njihove veličine.
Imajte na umu da ako se veći komad podeli na 2 polovine i ako je preostali deo veći od MINSIZE, biće vraćen nazad u neuređenu kantu.&#x20;
Imajte na umu da ako se veći komad podeli na 2 polovine i ako je preostali deo veći od MINSIZE, biće vraćen nazad u neuređenu kantu.
Dakle, neuređena kanta je način da se ubrza dodela memorije brzim ponovnim korišćenjem nedavno oslobođene memorije i smanjenjem potrebe za vremenski zahtevnim pretragama i spajanjima.
Dakle, neuređena kanta je način da se ubrza dodela memorije brzim ponovnim korišćenjem nedavno oslobođene memorije i smanjenjem potrebe za dugotrajnim pretragama i spajanjima.
{% hint style="danger" %}
Imajte na umu da čak i ako su komadi različitih kategorija, ako dostupan komad sudara sa drugim dostupnim komadom (čak i ako su originalno pripadali različitim kantama), biće spojeni.
@ -259,7 +259,7 @@ Imajte na umu da čak i ako su komadi različitih kategorija, ako dostupan komad
<details>
<summary>Dodaj primer neuređenog komada</summary>
<summary>Dodajte primer neuređenog komada</summary>
```c
#include <stdlib.h>
#include <stdio.h>
@ -287,9 +287,9 @@ free(chunks[i]);
return 0;
}
```
Primetite kako alociramo i oslobađamo 9 blokova iste veličine tako da **popunjavaju tcache**, a osmi je smešten u unsorted bin jer je **prevelik za fastbin**, dok deveti nije oslobođen tako da deveti i osmi **ne budu spojeni sa vršnim blokom**.
Primetite kako alociramo i oslobađamo 9 blokova iste veličine tako da **popunimo tcache** i osmi je smešten u unsorted bin jer je **prevelik za fastbin**, a deveti nije oslobođen tako da deveti i osmi **neće biti spojeni sa vršnim blokom**.
Kompajlirajte i debagujte sa prekidnom tačkom u ret opcode-u iz glavne funkcije. Zatim pomoću gef-a možete videti popunjavanje tcache bin-a i jedan blok u unsorted bin-u:
Kompajlirajte i debagujte sa prekidnom tačkom u `ret` opcode-u iz `main` funkcije. Zatim pomoću `gef` možete videti da je tcache bin pun i da je jedan blok u unsorted binu:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -340,7 +340,7 @@ Funkcija za izbor između malih i velikih binova:
```
<detalji>
<summary>Dodajte primer malog bloka</summary>
<sumiraj>Dodajte primer malog bloka</sumiraj>
```c
#include <stdlib.h>
#include <stdio.h>
@ -370,9 +370,9 @@ chunks[9] = malloc(0x110);
return 0;
}
```
Primetite kako alociramo i oslobađamo 9 blokova iste veličine tako da **popunimo tcache** i osmi je smešten u unsorted bin jer je **prevelik za fastbin**, a deveti nije oslobođen tako da deveti i osmi **ne budu spojeni sa vršnim blokom**. Zatim alociramo veći blok od 0x110 što dovodi do toga da **blok u unsorted binu pređe u small bin**.
Primetite kako alociramo i oslobađamo 9 blokova iste veličine tako da **popunjavaju tcache**, a osmi je smešten u unsorted bin jer je **prevelik za fastbin**, dok deveti nije oslobođen pa deveti i osmi **nisu spojeni sa vršnim blokom**. Zatim alociramo veći blok od 0x110 što dovodi do toga da **blok u unsorted binu pređe u small bin**.
Kompajlirajte i debagujte sa prekidnom tačkom u ret opcode-u iz glavne funkcije. Zatim sa gef-om možete videti popunjen tcache bin i jedan blok u small binu:
Kompajlirajte i debagujte sa prekidnom tačkom u `ret` opcode-u iz `main` funkcije. Zatim, pomoću `gef` alata možete videti da je tcache bin pun i da je jedan blok u small binu:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -396,9 +396,9 @@ Fastbins[idx=6, size=0x80] 0x00
### Velike kante
Za razliku od malih kanti, koje upravljaju komadićima fiksnih veličina, **svaka velika kanta upravlja opsegom veličina komadića**. Ovo je fleksibilnije, omogućavajući sistemu da se prilagodi **različitim veličinama** bez potrebe za posebnom kantom za svaku veličinu.
Za razliku od malih kanti, koje upravljaju komadićima fiksnih veličina, **svaka velika kanta obrađuje opseg veličina komadića**. Ovo je fleksibilnije, omogućavajući sistemu da se prilagodi **različitim veličinama** bez potrebe za posebnom kantom za svaku veličinu.
U memorijskom alokatoru, velike kante počinju tamo gde se završavaju male kante. Opsezi za velike kante postaju sve veći, što znači da prva kanta može pokrivati komadiće od 512 do 576 bajtova, dok sledeća pokriva od 576 do 640 bajtova. Ovaj obrazac se nastavlja, pri čemu najveća kanta sadrži sve komadiće veće od 1MB.
U alokatoru memorije, velike kante počinju tamo gde se završavaju male kante. Opsezi za velike kante postaju sve veći, što znači da prva kanta može obuhvatiti komadiće od 512 do 576 bajtova, dok sledeća obuhvata 576 do 640 bajtova. Ovaj obrazac se nastavlja, pri čemu najveća kanta sadrži sve komadiće iznad 1MB.
Velike kante sporije rade u poređenju sa malim kantama jer moraju **sortirati i pretraživati listu različitih veličina komadića kako bi pronašle najbolje odgovarajuće** za alokaciju. Kada se komadić ubaci u veliku kantu, mora biti sortiran, a prilikom alokacije memorije, sistem mora pronaći odgovarajući komadić. Ovaj dodatni rad ih čini **sporijim**, ali budući da su velike alokacije manje uobičajene od malih, to je prihvatljiva trgovina.
@ -470,9 +470,9 @@ chunks[0] = malloc(0x2000);
return 0;
}
```
Dve velike alokacije se vrše, zatim jedna se oslobađa (stavlja se u unsorted bin) i pravi se veća alokacija (premeštanje oslobođene u unsorted bin u large bin).
Izvrše se 2 velike alokacije, zatim se jedna oslobađa (stavlja u nesortirani bin) i vrši se veća alokacija (premeštanje oslobođene u nesortirani bin u veliki bin).
Kompajlirajte i debagujte sa prekidnom tačkom u ret opcode-u glavne funkcije. Zatim, pomoću gef-a možete videti popunjavanje tcache bina i jedan chunk u large binu:
Kompajlirajte to i debagujte sa prekidnom tačkom u `ret` opkodu iz `main` funkcije. Zatim, pomoću `gef` alata možete videti da je tcache bin pun i da je jedan blok u velikom binu:
```bash
gef➤ heap bin
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -496,7 +496,7 @@ Fastbins[idx=6, size=0x80] 0x00
```
</details>
### Vrhunski blok
### Vrhunski komad
```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
@ -522,7 +522,7 @@ the 2 preceding words to be zero during this interval as well.)
#define initial_top(M) (unsorted_chunks (M))
```
Osnovno, ovo je deo koji sadrži sav trenutno dostupan heap. Kada se izvrši malloc, ako nema dostupnog slobodnog chunk-a za korišćenje, ovaj top chunk će smanjiti svoju veličinu pružajući potreban prostor.\
Pokazivač na Top Chunk se čuva u strukturi `malloc_state`.
Pokazivač na Top Chunk je smešten u strukturi `malloc_state`.
Osim toga, na početku je moguće koristiti nesortirani chunk kao top chunk.
@ -542,7 +542,7 @@ gets(chunk);
return 0;
}
```
Nakon kompajliranja i debagovanja sa prekidnom tačkom u ret opcode-u glavne funkcije, primetio sam da je malloc vratio adresu: `0xaaaaaaac12a0` i ovo su chunk-ovi:
Nakon kompajliranja i debagovanja sa prekidnom tačkom u `ret` opkodu `main` funkcije, primetio sam da je malloc vratio adresu `0xaaaaaaac12a0` i ovo su blokovi:
```bash
gef➤ heap chunks
Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
@ -564,11 +564,11 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
```
</details>
### Poslednje podsećanje
### Poslednji Ostatatak
Kada se koristi malloc i deo je podeljen (na primer, iz nevezane liste ili iz vršnog bloka), deo koji je kreiran od preostalog dela podeljenog bloka naziva se Poslednje podsećanje i njegov pokazivač se čuva u strukturi `malloc_state`.
Kada se koristi malloc i deo je podeljen (na primer iz nesortirane kante ili iz vršnog bloka), deo koji je kreiran od preostalog dela podeljenog bloka naziva se Poslednji Ostatatak i njegov pokazivač se čuva u strukturi `malloc_state`.
## Tok dodele
## Tok Dodele
Pogledajte:
@ -576,7 +576,7 @@ Pogledajte:
[malloc-and-sysmalloc.md](heap-memory-functions/malloc-and-sysmalloc.md)
{% endcontent-ref %}
## Tok oslobađanja
## Tok Oslobađanja
Pogledajte:
@ -584,9 +584,9 @@ Pogledajte:
[free.md](heap-memory-functions/free.md)
{% endcontent-ref %}
## Provere bezbednosti funkcija hipa
## Provere Bezbednosti Funkcija Heap-a
Proverite provere bezbednosti koje obavljaju često korišćene funkcije u hipu u:
Proverite provere bezbednosti koje se vrše od strane često korišćenih funkcija u heap-u u:
{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
@ -605,10 +605,10 @@ Proverite provere bezbednosti koje obavljaju često korišćene funkcije u hipu
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili **telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>

44
binary-exploitation/libc-heap/double-free.md
View file

@ -1,26 +1,26 @@
# Dvostruko Oslobađanje
# Двоструко Ослобађање
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Научите хаковање AWS-а од нуле до героја са</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
Други начини да подржите HackTricks:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
* Ако желите да видите вашу **компанију рекламирану на HackTricks** или **преузмете HackTricks у PDF формату** проверите [**ПЛАНОВЕ ПРЕТПЛАТЕ**](https://github.com/sponsors/carlospolop)!
* Набавите [**званични PEASS & HackTricks сувенир**](https://peass.creator-spring.com)
* Откријте [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), нашу колекцију ексклузивних [**NFT-ова**](https://opensea.io/collection/the-peass-family)
* **Придружите се** 💬 [**Discord групи**](https://discord.gg/hRep4RUj7f) или [**telegram групи**](https://t.me/peass) или **пратите** нас на **Twitter-u** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Поделите своје хакерске трикове подношењем PR-ова на** [**HackTricks**](https://github.com/carlospolop/hacktricks) и [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github репозиторијумима.
</details>
## Osnovne Informacije
## Основне Информације
Ako oslobodite blok memorije više puta, možete poremetiti podatke alokatora i otvoriti vrata napadima. Evo kako se to dešava: kada oslobodite blok memorije, on se vraća u listu slobodnih blokova (npr. "fastbin"). Ako oslobodite isti blok dva puta uzastopno, alokator detektuje to i prijavljuje grešku. Ali ako **oslobodite još jedan blok između, provera dvostrukog oslobađanja se zaobilazi**, što uzrokuje korupciju.
Ако ослободите блок меморије више пута, може да се помете податке алокатора и отвори врати нападима. Ево како се дешава: када ослободите блок меморије, он се враћа у листу слободних чанкова (нпр. "брзи бин"). Ако ослободите исти блок двапут за редом, алокатор то открива и баца грешку. Али, ако **ослободите други чанк између, двоструко-ослобађање се прескаче**, изазивајући корупцију.
Sada, kada zatražite novu memoriju (koristeći `malloc`), alokator vam može dati **blok koji je dva puta oslobođen**. To može dovesti do toga da dva različita pokazivača pokazuju na istu lokaciju memorije. Ako napadač kontroliše jedan od tih pokazivača, može promeniti sadržaj te memorije, što može izazvati sigurnosne probleme ili im čak omogućiti izvršavanje koda.
Сада, када захтевате нову меморију (користећи `malloc`), алокатор вам може дати **блок који је двапут ослобођен**. Ово може довести до два различита показивача који показују на исту локацију меморије. Ако нападач контролише један од тих показивача, може променити садржај те меморије, што може изазвати безбедносне проблеме или им дозволити да изврше код.
Primer:
Пример:
```c
#include <stdio.h>
#include <stdlib.h>
@ -92,7 +92,7 @@ printf("i2: %p\n", (void *)i1);
return 0;
}
```
U ovom primeru, nakon što se tcache popuni sa nekoliko oslobođenih blokova, kod **oslobađa blok `h`, zatim blok `i`, a zatim ponovo `h`, što uzrokuje grešku dvostrukog oslobađanja**. Ovo otvara mogućnost dobijanja preklapajućih memorijskih adresa prilikom realokacije, što znači da dva ili više pokazivača mogu pokazivati na istu memorijsku lokaciju. Manipulisanje podacima putem jednog pokazivača može onda uticati na drugi, stvarajući kritičan sigurnosni rizik i potencijal za eksploataciju.
U ovom primeru, nakon što se tcache popuni sa nekoliko oslobođenih blokova (7), kod **oslobađa blok `h`, zatim blok `i`, a zatim ponovo `h`, uzrokujući dvostruko oslobođavanje** (poznato i kao Fast Bin duplikat). Ovo otvara mogućnost dobijanja preklapajućih memorijskih adresa prilikom realokacije, što znači da dva ili više pokazivača mogu pokazivati na istu memorijsku lokaciju. Manipulisanje podacima putem jednog pokazivača može zatim uticati na drugi, stvarajući kritičan sigurnosni rizik i potencijal za eksploataciju.
Izvršavajući to, primetite kako su **`i1` i `i2` dobili istu adresu**:
@ -119,6 +119,22 @@ h1: 0xaaab0f0c2380
</strong><strong>i2: 0xaaab0f0c23a0
</strong></code></pre>
## Primeri
* [**Dragon Army. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/dragon-army/)
* Možemo alocirati samo blokove veličine Fast-Bin, osim za veličinu `0x70`, što sprečava uobičajeno prepisivanje `__malloc_hook`.
* Umesto toga, koristimo PIE adrese koje počinju sa `0x56` kao cilj za Fast Bin duplikat (1/2 šanse).
* Jedno mesto gde se čuvaju PIE adrese je u `main_arena`, koja je unutar Glibc-a i blizu `__malloc_hook`.
* Ciljamo određeni offset `main_arena`-e da alociramo blok tamo i nastavljamo sa alociranjem blokova dok ne stignemo do `__malloc_hook`-a kako bismo dobili izvršenje koda.
* [**zero_to_hero. PicoCTF**](https://7rocky.github.io/en/ctf/picoctf/binary-exploitation/zero_to_hero/)
* Koristeći Tcache binove i prelivanje nulama, možemo postići situaciju dvostrukog oslobođavanja:
* Alociramo tri bloka veličine `0x110` (`A`, `B`, `C`)
* Oslobađamo `B`
* Oslobađamo `A` i ponovo alociramo da bismo iskoristili prelivanje nulama
* Sada je veličina polja `B` `0x100`, umesto `0x111`, tako da ga možemo ponovo osloboditi
* Imamo jedan Tcache-bin veličine `0x110` i jedan veličine `0x100` koji pokazuju na istu adresu. Dakle, imamo dvostruko oslobođavanje.
* Iskorišćavamo dvostruko oslobođavanje koristeći [Tcache trovanje](tcache-bin-attack.md)
## Reference
* [https://heap-exploitation.dhavalkapil.com/attacks/double\_free](https://heap-exploitation.dhavalkapil.com/attacks/double\_free)
@ -129,7 +145,7 @@ h1: 0xaaab0f0c2380
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili **telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

40
binary-exploitation/libc-heap/fast-bin-attack.md
View file

@ -1,12 +1,12 @@
# Brza Binarna Napad
# Brzi Bin Napad
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini da podržite HackTricks:
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -16,13 +16,13 @@ Drugi načini da podržite HackTricks:
## Osnovne Informacije
Za više informacija o tome šta je brza binarna provera posetite ovu stranicu:
Za više informacija o tome šta je brzi bin pogledajte ovu stranicu:
{% content-ref url="bins-and-memory-allocations.md" %}
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Pošto je brza binarna jednostruko povezana, postoji mnogo manje zaštite nego u drugim binarnim proverama i samo **modifikovanje adrese u oslobođenom brzom binu** isecku je dovoljno da biste mogli **dodeliti kasnije isečak na bilo kojoj memorijskoj adresi**.
Pošto je brzi bin jednostruko povezana lista, postoji mnogo manje zaštite nego u drugim binovima i samo **modifikovanje adrese u oslobođenom fast bin** delu je dovoljno da biste mogli **dodeliti kasnije deo na bilo kojoj memorijskoj adresi**.
Kao sažetak:
@ -134,26 +134,30 @@ printf("\n\nJust like that, we executed a fastbin attack to allocate an address
}
```
{% hint style="danger" %}
Ako je moguće prebrisati vrednost globalne promenljive **`global_max_fast`** velikim brojem, to omogućava generisanje brzih binova većih veličina, potencijalno omogućavajući izvođenje brzih bin napada u scenarijima gde to ranije nije bilo moguće.
Ako je moguće prebrisati vrednost globalne promenljive **`global_max_fast`** velikim brojem, to omogućava generisanje brzih bin chunk-ova većih veličina, potencijalno omogućavajući izvođenje brzih bin napada u scenarijima gde to ranije nije bilo moguće. Ova situacija je korisna u kontekstu [napada velikim binom](large-bin-attack.md) i [napada nesortiranim binom](unsorted-bin-attack.md).
{% endhint %}
## Primeri
* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html)**:**
* Moguće je alocirati delove, osloboditi ih, pročitati njihov sadržaj i popuniti ih (sa ranjivošću prelivanja).
* **Konsolidacija dela za infoleak**: Tehnika se uglavnom svodi na zloupotrebu prelivanja kako bi se napravila lažna prev\_size tako da se jedan prethodni deo stavi unutar većeg dela, tako da prilikom alociranja većeg dela koji sadrži još jedan deo, moguće je ispisati njegove podatke i procuriti adresu do libc-a (main\_arena+88).
* **Prepisivanje malloc kuke**: Za ovo, i zloupotrebu prethodne situacije preklapanja, bilo je moguće imati 2 dela koji su pokazivali na istu memoriju. Stoga, oslobađajući ih oboje (oslobađajući još jedan deo između da bi se izbegle zaštite), bilo je moguće imati isti deo u brzom binu 2 puta. Zatim, bilo je moguće ponovo ga alocirati, prepisati adresu sledećeg dela da pokazuje malo pre malloc\_hook-a (tako da pokazuje na celobrojnu vrednost koju malloc smatra slobodnom veličinom - još jedan zaobilazak), ponovo ga alocirati i zatim alocirati još jedan deo koji će primiti adresu do malloc kuka.\
Na kraju je **jedan alat** napisan tamo.
* Moguće je alocirati chunk-ove, osloboditi ih, pročitati njihov sadržaj i popuniti ih (sa ranjivošću prelivanja).
* **Konsolidacija chunk-a za infoleak**: Tehnika se uglavnom zloupotrebljava prelivanjem kako bi se stvorila lažna `prev_size` tako da se jedan prethodni chunk stavi unutar većeg, pa kada se alocira veći chunk koji sadrži još jedan chunk, moguće je ispisati njegove podatke i procuriti adresu do libc-a (`main_arena+88`).
* **Prepisivanje malloc kuke**: Za ovo, i zloupotrebljavajući prethodnu situaciju preklapanja, bilo je moguće imati 2 chunk-a koji su pokazivali na istu memoriju. Stoga, oslobađajući ih oboje (oslobađajući još jedan chunk između da bi se izbegle zaštite), bilo je moguće imati isti chunk u brzom binu 2 puta. Zatim, bilo je moguće ponovo ga alocirati, prepisati adresu sledećeg chunk-a da pokazuje malo pre `__malloc_hook` (tako da pokazuje na integer koji malloc smatra slobodnom veličinom - još jedan zaobilazak), ponovo ga alocirati, a zatim alocirati još jedan chunk koji će primiti adresu do malloc kuka.\
Na kraju je **jedan gadget** upisan tamo.
* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html)**:**
* Postoji prelivanje hipa i korisnik nakon oslobađanja i dvostruko oslobađanje jer kada se deo oslobodi moguće ga je ponovo koristiti i ponovo osloboditi pokazivače
* **Libc info leak**: Samo oslobodite neke delove i dobićete pokazivač do dela glavne arene. Kako možete ponovo koristiti oslobođene pokazivače, samo pročitajte ovu adresu.
* **Napad brzog bina**: Svi pokazivači na alokacije čuvaju se unutar niza, tako da možemo osloboditi par brzih bin delova i u poslednjem prepisati adresu da pokazuje malo pre ovog niza pokazivača. Zatim, alocirajte par delova iste veličine i prvo ćemo dobiti legitimni deo, a zatim lažni deo koji sadrži niz pokazivača. Sada možemo prepisati ove pokazivače alokacije da pokazuju na adresu `free` kako bi pokazivali na sistem, a zatim napisati deo 1 `"/bin/sh"` da zatim `oslobodite(deo1)` što će izvršiti `system("/bin/sh")`.
* Postoji prelivanje hipa i korišćenje nakon oslobađanja i duplo oslobađanje jer kada se chunk oslobodi moguće je ponovo koristiti i ponovo osloboditi pokazivače
* **Libc info leak**: Samo oslobodite neke chunk-ove i dobićete pokazivač do dela lokacije glavne arene. Kako možete ponovo koristiti oslobođene pokazivače, samo pročitajte ovu adresu.
* **Napad brzim binom**: Svi pokazivači na alokacije čuvaju se unutar niza, pa možemo osloboditi par brzih bin chunk-ova i u poslednjem prepisati adresu da pokazuje malo pre ovog niza pokazivača. Zatim, alocirajte par chunk-ova iste veličine i prvo ćemo dobiti legitimni, a zatim lažni koji sadrži niz pokazivača. Sada možemo prepisati ove alokacijske pokazivače da bi adresa GOT-a `free` pokazivala na `system`, a zatim napisati `"/bin/sh"` u chunk 1 da bismo zatim pozvali `free(chunk1)` što će umesto toga izvršiti `system("/bin/sh")`.
* **CTF** [**https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw19\_traveller/index.html**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw19\_traveller/index.html)
* Još jedan primer zloupotrebe prelivanja od 1B za konsolidaciju delova u nesortiranom binu i dobijanje libc infoleaka, a zatim izvođenje brzog bin napada za prepisivanje malloc kuke sa adresom jednog alata
* Još jedan primer zloupotrebe prelivanja jednim bajtom za konsolidaciju chunk-ova u nesortirani bin i dobijanje libc infoleaka, a zatim izvođenje napada brzim binom za prepisivanje malloc kuke sa adresom jednog gadgeta
* **CTF** [**https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html)
* Nakon infoleaka zloupotrebom nesortiranog bina sa UAF-om da procuri libc adresu i adresu PIE-a, eksploatacija ovog CTF-a koristila je brzi bin napad za alokaciju dela na mestu gde su se nalazili pokazivači do kontrolisanih delova tako da je bilo moguće prepisati određene pokazivače da bi se napisao jedan alat u GOT-u
* Možete pronaći napad brzog bina zloupotrebljen kroz napad na nesortirani bin:
* Imajte na umu da je uobičajeno pre izvođenja brzih bin napada zloupotrebiti listu neželjenih da bi procurili libc/heap adrese (kada je potrebno).
* Nakon infoleaka zloupotrebom nesortiranog bina sa UAF-om da bi procurili adresu libc-a i adresu PIE-a, eksploatacija ovog CTF-a koristila je napad brzim binom da alocira chunk na mestu gde su se nalazili pokazivači ka kontrolisanim chunk-ovima tako da je bilo moguće prepisati određene pokazivače da bi se napisao jedan gadget u GOT-u
* Možete pronaći napad brzim binom zloupotrebljen kroz napad nesortiranim binom:
* Imajte na umu da je uobičajeno pre izvođenja napada brzim binom zloupotrebiti listu slobodnih chunk-ova da bi procurili libc/heap adrese (kada je potrebno).
* [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
* Možemo alocirati samo chunk-ove veće od `0x100`.
* Prepišite `global_max_fast` koristeći napad nesortiranim binom (radi 1/16 puta zbog ASLR-a, jer moramo modifikovati 12 bitova, ali moramo modifikovati 16 bitova).
* Napad brzim binom za modifikovanje globalnog niza chunk-ova. Ovo daje proizvoljni čitanje/pisanje, što omogućava modifikaciju GOT-a i postavljanje neke funkcije da pokazuje na `system`.
{% content-ref url="unsorted-bin-attack.md" %}
[unsorted-bin-attack.md](unsorted-bin-attack.md)
@ -165,7 +169,7 @@ Na kraju je **jedan alat** napisan tamo.
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF-u** Proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

38
binary-exploitation/libc-heap/heap-overflow.md
View file

@ -6,9 +6,9 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodiču PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
@ -18,47 +18,53 @@ Drugi načini podrške HackTricks-u:
Prekoračenje hipa je poput [**prekoračenja steka**](../stack-overflow/), ali u hipu. U osnovi to znači da je neki prostor rezervisan u hipu za čuvanje podataka i **čuvani podaci su bili veći od rezervisanog prostora.**
Kod prekoračenja steka znamo da će neki registri poput pokazivača instrukcija ili okvira steka biti obnovljeni sa steka i moguće je zloupotrebiti to. U slučaju prekoračenja hipa, **nema podataka osetljivih podataka koji se podrazumevano čuvaju u hipu koji može biti prekoračen.** Međutim, mogu biti osetljivi podaci ili pokazivači, pa **kritičnost** ove ranjivosti **zavisi** o **kojim podacima mogu biti prepisani** i kako napadač može to zloupotrebiti.
Kod prekoračenja steka znamo da će neki registri poput pokazivača instrukcija ili okvira steka biti obnovljeni sa steka i moguće je zloupotrebiti to. U slučaju prekoračenja hipa, **nema podataka osetljivih po podrazumevanim postavkama** u hip delu koji može biti prekoračen. Međutim, mogu biti osetljivi podaci ili pokazivači, pa **kritičnost** ove ranjivosti **zavisi** o **kojim podacima mogu biti prepisani** i kako napadač može to zloupotrebiti.
{% hint style="success" %}
Da biste pronašli ofsete prekoračenja, možete koristiti iste obrasce kao u [**prekoračenjima steka**](../stack-overflow/#finding-stack-overflows-offsets).
Da biste pronašli ofsete prekoračenja, možete koristiti iste obrasce kao kod [**prekoračenja steka**](../stack-overflow/#finding-stack-overflows-offsets).
{% endhint %}
### Prekoračenje steka vs prekoračenje hipa
Kod prekoračenja steka, organizacija i podaci koji će biti prisutni na steku u trenutku kada se može pokrenuti ranjivost su prilično pouzdani. To je zato što je stek linearan, uvek se povećava u koliziji memorije, na **specifičnim mestima izvršavanja programa stek memorija obično čuva slične vrste podataka** i ima određenu strukturu sa nekim pokazivačima na kraju dela steka koji koristi svaka funkcija.
Kod prekoračenja steka, organizacija i podaci koji će biti prisutni na steku u trenutku kada se ranjivost može aktivirati su prilično pouzdani. To je zato što je stek linearan, uvek se povećava u koliziji memorije, na **specifičnim mestima izvršavanja programa stek memorija obično čuva slične vrste podataka** i ima određenu strukturu sa nekim pokazivačima na kraju dela steka koji se koristi za svaku funkciju.
Međutim, u slučaju prekoračenja hipa, jer se korišćena memorija ne povećava linearno već su **dodeljeni delovi obično na odvojenim pozicijama memorije** (ne jedan pored drugog) zbog **binova i zona** koji razdvajaju alokacije po veličini i zbog toga što se **prethodno oslobođena memorija koristi** pre nego što se dodele novi delovi. **Komplikovano je znati koji objekat će se sudariti sa onim koji je ranjiv** na prekoračenje hipa. Dakle, kada se pronađe prekoračenje hipa, potrebno je pronaći **pouzdan način da se željeni objekat nađe odmah u memoriji** pored onog koji može biti prekoračen.
Međutim, u slučaju prekoračenja hipa, korišćena memorija nije linearna već **dodeljeni blokovi obično su na odvojenim pozicijama memorije** (ne jedan pored drugog) zbog **kanti i zona** koje razdvajaju alokacije po veličini i zbog toga što se **prethodno oslobođena memorija koristi** pre nego što se dodeljuju novi blokovi. **Komplikovano je znati koji objekat će se sudariti sa onim koji je ranjiv** na prekoračenje hipa. Dakle, kada se pronađe prekoračenje hipa, potrebno je pronaći **pouzdan način da se željeni objekat nađe odmah u memoriji** pored onog koji može biti prekoračen.
Jedna od tehnika koja se koristi za to je **Heap Grooming** koja se koristi na primer [**u ovom postu**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). U postu je objašnjeno kako kada u iOS kernelu jedna zona ostane bez memorije za čuvanje delova memorije, proširuje se za jednu stranicu kernela, a ova stranica se deli na delove očekivanih veličina koji će se koristiti redom (do verzije iOS 9.2, zatim se ovi delovi koriste na nasumičan način kako bi se otežala eksploatacija ovih napada).
Jedna od tehnika korišćenih za to je **Gajenje hipa** koje se koristi na primer [**u ovom postu**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). U postu je objašnjeno kako kada u iOS kernelu zona ostane bez memorije za čuvanje blokova memorije, proširuje se za jednu stranicu kernela, a ova stranica se deli na blokove očekivanih veličina koji će se koristiti redom (do verzije iOS 9.2, zatim se ovi blokovi koriste na nasumičan način kako bi se otežala eksploatacija ovih napada).
Stoga, u prethodnom postu gde se dešava prekoračenje hipa, kako bi se naterao prekoračeni objekat da se sudari sa žrtvom, nekoliko **`kallocs` se forsira pomoću nekoliko niti kako bi se osiguralo da su svi slobodni delovi popunjeni i da je kreirana nova stranica**.
Stoga, u prethodnom postu gde se dešava prekoračenje hipa, kako bi se naterao prekoračeni objekat da se sudari sa žrtvom, nekoliko **`kallocs` je prisiljeno od strane nekoliko niti kako bi se osiguralo da su svi slobodni blokovi popunjeni i da je kreirana nova stranica**.
Da bi se prisililo popunjavanje ovim objektima određene veličine, **vanlinijska alokacija povezana sa iOS mach portom** je idealan kandidat. Oblikovanjem veličine poruke, moguće je tačno odrediti veličinu alokacije `kalloc` i kada odgovarajući mach port bude uništen, odgovarajuća alokacija će odmah biti oslobođena natrag `kfree`.
Da bi se nateralo ovo popunjavanje objektima određene veličine, **alokacija van linije povezana sa iOS mach portom** je idealan kandidat. Oblikovanjem veličine poruke, moguće je tačno odrediti veličinu alokacije `kalloc` i kada odgovarajući mach port bude uništen, odgovarajuća alokacija će odmah biti oslobođena natrag `kfree`.
Zatim, neki od ovih čuvara mogu biti **oslobođeni**. **`kalloc.4096` lista oslobođenih elemenata oslobađa elemente po principu poslednji unutra-prvi napolje**, što u osnovi znači da ako su neki čuvari oslobođeni i eksploatacija pokuša da alocira nekoliko objekata žrtava dok pokušava da alocira objekat ranjiv na prekoračenje, verovatno je da će ovaj objekat biti praćen objektom žrtve.
Zatim, neki od ovih čuvara mogu biti **oslobođeni**. Lista oslobođenih **`kalloc.4096`** elemenata oslobađa elemente po principu poslednji unutra-prvi napolje, što u osnovi znači da ako su neki čuvari oslobođeni i eksploatacija pokuša da alocira nekoliko objekata žrtava dok pokušava da alocira objekat ranjiv na prekoračenje, verovatno je da će ovaj objekat biti praćen objektom žrtve.
### Primer libc
### Primer libc-a
[**Na ovoj stranici**](https://guyinatuxedo.github.io/27-edit\_free\_chunk/heap\_consolidation\_explanation/index.html) moguće je pronaći osnovnu emulaciju prekoračenja hipa koja pokazuje kako prekoračenjem prethodnog bita u upotrebi sledećeg dela i položaj prethodne veličine moguće je **konsolidovati korišćeni deo** (praveći da misli da nije u upotrebi) i **zatim ga ponovo alocirati** kako bi se prepisali podaci koji se koriste u drugom pokazivaču.
[**Na ovoj stranici**](https://guyinatuxedo.github.io/27-edit\_free\_chunk/heap\_consolidation\_explanation/index.html) moguće je pronaći osnovnu emulaciju prekoračenja hipa koja pokazuje kako prekoračenjem prethodnog bita u upotrebi sledećeg bloka i pozicije prethodne veličine moguće je **konsolidovati korišćeni blok** (praveći da misli da nije u upotrebi) i **zatim ga ponovo alocirati** kako bi se prepisali podaci koji se koriste u drugom pokazivaču.
Još jedan primer sa [**protostar hip 0**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap0/index.html) pokazuje vrlo osnovan primer CTF-a gde se **prekoračenje hipa** može zloupotrebiti kako bi se pozvala funkcija pobednika i **dobila zastava**.
Još jedan primer [**protostar hip 0**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap0/index.html) pokazuje vrlo osnovan primer CTF-a gde se **prekoračenje hipa** može zloupotrebiti kako bi se pozvala funkcija pobednika i **dobila zastava**.
U primeru [**protostar hip 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) moguće je videti kako zloupotrebom prekoračenja bafera moguće je **prepisati u blizak deo adresu** gde će **proizvoljni podaci od korisnika** biti upisani.
U [**protostar hip 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) primeru moguće je videti kako zloupotrebom prekoračenja bafera moguće je **prepisati u blizak blok adresu** gde će **proizvoljni podaci od korisnika** biti upisani.
### Primer ARM64
Na stranici [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) možete pronaći primer prekoračenja hipa gde je komanda koja će biti izvršena smeštena u sledećem delu od prekoračenog dela. Dakle, moguće je izmeniti izvršenu komandu prepisivanjem je jednostavnim eksploatacijama kao što su:
Na stranici [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) možete pronaći primer prekoračenja hipa gde je komanda koja će biti izvršena smeštena u sledećem bloku od prekoračenog bloka. Dakle, moguće je izmeniti izvršenu komandu prekoračenjem jednostavnim eksploatacijama kao što su:
```bash
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
```
### Ostali primeri
* [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
* Koristimo ranjivost prelivanja celobrojnog tipa da bismo dobili prelivanje hipa.
* Korumpiramo pokazivače ka funkciji unutar `struct`-a prelivenog bloka da bismo postavili funkciju poput `system` i dobili izvršenje koda.
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJE**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

32
binary-exploitation/libc-heap/house-of-einherjar.md
View file

@ -18,7 +18,7 @@ Drugi načini podrške HackTricks-u:
### Kod
* Proverite primer sa [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
* Pogledajte primer sa [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
* Ili sa [https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation) (možda će biti potrebno popuniti tcache)
### Cilj
@ -29,29 +29,31 @@ Drugi načini podrške HackTricks-u:
* Kreirati lažan blok kada želimo da alociramo blok:
* Postaviti pokazivače da pokazuju na sebe kako bi se zaobišle provere ispravnosti
* Off by one prelazak sa jednog bloka na drugi kako bi se modifikovao prethodni u upotrebi
* Ukazati u `prev_size` zloupotrebljenog bloka off-by-one razliku između njega i lažnog bloka
* Veličina lažnog bloka takođe mora biti postavljena iste veličine kako bi se zaobišle provere ispravnosti
* Prekoračenje za jedan bajt sa nulom iz jednog bloka u sledeći kako bi se izmenila oznaka `PREV_INUSE`
* Ukazati u `prev_size` zloupotrebljenog bloka off-by-null razliku između njega i lažnog bloka
* Veličina lažnog bloka takođe mora biti postavljena na istu veličinu kako bi se zaobišle provere ispravnosti
* Za konstruisanje ovih blokova, biće vam potrebno curenje hipa.
### Napad
* Kreiran je `A` lažan blok unutar bloka koji kontroliše napadač pokazujući sa `fd` i `bk` na originalni blok kako bi se zaobišle zaštite
* Alocirana su još 2 bloka (`B` i `C`)
* Zloupotrebom off by one u `B` bloku bit je očišćen i podaci `prev_size` su prebrisani razlikom između mesta gde je alociran blok `C`, do lažnog bloka `A` generisanog prethodno
* Zloupotrebom off by one u `B` bloku, bit `prev in use` se čisti i podaci `prev_size` se prepisuju sa razlikom između mesta gde je alociran blok `C`, do lažnog bloka `A` generisanog ranije
* Ovaj `prev_size` i veličina u lažnom bloku `A` moraju biti iste kako bi se zaobišle provere.
* Zatim, tcache je popunjen
* Zatim, `C` je oslobođen tako da se konsoliduje sa lažnim blokom `A`
* Zatim, kreiran je novi blok `D` koji će početi u lažnom bloku `A` i pokrivati blok `B`
* Zatim, tcache se popunjava
* Zatim, `C` se oslobađa kako bi se konsolidovao sa lažnim blokom `A`
* Zatim, kreira se novi blok `D` koji će početi u lažnom bloku `A` i pokriti blok `B`
* Kuća Einherjar se završava ovde
* Ovo se može nastaviti sa brzim bin napadom:
* Osloboditi `B` da bi se dodao u brzi bin
* `fd` od `B` je prebrisan tako da pokazuje na ciljnu adresu zloupotrebljavajući blok `D` (jer sadrži `B` unutra)&#x20;
* Zatim, izvršene su 2 alokacije i druga će **alocirati ciljnu adresu**
* Ovo se može nastaviti sa brzim bin napadom ili trovanjem Tcache-om:
* Oslobodite `B` da ga dodate u brzi bin / Tcache
* `fd` od `B` se prepisuje tako da pokazuje na ciljnu adresu zloupotrebom bloka `D` (jer sadrži `B` unutra)&#x20;
* Zatim, vrše se 2 alokacije i druga će **alocirati ciljnu adresu**
## Reference i drugi primeri
* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad)
* Nakon oslobađanja pokazivača, njihovi podaci nisu anulirani, pa je i dalje moguće pristupiti njihovim podacima. Stoga je blok smešten u nesortirani bin i procurili su pokazivači koje sadrži (curenje libc-a) a zatim je novi hip smešten u nesortirani bin i procurila je adresa hipa iz pokazivača koji dobija.
*
* **CTF** [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad)
* Nakon oslobađanja pokazivača, njihovi podaci nisu anulirani, pa je i dalje moguće pristupiti njihovim podacima. Stoga je blok smešten u nesortirani bin i procurili su pokazivači koje sadrži (libc curenje) a zatim je novi hip smešten u nesortirani bin i procurila je adresa hipa iz pokazivača koji dobija.
* [**baby-talk. DiceCTF 2024**](https://7rocky.github.io/en/ctf/other/dicectf/baby-talk/)
* Bag prekoračenja nulom u `strtok`.
* Koristite Kuću Einherjar da biste dobili situaciju preklapanja blokova i završili sa trovanjem Tcache-om kako biste dobili proizvoljno pisanje.

28
binary-exploitation/libc-heap/house-of-force.md
View file

@ -8,9 +8,9 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJEM**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodiču PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* Otkrijte [**Porodičnu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
@ -25,18 +25,18 @@ Drugi načini podrške HackTricks-u:
### Cilj
* Cilj ovog napada je da se može alocirati blok na određenoj adresi.
* Cilj ovog napada je da se može alocirati komad na određenoj adresi.
### Zahtevi
* Prekoračenje koje omogućava prepisivanje veličine zaglavlja vršnog bloka (npr. -1).
* Prekoračenje koje omogućava prepisivanje veličine zaglavlja vrha komada (npr. -1).
* Biti u mogućnosti da se kontroliše veličina alociranja hipa
### Napad
Ako napadač želi da alocira blok na adresi P da bi prepisao vrednost ovde. Počinje tako što prepisuje veličinu vršnog bloka sa `-1` (možda prekoračenjem). Ovo osigurava da malloc neće koristiti mmap za bilo koju alokaciju jer će Vršni blok uvek imati dovoljno prostora.
Ako napadač želi da alocira komad na adresi P da bi prepisao vrednost ovde. Počinje tako što prepisuje veličinu vrha komada sa `-1` (možda sa prekoračenjem). Ovo osigurava da malloc neće koristiti mmap za bilo koju alokaciju jer će Vrh komada uvek imati dovoljno prostora.
Zatim, izračunajte udaljenost između adrese vršnog bloka i ciljnog prostora za alokaciju. Ovo je zato što će se malloc sa tom veličinom izvršiti kako bi se vršni blok premestio na tu poziciju. Na ovaj način se lako može izračunati razlika/veličina:
Zatim, izračunajte udaljenost između adrese vrha komada i ciljnog prostora za alokaciju. Ovo je zato što će se malloc sa tom veličinom izvršiti kako bi se premestio vrh komada na tu poziciju. Ovo je kako se razlika/veličina može lako izračunati:
```c
// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
/*
@ -49,10 +49,10 @@ Zatim, izračunajte udaljenost između adrese vršnog bloka i ciljnog prostora z
* req = target - old_top - 4*sizeof(long)
*/
```
Dakle, alokacija veličine `target - old_top - 4*sizeof(long)` (4 longa su zbog metapodataka vrhunskog bloka i novog bloka kada se alocira) će premestiti vrhunski blok na adresu koju želimo da prepisujemo.\
Zatim, uradite još jedan malloc da biste dobili blok koji sadrži na početku podatke za pisanje ciljne adrese.
Dakle, alociranjem veličine `target - old_top - 4*sizeof(long)` (4 long-a zbog metapodataka vrhunskog bloka i novog bloka kada je alociran) premestiće vrhunski blok na adresu koju želimo da prepisujemo.\
Zatim, uradite još jedan malloc da biste dobili blok na ciljanoj adresi.
### Reference i Drugi Primeri
### Reference & Drugi Primeri
* [https://github.com/shellphish/how2heap/tree/master](https://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)
@ -61,14 +61,14 @@ Zatim, uradite još jedan malloc da biste dobili blok koji sadrži na početku p
* [https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html)
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#hitcon-training-lab-11](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#hitcon-training-lab-11)
* Cilj ovog scenarija je ret2win gde treba izmeniti adresu funkcije koja će biti pozvana adresom funkcije ret2win
* Binarni fajl ima prelivanje koje se može zloupotrebiti za izmenu veličine vrhunskog bloka, koji je izmenjen na -1 ili p64(0xffffffffffffffff)
* Zatim se izračunava adresa mesta gde postoji pokazivač za prepisivanje, i razlika od trenutne pozicije vrhunskog bloka do tamo se alocira sa `malloc`
* Binarni fajl ima prekoračenje koje se može zloupotrebiti za izmenu veličine vrhunskog bloka, koji je izmenjen na -1 ili p64(0xffffffffffffffff)
* Zatim se izračunava adresa gde postoji pokazivač koji treba prepisati, i razlika od trenutne pozicije vrhunskog bloka do tamo se alocira sa `malloc`
* Na kraju se alocira novi blok koji će sadržati ovu željenu metu unutar koje će biti prepisana funkcija ret2win
* [https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=en&\_x\_tr\_pto=wapp](https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=en&\_x\_tr\_pto=wapp)
* U `Input your name:` postoji početna ranjivost koja omogućava otkrivanje adrese sa hipa
* Zatim u funkcionalnostima `Org:` i `Host:` moguće je popuniti 64B pokazivača kada se traži **org name**, koji na steku sledi adresu v2, koja se zatim prati navedenim **host name**. Kako će strcpy kopirati sadržaj s u blok veličine 64B, moguće je **prepisati veličinu vrhunskog bloka** podacima unetim unutar **host name**.
* Zatim u funkcionalnostima `Org:` i `Host:` moguće je popuniti 64B pokazivača kada se traži **org name**, koji na steku sledi adresa v2, koja se zatim prati navedenim **host name**. Kako će strcpy kopirati sadržaj s u blok veličine 64B, moguće je **prepisti veličinu vrhunskog bloka** sa podacima unetim u **host name**.
* Sada kada je moguće proizvoljno pisanje, GOT `atoi` je prepisan adresom printf-a. tada je moguće otkriti adresu `IO_2_1_stderr` _sa_ `%24$p`. I sa ovim curenjem libc-a bilo je moguće ponovo prepisati GOT `atoi` sa adresom `system` i pozvati je prosleđujući kao parametar `/bin/sh`
* Alternativna metoda [predložena u ovom drugom writeup-u](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), je prepisati `free` sa `puts`, a zatim dodati adresu `atoi@got`, u pokazivač koji će kasnije biti oslobođen tako da se curenje i ovim curenjem ponovo prepisuje `atoi@got` sa `system` i poziva se sa `/bin/sh`.
* [https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html](https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html)
* Postoji UAF koji omogućava ponovnu upotrebu bloka koji je oslobođen bez brisanja pokazivača. Zbog nekih metoda čitanja, moguće je otkriti libc adresu upisivanjem pokazivača na funkciju free u GOT ovde, a zatim pozivanjem funkcije za čitanje.
* Zatim je korišćen House of force (zloupotreba UAF-a) da se prepisuje veličina preostalog prostora sa -1, alocira blok dovoljno velik da se dođe do free hook-a, a zatim alocira još jedan blok koji će sadržati free hook. Zatim, u hook-u upisati adresu `system`, upisati u blok `"/bin/sh"` i na kraju osloboditi blok sa tim sadržajem stringa.
* Postoji UAF koji omogućava ponovnu upotrebu bloka koji je oslobođen bez brisanja pokazivača. Zbog nekih metoda čitanja, moguće je otkriti libc adresu pisanjem pokazivača na funkciju free u GOT-u ovde, a zatim pozivanjem funkcije za čitanje.
* Zatim je korišćen House of force (zloupotreba UAF-a) da se prepise veličina preostalog prostora sa -1, alocira blok dovoljno velik da se dođe do free hook-a, a zatim alocira još jedan blok koji će sadržati free hook. Zatim, u hook se upisuje adresa `system`, u blok se upisuje `"/bin/sh"` i na kraju se oslobađa blok sa tim sadržajem stringa.

48
binary-exploitation/libc-heap/house-of-lore.md
View file

@ -6,7 +6,7 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -21,51 +21,37 @@ Drugi načini podrške HackTricks-u:
* Proverite sa [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
* Ovo ne radi
* Ili: [https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c)
* Ovo ne radi čak i ako pokušava da zaobiđe neke provere dobijajući grešku: `malloc(): unaligned tcache chunk detected`
* Ovaj primer i dalje radi**:** [**https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html**](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)&#x20;
* Ovo takođe ne radi čak i ako pokušava da zaobiđe neke provere i dobija grešku: `malloc(): unaligned tcache chunk detected`
* Ovaj primer i dalje radi: [**https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html**](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)&#x20;
### Cilj
* Ubaciti **lažan mali blok u mali bin kako bi bilo moguće alocirati ga**.\
Imajte na umu da je dodati mali blok lažan, napadač ga kreira, a ne lažan blok na proizvoljnoj poziciji.
Imajte na umu da je dodati mali blok lažan blok koji napadač kreira, a ne lažan blok na proizvoljnoj poziciji.
### Zahtevi
* Kreirajte 2 lažna bloka i povežite ih sa njima i sa legitimnim blokom u malom binu:
* `lažan0.bk` -> `lažan1`
* `lažan1.fd` -> `lažan0`
* `lažan0.fd` -> `legit` (morate da modifikujete pokazivač u oslobođenom malom bin bloku putem neke druge ranjivosti)
* `legit.bk` -> `lažan0`
* Kreirati 2 lažna bloka i povezati ih zajedno i sa legitimnim blokom u malom binu:
* `fake0.bk` -> `fake1`
* `fake1.fd` -> `fake0`
* `fake0.fd` -> `legit` (treba da modifikujete pokazivač u oslobođenom malom bin bloku putem neke druge ranjivosti)
* `legit.bk` -> `fake0`
Tada ćete moći da alocirate `lažan0`.
Tada ćete moći da alocirate `fake0`.
### Napad
* Mali blok (`legit`) je alociran, zatim je alociran još jedan da se spreči konsolidacija sa vršnim blokom. Zatim, `legit` je oslobođen (pomerajući ga na nesortiranu listu) i zatim je alociran veći blok, **pomerajući `legit` u mali bin.**
* Mali blok (`legit`) je alociran, zatim je alociran još jedan da se spreči konsolidacija sa vršnim blokom. Zatim, se `legit` oslobađa (pomerajući ga na listu nesortiranih binova) i alocira se veći blok, **pomerajući `legit` u mali bin.**
* Napadač generiše par lažnih malih blokova i vrši potrebno povezivanje da bi zaobišao provere ispravnosti:
* `lažan0.bk` -> `lažan1`
* `lažan1.fd` -> `lažan0`
* `lažan0.fd` -> `legit` (morate da modifikujete pokazivač u oslobođenom malom bin bloku putem neke druge ranjivosti)
* `legit.bk` -> `lažan0`
* Alociran je mali blok da se dobije `legit`, čineći **`lažan0`** vrhom liste malih blokova
* Alociran je još jedan mali blok, dobijajući `lažan0` kao blok, omogućavajući potencijalno čitanje/pisanje pokazivača unutar njega.
* `fake0.bk` -> `fake1`
* `fake1.fd` -> `fake0`
* `fake0.fd` -> `legit` (treba da modifikujete pokazivač u oslobođenom malom bin bloku putem neke druge ranjivosti)
* `legit.bk` -> `fake0`
* Alocira se mali blok da bi se dobio legit, čineći **`fake0`** vrhom liste malih blokova
* Alocira se još jedan mali blok, dobijajući `fake0` kao blok, omogućavajući potencijalno čitanje/pisanje pokazivača unutar njega.
## Reference
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore)
* [https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>

42
binary-exploitation/libc-heap/house-of-rabbit.md
View file

@ -1,4 +1,4 @@
# Kuća Zeca
# Kuća zečeva
<details>
@ -6,9 +6,9 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodičnu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* Otkrijte [**Porodiču PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
@ -16,21 +16,21 @@ Drugi načini podrške HackTricks-u:
### Zahtevi
1. **Sposobnost Modifikacije Fastbin fd Pokazivača ili Veličine**: To znači da možete promeniti pokazivač napred za komad u fastbin-u ili njegovu veličinu.
2. **Sposobnost Pokretanja `malloc_consolidate`**: Ovo se može postići ili alociranjem velikog komada ili spajanjem vršnog komada, što prisiljava hip da konsoliduje komade.
1. **Sposobnost modifikacije pokazivača fd ili veličine fast bin-a**: To znači da možete promeniti pokazivač napred za deo u fastbin-u ili njegovu veličinu.
2. **Sposobnost pokretanja `malloc_consolidate`**: Ovo se može postići ili alociranjem velikog dela ili spajanjem vršnog dela, što prisiljava hip da konsoliduje delove.
### Ciljevi
1. **Stvaranje Preklapajućih Komada**: Da jedan komad preklapa sa drugim, omogućavajući dalje manipulacije hipom.
2. **Forgeovanje Lažnih Komada**: Da prevari alokator da tretira lažni komad kao legitimni komad tokom operacija hipa.
1. **Stvaranje preklapajućih delova**: Da bi jedan deo prekrio drugi, omogućavajući dalje manipulacije hipom.
2. **Forgeovanje lažnih delova**: Da bi prevarili alokator da tretira lažni deo kao legitimni deo tokom operacija hipa.
## Koraci Napada
## Koraci napada
### POC 1: Modifikacija Veličine Fastbin Komada
### POC 1: Modifikacija veličine fast bin dela
**Cilj**: Stvoriti preklapajući komad manipulišući veličinom fastbin komada.
**Cilj**: Stvaranje preklapajućeg dela manipulacijom veličine fastbin dela.
* **Korak 1: Alociranje Komada**
* **Korak 1: Alokacija Delova**
```cpp
unsigned long* chunk1 = malloc(0x40); // Allocates a chunk of 0x40 bytes at 0x602000
unsigned long* chunk2 = malloc(0x40); // Allocates another chunk of 0x40 bytes at 0x602050
@ -41,7 +41,7 @@ malloc(0x10); // Allocates a small chunk to change the
free(chunk1); // Frees the chunk at 0x602000
free(chunk2); // Frees the chunk at 0x602050
```
* **Korak 3: Izmena Veličine Čunka**
* **Korak 3: Izmena Veličine Bloka**
```cpp
chunk1[-1] = 0xa1; // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])
```
@ -49,13 +49,13 @@ chunk1[-1] = 0xa1; // Modify the size of chunk1 to 0xa1 (stored just before the
```cpp
malloc(0x1000); // Allocate a large chunk to trigger heap consolidation
```
Alociranje velikog bloka pokreće funkciju `malloc_consolidate`, spajajući male blokove u fastbinu. Manipulisana veličina `chunk1` uzrokuje preklapanje sa `chunk2`.
Alociranje velikog bloka pokreće funkciju `malloc_consolidate`, spajajući male blokove u brzom binu. Manipulisana veličina `chunk1` uzrokuje preklapanje sa `chunk2`.
Nakon konsolidacije, `chunk1` se preklapa sa `chunk2`, omogućavajući dalju eksploataciju.
Nakon konsolidacije, `chunk1` se preklapa sa `chunk2`, omogućavajući daljnju eksploataciju.
### POC 2: Modifikacija FD pokazivača
### POC 2: Modifikacija `fd` pokazivača
**Cilj**: Kreiranje lažnog bloka manipulacijom fd pokazivača fastbina.
**Cilj**: Kreiranje lažnog bloka manipulacijom brzog bin `fd` pokazivača.
* **Korak 1: Alociranje Blokova**
```cpp
@ -70,17 +70,17 @@ chunk2[1] = 0x31; // Fake chunk size 0x30
chunk2[7] = 0x21; // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk
```
* **Korak 3: Oslobađanje Chunk1**
* **Korak 3: Oslobađanje `chunk1`**
```cpp
free(chunk1); // Frees the chunk at 0x602000
```
**Objašnjenje**: Oslobađamo `chunk1`, dodajući ga na listu brzih blokova.
**Objašnjenje**: Oslobađamo `chunk1`, dodajući ga u listu fastbin.
* **Korak 4: Izmena FD-a Chunk1**
* **Korak 4: Modifikujemo `fd` od `chunk1`**
```cpp
chunk1[0] = 0x602060; // Modify the fd of chunk1 to point to the fake chunk within chunk2
```
**Objašnjenje**: Menjamo pokazivač napred (fd) `chunk1` da pokazuje na naš lažni blok unutar `chunk2`.
**Objašnjenje**: Menjamo pokazivač unapred (`fd`) `chunk1` da pokazuje na naš lažni blok unutar `chunk2`.
* **Korak 5: Pokretanje `malloc_consolidate`**
```cpp
@ -92,4 +92,4 @@ Lažni blok postaje deo liste brzih blokova, čineći ga legitimnim blokom za da
### Rezime
Tehnika **House of Rabbit** uključuje ili modifikovanje veličine brzog bloka kako bi se stvorili preklapajući blokovi ili manipulisanje fd pokazivačem kako bi se stvorili lažni blokovi. Ovo omogućava napadačima da falsifikuju legitimne blokove u hipu, omogućavajući različite oblike iskorišćavanja. Razumevanje i vežbanje ovih koraka će unaprediti vaše veštine iskorišćavanja hipa.
Tehnika **House of Rabbit** uključuje ili modifikovanje veličine brzog bin bloka kako bi se stvorili preklapajući blokovi ili manipulisanje `fd` pokazivača kako bi se stvorili lažni blokovi. Ovo omogućava napadačima da falsifikuju legitimne blokove u hipu, omogućavajući različite oblike iskorišćavanja. Razumevanje i vežbanje ovih koraka će unaprediti vaše veštine iskorišćavanja hipa.

18
binary-exploitation/libc-heap/house-of-spirit.md
View file

@ -6,7 +6,7 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJSTVO**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -77,7 +77,7 @@ return 0;
### Napad
* Kreirajte lažne chunk-ove koji zaobilaze sigurnosne provere: trebaće vam 2 lažna chunk-a koji tačno pokazuju ispravne veličine
* Kreirajte lažne chunk-ove koji zaobilaze sigurnosne provere: trebaće vam 2 lažna chunk-a koji u osnovi pokazuju tačne veličine na pravim pozicijama
* Na neki način oslobodite prvi lažni chunk kako bi se našao u brzom ili tcache bin-u, a zatim ga alocirajte kako biste prepisali tu adresu
**Kod sa** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **je odličan za razumevanje napada.** Iako ovaj šema iz koda to prilično dobro sumira:
@ -105,16 +105,20 @@ the important thing is the size values of the heap headers for our fake chunks
*/
```
{% hint style="info" %}
Napomena da je potrebno kreirati drugi blok kako bi se zaobišle određene provere ispravnosti.
Napomena da je potrebno kreirati drugi blok kako bi se zaobišle neke provere ispravnosti.
{% endhint %}
## Primeri
* CTF [https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html](https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html)
* **Libc infoleak**: Putem prelivanja moguće je promeniti pokazivač da pokazuje na GOT adresu kako bi se procurila libc adresa putem akcije čitanja CTF-a
* **House of Spirit**: Zloupotrebom brojača koji broji broj "pušaka" moguće je generisati lažnu veličinu prvog lažnog bloka, zatim zloupotrebom "poruke" moguće je lažirati drugu veličinu bloka i na kraju zloupotrebom prelivanja moguće je promeniti pokazivač koji će biti oslobođen tako da se naš prvi lažni blok oslobodi. Zatim ga možemo alocirati i unutar njega će biti adresa gde je "poruka" smeštena. Zatim je moguće usmeriti ovo ka ulazu `scanf` unutar GOT tabele, tako da je možemo prepisati adresom do sistema.\
* **CTF** [**https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html**](https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html)
* **Libc infoleak**: Preko prelivanja moguće je promeniti pokazivač da pokazuje na GOT adresu kako bi se procurila libc adresa putem akcije čitanja CTF-a
* **House of Spirit**: Zloupotrebom brojača koji broji broj "pušaka" moguće je generisati lažnu veličinu prvog lažnog bloka, zatim zloupotrebom "poruke" moguće je lažirati drugu veličinu bloka i na kraju zloupotrebom prelivanja moguće je promeniti pokazivač koji će biti oslobođen tako da se naš prvi lažni blok oslobodi. Zatim ga možemo alocirati i unutar njega će biti adresa gde je "poruka" smeštena. Zatim je moguće usmeriti to ka unosu `scanf` unutar GOT tabele, tako da možemo prepisati adresu sistema.\
Sledeći put kada se pozove `scanf`, možemo poslati unos `"/bin/sh"` i dobiti shell.
* [**Gloater. HTB Cyber Apocalypse CTF 2024**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/gloater/)
* **Glibc leak**: Neinicijalizovan bafer steka.
* **House of Spirit**: Možemo izmeniti prvi indeks globalnog niza pokazivača na hip. Sa jednim bajtom izmene, koristimo `free` na lažnom bloku unutar validnog bloka, tako da dobijemo situaciju preklapajućih blokova nakon ponovne alokacije. Sa tim, jednostavan napad trovanjem Tcache-a radi kako bi se dobio proizvoljni pisani primitiv.
## Reference
* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit)
@ -128,7 +132,7 @@ Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili **telegram grupi** ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Pridružite se** 💬 **Discord grupi** ili **telegram grupi** ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>

23
binary-exploitation/libc-heap/large-bin-attack.md
View file

@ -28,17 +28,17 @@ U osnovi, ovde možete videti kako, u najnovijoj "trenutnoj" verziji glibc-a (2.
U tom primeru možete pronaći sledeće uslove:
* Dodeljen je veliki chunk
* Dodeljen je veliki chunk manji od prvog ali na istom indeksu
* Mora biti manji tako da u binu mora ići prvo
* Alokiran je veliki chunk
* Alokiran je veliki chunk manji od prvog ali na istom indeksu
* Mora biti manji tako da ide prvi u binu
* (Chunk za sprečavanje spajanja sa vršnim chunk-om je kreiran)
* Zatim, prvi veliki chunk je oslobođen i dodeljen je novi chunk veći od njega -> Chunk1 ide u veliki bin
* Zatim, prvi veliki chunk je oslobođen i alociran je novi chunk veći od njega -> Chunk1 ide u veliki bin
* Zatim, drugi veliki chunk je oslobođen
* Sada, ranjivost: Napadač može modifikovati `chunk1->bk_nextsize` u `[cilj-0x20]`
* Zatim, dodeljen je veći chunk od chunk 2, tako da chunk2 bude ubačen u veliki bin prepisivanjem adrese `chunk1->bk_nextsize->fd_nextsize` sa adresom chunk2
* Zatim, alociran je veći chunk od chunk 2, tako da chunk2 bude ubačen u veliki bin i prepisuje adresu `chunk1->bk_nextsize->fd_nextsize` sa adresom chunk2
{% hint style="success" %}
Postoje i druge potencijalne scenarije, bitno je dodati u veliki bin chunk koji je **manji** od trenutnog X chunk-a u binu, tako da mora biti ubačen odmah pre njega u bin, i moramo biti u mogućnosti da modifikujemo X-ov **`bk_nextsize`** jer će se tu adresa manjeg chunk-a upisati.
Postoje i druge potencijalne scenarije, bitno je dodati u veliki bin chunk koji je **manji** od trenutnog X chunk-a u binu, tako da mora biti ubačen odmah pre njega u binu, i moramo biti u mogućnosti da modifikujemo X-ov **`bk_nextsize`** jer će se tu adresa manjeg chunk-a upisati.
{% endhint %}
Ovo je relevantan kod iz malloc-a. Dodati su komentari radi boljeg razumevanja kako je adresa prepisana:
@ -59,17 +59,24 @@ fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_
```
{% endcode %}
Ovo se može koristiti za **prepisivanje globalne promenljive `global_max_fast`** libc-a kako bi se zatim iskoristio napad brzim binom sa većim blokovima.
Ovo se može koristiti za **prepisivanje globalne promenljive `global_max_fast`** libc-a kako bi se zatim iskoristio napad brzim binovima sa većim blokovima.
Možete pronaći još jedno odlično objašnjenje ovog napada na [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin\_attack/largebin\_explanation0/index.html).
### Ostali primeri
* [**La casa de papel. HackOn CTF 2024**](https://7rocky.github.io/en/ctf/other/hackon-ctf/la-casa-de-papel/)
* Napad velikim binovima u istoj situaciji kako se pojavljuje u [**how2heap**](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/large\_bin\_attack.c).
* Pisanje primitiva je složenije, jer je `global_max_fast` beskoristan ovde.
* Potreban je FSOP da bi se završio eksploatacija.
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**

86
binary-exploitation/libc-heap/off-by-one-overflow.md
View file

@ -6,7 +6,7 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -16,18 +16,19 @@ Drugi načini podrške HackTricks-u:
## Osnovne informacije
Imajući samo pristup prekoračenju za jedan bajt, napadač može da izmeni bit `pre_in_use` sledećeg bloka, a kako trenutni blok neće biti u upotrebi, kraj bloka postaje informacija o veličini prethodnog bloka.\
Ovo omogućava manipulisanje blokovima koji su zapravo oslobođeni, potencijalno generišući blok koji sadrži drugi legitimni blok.
Imajući pristup samo prekoračenju za jedan bajt, napadaču je omogućeno da izmeni polje `size` sledećeg bloka. Ovo omogućava manipulaciju sa blokovima koji su zapravo oslobođeni, potencijalno generišući blok koji sadrži drugi legitimni blok. Eksploatacija je slična [dvostrukom oslobođavanju](double-free.md) ili preklapanju blokova.
Postoje 2 vrste ranjivosti prekoračenja za jedan bajt:
* Proizvoljan bajt: Ova vrsta omogućava prepisivanje tog bajta sa bilo kojom vrednošću
* Null prekoračenje za jedan bajt: Ova vrsta omogućava prepisivanje tog bajta samo sa 0x00
* Čest primer ove ranjivosti može se videti u sledećem kodu gde je ponašanje funkcija strlen i strcpy nekonzistentno, što omogućava postavljanje bajta 0x00 na početku sledećeg bloka.
* Nula bajt (off-by-null): Ova vrsta omogućava prepisivanje tog bajta samo sa 0x00
* Čest primer ove ranjivosti može se videti u sledećem kodu gde je ponašanje `strlen` i `strcpy` nekonzistentno, što omogućava postavljanje bajta 0x00 na početku sledećeg bloka.
* Ovo se može iskoristiti sa [House of Einherjar](house-of-einherjar.md).
* Ako se koristi Tcache, ovo se može iskoristiti u situaciju [dvostrukog oslobođavanja](double-free.md).
<details>
<summary>Null prekoračenje za jedan bajt</summary>
<summary>Off-by-null</summary>
```c
// From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/
int main(void)
@ -51,23 +52,32 @@ Među ostalim proverama, sada kada je komad slobodan, prethodna veličina se upo
### Primer koda:
* [https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c](https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c)
* Ovaj napad više ne funkcioniše zbog korišćenja Tcaches.
* Štaviše, ako pokušate da ga zloupotrebite koristeći veće komade (tako da Tcaches nisu uključene), dobićete grešku: `malloc(): invalid next size (unsorted)`
* Ovaj napad više ne funkcioniše zbog korišćenja Tcache-ova.
* Štaviše, ako pokušate da ga zloupotrebite koristeći veće komade (tako da Tcache-ovi nisu uključeni), dobićete grešku: `malloc(): invalid next size (unsorted)`
### Cilj
* Da se komad nalazi unutar drugog komada tako da pisanje pristupa nad tim drugim komadom omogućava prepisivanje sadržaja sadržanog komada
* Da se komad nalazi unutar drugog komada, tako da pisanje pristupa preko tog drugog komada omogućava prepisivanje sadržaja sadržanog komada
### Zahtevi
* Prekoračenje za jedan bajt kako bi se izmenile informacije o prethodnoj veličini metapodataka
* Prekoračenje za jedan bajt da se izmeni informacija o metapodacima veličine
### Napad
### Opšti napad off-by-one
* Rezervisana su 3 komada memorije (a, b, c) jedan za drugim. Zatim se oslobađa srednji komad. Prvi komad sadrži ranjivost prekoračenja za jedan bajt i napadač je zloupotrebljava sa 0x00 (ako je prethodni bajt bio 0x10, to bi navelo srednji komad da pokaže da je za 0x10 manji nego što zaista jeste).
* Zatim se alociraju još 2 manja komada u oslobađenom srednjem komadu (b), međutim, pošto `b + b->size` nikada ne ažurira komad c jer je pokazana adresa manja nego što bi trebalo.&#x20;
* Alocirajte tri komada `A`, `B` i `C` (recimo veličine 0x20), i još jedan da spreči konsolidaciju sa vršnim komadom.
* Oslobodite `C` (ubacen u 0x20 Tcache listu slobodnih komada).
* Koristite komad `A` da prekoračite na `B`. Zloupotrebite off-by-one da izmenite polje `size` od `B` sa 0x21 na 0x41.
* Sada imamo `B` koji sadrži slobodan komad `C`
* Oslobodite `B` i alocirajte 0x40 komad (biće ponovo postavljen ovde)
* Možemo izmeniti pokazivač `fd` od `C`, koji je i dalje slobodan (Tcache trovanje)
### Off-by-null napad
* Rezervišite 3 komada memorije (a, b, c) jedan za drugim. Zatim se oslobađa srednji komad. Prvi komad sadrži ranjivost prekoračenja za jedan bajt i napadač je zloupotrebljava sa 0x00 (ako je prethodni bajt bio 0x10, to bi navelo srednji komad da pokaže da je 0x10 manji nego što zaista jeste).
* Zatim, još 2 manja komada se alociraju u srednjem oslobođenom komadu (b), međutim, pošto `b + b->size` nikada ne ažurira c komad jer je pokazana adresa manja nego što bi trebalo.
* Zatim se b1 i c oslobađaju. Pošto `c - c->prev_size` i dalje pokazuje na b (sada b1), oba se konsoliduju u jedan komad. Međutim, b2 je i dalje unutar između b1 i c.
* Na kraju, vrši se nova alokacija memorije koja će zauzeti ovu oblast memorije koja će zapravo sadržati b2, omogućavajući vlasniku nove alokacije da kontroliše sadržaj b2.
* Na kraju, vrši se nova alokacija memorije koja će zapravo sadržati b2, omogućavajući vlasniku nove alokacije da kontroliše sadržaj b2.
Ova slika savršeno objašnjava napad:
@ -76,49 +86,39 @@ Ova slika savršeno objašnjava napad:
## Ostali primeri i reference
* [**https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks**](https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks)
* [**Bon-nie-appetit. HTB Cyber Apocalypse CTF 2022**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/bon-nie-appetit/)
* Off-by-one zbog `strlen` koji uzima u obzir polje `size` sledećeg komada.
* Tcache se koristi, pa opšti off-by-one napadi funkcionišu kako bi se dobio proizvoljni zapis sa Tcache trovanjem.
* [**Asis CTF 2016 b00ks**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#1-asis-ctf-2016-b00ks)
* Moguće je zloupotrebiti prekoračenje za jedan bajt kako bi se procurela adresa iz hipa jer bajt 0x00 na kraju stringa biva prepisan sledećim poljem.
* Proizvoljno pisanje se dobija zloupotrebom prekoračenja za jedan bajt kako bi se pokazivač usmerio na drugo mesto gde će biti izgrađena lažna struktura sa lažnim pokazivačima. Zatim je moguće pratiti pokazivač ove strukture kako bi se dobilo proizvoljno pisanje.
* Moguće je zloupotrebiti off-by-one da bi se procurela adresa iz hipa jer bajt 0x00 na kraju stringa biva prepisan sledećim poljem.
* Proizvoljni zapis se dobija zloupotrebom off-by-one zapisa da bi se pokazivač usmerio na drugo mesto gde će biti izgrađena lažna struktura sa lažnim pokazivačima. Zatim je moguće pratiti pokazivač ove strukture da bi se dobio proizvoljni zapis.
* Adresa libc-a procuri jer ako se hip proširi korišćenjem mmap, memorija alocirana pomoću mmap ima fiksni odmak od libc-a.
* Na kraju se zloupotrebljava proizvoljno pisanje kako bi se pisalo na adresu \_\_free\_hook sa jednim gedžetom.
* Na kraju se zloupotrebljava proizvoljni zapis da bi se upisalo na adresu \_\_free\_hook sa jednim gedžetom.
* [**plaidctf 2015 plaiddb**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#instance-2-plaidctf-2015-plaiddb)
* Postoji NULL ranjivost za jedan bajt u funkciji `getline` koja čita linije korisničkog unosa. Ova funkcija se koristi za čitanje "ključa" sadržaja, a ne samog sadržaja.
* U objašnjenju se stvaraju 5 početnih komada:
* Postoji NULL off-by-one ranjivost u funkciji `getline` koja čita linije korisničkog unosa. Ova funkcija se koristi za čitanje "ključa" sadržaja, a ne samog sadržaja.
* U objašnjenju se stvara 5 početnih komada:
* komad1 (0x200)
* komad2 (0x50)
* komad5 (0x68)
* komad3 (0x1f8)
* komad4 (0xf0)
* odbrambeni komad (0x400) kako bi se izbeglo konsolidovanje sa vršnim komadom
* Zatim se oslobađaju komadi 1, 5 i 3, tako da:
* komad odbrane (0x400) da bi se izbegla konsolidacija sa vršnim komadom
* Zatim se oslobađuju komadi 1, 5 i 3, tako da:
* ```python
[ 0x200 Komad 1 (slobodan) ] [ 0x50 Komad 2 ] [ 0x68 Komad 5 (slobodan) ] [ 0x1f8 Komad 3 (slobodan) ] [ 0xf0 Komad 4 ] [ 0x400 Odbrambeni komad ]
[ 0x200 Komad 1 (slobodan) ] [ 0x50 Komad 2 ] [ 0x68 Komad 5 (slobodan) ] [ 0x1f8 Komad 3 (slobodan) ] [ 0xf0 Komad 4 ] [ 0x400 Komad odbrane ]
```
* Zatim se zloupotrebljava komad3 (0x1f8) zloupotrebom null prekoračenja za jedan bajt pisanjem prev\_size u `0x4e0`.
* Zatim se zloupotrebljava komad3 (0x1f8) null off-by-one zapisom prev\_size na `0x4e0`.
* Primetite kako veličine početno alociranih komada1, 2, 5 i 3 plus zaglavlja 4 tih komada iznose `0x4e0`: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
* Zatim se oslobađa komad 4, generišući komad koji troši sve komade do početka:
* Zatim se oslobađuje komad 4, generišući komad koji troši sve komade do početka:
* ```python
[ 0x4e0 Komad 1-2-5-3 (slobodan) ] [ 0xf0 Komad 4 (korumpiran) ] [ 0x400 Odbrambeni komad ]
[ 0x4e0 Komad 1-2-5-3 (slobodan) ] [ 0xf0 Komad 4 (korumpiran) ] [ 0x400 Komad odbrane ]
```
* ```python
[ 0x200 Komad 1 (slobodan) ] [ 0x50 Komad 2 ] [ 0x68 Komad 5 (slobodan) ] [ 0x1f8 Komad 3 (slobodan) ] [ 0xf0 Komad 4 ] [ 0x400 Odbrambeni komad ]
[ 0x200 Komad 1 (slobodan) ] [ 0x50 Komad 2 ] [ 0x68 Komad 5 (slobodan) ] [ 0x1f8 Komad 3 (slobodan) ] [ 0xf0 Komad 4 ] [ 0x400 Komad odbrane ]
```
* Zatim se alocira `0x200` bajtova popunjavajući originalni komad 1
* I alocira se još 0x200 bajtova i uništava se komad2 i stoga nema prokletog procurivanja i ovo ne funkcioniše? Možda ovo ne bi trebalo raditi
* Zatim se alocira još jedan komad sa 0x58 "a" (prepisanje komada2 i dostizanje komada5) i menja se `fd` brze binarne grupe komada komada5 usmeravajući ga ka `__malloc_hook`
* I alocira se još 0x200 bajtova i uništava se komad2 i stoga nema curenja i ovo ne funkcioniše? Možda ovo ne bi trebalo da se uradi
* Zatim se alocira još jedan komad sa 0x58 "a" (prepisujući komad2 i dosežući komad5) i menja se `fd` brze binarne grupe komada komada5 usmeravajući ga ka `__malloc_hook`
* Zatim se alocira komad od 0x68 tako da je lažni brzi binarni komad u `__malloc_hook` sledeći brzi binarni komad
* Na kraju se alocira novi brzi binarni komad od 0x68 i `__malloc_hook` se prepisuje adresom `one_gadget`
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>
* Na kraju, alocira se novi brzi binarni komad od 0x68 i `__malloc_hook` se prepisuje sa adresom `one_gadget`
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) **i** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **github repozitorijume.**

12
binary-exploitation/libc-heap/overwriting-a-freed-chunk.md
View file

@ -18,19 +18,19 @@ Nekoliko predloženih tehnika eksploatacije hipa zahteva mogućnost prepisivanja
### Jednostavno korišćenje nakon oslobođenja
Ako je napadaču moguće **upisati informacije u slobodan blok**, mogao bi to zloupotrebiti da prepisuje potrebne pokazivače.
Ako je napadaču moguće **upisati informacije u oslobođeni blok**, mogao bi to zloupotrebiti da prepisuje potrebne pokazivače.
### Dvostruko oslobođavanje
### Dvostruko oslobođenje
Ako napadač može **`osloboditi` dva puta isti blok** (osloboditi druge blokove između potencijalno) i učiniti da bude **2 puta u istom binu**, bilo bi moguće korisniku **dodeliti blok kasnije**, **upisati potrebne pokazivače** i zatim ga **ponovo dodeliti** pokrećući akcije dodeljivanja bloka (npr. napad na brzi bin, napad na tcache...)
Ako napadač može **`osloboditi` dva puta isti blok** (osloboditi druge blokove između potencijalno) i učiniti da bude **2 puta u istom binu**, bilo bi moguće za korisnika da **dodeli blok kasnije**, **prepise potrebne pokazivače** i zatim ga **ponovo dodeli** pokrećući akcije dodeljivanja bloka (npr. napad na brzi bin, napad na tcache...)
### Preplavljenje hipa
Moguće je **preplaviti dodeljeni blok koji ima sledeći oslobođeni blok** i izmeniti neke zaglavlja/pokazivače.
Moguće je **preplaviti dodeljeni blok koji ima oslobođeni blok pored** i izmeniti neke zaglavlja/pokazivače.
### Preplavljenje za 1
### Preplavljenje za jedan bajt
U ovom slučaju bilo bi moguće **izmeniti veličinu** sledećeg bloka u memoriji. Napadač bi mogao to zloupotrebiti da **dodeli dodeljenom bloku veću veličinu**, zatim je **`oslobodi`**, čineći da blok bude **dodat u bin drugačije** veličine (veće), zatim dodeliti **lažnu veličinu**, i napad će imati pristup **bloku sa veličinom koja je veća** nego što zaista jeste, **omogućavajući stoga preplavljenje hipa** (proverite prethodni odeljak).
U ovom slučaju bilo bi moguće **izmeniti veličinu** sledećeg bloka u memoriji. Napadač bi mogao to zloupotrebiti da **napravi dodeljeni blok veće veličine**, zatim ga **`oslobodi`**, čineći da blok bude **dodat u bin drugačije** veličine (veće), zatim dodeli **lažnu veličinu**, i napad će imati pristup **bloku sa veličinom koja je veća** nego što zaista jeste, **omogućavajući stoga situaciju preklapanja blokova**, koja se može iskoristiti na isti način kao i **preplavljenje hipa** (proverite prethodni odeljak).
<details>

47
binary-exploitation/libc-heap/tcache-bin-attack.md
View file

@ -6,7 +6,7 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJSTVO**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -16,51 +16,44 @@ Drugi načini podrške HackTricks-u:
## Osnovne informacije
Za više informacija o tome šta je tcache bin pogledajte ovu stranicu:
Za više informacija o tome šta je Tcache bin pogledajte ovu stranicu:
{% content-ref url="bins-and-memory-allocations.md" %}
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Prvo, napomenimo da je Tcache uveden u glibc verziji 2.26.
Prvo, napomenimo da je Tcache uveden u Glibc verziji 2.26.
**Tcache** napad predložen na [**guyinatuxido stranici**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) veoma je sličan napadu na fast bin gde je cilj prepisati pokazivač na sledeći blok u binu unutar oslobođenog bloka na proizvoljnu adresu kako bi kasnije bilo moguće **dodeliti tu specifičnu adresu i potencijalno prepisati pokazivače**.
**Napad na Tcache** (poznat i kao **Tcache trovanje**) predložen na [**guyinatuxido stranici**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) veoma je sličan napadu na fast bin gde je cilj prepisati pokazivač na sledeći blok u binu unutar oslobođenog bloka na proizvoljnu adresu kako bi kasnije bilo moguće **dodeliti tu specifičnu adresu i potencijalno prepisati pokazivače**.
Međutim, danas, ako pokrenete pomenuti kod dobićete grešku: **`malloc(): unaligned tcache chunk detected`**. Dakle, potrebno je napisati kao adresu u novom pokazivaču poravnanu adresu (ili dovoljno puta izvršiti binarni fajl kako bi napisana adresa zapravo bila poravnata).
Međutim, danas, ako pokrenete pomenuti kod, dobićete grešku: **`malloc(): unaligned tcache chunk detected`**. Dakle, potrebno je upisati poravnatu adresu kao adresu u novom pokazivaču (ili dovoljno puta izvršiti binarni fajl kako bi upisana adresa zapravo bila poravnata).
### Napad na tcache indekse
### Napadi na Tcache indekse
Obično je moguće naći na početku hipa blok koji sadrži **broj blokova po indeksu** unutar tcache-a i adresu **glavnog bloka svakog indeksa tcache-a**. Ako iz nekog razloga bude moguće izmeniti ove informacije, bilo bi moguće **naterati glavni blok nekog indeksa da pokazuje ka željenoj adresi** (kao što je malloc hook) kako bi se zatim dodelio blok iste veličine kao indeks i prepisali sadržaji malloc hook-a u ovom slučaju.
Obično je moguće naći na početku hipa blok koji sadrži **broj blokova po indeksu** unutar tcache-a i adresu **glavnog bloka svakog indeksa tcache-a**. Ako iz nekog razloga bude moguće izmeniti ove informacije, bilo bi moguće **naterati glavni blok nekog indeksa da pokazuje na željenu adresu** (kao što je `__malloc_hook`) kako bi se zatim dodelio blok veličine indeksa i prepisali sadržaji `__malloc_hook` u ovom slučaju.
## Primeri
* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
* **Curenje informacija iz Libc-a**: Moguće je popuniti tcache-ove, dodati blok u nesortiranu listu, isprazniti tcache i **ponovo dodeliti blok iz nesortirane liste** samo prepisujući prvih 8B, ostavljajući **drugu adresu do libc-a iz bloka netaknutom tako da je možemo pročitati**.
* **Napad na Tcache**: Binarni fajl je ranjiv na 1B prelivanje hipa. Ovo će biti iskorišćeno da se promeni **veličina zaglavlja** dodeljenog bloka čineći ga većim. Zatim, ovaj blok će biti **oslobođen**, dodajući ga u tcache blokove lažne veličine. Zatim, dodelićemo blok sa lažnom veličinom, a prethodni blok će biti **vraćen znajući da je ovaj blok zapravo bio manji** i to pruža mogućnost da se **prepise sledeći blok u memoriji**.\
Iskoristićemo ovo da **prepisemo pokazivač FD sledećeg bloka** da pokazuje na **`malloc_hook`**, tako da je moguće alocirati 2 pokazivača: prvo legitimni pokazivač koji smo upravo izmenili, a zatim će druga alokacija vratiti blok u **`malloc_hook`** koji je moguće iskoristiti za pisanje **one gadget-a**.
* **Libc informacije o curenju**: Moguće je popuniti tcache-ove, dodati blok u nesortiranu listu, isprazniti tcache i **ponovo dodeliti blok iz nesortirane liste** samo prepisujući prvih 8B, ostavljajući **drugu adresu libc-a iz bloka netaknutu tako da je možemo pročitati**.
* **Napad na Tcache**: Binarni fajl je ranjiv na 1B prelivanje hipa. Ovo će biti zloupotrebljeno da se promeni **veličina zaglavlja** dodeljenog bloka čineći ga većim. Zatim, ovaj blok će biti **oslobođen**, dodajući ga u tcache blokove lažne veličine. Zatim, dodelićemo blok sa lažiranom veličinom, a prethodni blok će biti **vraćen znajući da je ovaj blok zapravo bio manji** i to pruža mogućnost da se **prepise sledeći blok u memoriji**.\
Iskoristićemo ovo da **prepšemo pokazivač FD sledećeg bloka** da pokazuje na **`malloc_hook`**, tako da je moguće alocirati 2 pokazivača: prvo legitimni pokazivač koji smo upravo izmenili, a zatim druga alokacija će vratiti blok u **`malloc_hook`** koji je moguće zloupotrebiti da se napiše **one gadget**.
* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
* **Curenje informacija iz Libc-a**: Postoji upotreba nakon oslobođenog i dvostrukog oslobođenja. U ovom writeup-u autor je otkrio adresu libc-a čitajući adresu bloka smeštenog u malom binu (kao curenje iz nesortiranog bina ali iz malog).
* **Napad na Tcache**: Tcache je izvršen putem **dvostrukog oslobođenja**. Isti blok je oslobođen dva puta, tako da će unutar Tcache-a blok pokazivati na sebe. Zatim, on se dodeljuje, njegov FD pokazivač se menja da pokazuje na **free hook** i zatim se ponovo dodeljuje tako da će sledeći blok na listi biti u free hook-u. Zatim, i ovaj je dodeljen i moguće je napisati adresu `system` ovde tako da kada se dodeli malloc koji sadrži `"/bin/sh"` dobijemo shell.
* **Libc informacije o curenju**: Postoji upotreba nakon oslobođenja i dvostruko oslobođavanje. U ovom writeup-u autor je otkrio adresu libc-a čitajući adresu bloka smeštenog u malom binu (kao što je curenje iz nesortiranog bina ali iz malog).
* **Napad na Tcache**: Tcache je izvršen putem **dvostrukog oslobođavanja**. Isti blok je oslobođen dva puta, tako da će unutar Tcache-a blok pokazivati na sebe. Zatim, on se alocira, njegov FD pokazivač se menja da pokazuje na **free hook** i zatim se ponovo alocira tako da će sledeći blok na listi biti u free hook-u. Zatim, i ovaj je alociran i moguće je napisati adresu `system` ovde tako da kada se oslobođe malloc koji sadrži `"/bin/sh"` dobijemo shell.
* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html)
* Glavna ranjivost ovde je mogućnost `oslobađanja` bilo koje adrese u hipu navođenjem njenog ofseta
* **Napad na tcache indekse**: Moguće je alocirati i osloboditi blok određene veličine koji kada se skladišti unutar tcache bloka (blok sa informacijama o binovima tcache-a) generisaće **adresu sa vrednošću 0x100**. Ovo je zato što tcache čuva broj blokova u svakom binu u različitim bajtovima, stoga jedan blok u jednom specifičnom indeksu generiše vrednost 0x100.
* **Napad na Tcache indekse**: Moguće je alocirati i osloboditi blok određene veličine koji kada se skladišti unutar tcache bloka (blok sa informacijama o binovima tcache-a) generisaće **adresu sa vrednošću 0x100**. Ovo je zato što tcache čuva broj blokova u svakom binu u različitim bajtovima, stoga jedan blok u jednom određenom indeksu generiše vrednost 0x100.
* Zatim, ova vrednost izgleda kao da postoji blok veličine 0x100. Omogućava zloupotrebu tako što se `oslobodi` ova adresa. Ovo će **dodati tu adresu u indeks blokova veličine 0x100 u tcache-u**.
* Zatim, **alociranjem** bloka veličine **0x100**, prethodna adresa će biti vraćena kao blok, omogućavajući prepisivanje drugih tcache indeksa.\
Na primer, postavljanjem adrese malloc hook-a u jednom od njih i alokacijom bloka veličine tog indeksa omogućiće dobijanje bloka u calloc hook-u, što omogućava pisanje one gadget-a za dobijanje shell-a.
Na primer, postavljanje adrese malloc hook-a u jednom od njih i alokacija bloka veličine tog indeksa omogućiće blok u calloc hook-u, što omogućava pisanje one gadgeta za dobijanje shell-a.
* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html)
* Isti ranjivost kao i prethodno sa jednim dodatnim ograničenjem
* **Napad na tcache indekse**: Sličan napad kao prethodni ali sa manje koraka tako što se **oslobađa blok koji sadrži informacije o tcache-u** tako da se njegova adresa doda u tcache indeks njegove veličine tako da je moguće alocirati tu veličinu i dobiti informacije o tcache bloku kao blok, što omogućava dodavanje free hook-a kao adrese jednog indeksa, alokacija toga, i pisanje one gadget-a na njemu.
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJSTVO**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Napad na Tcache indekse**: Sličan napad prethodnom ali sa manje koraka tako što se **oslobađa blok koji sadrži informacije o tcache-u** tako da se njegova adresa doda u tcache indeks njegove veličine tako da je moguće alocirati tu veličinu i dobiti informacije o tcache bloku kao blok, što omogućava dodavanje free hook-a kao adrese jednog indeksa, alokacija toga, i pisanje one gadgeta na njemu.
* [**Matematička Vrata. HTB Cyber Apocalypse CTF 2023**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/math-door/)
* **Pisanje Nakon Oslobođenja** da se doda broj pokazivaču `fd`.
* Potrebno je puno **heap feng-shui**-a u ovom izazovu. Writeup pokazuje kako je **kontrolisanje glave Tcache** slobodne liste prilično korisno.
* **Glibc curenje** kroz `stdout` (FSOP).
* **Tcache trovanje** da se dobije proizvoljno pisanje primitive.
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>

36
binary-exploitation/libc-heap/unlink-attack.md
View file

@ -93,35 +93,35 @@ return 0;
### Cilj
Ovaj napad omogućava **promenu pokazivača na blok tako da pokazuje 3 adrese pre sebe**. Ako nova lokacija (okolina gde se pokazivač nalazio) sadrži zanimljive stvari, poput drugih kontrolisanih alokacija / steka..., moguće je čitati/pisati preko njih kako bi se prouzrokovala veća šteta.
Ovaj napad omogućava **promenu pokazivača na blok tako da pokazuje na 3 adrese pre sebe**. Ako nova lokacija (okolina gde je pokazivač bio smešten) sadrži zanimljive stvari, poput drugih kontrolisanih alokacija / steka..., moguće je čitati/pisati preko njih kako bi se prouzrokovala veća šteta.
* Ako se ovaj pokazivač nalazio na steku, jer sada pokazuje 3 adrese pre sebe i korisnik potencijalno može da ga čita i menja, biće moguće procuriti osetljive informacije sa steka ili čak izmeniti povratnu adresu (možda) bez dodirivanja kanara
* U CTF primerima, ovaj pokazivač se nalazi u nizu pokazivača na druge alokacije, stoga, praveći ga da pokazuje 3 adrese pre i mogući pristup čitanju i pisanju, moguće je naterati druge pokazivače da pokazuju na druge adrese.\
Pošto korisnik potencijalno može čitati/pisati i druge alokacije, može procuriti informacije ili prepisati nove adrese na proizvoljnim lokacijama (kao u GOT).
* Ako je ovaj pokazivač bio smešten u steku, jer sada pokazuje 3 adrese pre sebe i korisnik potencijalno može da ga čita i menja, biće moguće procureti osetljive informacije sa steka ili čak izmeniti povratnu adresu (možda) bez dodirivanja kanara
* U CTF primerima, ovaj pokazivač se nalazi u nizu pokazivača na druge alokacije, stoga, čineći ga da pokazuje 3 adrese pre i mogući za čitanje i pisanje, moguće je naterati druge pokazivače da pokazuju na druge adrese.\
Pošto korisnik potencijalno može čitati/pisati i druge alokacije, može procureti informacije ili prepisati nove adrese na proizvoljnim lokacijama (kao u GOT).
### Zahtevi
* Određena kontrola nad memorijom (npr. stek) kako bi se kreirali par blokova dajući vrednosti nekim od atributa.
* Određena kontrola u memoriji (npr. steku) kako bi se kreiralo nekoliko blokova dajući vrednosti nekim od atributa.
* Procurenje steka kako bi se postavili pokazivači lažnog bloka.
### Napad
* Postoje par blokova (blok1 i blok2)
* Postoje dva bloka (blok1 i blok2)
* Napadač kontroliše sadržaj bloka1 i zaglavlja bloka2.
* U bloku1 napadač kreira strukturu lažnog bloka:
* Da bi zaobišao zaštitu, osigurava da je polje `size` ispravno postavljeno kako bi izbegao grešku: `corrupted size vs. prev_size while consolidating`
* i polja `fd` i `bk` lažnog bloka pokazuju na mesto gde je pokazivač bloka1 smešten sa ofsetima -3 i -2, tako da `fake_chunk->fd->bk` i `fake_chunk->bk->fd` pokazuju na poziciju u memoriji (steku) gde se zaista nalazi adresa bloka1:
* i polja `fd` i `bk` lažnog bloka pokazuju na mesto gde je smešten pokazivač bloka1 sa ofsetima -3 i -2, tako da `fake_chunk->fd->bk` i `fake_chunk->bk->fd` pokazuju na poziciju u memoriji (steku) gde se zaista nalazi adresa bloka1:
<figure><img src="../../.gitbook/assets/image (1245).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
* Zaglavlja bloka2 su modifikovana kako bi se naznačilo da prethodni blok nije korišćen i da je veličina jednaka veličini sadržanoj u lažnom bloku.
* Zaglavlja bloka2 se menjaju kako bi se naznačilo da prethodni blok nije korišćen i da je veličina veličina lažnog bloka koji sadrži.
* Kada se drugi blok oslobodi, tada se dešava odvajanje ovog lažnog bloka:
* `fake_chunk->fd->bk` = `fake_chunk->bk`
* `fake_chunk->bk->fd` = `fake_chunk->fd`
* Prethodno je napravljeno da `fake_chunk->fd->bk` i `fake_chunk->fd->bk` pokazuju na isto mesto (lokaciju na steku gde je smešten `blok1`, tako da je to bila validna povezana lista). Pošto **oboje pokazuju na istu lokaciju**, samo poslednje (`fake_chunk->bk->fd = fake_chunk->fd`) će imati **efekat**.
* Ovo će **prepistati pokazivač na blok1 na steku na adresu (ili bajtove) smeštene 3 adrese pre na steku**.
* Dakle, ako napadač može da kontroliše sadržaj bloka1 ponovo, biće u mogućnosti da **piše unutar steka**, moguće je prepisati povratnu adresu preskačući kanaricu i modifikovati vrednosti i pokazivače lokalnih promenljivih. Čak ponovno modifikujući adresu bloka1 smeštenu na steku na drugu lokaciju gde, ako napadač ponovo može da kontroliše sadržaj bloka1, biće u mogućnosti da piše bilo gde.
* Imajte na umu da je ovo bilo moguće jer su **adrese smeštene na steku**. Rizik i eksploatacija mogu zavisiti o **gde su adrese lažnog bloka smeštene**.
* Prethodno je napravljeno da `fake_chunk->fd->bk` i `fake_chunk->bk->fd` pokazuju na isto mesto (lokacija na steku gde je smešten `blok1`, tako da je to bila validna povezana lista). Pošto **oboje pokazuju na istu lokaciju**, samo poslednje (`fake_chunk->bk->fd = fake_chunk->fd`) će imati **efekat**.
* Ovo će **prepistati pokazivač na blok1 u steku na adresu (ili bajtove) smeštene 3 adrese pre u steku**.
* Stoga, ako napadač može ponovo kontrolisati sadržaj bloka1, biće u mogućnosti da **piše unutar steka**, moguće je potencijalno prepisati povratnu adresu preskačući kanar i modifikovati vrednosti i pokazivače lokalnih promenljivih. Čak i ponovno modifikovanje adrese bloka1 smeštene u steku na drugu lokaciju gde ako napadač ponovo može kontrolisati sadržaj bloka1, biće u mogućnosti da piše bilo gde.
* Imajte na umu da je ovo bilo moguće jer su **adrese smeštene u steku**. Rizik i eksploatacija mogu zavisiti o **gde su adrese lažnog bloka smeštene**.
<figure><img src="../../.gitbook/assets/image (1246).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
@ -130,11 +130,11 @@ Pošto korisnik potencijalno može čitati/pisati i druge alokacije, može procu
* [https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit)
* Iako bi bilo čudno pronaći unlink napad čak i u CTF-u, ovde imate neke writeup-ove gde je ovaj napad korišćen:
* Primer CTF-a: [https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html)
* U ovom primeru, umesto steka postoji niz malloc adresa. Unlink napad se izvodi kako bi se mogao alocirati blok ovde, stoga je moguće kontrolisati pokazivače niza malloc adresa. Zatim, postoji još jedna funkcionalnost koja omogućava modifikaciju sadržaja blokova na ovim adresama, što omogućava usmeravanje adresa ka GOT-u, modifikaciju adresa funkcija za dobijanje procurivanja libc-a i RCE.
* U ovom primeru, umesto steka postoji niz malloc adresa. Unlink napad se izvodi kako bi se mogao alocirati blok ovde, stoga je moguće kontrolisati pokazivače niza malloc adresa. Zatim, postoji još jedna funkcionalnost koja omogućava modifikaciju sadržaja blokova na ovim adresama, što omogućava usmeravanje adresa ka GOT-u, modifikaciju adresa funkcija za dobijanje procuretaka i RCE.
* Još jedan primer CTF-a: [https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html)
* Baš kao i u prethodnom primeru, postoji niz adresa alokacija. Moguće je izvesti unlink napad kako bi se adresa prve alokacije usmerila na nekoliko pozicija pre početka niza i zatim prepisati ovu alokaciju na novu poziciju. Stoga je moguće prepisati pokazivače drugih alokacija da pokazuju na GOT atoi, ispisati ga da se dobije procurivanje libc-a, a zatim prepisati atoi GOT sa adresom do jednog alata.
* CTF primer sa prilagođenim malloc i free funkcijama koje zloupotrebljavaju ranjivost veoma sličnu unlink napadu: [https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html)
* Postoji prekoračenje koje omogućava kontrolu FD i BK pokazivača prilagođenog malloc-a koji će biti (prilagođeno) oslobođen. Osim toga, heap ima exec bit, tako da je moguće procuriti adresu heap-a i usmeriti funkciju iz GOT-a ka heap bloku sa shellkodom za izvršavanje.
* Kao i u prethodnom primeru, postoji niz adresa alokacija. Moguće je izvesti unlink napad kako bi se adresa prve alokacije usmerila na nekoliko pozicija pre početka niza i zatim prepisati ovu alokaciju na novu poziciju. Stoga je moguće prepisati pokazivače drugih alokacija da pokazuju na GOT atoi, ispisati ga da se dobije procuretak libc-a, a zatim prepisati atoi GOT sa adresom do jednog gedžeta.
* Primer CTF-a sa prilagođenim malloc i free funkcijama koje zloupotrebljavaju ranjivost veoma sličnu unlink napadu: [https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html)
* Postoji prekoračenje koje omogućava kontrolu FD i BK pokazivača prilagođenog malloc-a koji će biti (prilagođeno) oslobođen. Osim toga, heap ima exec bit, tako da je moguće procureti adresu heap-a i usmeriti funkciju iz GOT-a ka heap bloku sa shellkodom za izvršavanje.
<details>
@ -142,10 +142,10 @@ Pošto korisnik potencijalno može čitati/pisati i druge alokacije, može procu
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRETPLATU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili **telegram grupi** ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>

68
binary-exploitation/libc-heap/unsorted-bin-attack.md
View file

@ -6,7 +6,7 @@
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -22,46 +22,46 @@ Za više informacija o tome šta je nesortirana binarna provera, pogledajte ovu
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Nesortirane liste mogu da upišu adresu u `unsorted_chunks (av)` u adresu `bk` bloka. Dakle, ako napadač može **izmeniti adresu pokazivača bk** u bloku unutar nesortirane binarne hrpe, mogao bi **upisati tu adresu na proizvoljnu adresu** što bi moglo biti korisno za otkrivanje libc adresa ili zaobići neke odbrane.
Nesortirane liste mogu da upišu adresu u `unsorted_chunks (av)` u adresu `bk` bloka. Dakle, ako napadač može **izmeniti adresu pokazivača `bk`** u bloku unutar nesortirane binarne hrpe, mogao bi **upisati tu adresu na proizvoljnu adresu** što bi moglo biti korisno za otkrivanje adresa Glibc-a ili zaobići neku odbranu.
Dakle, u osnovi, ovaj napad omogućava da se **prepiše proizvoljna adresa velikim brojem** (adresa koja bi mogla biti adresa hrpe ili libc adresa) poput neke adrese steka koja bi mogla biti otkrivena ili neko ograničenje poput globalne promenljive **`global_max_fast`** kako bi se omogućilo kreiranje brzih bin binova većih veličina (i preći sa napada na nesortiranu binarnu hrpu na napad na brzi bin).
Dakle, u osnovi, ovaj napad omogućava da se **postavi veliki broj na proizvoljnu adresu**. Taj veliki broj je adresa, koja može biti adresa hrpe ili adresa Glibc-a. Tipična meta je **`global_max_fast`** kako bi se omogućilo kreiranje brzih bin binova većih veličina (i preći sa napada na nesortiranu binarnu hrpu na napad na brzi bin).
{% hint style="success" %}
Pogledajte primer koji je dat na [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) i koristeći 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine blokova (kako bi se izbegli tcache-ovi), moguće je videti da se **danas** pokreće greška **`malloc(): unsorted double linked list corrupted`**.
Pogledajte primer koji je dat na [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) i koristeći 0x4000 i 0x5000 umesto 0x400 i 0x500 kao veličine blokova (kako bi se izbegao Tcache), moguće je videti da se **danas** aktivira greška **`malloc(): unsorted double linked list corrupted`**.
Stoga, ovaj napad na nesortiranu binarnu hrpu sada (pored ostalih provera) takođe zahteva da se može popraviti duplirana povezana lista tako da se zaobiđe `victim->bck->fd == victim` ili ne `victim->fd == av (arena)`. Što znači da adresa na koju želimo da pišemo mora imati adresu lažnog bloka na svojoj poziciji `fd` i da lažni blok `fd` pokazuje na arenu.
Stoga, ovaj napad na nesortiranu binarnu hrpu sada (pored ostalih provera) takođe zahteva da se može popraviti duplirana povezana lista tako da se zaobiđe `victim->bk->fd == victim` ili ne `victim->fd == av (arena)`, što znači da adresa na koju želimo da pišemo mora imati adresu lažnog bloka na svojoj poziciji `fd` i da lažni blok `fd` pokazuje na arenu.
{% endhint %}
{% hint style="danger" %}
Imajte na umu da ovaj napad korumpira nesortiranu binarnu hrpu (takođe i male i velike). Zato sada možemo **koristiti alokacije iz brzih binova** (kompleksniji program može vršiti druge alokacije i rušiti se), i da bismo pokrenuli ovo moramo **dodeliti istu veličinu ili će program pasti**.
Imajte na umu da ovaj napad korumpira nesortiranu binarnu hrpu (takođe i male i velike). Zato sada možemo **koristiti alokacije iz brzih binova** (neki složeniji program može vršiti druge alokacije i rušiti se), i da bismo pokrenuli ovo moramo **dodeliti istu veličinu ili će program pasti**.
Imajte na umu da bi pravljenje **`global_max_fast`** moglo pomoći u ovom slučaju verujući da će brzi bin moći da se brine o svim ostalim alokacijama dok se eksploatacija ne završi.
Imajte na umu da prebrisavanje **`global_max_fast`** može pomoći u ovom slučaju verujući da će brzi bin biti u mogućnosti da se brine o svim ostalim alokacijama dok se eksploatacija ne završi.
{% endhint %}
Kod sa [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) objašnjava to vrlo dobro, iako ako izmenite alokacije da alociraju memoriju dovoljno veliku da ne završe u tcache-u, možete videti da se pomenuta greška pojavljuje sprečavajući ovu tehniku: **`malloc(): unsorted double linked list corrupted`**
Kod sa [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) objašnjava to vrlo dobro, iako ako izmenite alokacije memorije da alocirate dovoljno veliku memoriju kako ne bi završili u Tcache, možete videti da se pomenuta greška pojavljuje sprečavajući ovu tehniku: **`malloc(): unsorted double linked list corrupted`**
## Napad na nesortiranu binarnu hrpu za curenje informacija
## Napad na nesortiranu binarnu hrpu za otkrivanje informacija
Ovo je zapravo vrlo osnovan koncept. Blokovi u nesortiranoj binarnoj hrpi će imati pokazivače dvostruke pokazivače za kreiranje binova. Prvi blok u nesortiranoj binarnoj hrpi zapravo će imati **FD** i **BK** linkove **koji pokazuju na deo glavne arene (libc)**.\
Dakle, ako možete **ubaciti blok unutar nesortirane binarne hrpe i pročitati ga** (korišćenje nakon oslobađanja) ili **ponovo ga alocirati bez prepisivanja bar 1 od pokazivača** da biste ga zatim **pročitali**, možete imati **curenje libc informacija**.
Ovo je zapravo vrlo osnovan koncept. Blokovi u nesortiranoj binarnoj hrpi će imati pokazivače. Prvi blok u nesortiranoj binarnoj hrpi će zapravo imati **`fd`** i **`bk`** veze **koje pokazuju na deo glavne arene (Glibc)**.\
Dakle, ako možete **ubaciti blok unutar nesortirane binarne hrpe i pročitati ga** (korišćenje nakon oslobađanja) ili **ponovo ga alocirati bez prepisivanja bar 1 od pokazivača** da biste ga zatim **pročitali**, možete imati **Glibc info otkrivanje**.
Sličan [**napad korišćen u ovom writeup-u**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), bio je da se zloupotrebi struktura od 4 bloka (A, B, C i D - D je samo da spreči konsolidaciju sa vršnim blokom) tako da je prelivanje nula bajta u B korišćeno da C pokaže da B nije korišćen. Takođe, u B je modifikovan podatak `prev_size` tako da veličina umesto veličine B bude A+B.\
Zatim je C oslobođen, i konsolidovan sa A+B (ali B je i dalje bio u upotrebi). Alociran je novi blok veličine A i zatim su curenje libc adresa napisane u B odakle su procurele.
Sličan [**napad korišćen u ovom objašnjenju**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), bio je da se zloupotrebi struktura od 4 bloka (A, B, C i D - D je samo da spreči konsolidaciju sa vršnim blokom) tako da je prelivanje nula bajta u B korišćeno da C pokaže da B nije korišćen. Takođe, u B je modifikovan podatak `prev_size` tako da veličina umesto veličine B bude A+B.\
Zatim je C oslobođen, i konsolidovan sa A+B (ali B je i dalje bio u upotrebi). Alociran je novi blok veličine A i zatim su adrese Glibc-a koje su procurile upisane u B odakle su procurile.
## Reference i drugi primeri
* [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap)
* Cilj je prepisati globalnu promenljivu sa vrednošću većom od 4869 kako bi se mogla dobiti zastava i PIE nije omogućen.
* Cilj je prebrisati globalnu promenljivu vrednošću većom od 4869 kako bi bilo moguće dobiti zastavicu i PIE nije omogućen.
* Moguće je generisati blokove proizvoljnih veličina i postoji prelivanje hrpe sa željenom veličinom.
* Napad počinje kreiranjem 3 bloka: blok0 za zloupotrebu preliva, blok1 za prelivanje i blok2 kako vršni blok ne bi konsolidovao prethodne.
* Zatim, blok1 je oslobođen i blok0 je preliven tako da pokazivač bk bloka1 pokazuje na: `bk = magic - 0x10`
* Zatim je alociran blok3 iste veličine kao blok1, što će pokrenuti napad na nesortiranu binarnu hrpu i izmeniti vrednost globalne promenljive, omogućavajući dobijanje zastave.
* Zatim, blok1 je oslobođen i blok0 je preliven tako da pokazivač `bk` bloka1 pokazuje na: `bk = magic - 0x10`
* Zatim je alociran blok3 iste veličine kao blok1, što će pokrenuti napad na nesortiranu binarnu hrpu i izmeniti vrednost globalne promenljive, omogućavajući dobijanje zastavice.
* [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html)
* Funkcija spajanja je ranjiva jer ako su oba prosleđena indeksa isti, ponovo će alocirati na njemu, a zatim ga osloboditi ali će vratiti pokazivač na tu oslobođenu regiju koja može biti korišćena.
* Stoga, **kreirana su 2 bloka**: **blok0** koji će biti spojen sa samim sobom i blok1 da spreči konsolidaciju sa vršnim blokom. Zatim je **pozvana funkcija spajanja sa blokom0** dva puta što će izazvati korišćenje nakon oslobađanja.
* Zatim je pozvana **`view`** funkcija sa indeksom 2 (koji je indeks bloka korišćenja nakon oslobađanja), što će **procureti libc adresu**.
* Pošto binarni fajl ima zaštitu da alocira samo veličine veće od **`global_max_fast`** tako da se ne koristi fastbin, napad na nesortiranu binarnu hrpu će biti korišćen da se prepise globalna promenljiva `global_max_fast`.
* Zatim je moguće pozvati funkciju za izmenu sa indeksom 2 (pokazivač korišćenja nakon oslobađanja) i prepisati pokazivač `bk` da pokazuje na `p64(global_max_fast-0x10)`. Zatim, kreiranjem novog bloka će se koristiti prethodno kompromitovana adresa oslobođenog mesta (0x20) će **pokrenuti napad na nesortiranu binarnu hrpu** prepisivanjem `global_max_fast` sa veoma velikom vrednošću, omogućavajući sada kreiranje blokova u brzim binovima.
* Stoga, **kreirana su 2 bloka**: **blok0** koji će biti spojen sa samim sobom i blok1 da spreči konsolidaciju sa vršnim blokom. Zatim je **pozvana funkcija spajanja sa blokom0** dva puta što će izazvati upotrebu nakon oslobađanja.
* Zatim je pozvana **`view`** funkcija sa indeksom 2 (koji je indeks bloka nakon oslobađenja), što će **procureti adresu Glibc-a**.
* Kako binarni fajl ima zaštitu da samo alocira veličine veće od **`global_max_fast`** tako da nema korišćenja brzih binova, biće korišćen napad na nesortiranu binarnu hrpu da se prepiše globalna promenljiva `global_max_fast`.
* Zatim je moguće pozvati funkciju edit sa indeksom 2 (pokazivač nakon oslobađenja) i prepisati pokazivač `bk` da pokazuje na `p64(global_max_fast-0x10)`. Zatim, kreiranjem novog bloka će se koristiti prethodno kompromitovana adresa oslobođenog mesta (0x20) će **pokrenuti napad na nesortiranu binarnu hrpu** prebrisavajući `global_max_fast` sa veoma velikom vrednošću, omogućavajući sada kreiranje blokova u brzim binovima.
* Sada se vrši **napad na brze binove**:
* Prvo je otkriveno da je moguće raditi sa brzim **blokovima veličine 200** na lokaciji **`__free_hook`**:
* <pre class="language-c"><code class="lang-c">gef➤ p &#x26;__free_hook
@ -73,9 +73,27 @@ gef➤ x/60gx 0x7ff1e9e607a8 - 0x59
0x7ff1e9e6077f &#x3C;_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000
</code></pre>
* Ako uspemo da dobijemo brzi blok veličine 0x200 na ovoj lokaciji, biće moguće prepisati pokazivač funkcije koji će biti izvršen
* Za to, kreira se novi blok veličine `0xfc` i poziva se spojena funkcija sa tim pokazivačem dva puta, na taj način dobijamo pokazivač na oslobođeni blok veličine `0xfc*2 = 0x1f8` u brzom binu.
* Zatim se poziva funkcija za uređivanje u ovom bloku kako bi se izmenila adresa **`fd`** ovog brzog bina da pokazuje na prethodnu funkciju **`__free_hook`**.
* Zatim se kreira blok veličine `0x1f8` kako bi se iz brzog bina povukao prethodni beskorisni blok, tako da se kreira još jedan blok veličine `0x1f8` kako bi se dobio brzi bin blok u **`__free_hook`** koji je prepisan adresom funkcije **`system`**.
* Na kraju se oslobođuje blok koji sadrži string `/bin/sh\x00` pozivom funkcije za brisanje, pokrećući funkciju **`__free_hook`** koja pokazuje na sistem sa `/bin/sh\x00` kao parametrom.
* Za to, kreira se novi blok veličine `0xfc` i poziva se spojena funkcija sa tim pokazivačem dva puta, na taj način dobijamo pokazivač na oslobođeni blok veličine `0xfc*2 = 0x1f8` u brzom bloku.
* Zatim se poziva funkcija za uređivanje u ovom bloku kako bi se izmenila adresa **`fd`** ovog brzog bloka da pokazuje na prethodnu funkciju **`__free_hook`**.
* Zatim se kreira blok veličine `0x1f8` kako bi se iz brzog bloka povukao prethodni beskorisni blok, tako da se kreira još jedan blok veličine `0x1f8` kako bi se dobio brzi blok u **`__free_hook`** koji je prepisan adresom funkcije **`system`**.
* I na kraju se oslobođuje blok koji sadrži string `/bin/sh\x00` pozivom funkcije brisanja, pokrećući funkciju **`__free_hook`** koja pokazuje na sistem sa `/bin/sh\x00` kao parametrom.
* **CTF** [**https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw19\_traveller/index.html**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw19\_traveller/index.html)
* Još jedan primer zloupotrebe prelivanja od 1B kako bi se konsolidovali blokovi u nesortiranom binu i dobila informacija o libc curenju, a zatim izvršio napad na brzi bin kako bi se prepisao malloc kuka sa adresom jednog alata
* Još jedan primer zloupotrebe prelivanja od 1B kako bi se konsolidovali blokovi u nesortiranom bloku i dobio libc infoleak, a zatim izvršio brzi bin napad kako bi se prepisao malloc hook sa adresom jednog alata
* [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
* Možemo alocirati samo blokove veće od `0x100`.
* Prepisati `global_max_fast` korišćenjem napada na nesortirani blok (radi 1/16 puta zbog ASLR-a, jer moramo izmeniti 12 bitova, ali moramo izmeniti 16 bitova).
* Brzi bin napad za izmenu globalnog niza blokova. Ovo daje proizvoljni čitanje/pisanje, što omogućava izmenu GOT i postavljanje neke funkcije da pokazuje na `system`.
<details>
<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Drugi načini podrške HackTricks-u:
* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** Proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
</details>