Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-02-16 22:18:27 +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:46 +00:00
parent 13bb46fb41
commit 3a543e9e9d
15 changed files with 318 additions and 312 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -2,34 +2,34 @@
<details>
<summary><strong>Zacznij od zera i stań się ekspertem od hakowania AWS dzięki</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Podstawowe Informacje
Aby poprawić efektywność przechowywania kawałków, każdy kawałek nie jest przechowywany tylko w jednym związku, ale istnieje kilka typów. Są to tzw. bins i istnieje 5 typów bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) małych bins, 63 dużych bins, 1 bin niesortowany, 10 szybkich bins i 64 bins tcache na wątek.
Aby poprawić efektywność przechowywania kawałków, każdy kawałek nie jest przechowywany tylko w jednym związku, ale istnieje kilka typów. Są to tzw. bins i istnieje 5 typów bins: [62](https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blob;f=malloc/malloc.c;h=6e766d11bc85b6480fa5c9f2a76559f8acf9deb5;hb=HEAD#l1407) małych bins, 63 dużych bins, 1 nieuporządkowany bin, 10 szybkich bins i 64 tcache bins na wątek.
Początkowy adres do każdego bin niesortowanego, małego i dużego znajduje się w tym samym tablicy. Indeks 0 jest nieużywany, 1 to bin niesortowany, biny 2-64 to małe biny, a biny 65-127 to duże biny.
Początkowy adres do każdego nieuporządkowanego, małego i dużego binu znajduje się w tej samej tablicy. Indeks 0 jest nieużywany, 1 to nieuporządkowany bin, biny 2-64 to małe biny, a biny 65-127 to duże biny.
### Bins Tcache (Bufor na Wątek)
### Tcache (Bufor na Wątek) Bins
Mimo że wątki starają się mieć swoją własną stertę (patrz [Areny](bins-and-memory-allocations.md#arenas) i [Podsterty](bins-and-memory-allocations.md#subheaps)), istnieje możliwość, że proces z wieloma wątkami (np. serwer internetowy) **będzie dzielił stertę z innymi wątkami**. W takim przypadku głównym rozwiązaniem jest użycie **blokad**, które mogą **znacząco spowolnić wątki**.
Mimo że wątki starają się mieć własny stert (zobacz [Areny](bins-and-memory-allocations.md#arenas) i [Podsterty](bins-and-memory-allocations.md#subheaps)), istnieje możliwość, że proces z wieloma wątkami (np. serwer internetowy) **będzie dzielił stert z innymi wątkami**. W takim przypadku głównym rozwiązaniem jest użycie **blokad**, które mogą **znacząco spowolnić wątki**.
Dlatego tcache jest podobny do szybkiego bina na wątek w taki sposób, że jest to **jednokierunkowa lista** nie łącząca kawałków. Każdy wątek ma **64 jednokierunkowe biny tcache**. Każdy bin może zawierać maksymalnie [7 kawałków o tej samej wielkości](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) o rozmiarze [24 do 1032B na systemach 64-bitowych i 12 do 516B na systemach 32-bitowych](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
Dlatego tcache jest podobny do szybkiego binu na wątek w taki sposób, że jest to **jednokierunkowa lista** nie łącząca kawałków. Każdy wątek ma **64 jednokierunkowe tcache biny**. Każdy bin może zawierać maksymalnie [7 kawałków o tej samej wielkości](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l323) o rozmiarze od [24 do 1032B na systemach 64-bitowych i od 12 do 516B na systemach 32-bitowych](https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=2527e2504761744df2bdb1abdc02d936ff907ad2;hb=d5c3fafc4307c9b7a4c7d5cb381fcdbfad340bcc#l315).
Gdy wątek zwalnia kawałek, jeśli nie jest zbyt duży, aby być przydzielony do tcache, a odpowiedni bin tcache **nie jest pełny** (już 7 kawałków), **zostanie tam przydzielony**. Jeśli nie może trafić do tcache, będzie musiał poczekać na blokadę sterty, aby móc wykonać operację zwolnienia globalnie.
Gdy **kawałek jest przydzielany**, jeśli istnieje wolny kawałek wymaganego rozmiaru w **Tcache, zostanie użyty**, jeśli nie, będzie musiał poczekać na blokadę sterty, aby znaleźć go w globalnych binach lub utworzyć nowy.\
Istnieje także optymalizacja, w tym przypadku, podczas posiadania blokady sterty, wątek **wypełni swoje Tcache kawałkami sterty (7) o żądanym rozmiarze**, więc jeśli potrzebuje więcej, znajdzie je w Tcache.
Istnieje także optymalizacja, w tym przypadku, podczas posiadania blokady sterty, wątek **wypełni swoje Tcache kawałkami sterty (7) o żądanym rozmiarze**, więc w przypadku potrzeby więcej, znajdzie je w Tcache.
<details>
@ -57,6 +57,10 @@ Tcachebins[idx=0, size=0x20, count=1] ← Chunk(addr=0xaaaaaaac12a0, size=0x20,
#### Struktury i funkcje Tcache
W poniższym kodzie można zobaczyć **maksymalne pojemniki** i **kawałki na indeks**, strukturę **`tcache_entry`** stworzoną w celu uniknięcia podwójnych zwolnień oraz **`tcache_perthread_struct`**, strukturę, którą każdy wątek używa do przechowywania adresów do każdego indeksu pojemnika.
<details>
<summary><code>tcache_entry</code> i <code>tcache_perthread_struct</code></summary>
```c
// From https://github.com/bminor/glibc/blob/f942a732d37a96217ef828116ebe64a644db18d7/malloc/malloc.c
@ -159,19 +163,19 @@ Tcache ma kilka kubełków w zależności od rozmiaru, a początkowe wskaźniki
### Szybkie kubełki
Szybkie kubełki są zaprojektowane, aby **przyspieszyć alokację pamięci dla małych fragmentów**, trzymając niedawno zwolnione fragmenty w strukturze szybkiego dostępu. Te kubełki korzystają z podejścia Last-In, First-Out (LIFO), co oznacza, że **najbardziej niedawno zwolniony fragment jest pierwszy**, który zostanie ponownie użyty, gdy pojawi się nowe żądanie alokacji. To zachowanie jest korzystne dla szybkości, ponieważ szybciej jest wstawiać i usuwać z góry stosu (LIFO) w porównaniu do kolejki (FIFO).
Szybkie kubełki są zaprojektowane, aby **przyspieszyć alokację pamięci dla małych fragmentów**, trzymając niedawno zwolnione fragmenty w strukturze szybkiego dostępu. Te kubełki używają podejścia Last-In, First-Out (LIFO), co oznacza, że **najbardziej niedawno zwolniony fragment jest pierwszy**, który będzie ponownie używany, gdy pojawi się nowe żądanie alokacji. To zachowanie jest korzystne dla szybkości, ponieważ szybciej jest wstawiać i usuwać z góry stosu (LIFO) w porównaniu do kolejki (FIFO).
Dodatkowo, **szybkie kubełki używają list jednokierunkowych**, a nie dwukierunkowych, co dodatkowo poprawia szybkość. Ponieważ fragmenty w szybkich kubełkach nie są łączone z sąsiadującymi, nie ma potrzeby skomplikowanej struktury, która pozwala na usuwanie z środka. Lista jednokierunkowa jest prostsza i szybsza dla tych operacji.
Dodatkowo, **szybkie kubełki używają list jednokierunkowych**, a nie dwukierunkowych, co dodatkowo poprawia szybkość. Ponieważ fragmenty w szybkich kubełkach nie są łączone z sąsiadującymi, nie ma potrzeby skomplikowanej struktury, która pozwala na usuwanie ze środka. Lista jednokierunkowa jest prostsza i szybsza dla tych operacji.
W zasadzie, to co się tutaj dzieje, to że nagłówek (wskaźnik do pierwszego fragmentu do sprawdzenia) zawsze wskazuje na najnowszy zwolniony fragment tego rozmiaru. Więc:
* Gdy alokowany jest nowy fragment tego rozmiaru, nagłówek wskazuje na wolny fragment do użycia. Ponieważ ten wolny fragment wskazuje na następny do użycia, ten adres jest przechowywany w nagłówku, aby następna alokacja wiedziała, gdzie znaleźć dostępny fragment.
* Gdy fragment jest zwalniany, wolny fragment zapisze adres bieżącego dostępnego fragmentu, a adres tego nowo zwolnionego fragmentu zostanie umieszczony w nagłówku.
* Gdy fragment jest zwalniany, wolny fragment zapisze adres do aktualnie dostępnego fragmentu, a adres tego nowo zwolnionego fragmentu zostanie umieszczony w nagłówku.
Maksymalny rozmiar listy jednokierunkowej to `0x80`, a są one zorganizowane tak, że fragment o rozmiarze `0x20-0x2f` będzie w indeksie `0`, fragment o rozmiarze `0x30-0x3f` będzie w `idx` `1`...
Maksymalny rozmiar listy jednokierunkowej to `0x80`, są one zorganizowane tak, że fragment o rozmiarze `0x20` będzie w indeksie `0`, fragment o rozmiarze `0x30` będzie w indeksie `1`...
{% hint style="danger" %}
Fragmenty w szybkich kubełkach nie są ustawione jako dostępne, więc są trzymane jako fragmenty szybkich kubełków przez pewien czas, zamiast móc łączyć się z innymi wolnymi fragmentami otaczającymi je.
Fragmenty w szybkich kubełkach nie są ustawione jako dostępne, więc są trzymane jako fragmenty szybkich kubełków przez jakiś czas zamiast móc łączyć się z innymi wolnymi fragmentami otaczającymi je.
{% endhint %}
```c
// From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1711
@ -238,7 +242,7 @@ return 0;
```
Zauważ, jak alokujemy i zwalniamy 8 bloków tego samego rozmiaru, aby wypełnić tcache, a ósmy jest przechowywany w szybkim bloku.
Skompiluj to i debuguj z punktem przerwania w operacji powrotu z funkcji main. Następnie za pomocą gef możesz zobaczyć wypełnienie kubełka tcache i jeden blok w szybkim kubełku:
Skompiluj to i debuguj z punktem przerwania w operacji `ret` z funkcji `main`. Następnie za pomocą `gef` możesz zobaczyć, że pojemnik tcache jest pełny, a jeden blok znajduje się w szybkim bloku:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -249,13 +253,13 @@ Fastbins[idx=1, size=0x30] 0x00
```
### Nieuporządkowany blok
Nieuporządkowany blok to **pamięć podręczna** używana przez menedżera sterty do przyspieszenia alokacji pamięci. Oto jak to działa: Gdy program zwalnia kawałek pamięci, i jeśli ten kawałek nie może być przydzielony do tcache lub fast bin i nie koliduje z kawałkiem najwyższym, menedżer sterty nie umieszcza go od razu w określonym małym lub dużym pojemniku. Zamiast tego najpierw próbuje **połączyć go z sąsiednimi wolnymi kawałkami**, aby utworzyć większy blok wolnej pamięci. Następnie umieszcza ten nowy kawałek w ogólnym pojemniku o nazwie "nieuporządkowany blok".
Nieuporządkowany blok to **pamięć podręczna** używana przez menedżera sterty do przyspieszenia alokacji pamięci. Oto jak to działa: Gdy program zwalnia kawałek pamięci, i jeśli ten kawałek nie może być zaalokowany w tcache lub fast bin i nie koliduje z kawałkiem szczytowym, menedżer sterty nie umieszcza go od razu w określonym małym lub dużym pojemniku. Zamiast tego najpierw próbuje **połączyć go z sąsiednimi wolnymi kawałkami**, aby utworzyć większy blok wolnej pamięci. Następnie umieszcza ten nowy kawałek w ogólnym pojemniku o nazwie "nieuporządkowany blok".
Gdy program **prosi o pamięć**, menedżer sterty **sprawdza nieuporządkowany blok**, aby zobaczyć, czy jest tam kawałek wystarczającej wielkości. Jeśli znajdzie taki, od razu go używa. Jeśli nie znajdzie odpowiedniego kawałka w nieuporządkowanym bloku, przenosi wszystkie kawałki z tej listy do odpowiadających im pojemników, małych lub dużych, w zależności od ich wielkości.
Zauważ, że jeśli większy kawałek zostanie podzielony na 2 połowy i reszta będzie większa niż MINSIZE, zostanie on umieszczony z powrotem w nieuporządkowanym bloku.&#x20;
Należy zauważyć, że jeśli większy kawałek jest podzielony na 2 połowy i reszta jest większa niż MINSIZE, zostanie on ponownie umieszczony w nieuporządkowanym bloku.
Tak więc nieuporządkowany blok jest sposobem na przyspieszenie alokacji pamięci poprzez szybkie ponowne wykorzystanie niedawno zwolnionej pamięci i zmniejszenie potrzeby czasochłonnych wyszukiwań i łączeń.
Tak więc nieuporządkowany blok jest sposobem na przyspieszenie alokacji pamięci poprzez szybkie ponowne wykorzystanie niedawno zwolnionej pamięci i zmniejszenie potrzeby czasochłonnych wyszukiwań i łączenia.
{% hint style="danger" %}
Zauważ, że nawet jeśli kawałki należą do różnych kategorii, jeśli dostępny kawałek koliduje z innym dostępnym kawałkiem (nawet jeśli początkowo należą do różnych pojemników), zostaną one połączone.
@ -291,9 +295,9 @@ free(chunks[i]);
return 0;
}
```
Zauważ, jak alokujemy i zwalniamy 9 fragmentów tego samego rozmiaru, aby **wypełnić tcache**, a ósmy jest przechowywany w nieuporządkowanym pojemniku, ponieważ jest **zbyt duży dla fastbin**, a dziewiąty nie jest zwolniony, więc dziewiąty i ósmy **nie są scalane z głównym fragmentem**.
Zauważ, jak alokujemy i zwalniamy 9 bloków tego samego rozmiaru, aby **wypełnić tcache**, a ósmy jest przechowywany w nieuporządkowanym bloku, ponieważ jest **za duży dla fastbin**, a dziewiąty nie jest zwolniony, więc dziewiąty i ósmy **nie są scalane z głównym blokiem**.
Skompiluj to i debuguj z punktem przerwania w opcode ret z funkcji main. Następnie za pomocą gef możesz zobaczyć wypełnienie pojemnika tcache i jeden fragment w nieuporządkowanym pojemniku:
Skompiluj to i debuguj z punktem przerwania w operacji `ret` z funkcji `main`. Następnie za pomocą `gef` możesz zobaczyć, że blok tcache jest pełny, a jeden blok znajduje się w nieuporządkowanym bloku:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -317,7 +321,7 @@ Fastbins[idx=6, size=0x80] 0x00
Małe pojemniki są szybsze niż duże pojemniki, ale wolniejsze niż szybkie pojemniki.
Każdy z 62 pojemników będzie zawierał **kawałki tej samej wielkości**: 16, 24, ... (z maksymalną wielkością 504 bajtów w 32 bitach i 1024 w 64 bitach). Pomaga to w szybkości znajdowania pojemnika, w którym powinna być przydzielona przestrzeń oraz w wstawianiu i usuwaniu wpisów na tych listach.
Każdy z 62 pojemników będzie zawierał **kawałki tej samej wielkości**: 16, 24, ... (z maksymalną wielkością 504 bajtów w 32 bitach i 1024 w 64 bitach). Pomaga to w szybkości znajdowania pojemnika, w którym powinno być zaalokowane miejsce oraz w wstawianiu i usuwaniu wpisów na tych listach.
Tak jest obliczana wielkość małego pojemnika zgodnie z indeksem pojemnika:
@ -337,7 +341,7 @@ Tak jest obliczana wielkość małego pojemnika zgodnie z indeksem pojemnika:
((SMALLBIN_WIDTH == 16 ? (((unsigned) (sz)) >> 4) : (((unsigned) (sz)) >> 3))\
+ SMALLBIN_CORRECTION)
```
Funkcja do wyboru między małymi i dużymi kubełkami:
Funkcja do wyboru między małymi a dużymi kubełkami:
```c
#define bin_index(sz) \
((in_smallbin_range (sz)) ? smallbin_index (sz) : largebin_index (sz))
@ -376,7 +380,7 @@ return 0;
```
Zauważ, jak alokujemy i zwalniamy 9 bloków tego samego rozmiaru, aby **wypełnić tcache**, a ósmy jest przechowywany w nieuporządkowanym bloku, ponieważ jest **za duży dla fastbin**, a dziewiąty nie jest zwolniony, więc dziewiąty i ósmy **nie są scalane z głównym blokiem**. Następnie alokujemy większy blok o rozmiarze 0x110, co powoduje, że **blok w nieuporządkowanym bloku przechodzi do małego bloku**.
Skompiluj to i debuguj z punktem przerwania w opcode ret z funkcji main. Następnie za pomocą gef możesz zobaczyć wypełnienie tcache bin i jeden blok w małym bloku:
Skompiluj to i debuguj z punktem przerwania w operacji `ret` z funkcji `main`. Następnie za pomocą `gef` możesz zobaczyć, że blok tcache jest pełny, a jeden blok znajduje się w małym bloku:
```bash
gef➤ heap bins
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -400,11 +404,11 @@ Fastbins[idx=6, size=0x80] 0x00
### Duże pojemniki
W przeciwieństwie do małych pojemników, które zarządzają kawałkami o stałych rozmiarach, **każdy duży pojemnik obsługuje zakres rozmiarów kawałków**. Jest to bardziej elastyczne, pozwalając systemowi pomieścić **różne rozmiary** bez konieczności posiadania osobnego pojemnika dla każdego rozmiaru.
W przeciwieństwie do małych pojemników, które zarządzają kawałkami o stałych rozmiarach, **każdy duży pojemnik obsługuje zakres rozmiarów kawałków**. Jest to bardziej elastyczne, pozwalając systemowi dostosować się do **różnych rozmiarów** bez konieczności posiadania osobnego pojemnika dla każdego rozmiaru.
W alokatorze pamięci duże pojemniki zaczynają się tam, gdzie kończą się małe pojemniki. Zakresy dla dużych pojemników rosną stopniowo, co oznacza, że pierwszy pojemnik może obejmować kawałki od 512 do 576 bajtów, podczas gdy kolejny obejmuje 576 do 640 bajtów. Ten wzorzec się powtarza, a największy pojemnik zawiera wszystkie kawałki powyżej 1 MB.
W alokatorze pamięci duże pojemniki zaczynają się tam, gdzie kończą się małe pojemniki. Zakresy dla dużych pojemników rosną stopniowo, co oznacza, że pierwszy pojemnik może obejmować kawałki od 512 do 576 bajtów, podczas gdy następny obejmuje 576 do 640 bajtów. Ten wzorzec się kontynuuje, a największy pojemnik zawiera wszystkie kawałki powyżej 1 MB.
Duże pojemniki są wolniejsze w obsłudze w porównaniu z małymi pojemnikami, ponieważ muszą **sortować i przeszukiwać listę różnych rozmiarów kawałków, aby znaleźć najlepsze dopasowanie** dla alokacji. Gdy kawałek jest wstawiany do dużego pojemnika, musi być posortowany, a podczas alokacji pamięci system musi znaleźć odpowiedni kawałek. Dodatkowa praca sprawia, że są one **wolniejsze**, ale ponieważ duże alokacje są mniej powszechne niż małe, jest to akceptowalny kompromis.
Duże pojemniki są wolniejsze w obsłudze w porównaniu z małymi pojemnikami, ponieważ muszą **sortować i przeszukiwać listę różnych rozmiarów kawałków, aby znaleźć najlepsze dopasowanie** dla alokacji. Gdy kawałek jest wstawiany do dużego pojemnika, musi być posortowany, a gdy pamięć jest alokowana, system musi znaleźć odpowiedni kawałek. Dodatkowa praca sprawia, że są one **wolniejsze**, ale ponieważ duże alokacje są mniej powszechne niż małe, jest to akceptowalny kompromis.
Istnieją:
@ -413,7 +417,7 @@ Istnieją:
* 8 pojemników o zakresie 4096B (częściowo kolidują z małymi pojemnikami)
* 4 pojemniki o zakresie 32768B
* 2 pojemniki o zakresie 262144B
* 1 pojemnik na pozostałe rozmiary
* 1 pojemnik dla pozostałych rozmiarów
<details>
@ -474,9 +478,9 @@ chunks[0] = malloc(0x2000);
return 0;
}
```
2 duże alokacje są wykonywane, następnie jedna z nich jest zwalniana (umieszczając ją w nieuporządkowanym pojemniku) i dokonywana jest większa alokacja (przenosząc zwolnioną do pojemnika nieuporządkowanego do pojemnika dużego).
2 duże alokacje są wykonywane, następnie jedna z nich jest zwalniana (umieszczając ją w nieuporządkowanym pojemniku) i wykonywana jest większa alokacja (przenosząc zwolnioną do pojemnika nieuporządkowanego do pojemnika dużego).
Skompiluj to i debuguj z punktem przerwania w opcode ret z funkcji main. Następnie za pomocą gef możesz zobaczyć wypełnienie pojemnika tcache i jeden fragment w pojemniku dużym:
Skompiluj to i debuguj z punktem przerwania w operacji `ret` z funkcji `main`. Następnie za pomocą `gef` możesz zobaczyć, że pojemnik tcache jest pełny, a jeden kawałek znajduje się w dużym pojemniku:
```bash
gef➤ heap bin
──────────────────────────────────────────────────────────────────────────────── Tcachebins for thread 1 ────────────────────────────────────────────────────────────────────────────────
@ -525,14 +529,13 @@ the 2 preceding words to be zero during this interval as well.)
/* Conveniently, the unsorted bin can be used as dummy top on first call */
#define initial_top(M) (unsorted_chunks (M))
```
Podstawowo, to kawałek zawiera całą obecnie dostępną stertę. Gdy wykonywane jest malloc, jeśli nie ma dostępnego wolnego kawałka do użycia, ten kawałek wierzchołkowy będzie zmniejszał swoją wielkość, zapewniając niezbędną przestrzeń.\
Wskaźnik do kawałka wierzchołkowego jest przechowywany w strukturze `malloc_state`.
Podstawowo, to kawałek zawiera całą obecnie dostępną stertę. Gdy wykonywane jest malloc, jeśli nie ma dostępnego wolnego kawałka do użycia, ten kawałek wierzchołkowy będzie zmniejszał swoją wielkość, zapewniając niezbędną przestrzeń. Wskaźnik do kawałka wierzchołkowego jest przechowywany w strukturze `malloc_state`.
Co więcej, na początku możliwe jest użycie kawałka niesortowanego jako kawałka wierzchołkowego.
<details>
<summary>Przykład obserwacji kawałka wierzchołkowego</summary>
<summary>Zobacz przykład kawałka wierzchołkowego</summary>
```c
#include <stdlib.h>
#include <stdio.h>
@ -546,7 +549,7 @@ gets(chunk);
return 0;
}
```
Po skompilowaniu i debugowaniu z punktem przerwania w operacji powrotu (ret opcode) funkcji main zauważyłem, że malloc zwrócił adres: `0xaaaaaaac12a0`, a to są fragmenty:
Po skompilowaniu i debugowaniu z punktem przerwania w operacji `ret` w `main`, zauważyłem, że malloc zwrócił adres `0xaaaaaaac12a0`, a oto kawałki:
```bash
gef➤ heap chunks
Chunk(addr=0xaaaaaaac1010, size=0x290, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
@ -559,8 +562,8 @@ Chunk(addr=0xaaaaaaac16d0, size=0x410, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_
[0x0000aaaaaaac16d0 41 41 41 41 41 41 41 0a 00 00 00 00 00 00 00 00 AAAAAAA.........]
Chunk(addr=0xaaaaaaac1ae0, size=0x20530, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) ← top chunk
```
Gdzie można zobaczyć, że najwyższy kawałek znajduje się pod adresem `0xaaaaaaac1ae0`. To żadna niespodzianka, ponieważ ostatnio zaalokowany kawałek był pod adresem `0xaaaaaaac12a0` o wielkości `0x410`, a `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0`.\
Można również zobaczyć długość najwyższego kawałka na jego nagłówku kawałka:
Gdzie można zobaczyć, że kawałek górny znajduje się pod adresem `0xaaaaaaac1ae0`. To żadna niespodzianka, ponieważ ostatni przydzielony kawałek był pod adresem `0xaaaaaaac12a0` o rozmiarze `0x410` i `0xaaaaaaac12a0 + 0x410 = 0xaaaaaaac1ae0`.\
Można również zobaczyć długość kawałka Top na jego nagłówku kawałka:
```bash
gef➤ x/8wx 0xaaaaaaac1ae0 - 16
0xaaaaaaac1ad0: 0x00000000 0x00000000 0x00020531 0x00000000
@ -568,9 +571,9 @@ gef➤ x/8wx 0xaaaaaaac1ae0 - 16
```
</details>
### Ostatnie Przypomnienie
### Ostatni Resztek
Kiedy używane jest malloc i kawałek jest podzielony (na przykład z listy niepołączonych lub z kawałka na szczycie), kawałek stworzony z reszty podzielonego kawałka nazywany jest Ostatnim Przypomnieniem, a jego wskaźnik jest przechowywany w strukturze `malloc_state`.
Kiedy używane jest malloc i kawałek jest podzielony (na przykład z nieuporządkowanego bloku lub z głównego kawałka), kawałek stworzony z reszty podzielonego kawałka nazywany jest Ostatnim Resztkiem, a jego wskaźnik jest przechowywany w strukturze `malloc_state`.
## Przepływ Alokacji
@ -588,9 +591,9 @@ Sprawdź:
[free.md](heap-memory-functions/free.md)
{% endcontent-ref %}
## Sprawdzenia Bezpieczeństwa Funkcji Stosowanych w Stosie
## Sprawdzenia Bezpieczeństwa Funkcji Stosowanych w Działaniu Sterty
Sprawdź sprawdzenia bezpieczeństwa wykonywane przez często używane funkcje w stosie w:
Sprawdź sprawdzenia bezpieczeństwa wykonywane przez często używane funkcje w stercie w:
{% content-ref url="heap-memory-functions/heap-functions-security-checks.md" %}
[heap-functions-security-checks.md](heap-memory-functions/heap-functions-security-checks.md)
@ -609,10 +612,10 @@ Sprawdź sprawdzenia bezpieczeństwa wykonywane przez często używane funkcje w
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

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

@ -2,11 +2,11 @@
<details>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -16,9 +16,9 @@ Inne sposoby wsparcia HackTricks:
## Podstawowe Informacje
Jeśli zwolnisz blok pamięci więcej niż raz, może to zaburzyć dane alokatora i otworzyć drzwi do ataków. Oto jak to się dzieje: gdy zwalniasz blok pamięci, wraca on do listy wolnych fragmentów (np. "fastbin"). Jeśli zwolnisz ten sam blok dwa razy z rzędu, alokator wykrywa to i zgłasza błąd. Ale jeśli **zwolnisz inny fragment pomiędzy nimi, sprawdzanie podwójnego zwolnienia jest pomijane**, co powoduje uszkodzenia.
Jeśli zwolnisz blok pamięci więcej niż raz, może to zaburzyć dane alokatora i otworzyć drzwi do ataków. Oto jak to się dzieje: gdy zwalniasz blok pamięci, wraca on do listy wolnych fragmentów (np. "szybki blok"). Jeśli zwolnisz ten sam blok dwa razy z rzędu, alokator wykrywa to i zgłasza błąd. Ale jeśli **zwolnisz inny fragment pomiędzy nimi, sprawdzanie podwójnego zwolnienia jest obejścione**, co powoduje uszkodzenie.
Teraz, gdy prosisz o nową pamięć (używając `malloc`), alokator może dać ci **blok, który został zwolniony dwukrotnie**. Może to prowadzić do dwóch różnych wskaźników wskazujących na tę samą lokalizację pamięci. Jeśli atakujący kontroluje jeden z tych wskaźników, może zmienić zawartość tej pamięci, co może powodować problemy z bezpieczeństwem lub nawet umożliwić mu wykonanie kodu.
Teraz, gdy poprosisz o nową pamięć (używając `malloc`), alokator może dać ci **blok, który został zwolniony dwukrotnie**. Może to prowadzić do dwóch różnych wskaźników wskazujących na tę samą lokalizację pamięci. Jeśli atakujący kontroluje jeden z tych wskaźników, może zmienić zawartość tej pamięci, co może powodować problemy z bezpieczeństwem lub nawet umożliwić mu wykonanie kodu.
Przykład:
```c
@ -92,11 +92,11 @@ printf("i2: %p\n", (void *)i1);
return 0;
}
```
W tym przykładzie, po zapełnieniu tcache kilkoma zwolnionymi fragmentami, **kod zwalnia fragment `h`, następnie fragment `i`, a następnie ponownie `h`, powodując błąd podwójnego zwolnienia**. Otwiera to możliwość otrzymywania nakładających się adresów pamięci podczas ponownego przydziału, co oznacza, że dwa lub więcej wskaźników może wskazywać na tę samą lokalizację pamięci. Manipulowanie danymi za pomocą jednego wskaźnika może wpłynąć na drugi, tworząc poważne ryzyko bezpieczeństwa i potencjał do eksploatacji.
W tym przykładzie, po zapełnieniu tcache kilkoma zwolnionymi fragmentami (7), kod **zwalnia fragment `h`, następnie fragment `i`, a następnie ponownie `h`, powodując podwójne zwolnienie** (znane również jako duplikat Fast Bin). Otwiera to możliwość otrzymywania nakładających się adresów pamięci podczas ponownego przydzielania, co oznacza, że dwa lub więcej wskaźników mogą wskazywać na ten sam obszar pamięci. Manipulowanie danymi za pomocą jednego wskaźnika może wpłynąć na drugi, tworząc poważne ryzyko bezpieczeństwa i potencjał do eksploatacji.
Wykonując to, zauważ, jak **`i1` i `i2` otrzymały ten sam adres**:
<pre><code>Przydziały początkowe:
<pre><code>Alokacje początkowe:
a: 0xaaab0f0c22a0
b: 0xaaab0f0c22c0
c: 0xaaab0f0c22e0
@ -106,7 +106,7 @@ f: 0xaaab0f0c2340
g: 0xaaab0f0c2360
h: 0xaaab0f0c2380
i: 0xaaab0f0c23a0
Po ponownym przydziale:
Po ponownych przydziałach:
a1: 0xaaab0f0c2360
b1: 0xaaab0f0c2340
c1: 0xaaab0f0c2320
@ -119,7 +119,23 @@ h1: 0xaaab0f0c2380
</strong><strong>i2: 0xaaab0f0c23a0
</strong></code></pre>
## Referencje
## Przykłady
* [**Dragon Army. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/dragon-army/)
* Możemy przydzielać tylko fragmenty o rozmiarze Fast-Bin, z wyjątkiem rozmiaru `0x70`, co uniemożliwia standardowe nadpisanie `__malloc_hook`.
* Zamiast tego używamy adresów PIE, które zaczynają się od `0x56` jako celu dla Fast Bin dup (1/2 szansy).
* Jednym miejscem, gdzie przechowywane są adresy PIE, jest `main_arena`, która znajduje się wewnątrz Glibc i w pobliżu `__malloc_hook`.
* Celujemy w określony offset `main_arena`, aby przydzielić tam fragment, a następnie kontynuujemy przydzielanie fragmentów, aż dotrzemy do `__malloc_hook`, aby uzyskać wykonanie kodu.
* [**zero_to_hero. PicoCTF**](https://7rocky.github.io/en/ctf/picoctf/binary-exploitation/zero_to_hero/)
* Korzystając z pojemników Tcache i przepełnienia bajtu zerowego, możemy osiągnąć sytuację podwójnego zwolnienia:
* Alokujemy trzy fragmenty o rozmiarze `0x110` (`A`, `B`, `C`)
* Zwalniamy `B`
* Zwalniamy `A` i ponownie przydzielamy, aby skorzystać z przepełnienia bajtu zerowego
* Teraz pole rozmiaru `B` to `0x100`, zamiast `0x111`, więc możemy go ponownie zwolnić
* Mamy jeden pojemnik Tcache o rozmiarze `0x110` i jeden o rozmiarze `0x100`, które wskazują na ten sam adres. Mamy więc podwójne zwolnienie.
* Wykorzystujemy podwójne zwolnienie za pomocą [zatruwania Tcache](tcache-bin-attack.md)
## Odnośniki
* [https://heap-exploitation.dhavalkapil.com/attacks/double\_free](https://heap-exploitation.dhavalkapil.com/attacks/double\_free)
@ -133,6 +149,6 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

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

@ -6,7 +6,7 @@
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
@ -22,7 +22,7 @@ Aby uzyskać więcej informacji na temat tego, co to jest szybki bin, sprawdź t
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Ponieważ szybki bin jest jednokierunkowy, istnieje znacznie mniej zabezpieczeń niż w innych binach i wystarczy **zmodyfikować adres w zwolnionym fragmencie szybkiego binu**, aby móc **później przydzielić fragment w dowolnym adresie pamięci**.
Ponieważ szybki bin jest listą jednokierunkową, istnieje znacznie mniej zabezpieczeń niż w innych binach i wystarczy **zmodyfikować adres w zwolnionym fragmencie szybkiego binu**, aby móc **później przydzielić fragment w dowolnym adresie pamięci**.
Podsumowując:
@ -134,26 +134,30 @@ printf("\n\nJust like that, we executed a fastbin attack to allocate an address
}
```
{% hint style="danger" %}
Jeśli jest możliwe nadpisanie wartości zmiennej globalnej **`global_max_fast`** dużą liczbą, pozwala to generować szybkie bloki większych rozmiarów, potencjalnie umożliwiając przeprowadzenie ataków szybkich bloków w scenariuszach, w których wcześniej nie było to możliwe.
Jeśli jest możliwe nadpisanie wartości zmiennej globalnej **`global_max_fast`** dużą liczbą, pozwala to generować szybkie kawałki o większych rozmiarach, potencjalnie umożliwiając przeprowadzenie ataków na szybkie kawałki w scenariuszach, gdzie wcześniej nie było to możliwe. Ta sytuacja jest przydatna w kontekście [ataku na duży kawałek](large-bin-attack.md) i [ataku na nieuporządkowany kawałek](unsorted-bin-attack.md).
{% endhint %}
## Przykłady
* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html)**:**
* Możliwe jest alokowanie fragmentów, zwalnianie ich, odczytywanie ich zawartości i wypełnianie ich (z wykorzystaniem podatności na przepełnienie).
* **Skonsoliduj fragment w celu wycieku informacji**: Technika polega głównie na nadużywaniu przepełnienia w celu stworzenia fałszywej wartości `prev_size`, dzięki czemu jeden poprzedni fragment jest umieszczany w większym fragmencie. Dzięki temu, alokując większy fragment zawierający inny fragment, możliwe jest wydrukowanie jego danych i wyciek adresu do libc (main\_arena+88).
* **Nadpisanie hakera malloc**: Dzięki temu i nadużywaniu poprzedniej sytuacji nakładania się, było możliwe posiadanie 2 fragmentów wskazujących na tę samą pamięć. Dlatego zwalniając je oba (zwalniając inny fragment pomiędzy nimi, aby uniknąć zabezpieczeń), było możliwe posiadanie tego samego fragmentu w szybkim bloku 2 razy. Następnie było możliwe ponowne go zaalokowanie, nadpisanie adresu następnego fragmentu, aby wskazywał trochę przed hakera malloc (aby wskazywał na liczbę całkowitą, którą malloc uważa za rozmiar wolny - kolejne obejście), ponowne zaalokowanie go i następnie zaalokowanie innego fragmentu, który otrzyma adresy hakera malloc.\
Ostatecznie wstawiono tam **jeden gadżet**.
* Możliwe jest alokowanie kawałków, zwalnianie ich, odczytywanie ich zawartości i wypełnianie ich (z wykorzystaniem podatności na przepełnienie).
* **Skonsoliduj kawałek w celu wycieku informacji**: Technika polega na nadużyciu przepełnienia, aby stworzyć fałszywy `prev_size`, dzięki czemu jeden poprzedni kawałek jest umieszczany w większym, więc przy alokowaniu większego kawałka zawierającego inny kawałek, możliwe jest wydrukowanie jego danych i wyciek adresu do libc (`main_arena+88`).
* **Nadpisz hak malloc**: Dzięki temu i nadużywaniu poprzedniej sytuacji nakładania się, było możliwe posiadanie 2 kawałków wskazujących na tę samą pamięć. Dlatego zwolnienie ich obu (zwalnianie innego kawałka pomiędzy nimi, aby uniknąć zabezpieczeń) pozwoliło na posiadanie tego samego kawałka w szybkim kawałku 2 razy. Następnie było możliwe ponowne go zaalokować, nadpisać adres następnego kawałka, aby wskazywał trochę przed `__malloc_hook` (aby wskazywał na liczbę całkowitą, którą malloc uważa za rozmiar wolny - kolejne obejście), ponownie go zaalokować, a następnie zaalokować inny kawałek, który otrzyma adresy haków malloc.\
Ostatecznie wstawiono tam **jedno narzędzie**.
* **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html)**:**
* Istnieje przepełnienie sterty oraz użytkownika po zwolnieniu i podwójnym zwolnieniu, ponieważ po zwolnieniu fragmentu możliwe jest ponowne użycie i ponowne zwolnienie wskaźników.
* **Wyciek informacji z libc**: Wystarczy zwolnić kilka fragmentów, a otrzymają one wskaźnik do części lokalizacji głównej areny. Ponieważ można ponownie użyć zwolnionych wskaźników, wystarczy odczytać ten adres.
* **Atak szybkiego bloku**: Wszystkie wskaźniki do alokacji są przechowywane wewnątrz tablicy, więc możemy zwolnić kilka fragmentów szybkich bloków, a w ostatnim nadpisać adres, aby wskazywał trochę przed tę tablicę wskaźników. Następnie zaalokować kilka fragmentów o takim samym rozmiarze, najpierw otrzymamy prawdziwy, a następnie fałszywy fragment zawierający tablicę wskaźników. Teraz możemy nadpisać te wskaźniki alokacji, aby wskazywały na adres `free` w celu wskazania na system, a następnie zapisać fragment 1 `"/bin/sh"`, a następnie `free(chunk1)`, co spowoduje wykonanie `system("/bin/sh")`.
* Istnieje przepełnienie sterty i użycie po zwolnienu oraz podwójne zwolnienie, ponieważ po zwolnieniu kawałka możliwe jest ponowne użycie i ponowne zwolnienie wskaźników.
* **Wyciek informacji z libc**: Wystarczy zwolnić kilka kawałków, a otrzymamy wskaźnik do części lokalizacji głównej areny. Ponieważ można ponownie użyć zwolnionych wskaźników, wystarczy odczytać ten adres.
* **Atak na szybkie kawałki**: Wszystkie wskaźniki do alokacji są przechowywane wewnątrz tablicy, więc możemy zwolnić kilka szybkich kawałków, a w ostatnim nadpisać adres, aby wskazywał trochę przed tą tablicą wskaźników. Następnie zaalokować kilka kawałków o tym samym rozmiarze i otrzymamy najpierw prawdziwy, a następnie fałszywy kawałek zawierający tablicę wskaźników. Teraz możemy nadpisać te wskaźniki alokacji, aby adres GOT `free` wskazywał na `system`, a następnie zapisać `"/bin/sh"` w kawałku 1, a następnie wywołać `free(chunk1)`, który zamiast tego wykona `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)
* Kolejny przykład nadużywania przepełnienia o 1B w celu skonsolidowania fragmentów w nieposortowanym bloku i uzyskania wycieku informacji z libc, a następnie przeprowadzenia ataku szybkiego bloku w celu nadpisania haka malloc adresem jednego gadżetu
* Kolejny przykład nadużywania przepełnienia jednego bajtu do skonsolidowania kawałków w nieuporządkowanym kawałku, uzyskania wycieku informacji z libc, a następnie przeprowadzenia ataku na szybkie kawałki w celu nadpisania haka malloc adresem jednego narzędzia.
* **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)
* Po wycieku informacji nadużywając nieposortowanego bloku z UAF w celu wycieku adresu libc i adresu PIE, wykorzystano atak szybkiego bloku w tej CTF do zaalokowania fragmentu w miejscu, gdzie znajdowały się wskaźniki do kontrolowanych fragmentów, dzięki czemu możliwe było nadpisanie pewnych wskaźników w celu zapisania jednego gadżetu w GOT
* Możesz znaleźć atak szybkiego bloku nadużywany poprzez atak na nieposortowany blok:
* Zauważ, że zanim przeprowadzisz ataki szybkiego bloku, często nadużywa się listę niechcianych, aby wyciekać adresy libc/sterty (jeśli jest to konieczne).
* Po wycieku informacji nadużywając nieuporządkowanego kawałka z UAF do wycieku adresu libc i adresu PIE, wykorzystano atak na szybkie kawałki, aby zaalokować kawałek w miejscu, gdzie znajdowały się wskaźniki do kontrolowanych kawałków, dzięki czemu możliwe było nadpisanie pewnych wskaźników, aby zapisać jedno narzędzie w GOT
* Możesz znaleźć atak na szybkie kawałki nadużywany poprzez atak na nieuporządkowany kawałek:
* Zauważ, że przed przeprowadzeniem ataków na szybkie kawałki często nadużywa się listy wolnych kawałków do wycieku adresów libc/sterty (jeśli jest to konieczne).
* [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
* Możemy alokować tylko kawałki o rozmiarze większym niż `0x100`.
* Nadpisz `global_max_fast` za pomocą ataku na nieuporządkowany kawałek (działa 1/16 razy ze względu na ASLR, ponieważ musimy zmodyfikować 12 bitów, ale musimy zmodyfikować 16 bitów).
* Atak na szybkie kawałki w celu zmodyfikowania globalnej tablicy kawałków. To daje arbitralne prymitywy odczytu/zapisu, co pozwala na modyfikację GOT i ustawienie pewnej funkcji, aby wskazywała na `system`.
{% content-ref url="unsorted-bin-attack.md" %}
[unsorted-bin-attack.md](unsorted-bin-attack.md)
@ -168,7 +172,7 @@ Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

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

@ -10,7 +10,7 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
@ -18,7 +18,7 @@ Inne sposoby wsparcia HackTricks:
Przepełnienie sterty jest podobne do [**przepełnienia stosu**](../stack-overflow/), ale występuje w stercie. Oznacza to, że pewna przestrzeń została zarezerwowana w stercie do przechowywania danych i **przechowywane dane były większe niż zarezerwowana przestrzeń**.
W przypadku przepełnień stosu wiemy, że niektóre rejestry, takie jak wskaźnik instrukcji lub ramka stosu, zostaną przywrócone ze stosu i możliwe jest ich nadużycie. W przypadku przepełnień sterty **domyślnie nie ma przechowywanych żadnych wrażliwych informacji** w kawałku sterty, który może zostać przepełniony. Jednak mogą to być wrażliwe informacje lub wskaźniki, więc **krytyczność** tej podatności **zależy** od **tego, które dane mogą zostać nadpisane** i jak atakujący mógłby to wykorzystać.
W przypadku przepełnień stosu wiemy, że niektóre rejestry, takie jak wskaźnik instrukcji lub ramka stosu, zostaną przywrócone ze stosu i możliwe jest ich nadużycie. W przypadku przepełnień sterty **domyślnie nie przechowywane są żadne wrażliwe informacje** w kawałku sterty, który może zostać przepełniony. Jednak mogą to być wrażliwe informacje lub wskaźniki, więc **krytyczność** tej podatności **zależy** od **tego, które dane mogą zostać nadpisane** i jak atakujący mógłby to wykorzystać.
{% hint style="success" %}
Aby znaleźć przesunięcia przepełnień, można użyć tych samych wzorców co przy [**przepełnieniach stosu**](../stack-overflow/#finding-stack-overflows-offsets).
@ -26,17 +26,17 @@ Aby znaleźć przesunięcia przepełnień, można użyć tych samych wzorców co
### Przepełnienia stosu vs przepełnienia sterty
W przypadku przepełnień stosu układ i dane, które będą obecne na stosie w momencie wystąpienia podatności, są dość niezawodne. Wynika to z faktu, że stos jest liniowy, zawsze zwiększający się w kolizyjnej pamięci, w **konkretnych miejscach działania programu pamięć stosu zazwyczaj przechowuje podobny rodzaj danych** i ma określoną strukturę z pewnymi wskaźnikami na końcu części stosu używanej przez każdą funkcję.
W przypadku przepełnień stosu układ i dane, które będą obecne na stosie w momencie wywołania podatności, są dość niezawodne. Wynika to z faktu, że stos jest liniowy, zawsze zwiększający się w pamięci kolizyjnej, w **konkretnych miejscach działania programu pamięć stosu zazwyczaj przechowuje podobne rodzaje danych** i ma określoną strukturę z pewnymi wskaźnikami na końcu części stosu używanej przez każdą funkcję.
Jednak w przypadku przepełnienia sterty, ponieważ używana pamięć nie jest liniowa, ale **zarezerwowane kawałki są zazwyczaj w oddzielonych pozycjach pamięci** (nie obok siebie) z powodu **kubłów i stref**, które separują alokacje według rozmiaru i ponieważ **poprzednio zwolniona pamięć jest używana** przed alokacją nowych kawałków. Jest **trudno określić obiekt, który będzie kolidować z obiektem podatnym** na przepełnienie sterty. Dlatego, gdy znajdowane jest przepełnienie sterty, konieczne jest znalezienie **niezawodnego sposobu, aby pożądany obiekt był następny w pamięci** od tego, który może zostać przepełniony.
Jednak w przypadku przepełnień sterty używana pamięć nie jest liniowa, ale **przydzielane kawałki są zazwyczaj w oddzielnych pozycjach pamięci** (nie obok siebie) ze względu na **kosze i strefy** oddzielające alokacje według rozmiaru oraz dlatego, że **poprzednio zwolniona pamięć jest używana** przed przydzieleniem nowych kawałków. Jest **trudno określić obiekt, który będzie kolidować z obiektem podatnym** na przepełnienie sterty. Dlatego, gdy znajdowane jest przepełnienie sterty, konieczne jest znalezienie **niezawodnego sposobu, aby pożądany obiekt był następny w pamięci** po obiekcie, który może zostać przepełniony.
Jedną z technik używanych do tego jest **Grooming sterty**, która jest używana na przykład [**w tym poście**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). W poście wyjaśniono, że gdy w jądrze iOS strefa wyczerpie pamięć do przechowywania kawałków pamięci, rozszerza ją o stronę jądra, a ta strona jest dzielona na kawałki o oczekiwanych rozmiarach, które będą używane w kolejności (do wersji iOS 9.2, następnie te kawałki są używane w losowy sposób, aby utrudnić eksploatację tych ataków).
Jedną z technik używanych do tego celu jest **Grooming sterty**, która jest używana na przykład [**w tym poście**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). W poście wyjaśniono, że gdy w jądrze iOS brakuje pamięci do przechowywania kawałków pamięci, rozszerza ją o stronę jądra, a ta strona jest dzielona na kawałki o oczekiwanych rozmiarach, które będą używane w kolejności (do wersji iOS 9.2, następnie te kawałki są używane w losowy sposób, aby utrudnić eksploatację tych ataków).
Dlatego w poprzednim poście, gdzie występuje przepełnienie sterty, aby wymusić, aby obiekt podatny na przepełnienie kolidował z obiektem ofiary, kilka **`kallocs` jest wymuszanych przez kilka wątków, aby upewnić się, że wszystkie wolne kawałki są wypełnione i że zostaje utworzona nowa strona**.
Aby wymusić to wypełnienie obiektami o określonym rozmiarze, **alokacja poza linią związaną z portem mach iOS** jest idealnym kandydatem. Poprzez dostosowanie rozmiaru wiadomości możliwe jest dokładne określenie rozmiaru alokacji `kalloc`, a gdy odpowiadający port mach zostanie zniszczony, odpowiadająca alokacja zostanie natychmiast zwolniona z powrotem do `kfree`.
Aby wymusić to wypełnienie obiektami o określonym rozmiarze, **przydział poza linią związanego z portem mach iOS** jest idealnym kandydatem. Poprzez dostosowanie rozmiaru wiadomości można dokładnie określić rozmiar alokacji `kalloc`, a gdy odpowiadający port mach zostanie zniszczony, odpowiadająca alokacja zostanie natychmiast zwolniona z powrotem do `kfree`.
Następnie niektóre z tych miejsc mogą być **zwolnione**. Lista zwolnionych elementów **`kalloc.4096` zwalnia elementy w kolejności od ostatniego do pierwszego**, co oznacza, że jeśli niektóre miejsca są zwalniane i exploit próbuje alokować kilka obiektów ofiary, podczas gdy próbuje alokować obiekt podatny na przepełnienie, jest prawdopodobne, że ten obiekt będzie następowany przez obiekt ofiary.
Następnie niektóre z tych miejsc mogą być **zwolnione**. Lista zwolnionych elementów **`kalloc.4096` zwalnia elementy w kolejności ostatni wchodzi, pierwszy wychodzi**, co w zasadzie oznacza, że jeśli niektóre miejsca są zwalniane i exploit próbuje alokować kilka obiektów ofiary, próbując przydzielić obiekt podatny na przepełnienie, jest prawdopodobne, że ten obiekt będzie następowany przez obiekt ofiary.
### Przykładowa biblioteka libc
@ -44,24 +44,30 @@ Następnie niektóre z tych miejsc mogą być **zwolnione**. Lista zwolnionych e
Inny przykład z [**protostar heap 0**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap0/index.html) pokazuje bardzo podstawowy przykład CTF, w którym **przepełnienie sterty** może być wykorzystane do wywołania funkcji zwycięzcy i **uzyskania flagi**.
W przykładzie [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) można zobaczyć, jak nadużycie przepełnienia bufora umożliwia **nadpisanie w sąsiednim kawałku adresu**, gdzie **dowolne dane od użytkownika** zostaną zapisane.
W przykładzie [**protostar heap 1**](https://guyinatuxedo.github.io/24-heap\_overflow/protostar\_heap1/index.html) można zobaczyć, jak nadużywając przepełnienia bufora, można **nadpisać w sąsiednim kawałku adres**, gdzie **dowolne dane od użytkownika** zostaną zapisane.
### Przykład ARM64
Na stronie [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/) znajdziesz przykład przepełnienia sterty, gdzie polecenie, które ma zostać wykonane, jest przechowywane w następnym kawałku po przepełnionym kawałku. Dlatego możliwe jest zmodyfikowanie wykonywanego polecenia poprzez nadpisanie go prostym exploitem.
Na stronie [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/) znajdziesz przykład przepełnienia sterty, gdzie polecenie, które ma zostać wykonane, jest przechowywane w następnym kawałku po przepełnionym kawałku. Dlatego można zmodyfikować wykonane polecenie, nadpisując je prostym exploitem, takim jak:
```bash
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
```
### Inne przykłady
* [**Auth-or-out. Hack The Box**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/auth-or-out/)
* Wykorzystujemy podatność na przepełnienie liczby całkowitej, aby uzyskać przepełnienie sterty.
* Szkodzimy wskaźnikom do funkcji wewnątrz `struct` przepelnionego fragmentu, aby ustawić funkcję taką jak `system` i uzyskać wykonanie kodu.
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Zacznij od zera i zostań mistrzem hakowania AWS dzięki</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Kup [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na githubie.
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>

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

@ -2,15 +2,15 @@
<details>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCYJNY**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
</details>
@ -29,29 +29,31 @@ Inne sposoby wsparcia HackTricks:
* Utwórz fałszywy kawałek, gdy chcemy zaalokować kawałek:
* Ustaw wskaźniki tak, aby wskazywały na siebie same, aby ominąć kontrole spójności
* Przesunięcie o jeden z jednego kawałka do drugiego, aby zmodyfikować poprzedni w użyciu
* Wskaż w `prev_size` nadużywanego kawałka o jeden różnicę między nim a fałszywym kawałkiem
* Przepełnij jeden bajt z bajtem null z jednego kawałka do następnego, aby zmodyfikować flagę `PREV_INUSE`.
* Wskaż w `prev_size` nadużywanego kawałka off-by-null różnicę między nim a fałszywym kawałkiem
* Rozmiar fałszywego kawałka musi również być ustawiony na ten sam rozmiar, aby ominąć kontrole spójności
* Do skonstruowania tych kawałków będziesz potrzebować wycieku sterty.
### Atak
* `A` fałszywy kawałek jest tworzony wewnątrz kawałka kontrolowanego przez atakującego, wskazując z `fd` i `bk` na oryginalny kawałek, aby ominąć zabezpieczenia
* Alokowane są 2 inne kawałki (`B` i `C`)
* Wykorzystując przesunięcie o jeden w kawałku `B`, bit `prev in use` jest czyszczony, a dane `prev_size` są nadpisywane różnicą między miejscem, w którym jest alokowany kawałek `C`, a fałszywym kawałkiem `A` wygenerowanym wcześniej
* Utworzono `A` fałszywy kawałek wewnątrz kawałka kontrolowanego przez atakującego, wskazujący z `fd` i `bk` na oryginalny kawałek, aby ominąć zabezpieczenia
* Zaalokowano 2 inne kawałki (`B` i `C`)
* Wykorzystując off by one w kawałku `B`, wyczyść bit `prev in use` i nadpisz dane `prev_size` różnicą między miejscem, w którym zaalokowany jest kawałek `C`, a fałszywym kawałkiem `A` wygenerowanym wcześniej
* Ten `prev_size` oraz rozmiar w fałszywym kawałku `A` muszą być takie same, aby ominąć kontrole.
* Następnie wypełniana jest tcache
* Następnie `C` jest zwalniane, aby skonsolidowało się z fałszywym kawałkiem `A`
* Następnie tworzony jest nowy kawałek `D`, który będzie zaczynał się w fałszywym kawałku `A` i pokrywał kawałek `B`
* Następnie wypełnij tcache
* Następnie zwolnij `C`, aby skonsolidował się z fałszywym kawałkiem `A`
* Następnie utwórz nowy kawałek `D`, który będzie zaczynał się w fałszywym kawałku `A` i pokrywał kawałek `B`
* Dom Einherjar kończy się tutaj
* Można kontynuować to atakiem na fast bin:
* Zwolnij `B`, aby dodać go do fast bin
* `fd` `B` jest nadpisywane, aby wskazywał na docelowy adres nadużywając kawałka `D` (ponieważ zawiera w sobie `B`)&#x20;
* Następnie wykonuje się 2 alokacje i druga z nich będzie **alokować docelowy adres**
* Można kontynuować to atakiem na fast bin lub zatruciem Tcache:
* Zwolnij `B`, aby dodać go do fast bin / Tcache
* Nadpisz `fd` `B`, aby wskazywał na docelowy adres, nadużywając kawałka `D` (ponieważ zawiera w sobie `B`)&#x20;
* Następnie wykonaj 2 alokacje pamięci i druga z nich będzie **alokować adres docelowy**
## Odwołania i inne przykłady
* [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)
* Po zwolnieniu wskaźników nie są one zerowane, więc wciąż można uzyskać do nich dostęp. Dlatego kawałek jest umieszczany w nieposortowanym pojemniku i wyciekane są wskaźniki, które zawiera (wyciek libc), a następnie nowa sterta jest umieszczana w nieposortowanym pojemniku i wyciekany jest adres sterty z wskaźnika, który otrzymuje.
*
* **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)
* Po zwolnieniu wskaźników nie są one zerowane, więc wciąż można uzyskać do nich dostęp. Dlatego kawałek jest umieszczany w kubełku nieuporządkowanym i wyciekane są wskaźniki, które zawiera (wyciek libc), a następnie nowa sterta jest umieszczana w kubełku nieuporządkowanym i wyciekany jest adres sterty z wskaźnika, który otrzymuje.
* [**baby-talk. DiceCTF 2024**](https://7rocky.github.io/en/ctf/other/dicectf/baby-talk/)
* Błąd przepełnienia bajtem null w `strtok`.
* Użyj Domu Einherjar, aby uzyskać sytuację nakładających się kawałków i zakończ zatruciem Tcache, aby uzyskać arbitralne pisanie.

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

@ -9,7 +9,7 @@ Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** sprawdź [**PLAN SUBSKRYPCYJNY**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
@ -47,8 +47,7 @@ Następnie oblicz odległość między adresem top chunk a docelowym miejscem al
* req = target - old_top - 4*sizeof(long)
*/
```
Dlatego alokując rozmiar `target - old_top - 4*sizeof(long)` (4 longi, ponieważ metadane top chunka i nowego chunka po alokacji) przesuniemy top chunka pod adres, który chcemy nadpisać.\
Następnie wykonujemy kolejne malloc, aby uzyskać chunk zawierający na początku dane do zapisania docelowego adresu.
Dlatego przydzielenie rozmiaru `target - old_top - 4*sizeof(long)` (4 longi, ponieważ metadane top chunk i nowego chunka są przydzielane) spowoduje przeniesienie top chunka pod adres, który chcemy nadpisać. Następnie wykonaj kolejne malloc, aby uzyskać chunka pod docelowym adresem.
### Odnośniki i Inne Przykłady
@ -59,14 +58,14 @@ Następnie wykonujemy kolejne malloc, aby uzyskać chunk zawierający na począt
* [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)
* Celem tego scenariusza jest ret2win, gdzie musimy zmodyfikować adres funkcji, która zostanie wywołana przez funkcję ret2win.
* W binarnym pliku istnieje przepełnienie, które można wykorzystać do zmodyfikowania rozmiaru top chunka, który jest zmieniony na -1 lub p64(0xffffffffffffffff).
* Następnie obliczany jest adres miejsca, gdzie istnieje wskaźnik do nadpisania, a różnica od bieżącej pozycji top chunka do tego miejsca jest alokowana za pomocą `malloc`.
* Na koniec alokowany jest nowy chunk, który będzie zawierał ten pożądany cel, w który zostanie nadpisany funkcją ret2win.
* Binarny plik ma przepełnienie, które można wykorzystać do zmodyfikowania rozmiaru top chunka, który jest zmieniony na -1 lub p64(0xffffffffffffffff).
* Następnie obliczany jest adres miejsca, gdzie istnieje wskaźnik do nadpisania, a różnica między bieżącą pozycją top chunka a tam jest alokowana za pomocą `malloc`.
* W końcu alokowany jest nowy chunk, który będzie zawierał ten pożądany cel, wewnątrz którego zostanie nadpisany funkcją 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)
* W `Input your name:` istnieje początkowa podatność, która pozwala na wyciek adresu z heapa.
* Następnie w funkcjonalności `Org:` i `Host:` można wypełnić 64B wskaźnika `s` podczas pytania o **nazwę org**, która na stosie jest następnie śledzona przez adres v2, a następnie wskazaną **nazwę hosta**. Ponieważ strcpy będzie kopiować zawartość s do chunka o rozmiarze 64B, możliwe jest **nadpisanie rozmiaru top chunka** danymi wprowadzonymi w **nazwie hosta**.
* W `Wprowadź swoje imię:` istnieje początkowa podatność, która pozwala na wyciek adresu z heapa.
* Następnie w funkcjonalności `Org:` i `Host:` można wypełnić 64B wskaźnika `s`, gdy zostanie zapytane o **nazwę org**, która na stosie jest następnie śledzona przez adres v2, a następnie przez wskazaną **nazwę hosta**. Ponieważ strcpy będzie kopiować zawartość s do chunka o rozmiarze 64B, możliwe jest **nadpisanie rozmiaru top chunka** danymi umieszczonymi w **nazwie hosta**.
* Teraz, gdy możliwe jest dowolne zapisywanie, GOT `atoi` został nadpisany adresem printf. Następnie możliwe było wyciekanie adresu `IO_2_1_stderr` _z_ `%24$p`. Dzięki temu wyciekowi libc możliwe było ponowne nadpisanie GOT `atoi` adresem `system` i wywołanie go, przekazując jako parametr `/bin/sh`.
* Alternatywna metoda [zapropnowana w tym innym rozwiązaniu](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), polega na nadpisaniu `free` z `puts`, a następnie dodaniu adresu `atoi@got` w wskaźniku, który zostanie później zwolniony, aby został wycieknięty, a z tym wyciekiem ponowne nadpisanie `atoi@got` z `system` i wywołanie go z `/bin/sh`.
* Alternatywna metoda [zapropowana w tym innym rozwiązaniu](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), polega na nadpisaniu `free` z `puts`, a następnie dodaniu adresu `atoi@got` w wskaźniku, który zostanie później zwolniony, aby został wycieknięty, a tym wyciekiem ponowne nadpisanie `atoi@got` z `system` i wywołanie go z `/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)
* Istnieje UAF, który pozwala na ponowne użycie zwolnionego chunka bez wyczyszczenia wskaźnika. Ponieważ istnieją pewne metody odczytu, możliwe jest wyciekanie adresu libc poprzez zapisanie wskaźnika do funkcji free w GOT i następnie wywołanie funkcji odczytu.
* Następnie, użyto House of force (wykorzystując UAF) do nadpisania rozmiaru pozostałej przestrzeni na -1, alokowania wystarczająco dużego chunka, aby dotrzeć do free hook, a następnie alokowania innego chunka, który będzie zawierał free hook. Następnie, w hooku zapisano adres `system`, w chunku zapisano `"/bin/sh"` i na koniec zwolniono chunk z tym zawartością ciągu znaków.
* Istnieje UAF, który pozwala na ponowne użycie zwolnionego chunka bez wyczyszczenia wskaźnika. Ponieważ istnieją pewne metody odczytu, możliwe jest wyciekanie adresu libc, zapisując wskaźnik do funkcji free w GOT i następnie wywołując funkcję odczytu.
* Następnie, użyto House of force (wykorzystując UAF) do nadpisania rozmiaru pozostałej przestrzeni na -1, zaalokowania wystarczająco dużego chunka, aby dotrzeć do free hook, a następnie zaalokowania innego chunka, który będzie zawierał free hook. Następnie, w hooku zapisano adres `system`, w chunku `"/bin/sh"` i ostatecznie zwolniono chunk z tym zawartością ciągu znaków.

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

@ -10,7 +10,7 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
</details>
@ -22,16 +22,16 @@ Inne sposoby wsparcia HackTricks:
* To nie działa
* Lub: [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)
* To również nie działa, nawet jeśli próbuje ominąć pewne kontrole i otrzymuje błąd: `malloc(): unaligned tcache chunk detected`
* Ten przykład wciąż działa**:** [**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;
* Ten przykład wciąż działa: [**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;
### Cel
* Wstaw **fałszywy mały kawałek do małego pojemnika, aby można go było zaalokować**.\
Zauważ, że dodany mały kawałek jest fałszywy, który atakujący tworzy, a nie fałszywy w dowolnej pozycji.
Zauważ, że dodany mały kawałek to fałszywy kawałek stworzony przez atakującego, a nie fałszywy kawałek na dowolnej pozycji.
### Wymagania
* Utwórz 2 fałszywe kawałki i połącz je ze sobą oraz z prawdziwym kawałkiem w małym pojemniku:
* Stwórz 2 fałszywe kawałki i połącz je ze sobą oraz z prawdziwym kawałkiem w małym pojemniku:
* `fake0.bk` -> `fake1`
* `fake1.fd` -> `fake0`
* `fake0.fd` -> `legit` (musisz zmodyfikować wskaźnik w zwolnionym kawałku małego pojemnika za pomocą innej luki)
@ -41,31 +41,17 @@ Wtedy będziesz mógł zaalokować `fake0`.
### Atak
* Zaalokowany jest mały kawałek (`legit`), następnie zaalokowany jest kolejny, aby zapobiec konsolidacji z kawałkiem górnym. Następnie `legit` jest zwalniany (przenosząc go do listy nieuporządkowanej) i zaalokowany jest większy kawałek, **przenosząc `legit` do małego pojemnika.**
* Zaalokowany jest mały kawałek (`legit`), następnie zaalokowany jest kolejny, aby zapobiec konsolidacji z kawałkiem górnym. Następnie `legit` jest zwalniany (przenosząc go na listę nieuporządkowaną) i zaalokowany jest większy kawałek, **przenosząc `legit` do małego pojemnika.**
* Atakujący generuje kilka fałszywych małych kawałków i tworzy potrzebne połączenia, aby ominąć kontrole spójności:
* `fake0.bk` -> `fake1`
* `fake1.fd` -> `fake0`
* `fake0.fd` -> `legit` (musisz zmodyfikować wskaźnik w zwolnionym kawałku małego pojemnika za pomocą innej luki)
* `legit.bk` -> `fake0`
* Zaalokowany jest mały kawałek, aby uzyskać `legit`, przenosząc **`fake0`** na górę listy małych pojemników
* Zaalokowany jest mały kawałek, aby uzyskać `legit`, przenosząc **`fake0`** na listę górnych kawałków małych pojemników
* Następnie zaalokowany jest kolejny mały kawałek, uzyskując `fake0` jako kawałek, co potencjalnie pozwala na odczyt/zapis wskaźników wewnątrz niego.
## Odwołania
## Odnośniki
* [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>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>

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

@ -9,34 +9,34 @@ Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>
### Wymagania
1. **Zdolność do Modyfikacji Wskaźnika fd lub Rozmiaru Fastbin**: Oznacza to, że możesz zmienić wskaźnik do przodu fragmentu w fastbin lub jego rozmiar.
2. **Zdolność do Wywołania `malloc_consolidate`**: Można to zrobić poprzez przydzielenie dużego fragmentu lub scalenie fragmentu górnego, co zmusza stertę do konsolidacji fragmentów.
1. **Zdolność do modyfikacji wskaźnika fd lub rozmiaru fastbin**: Oznacza to, że możesz zmienić wskaźnik do przodu fragmentu w fastbin lub jego rozmiar.
2. **Zdolność do wywołania `malloc_consolidate`**: Można to zrobić poprzez przydzielenie dużego fragmentu lub scalenie fragmentu górnego, co zmusza stertę do konsolidacji fragmentów.
### Cele
1. **Utworzenie Nakładających się Fragmentów**: Aby jeden fragment nakładał się na drugi, umożliwiając dalsze manipulacje stertą.
2. **Podrobienie Fałszywych Fragmentów**: Aby oszukać alokator, aby traktował fałszywy fragment jako prawidłowy fragment podczas operacji na stercie.
1. **Utworzenie nakładających się fragmentów**: Aby jeden fragment nakładał się na drugi, umożliwiając dalsze manipulacje stertą.
2. **Podrobienie fałszywych fragmentów**: Aby oszukać alokator, aby traktował fałszywy fragment jako prawidłowy podczas operacji na stercie.
## Kroki Ataku
## Kroki ataku
### POC 1: Modyfikacja Rozmiaru Fragmentu Fastbin
### POC 1: Modyfikacja rozmiaru fragmentu fastbin
**Cel**: Utworzenie nakładającego się fragmentu poprzez manipulację rozmiarem fragmentu fastbin.
* **Krok 1: Alokacja Fragmentów**
* **Krok 1: Alokacja fragmentów**
```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
malloc(0x10); // Allocates a small chunk to change the fastbin state
```
* **Krok 2: Zwolnij bloki**
* **Krok 2: Zwolnij kawałki**
```cpp
free(chunk1); // Frees the chunk at 0x602000
free(chunk2); // Frees the chunk at 0x602050
@ -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
```
Przydzielanie dużej porcji wywołuje funkcję `malloc_consolidate`, łącząc małe porcje w fastbin. Zmanipulowany rozmiar `chunk1` powoduje nakładanie się na `chunk2`.
Przydzielanie dużej porcji powoduje wywołanie funkcji `malloc_consolidate`, łączącej małe porcje w szybkim pojemniku. Zmanipulowany rozmiar `chunk1` powoduje nakładanie się na `chunk2`.
Po konsolidacji, `chunk1` nakłada się na `chunk2`, umożliwiając dalsze wykorzystanie.
Po konsolidacji `chunk1` nakłada się na `chunk2`, co umożliwia dalsze wykorzystanie.
### POC 2: Zmodyfikuj wskaźnik FD
### POC 2: Zmodyfikuj wskaźnik `fd`
**Cel**: Stwórz fałszywą porcję, manipulując wskaźnikiem fd fastbin.
**Cel**: Stwórz fałszywą porcję, manipulując wskaźnikiem `fd` w szybkim pojemniku.
* **Krok 1: Przydziel porcje**
```cpp
@ -64,32 +64,28 @@ unsigned long* chunk2 = malloc(0x100); // Allocates a chunk of 0x100 bytes at 0x
```
**Wyjaśnienie**: Alokujemy dwa fragmenty, jeden mniejszy i jeden większy, aby przygotować stertę do fałszywego fragmentu.
* **Krok 2: Utwórz Fałszywy Fragment**
* **Krok 2: Utwórz fałszywy fragment**
```cpp
chunk2[1] = 0x31; // Fake chunk size 0x30
chunk2[7] = 0x21; // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk
```
* **Krok 3: Zwolnij Chunk1**
* **Krok 3: Zwolnij `chunk1`**
```cpp
free(chunk1); // Frees the chunk at 0x602000
```
**Wyjaśnienie**: Zwolniamy `chunk1`, dodając go do listy fastbin.
* **Krok 4: Zmodyfikuj FD Chunk1**
* **Krok 4: Zmodyfikuj `fd` `chunk1`**
```cpp
chunk1[0] = 0x602060; // Modify the fd of chunk1 to point to the fake chunk within chunk2
```
**Wyjaśnienie**: Zmieniamy wskaźnik w przód (fd) `chunk1`, aby wskazywał na nasz fałszywy kawałek wewnątrz `chunk2`.
**Wyjaśnienie**: Zmieniamy wskaźnik w przód (`fd`) `chunk1`, aby wskazywał na nasz fałszywy kawałek wewnątrz `chunk2`.
* **Krok 5: Wywołaj `malloc_consolidate`**
```cpp
malloc(5000); // Allocate a large chunk to trigger heap consolidation
```
Alokowanie ponownie dużej porcji powoduje wywołanie `malloc_consolidate`, które przetwarza fałszywy kawałek.
Fałszywy kawałek staje się częścią listy fastbin, co czyni go prawidłowym kawałkiem do dalszego wykorzystania.
### Podsumowanie
Technika **House of Rabbit** polega na zmodyfikowaniu rozmiaru kawałka fastbin w celu stworzenia nakładających się kawałków lub manipulacji wskaźnikiem fd w celu stworzenia fałszywych kawałków. Pozwala to atakującym na tworzenie prawidłowych kawałków na stercie, umożliwiając różne formy eksploatacji. Zrozumienie i praktykowanie tych kroków poprawi Twoje umiejętności eksploatacji sterty.
Technika **House of Rabbit** polega na zmodyfikowaniu rozmiaru fragmentu fast bin w celu stworzenia nakładających się fragmentów lub manipulacji wskaźnikiem `fd` w celu stworzenia fałszywych fragmentów. Pozwala to atakującym na tworzenie prawidłowych fragmentów na stercie, umożliwiając różne formy eksploatacji. Zrozumienie i praktykowanie tych kroków poprawi Twoje umiejętności eksploatacji sterty.

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

@ -2,15 +2,15 @@
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Kup [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>
@ -73,7 +73,7 @@ return 0;
### Wymagania
* Ten atak wymaga, aby atakujący mógł stworzyć kilka fałszywych szybkich kawałków wskazujących poprawnie wartość ich rozmiaru, a następnie zwolnić pierwszy fałszywy kawałek, aby trafił do pojemnika.
* Ten atak wymaga, aby atakujący mógł stworzyć kilka fałszywych szybkich kawałków wskazujących poprawnie wartość rozmiaru i następnie zwolnić pierwszy fałszywy kawałek, aby trafił do pojemnika.
### Atak
@ -105,23 +105,27 @@ the important thing is the size values of the heap headers for our fake chunks
*/
```
{% hint style="info" %}
Zauważ, że konieczne jest utworzenie drugiego fragmentu w celu ominięcia pewnych kontroli poprawności.
Należy utworzyć drugi kawałek, aby ominąć pewne kontrole poprawności.
{% endhint %}
## Przykłady
* 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**: Poprzez przepełnienie można zmienić wskaźnik tak, aby wskazywał na adres GOT w celu wycieku adresu libc poprzez akcję odczytu CTF
* **House of Spirit**: Nadużywając licznika, który liczy liczbę "karabinów", można wygenerować fałszywy rozmiar pierwszego fałszywego fragmentu, a następnie, nadużywając "wiadomości", można sfałszować drugi rozmiar fragmentu, a następnie, nadużywając przepełnienia, można zmienić wskaźnik, który zostanie zwolniony, więc nasz pierwszy fałszywy fragment zostanie zwolniony. Następnie możemy go przydzielić i wewnątrz niego będzie adres, pod którym przechowywana jest "wiadomość". Następnie można sprawić, aby wskazywała ona na wpis `scanf` w tabeli GOT, dzięki czemu możemy go nadpisać adresem do systemu.\
* **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)
* **Wyciek informacji z Libc**: Poprzez przepełnienie można zmienić wskaźnik tak, aby wskazywał na adres GOT, aby wyciec adres Libc poprzez akcję odczytu CTF
* **House of Spirit**: Nadużywając licznika, który liczy liczbę "karabinów", można wygenerować fałszywy rozmiar pierwszego fałszywego kawałka, a następnie, nadużywając "wiadomości", można sfałszować drugi rozmiar kawałka, a następnie, nadużywając przepełnienia, można zmienić wskaźnik, który zostanie zwolniony, więc nasz pierwszy fałszywy kawałek zostanie zwolniony. Następnie możemy go przydzielić i wewnątrz niego będzie adres, pod którym przechowywana jest "wiadomość". Następnie można sprawić, aby wskazywał on na wpis `scanf` w tabeli GOT, dzięki czemu możemy nadpisać go adresem do systemu.\
Następnym razem, gdy zostanie wywołane `scanf`, możemy wysłać wejście `"/bin/sh"` i uzyskać dostęp do powłoki.
* [**Gloater. HTB Cyber Apocalypse CTF 2024**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/gloater/)
* **Wyciek Glibc**: Niezainicjowany bufor stosu.
* **House of Spirit**: Możemy zmodyfikować pierwszy indeks globalnej tablicy wskaźników na stertę. Za pomocą jednobajtowej modyfikacji używamy `free` na fałszywym kawałku wewnątrz poprawnego kawałka, dzięki czemu po ponownym przydzieleniu otrzymujemy sytuację nakładających się kawałków. Dzięki temu atak trucizny Tcache działa, aby uzyskać arbitralne pisanie.
## Odnośniki
* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_spirit)
<details>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Dowiedz się, jak hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:

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

@ -24,24 +24,24 @@ Aby uzyskać więcej informacji na temat tego, co to jest duży kubeł, sprawdź
Można znaleźć świetny przykład w [**how2heap - atak na duży kubeł**](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/large\_bin\_attack.c).
W zasadzie można zobaczyć, jak w najnowszej "obecnej" wersji glibc (2.35) nie jest sprawdzane: **`P->bk_nextsize`**, co pozwala zmodyfikować dowolny adres wartością dużego kawałka kubełka, jeśli spełnione są pewne warunki.
W zasadzie tutaj można zobaczyć, jak w najnowszej "obecnej" wersji glibc (2.35) nie jest sprawdzane: **`P->bk_nextsize`**, co pozwala zmodyfikować dowolny adres za pomocą wartości kawałka dużego kubełka, jeśli spełnione są pewne warunki.
W tym przykładzie można znaleźć następujące warunki:
* Zaalokowany jest duży kawałek
* Zaalokowany jest duży kawałek mniejszy od pierwszego, ale o tym samym indeksie
* Zaalokowany jest duży kawałek mniejszy od pierwszego, ale w tym samym indeksie
* Musi być mniejszy, więc musi iść pierwszy w kubełku
* (Tworzony jest kawałek, aby zapobiec scaleniu z kawałkiem górnym)
* Następnie pierwszy duży kawałek jest zwalniany, a alokowany jest nowy kawałek większy od niego -> Kawałek1 trafia do dużego kubełka
* Następnie zwalniany jest drugi duży kawałek
* Teraz podatność: Atakujący może zmodyfikować `chunk1->bk_nextsize` na `[target-0x20]`
* Następnie alokowany jest większy kawałek niż kawałek 2, więc kawałek2 jest wstawiany do dużego kubełka, nadpisując adres `chunk1->bk_nextsize->fd_nextsize` adresem kawałka2
* Następnie drugi duży kawałek jest zwalniany
* Teraz podatność: Atakujący może zmodyfikować `chunk1->bk_nextsize` na `[cel-0x20]`
* Następnie jest alokowany większy kawałek niż kawałek 2, więc kawałek2 jest wstawiany do dużego kubełka, nadpisując adres `chunk1->bk_nextsize->fd_nextsize` adresem kawałka2
{% hint style="success" %}
Istnieją inne potencjalne scenariusze, chodzi o dodanie do dużego kubełka kawałka, który jest **mniejszy** niż aktualny kawałek X w kubełku, więc musi zostać wstawiony tuż przed nim w kubełku, i musimy móc zmodyfikować **`bk_nextsize`** X, ponieważ właśnie tam zostanie zapisany adres mniejszego kawałka.
Istnieją inne potencjalne scenariusze, chodzi o dodanie do dużego kubełka kawałka, który jest **mniejszy** niż aktualny kawałek X w kubełku, więc musi zostać wstawiony tuż przed nim w kubełku, i musimy móc zmodyfikować **`bk_nextsize`** X, ponieważ tam zostanie zapisany adres mniejszego kawałka.
{% endhint %}
Oto odpowiedni kod z malloc. Dodano komentarze, aby lepiej zrozumieć, jak został nadpisany adres:
Oto istotny kod z malloc. Dodano komentarze, aby lepiej zrozumieć, jak został nadpisany adres:
{% code overflow="wrap" %}
```c
@ -59,13 +59,20 @@ fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_
```
{% endcode %}
To może być wykorzystane do **nadpisania zmiennej globalnej `global_max_fast`** biblioteki libc, aby następnie wykorzystać atak na szybkie kubełki z większymi kawałkami.
To można wykorzystać do **nadpisania zmiennej globalnej `global_max_fast`** w bibliotece libc, aby następnie wykorzystać atak na szybkie kubełki z większymi kawałkami.
Możesz znaleźć inną świetną wyjaśnienie tego ataku na stronie [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin\_attack/largebin\_explanation0/index.html).
### Inne przykłady
* [**La casa de papel. HackOn CTF 2024**](https://7rocky.github.io/en/ctf/other/hackon-ctf/la-casa-de-papel/)
* Atak na duży kubełek w takiej samej sytuacji, jak to się pojawia w [**how2heap**](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/large\_bin\_attack.c).
* Pierwotne pisanie jest bardziej skomplikowane, ponieważ `global_max_fast` jest tu bezużyteczne.
* FSOP jest potrzebny do zakończenia eksploatacji.
<details>
<summary><strong>Zacznij od zera i zostań ekspertem AWS w dziedzinie hakowania dzięki</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
@ -73,6 +80,6 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

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

@ -10,24 +10,25 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Podstawowe informacje
Mając dostęp tylko do przepełnienia o 1B, atakujący może zmodyfikować bit `pre_in_use` z następnego fragmentu, a ponieważ bieżący fragment nie jest w użyciu, koniec fragmentu staje się informacją o rozmiarze poprzedniego fragmentu.\
To pozwala manipulować, które fragmenty są faktycznie zwalniane, potencjalnie generując fragment zawierający inny prawidłowy fragment.
Mając dostęp tylko do przepełnienia o jeden bajt, atakujący może zmodyfikować pole `size` z następnego fragmentu. Pozwala to manipulować, które fragmenty są faktycznie zwalniane, potencjalnie generując fragment zawierający inny prawidłowy fragment. Wykorzystanie jest podobne do [podwójnego zwalniania pamięci](double-free.md) lub nakładających się fragmentów.
Istnieją 2 rodzaje podatności na przepełnienie o jeden:
* Dowolny bajt: Ten rodzaj pozwala nadpisać ten bajt dowolną wartością
* Null off by one: Ten rodzaj pozwala nadpisać ten bajt tylko wartością 0x00
* Powszechnym przykładem tej podatności może być kod, w którym zachowanie funkcji strlen i strcpy jest niekonsekwentne, co pozwala na ustawienie bajtu 0x00 na początku następnego fragmentu.
* Bajt zerowy (off-by-null): Ten rodzaj pozwala nadpisać ten bajt tylko wartością 0x00
* Przykładem takiej podatności może być poniższy kod, w którym zachowanie funkcji `strlen` i `strcpy` jest niekonsekwentne, co pozwala na ustawienie bajtu 0x00 na początku następnego fragmentu.
* Można to wykorzystać za pomocą [House of Einherjar](house-of-einherjar.md).
* Jeśli używany jest Tcache, można to wykorzystać do sytuacji [podwójnego zwalniania pamięci](double-free.md).
<details>
<summary>Null off by one</summary>
<summary>Off-by-null</summary>
```c
// From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/
int main(void)
@ -46,7 +47,7 @@ return 0;
```
</details>
Wśród innych sprawdzeń, teraz za każdym razem, gdy kawałek jest zwalniany, poprzedni rozmiar jest porównywany z rozmiarem skonfigurowanym w metadanych kawałka, co sprawia, że ten atak jest dość skomplikowany od wersji 2.28.
Wśród innych sprawdzeń, teraz za każdym razem, gdy kawałek jest zwalniany, rozmiar poprzedni jest porównywany z rozmiarem skonfigurowanym w metadanych kawałka, co sprawia, że ten atak jest dość skomplikowany od wersji 2.28.
### Przykład kodu:
@ -56,33 +57,45 @@ Wśród innych sprawdzeń, teraz za każdym razem, gdy kawałek jest zwalniany,
### Cel
* Umieścić kawałek wewnątrz innego kawałka, dzięki czemu dostęp do zapisu na ten drugi kawałek pozwala nadpisać zawarty w nim kawałek
* Umieść kawałek wewnątrz innego kawałka, dzięki czemu dostęp do zapisu na ten drugi kawałek pozwala nadpisać zawarty w nim kawałek
### Wymagania
* Przepełnienie o jeden, aby zmodyfikować informacje metadanych poprzedniego rozmiaru
* Przepełnienie o jeden, aby zmodyfikować informacje o metadanych rozmiaru
### Atak
### Ogólny atak off-by-one
* Rezerwowane są 3 kawałki pamięci (a, b, c) jeden po drugim. Następnie środkowy jest zwalniany. Pierwszy zawiera podatność na przepełnienie o jeden bajt i atakujący ją wykorzystuje z użyciem 0x00 (jeśli poprzedni bajt był 0x10, sprawiłoby to, że środkowy kawałek wskazywałby, że jest o 0x10 mniejszy niż naprawdę).
* Następnie, w środkowym zwolnionym kawałku (b) alokowane są 2 mniejsze kawałki, jednakże, ponieważ `b + b->size` nigdy nie aktualizuje kawałka c, ponieważ wskazany adres jest mniejszy niż powinien.&#x20;
* Następnie, b1 i c są zwalniane. Ponieważ `c - c->prev_size` nadal wskazuje na b (teraz b1), oba są konsolidowane w jeden kawałek. Jednakże, b2 nadal znajduje się w środku między b1 i c.
* W końcu wykonywane jest nowe malloc odzyskujące ten obszar pamięci, który faktycznie będzie zawierał b2, pozwalając właścicielowi nowego malloc kontrolować zawartość b2.
* Zaalokuj trzy kawałki `A`, `B` i `C` (powiedzmy rozmiary 0x20), oraz kolejny, aby zapobiec konsolidacji z kawałkiem górnym.
* Zwolnij `C` (wstawiony do listy wolnych Tcache 0x20).
* Użyj kawałka `A`, aby przepełnić `B`. Wykorzystaj off-by-one, aby zmodyfikować pole `size` `B` z 0x21 na 0x41.
* Teraz mamy `B` zawierający wolny kawałek `C`
* Zwolnij `B` i zaalokuj kawałek 0x40 (zostanie tu ponownie umieszczony)
* Możemy zmodyfikować wskaźnik `fd` z `C`, który nadal jest wolny (zatrucie Tcache)
### Atak off-by-null
* Rezerwuje się 3 kawałki pamięci (a, b, c) jeden po drugim. Następnie środkowy jest zwalniany. Pierwszy zawiera podatność na przepełnienie o jeden, a atakujący ją z wykorzystaniem 0x00 (jeśli poprzedni bajt był 0x10, sprawi, że środkowy kawałek wskaże, że jest o 0x10 mniejszy, niż w rzeczywistości jest).
* Następnie, w środku zwolnionego kawałka (b) zaalokowano 2 mniejsze kawałki, jednakże, ponieważ `b + b->size` nigdy nie aktualizuje kawałka c, ponieważ adres wskazywany jest mniejszy, niż powinien.
* Następnie, b1 i c są zwalniane. Ponieważ `c - c->prev_size` wciąż wskazuje na b (teraz b1), oba są konsolidowane w jeden kawałek. Jednakże, b2 nadal znajduje się wewnątrz pomiędzy b1 i c.
* W końcu, wykonywane jest nowe przydział pamięci malloc, odzyskując ten obszar pamięci, który faktycznie będzie zawierał b2, pozwalając właścicielowi nowego malloc kontrolować zawartość b2.
To zdjęcie doskonale wyjaśnia atak:
<figure><img src="../../.gitbook/assets/image (1247).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks">https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks</a></p></figcaption></figure>
## Inne Przykłady i Odnośniki
## Inne Przykłady & Referencje
* [**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 z powodu `strlen` uwzględniającego pole `size` następnego kawałka.
* Używany jest Tcache, więc ogólne ataki off-by-one działają, aby uzyskać arbitralne pisanie zatruciem Tcache.
* [**Asis CTF 2016 b00ks**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#1-asis-ctf-2016-b00ks)
* Możliwe jest wykorzystanie przepełnienia o jeden do wycieku adresu z heap, ponieważ bajt 0x00 na końcu łańcucha zostaje nadpisany przez następne pole.
* Zapis dowolny jest uzyskiwany poprzez wykorzystanie przepełnienia o jeden, aby sprawić, że wskaźnik wskazuje na inne miejsce, gdzie zostanie zbudowana fałszywa struktura z fałszywymi wskaźnikami. Następnie możliwe jest śledzenie wskaźnika tej struktury, aby uzyskać zapis dowolny.
* Adres libc jest wyciekany, ponieważ jeśli heap jest rozszerzany za pomocą mmap, pamięć przydzielona przez mmap ma stały przesunięcie od libc.
* W końcu zapis dowolny jest wykorzystywany do zapisania adresu \_\_free\_hook za pomocą one gadgeta.
* Możliwe jest wykorzystanie off-by-one do wycieku adresu z heap, ponieważ bajt 0x00 na końcu łańcucha znaków jest nadpisywany przez następne pole.
* Pisanie arbitralne jest uzyskiwane poprzez nadużycie off-by-one write, aby wskaźnik wskazywał na inne miejsce, gdzie zostanie zbudowana fałszywa struktura z fałszywymi wskaźnikami. Następnie możliwe jest śledzenie wskaźnika tej struktury, aby uzyskać arbitralne pisanie.
* Adres libc jest wyciekany, ponieważ jeśli sterta jest rozszerzana za pomocą mmap, pamięć zaalokowana przez mmap ma stały przesunięcie od libc.
* W końcu, nadużywane jest arbitralne pisanie, aby zapisać w adresie \_\_free\_hook z adresem one gadget.
* [**plaidctf 2015 plaiddb**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#instance-2-plaidctf-2015-plaiddb)
* Istnieje podatność NULL off by one w funkcji `getline`, która czyta linie wejściowe użytkownika. Ta funkcja służy do odczytywania "klucza" zawartości, a nie samej zawartości.
* Istnieje podatność NULL off-by-one w funkcji `getline`, która czyta linie wejściowe użytkownika. Ta funkcja służy do odczytywania "klucza" zawartości, a nie samej zawartości.
* W opisie 5 początkowych kawałków jest tworzonych:
* kawałek1 (0x200)
* kawałek2 (0x50)
@ -92,33 +105,20 @@ To zdjęcie doskonale wyjaśnia atak:
* obrona kawałka (0x400) aby uniknąć konsolidacji z kawałkiem górnym
* Następnie kawałki 1, 5 i 3 są zwalniane, więc:
* ```python
[ 0x200 Kawałek 1 (zwolniony) ] [ 0x50 Kawałek 2 ] [ 0x68 Kawałek 5 (zwolniony) ] [ 0x1f8 Kawałek 3 (zwolniony) ] [ 0xf0 Kawałek 4 ] [ 0x400 Kawałek obrony ]
[ 0x200 Kawałek 1 (wolny) ] [ 0x50 Kawałek 2 ] [ 0x68 Kawałek 5 (wolny) ] [ 0x1f8 Kawałek 3 (wolny) ] [ 0xf0 Kawałek 4 ] [ 0x400 Kawałek obrony ]
```
* Następnie nadużywając kawałka3 (0x1f8) wykorzystywane jest null off-by-one, zapisując prev\_size na `0x4e0`.
* Zauważ, jak rozmiary początkowo przydzielonych kawałków1, 2, 5 i 3 plus nagłówki 4 tych kawałków równają się `0x4e0`: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
* Następnie nadużywając kawałka3 (0x1f8) wykorzystuje się null off-by-one, zapisując prev\_size na `0x4e0`.
* Zauważ, jak rozmiary początkowo zaalokowanych kawałków1, 2, 5 i 3 plus nagłówki 4 z tych kawałków równają się `0x4e0`: `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
* Następnie, kawałek 4 jest zwalniany, generując kawałek, który zużywa wszystkie kawałki aż do początku:
* ```python
[ 0x4e0 Kawałek 1-2-5-3 (zwolniony) ] [ 0xf0 Kawałek 4 (zepsuty) ] [ 0x400 Kawałek obrony ]
[ 0x4e0 Kawałek 1-2-5-3 (wolny) ] [ 0xf0 Kawałek 4 (zepsuty) ] [ 0x400 Kawałek obrony ]
```
* ```python
[ 0x200 Kawałek 1 (zwolniony) ] [ 0x50 Kawałek 2 ] [ 0x68 Kawałek 5 (zwolniony) ] [ 0x1f8 Kawałek 3 (zwolniony) ] [ 0xf0 Kawałek 4 ] [ 0x400 Kawałek obrony ]
[ 0x200 Kawałek 1 (wolny) ] [ 0x50 Kawałek 2 ] [ 0x68 Kawałek 5 (wolny) ] [ 0x1f8 Kawałek 3 (wolny) ] [ 0xf0 Kawałek 4 ] [ 0x400 Kawałek obrony ]
```
* Następnie, przydzielane są `0x200` bajtów wypełniając oryginalny kawałek 1
* I przydzielane są kolejne 0x200 bajtów i kawałek2 jest zniszczony i dlatego nie ma żadnego wycieku i to nie działa? Może tego nie należy robić
* Następnie przydzielany jest kolejny kawałek o długości 0x58 "a" (nadpisując kawałek2 i docierając do kawałka5) i modyfikowany jest `fd` szybkiego kawałka binarnego kawałka5 wskazując na `__malloc_hook`
* Następnie, przydzielany jest kawałek o długości 0x68, więc fałszywy szybki kawałek binarny w `__malloc_hook` jest następnym szybkim kawałkiem binarnym
* W końcu, przydzielany jest nowy szybki kawałek binarny o długości 0x68 i `__malloc_hook` jest nadpisywany adresem `one_gadget`
<details>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
* Następnie, zaalokowane są `0x200` bajtów wypełniając oryginalny kawałek 1
* I zaalokowane są kolejne 0x200 bajtów i kawałek2 jest zniszczony i dlatego nie ma żadnego wycieku i to nie działa? Być może tego nie powinno się robić
* Następnie, zaalokowano inny kawałek z 0x58 "a" (nadpisując kawałek2 i docierając do kawałka5) i zmodyfikowano `fd` kawałka fast bin kawałka kawałka5 wskazując go na `__malloc_hook`
* Następnie, zaalokowano kawałek o rozmiarze 0x68, więc fałszywy kawałek fast bin w `__malloc_hook` jest następnym kawałkiem fast bin
* W końcu, zaalokowano nowy kawałek fast bin o rozmiarze 0x68 i `__malloc_hook` jest nadpisany adresem `one_gadget`
* **Udostępnij swoje sztuczki hakerskie, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) **i** [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) **na githubie.**

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

@ -2,7 +2,7 @@
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
@ -10,11 +10,11 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
Kilka proponowanych technik eksploatacji sterty wymaga możliwości nadpisania wskaźników wewnątrz zwolnionych fragmentów. Celem tej strony jest podsumowanie potencjalnych podatności, które mogą umożliwić taki dostęp:
Kilka proponowanych technik eksploatacji sterty wymaga nadpisania wskaźników wewnątrz zwolnionych fragmentów. Celem tej strony jest podsumowanie potencjalnych podatności, które mogą umożliwić uzyskanie tego dostępu:
### Proste Użycie Po Zwolnieniu
@ -22,19 +22,19 @@ Jeśli atakujący może **zapisać informacje w zwolnionym fragmencie**, może t
### Podwójne Zwolnienie
Jeśli atakujący może **`zwolnić` dwa razy ten sam fragment** (zwolnić inne fragmenty pomiędzy potencjalnie) i sprawić, że będzie **2 razy w tym samym kubełku**, użytkownik będzie mógł **przydzielić później ten fragment**, **zapisać potrzebne wskaźniki** a następnie **ponownie go przydzielić**, co wywoła akcje związaną z przydzieleniem fragmentu (np. atak na szybki kubełek, atak na tcache...)
Jeśli atakujący może **`zwolnić` dwa razy ten sam fragment** (zwolnić inne fragmenty pomiędzy potencjalnie) i sprawić, że będzie **2 razy w tym samym kubełku**, użytkownik będzie mógł **przydzielić później fragment**, **zapisać potrzebne wskaźniki**, a następnie **ponownie go przydzielić**, co wywoła działania związane z przydzieleniem fragmentu (np. atak na szybki kubełek, atak tcache...)
### Przepełnienie Sterty
Możliwe jest **przepełnienie przydzielonego fragmentu mającego następnie zwolniony fragment** i zmodyfikowanie niektórych nagłówków/wskaźników.
Możliwe jest **przepełnienie przydzielonego fragmentu mającego obok zwolniony fragment** i zmodyfikowanie niektórych nagłówków/wskaźników.
### Przepełnienie o 1
### Przepełnienie o Jeden
W tym przypadku możliwe jest **zmodyfikowanie rozmiaru** następnego fragmentu w pamięci. Atakujący mógłby to wykorzystać, aby **przydzielić większy rozmiar przydzielonego fragmentu**, a następnie **`zwolnić`** go, sprawiając, że fragment zostanie **dodany do kubełka o innym** rozmiarze (większym), a następnie przydzielić **fałszywy rozmiar**, a atakujący będzie miał dostęp do **fragmentu o większym rozmiarze** niż w rzeczywistości, **umożliwiając tym samym przepełnienie sterty** (sprawdź poprzednią sekcję).
W tym przypadku możliwe byłoby **zmodyfikowanie rozmiaru** następnego fragmentu w pamięci. Atakujący mógłby wykorzystać to, aby **przydzielić przydzielony fragment większego rozmiaru**, a następnie **`zwolnić`** go, sprawiając, że fragment zostanie **dodany do kubełka o innym** rozmiarze (większym), a następnie przydzielić **fałszywy rozmiar**, a atakujący będzie miał dostęp do **fragmentu o większym rozmiarze** niż jest naprawdę, **umożliwiając tym samym sytuację nakładających się fragmentów**, która jest eksploatowalna w ten sam sposób co **przepełnienie sterty** (sprawdź poprzednią sekcję).
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
@ -42,6 +42,6 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>

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

@ -1,66 +1,59 @@
# Atak na Tcache Bin
# Atak na kubełek Tcache
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCYJNY**](https://github.com/sponsors/carlospolop)!
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) albo **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>
## Podstawowe informacje
Aby uzyskać więcej informacji na temat tego, co to jest tcache bin, sprawdź tę stronę:
Aby uzyskać więcej informacji na temat tego, co to jest kubełek Tcache, sprawdź tę stronę:
{% content-ref url="bins-and-memory-allocations.md" %}
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Po pierwsze, zauważ, że Tcache został wprowadzony w wersji glibc 2.26.
Po pierwsze, zauważ, że Tcache został wprowadzony w wersji Glibc 2.26.
Atak **Tcache** zaproponowany na stronie [**guyinatuxido**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) jest bardzo podobny do ataku na fast bin, gdzie celem jest nadpisanie wskaźnika do następnego fragmentu w binie wewnątrz zwolnionego fragmentu na dowolny adres, aby później było możliwe **zaalokowanie tego konkretnego adresu i potencjalne nadpisanie wskaźników**.
**Atak na Tcache** (znany również jako **zatrucie Tcache**) zaproponowany na stronie [**guyinatuxido**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) jest bardzo podobny do ataku na szybki kubełek, gdzie celem jest nadpisanie wskaźnika do następnego fragmentu w kubełku wewnątrz zwolnionego fragmentu na dowolny adres, aby później było możliwe **przydzielenie tego konkretnego adresu i potencjalne nadpisanie wskaźników**.
Jednak obecnie, jeśli uruchomisz wspomniany kod, otrzymasz błąd: **`malloc(): unaligned tcache chunk detected`**. Dlatego konieczne jest wpisanie jako adresu w nowy wskaźnik adresu wyrównanego (lub wystarczająco wiele razy uruchomienie binarnego pliku, aby wpisany adres był faktycznie wyrównany).
Jednak obecnie, jeśli uruchomisz wspomniany kod, otrzymasz błąd: **`malloc(): unaligned tcache chunk detected`**. Dlatego konieczne jest wpisanie jako adresu w nowy wskaźnik adresu wyrównanego (lub wykonanie wystarczającej liczby razy binarnie, aby wpisany adres był faktycznie wyrównany).
### Atak na indeksy Tcache
Zazwyczaj na początku sterty można znaleźć fragment zawierający **liczbę fragmentów na indeks** wewnątrz tcache oraz adres do **głównego fragmentu każdego indeksu tcache**. Jeśli z jakiegoś powodu możliwe jest zmodyfikowanie tych informacji, można **spowodować, że główny fragment pewnego indeksu wskaże na pożądany adres** (np. hak malloc) aby następnie zaalokować fragment o rozmiarze indeksu i nadpisać zawartość hakera malloc w tym przypadku.
Zazwyczaj na początku sterty można znaleźć fragment zawierający **liczbę fragmentów na indeks** wewnątrz tcache oraz adres do **głównego fragmentu każdego indeksu tcache**. Jeśli z jakiegoś powodu możliwe jest zmodyfikowanie tych informacji, byłoby możliwe **spowodowanie, aby główny fragment jakiegoś indeksu wskazywał na pożądany adres** (np. `__malloc_hook`), aby następnie przydzielić fragment o rozmiarze indeksu i nadpisać zawartość `__malloc_hook` w tym przypadku.
## Przykłady
* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
* **Wyciek informacji z libc**: Możliwe jest zapełnienie tcaches, dodanie fragmentu do listy nieuporządkowanej, opróżnienie tcache i **ponowne zaalokowanie fragmentu z listy nieuporządkowanej** nadpisując tylko pierwsze 8B, pozostawiając **drugi adres do libc z fragmentu nietknięty, dzięki czemu możemy go odczytać**.
* **Atak Tcache**: Binarny plik jest podatny na przepełnienie sterty o 1B. Zostanie to wykorzystane do zmiany **nagłówka rozmiaru** zaalokowanego fragmentu, zwiększając go. Następnie ten fragment zostanie **zwolniony**, dodając go do tcache fragmentów o fałszywym rozmiarze. Następnie zaalokujemy fragment o fałszywym rozmiarze, a poprzedni fragment zostanie **zwrócony, wiedząc, że ten fragment był faktycznie mniejszy**, co daje możliwość **nadpisania następnego fragmentu w pamięci**.\
Będziemy wykorzystywać to do **nadpisania wskaźnika FD następnego fragmentu** wskazującego na **`malloc_hook`**, dzięki czemu możliwe będzie zaalokowanie 2 wskaźników: najpierw prawidłowy wskaźnik, który właśnie zmodyfikowaliśmy, a następnie druga alokacja zwróci fragment w **`malloc_hook`**, który można wykorzystać do napisania **one gadget**.
* **Wyciek informacji z Libc**: Możliwe jest zapełnienie tcaches, dodanie fragmentu do listy nieuporządkowanej, opróżnienie tcache i **ponowne przydzielenie fragmentu z listy nieuporządkowanej**, nadpisując tylko pierwsze 8B, pozostawiając **drugi adres do Libc z fragmentu nietknięty, dzięki czemu możemy go odczytać**.
* **Atak na Tcache**: Binarne jest podatne na przepełnienie sterty o 1B. Zostanie to wykorzystane do zmiany **nagłówka rozmiaru** przydzielonego fragmentu, zwiększając go. Następnie ten fragment zostanie **zwolniony**, dodając go do tcache fragmentów o fałszywym rozmiarze. Następnie przydzielimy fragment o sfałszowanym rozmiarze, a poprzedni fragment zostanie **zwrócony, wiedząc, że ten fragment był faktycznie mniejszy**, co daje możliwość **nadpisania następnego fragmentu w pamięci**.\
Będziemy wykorzystywać to do **nadpisania wskaźnika FD następnego fragmentu**, aby wskazywał na **`malloc_hook`**, dzięki czemu możliwe będzie przydzielenie 2 wskaźników: najpierw prawidłowy wskaźnik, który właśnie zmodyfikowaliśmy, a następnie druga alokacja zwróci fragment w **`malloc_hook`**, który można wykorzystać do napisania **one gadget**.
* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
* **Wyciek informacji z libc**: Występuje tu użycie po zwolnieniu i podwójne zwolnienie. W tym rozwiązaniu autor wyciekł adres libc, odczytując adres fragmentu umieszczonego w małym binie (podobnie jak wyciek z nieuporządkowanego binu, ale z małego).
* **Atak Tcache**: Wykonuje się Tcache poprzez **podwójne zwolnienie**. Ten sam fragment jest zwalniany dwukrotnie, więc wewnątrz Tcache fragment ten będzie wskazywał na siebie. Następnie jest on alokowany, jego wskaźnik FD jest modyfikowany, aby wskazywał na **free hook**, a następnie jest ponownie alokowany, więc następny fragment na liście będzie w free hook. Następnie ten fragment również jest alokowany i możliwe jest zapisanie adresu `system` tutaj, więc gdy zostanie zwolniony malloc zawierający `"/bin/sh"`, otrzymamy powłokę.
* **Wyciek informacji z Libc**: Występuje tu użycie po zwolnieniu i podwójne zwolnienie. W tym rozwiązaniu autor wyciekł adres Libc, odczytując adres fragmentu umieszczonego w małym kubełku (podobnie jak wyciek z kubełka nieuporządkowanego, ale z małego).
* **Atak na Tcache**: Wykonuje się Tcache poprzez **podwójne zwolnienie** tego samego fragmentu, więc wewnątrz Tcache fragment ten będzie wskazywał na siebie. Następnie jest on przydzielany, jego wskaźnik FD jest modyfikowany, aby wskazywał na **free hook**, a następnie jest on ponownie przydzielany, więc następny fragment na liście znajdzie się w free hook. Następnie jest on również przydzielany i możliwe jest zapisanie adresu `system` tutaj, więc gdy zostanie zwolniony malloc zawierający `"/bin/sh"`, uzyskamy dostęp do powłoki.
* 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)
* Główną luką jest możliwość `zwolnienia` dowolnego adresu na stercie, wskazując jego przesunięcie
* **Atak na indeksy Tcache**: Możliwe jest zaalokowanie i zwolnienie fragmentu o rozmiarze, który przechowywany wewnątrz fragmentu tcache (fragment z informacjami o binach tcache) spowoduje wygenerowanie **adresu o wartości 0x100**. Wynika to z faktu, że tcache przechowuje liczbę fragmentów w każdym binie w różnych bajtach, dlatego jeden fragment w jednym konkretnym indeksie generuje wartość 0x100.
* **Atak na indeksy Tcache**: Możliwe jest przydzielenie i zwolnienie fragmentu o rozmiarze, który przechowywany wewnątrz fragmentu tcache (fragment z informacjami o kubełkach tcache) spowoduje wygenerowanie **adresu o wartości 0x100**. Wynika to z faktu, że tcache przechowuje liczbę fragmentów w każdym kubełku w różnych bajtach, dlatego jeden fragment w jednym konkretnym indeksie generuje wartość 0x100.
* Następnie ta wartość wygląda na to, jakby istniał fragment o rozmiarze 0x100. Pozwala to na wykorzystanie go poprzez `zwolnienie` tego adresu. Spowoduje to **dodanie tego adresu do indeksu fragmentów o rozmiarze 0x100 w tcache**.
* Następnie, **zaalokowanie** fragmentu o rozmiarze **0x100**, poprzedni adres zostanie zwrócony jako fragment, co pozwala na nadpisanie innych indeksów tcache.\
Na przykład umieszczenie adresu hakera malloc w jednym z nich i zaalokowanie fragmentu o rozmiarze tego indeksu umożliwi uzyskanie fragmentu w hakera calloc, co pozwala na napisanie one gadgeta, aby uzyskać powłokę.
* Następnie, **przydzielając** fragment o rozmiarze **0x100**, poprzedni adres zostanie zwrócony jako fragment, co pozwala na nadpisanie innych indeksów tcache.\
Na przykład umieszczenie adresu malloc hook w jednym z nich i przydzielenie fragmentu o rozmiarze tego indeksu umożliwi uzyskanie fragmentu w calloc hook, co pozwala na napisanie one gadgeta, aby uzyskać dostęp do powłoki.
* 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)
* Ta sama podatność co wcześniej z jednym dodatkowym ograniczeniem
* **Atak na indeksy Tcache**: Podobny atak do poprzedniego, ale z użyciem mniejszej liczby kroków poprzez **zwolnienie fragmentu zawierającego informacje o tcache**, dzięki czemu jego adres zostaje dodany do indeksu tcache jego rozmiaru, co umożliwia zaalokowanie tego rozmiaru i uzyskanie informacji o fragmencie tcache jako fragmentu, co pozwala dodać free hook jako adres jednego indeksu, zaalokować go i zapisać na nim one gadgeta.
<details>
<summary><strong>Nauka hakowania AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCYJNY**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Atak na indeksy Tcache**: Podobny atak do poprzedniego, ale z użyciem mniejszej liczby kroków poprzez **zwolnienie fragmentu zawierającego informacje o tcache**, dzięki czemu jego adres zostaje dodany do indeksu tcache jego rozmiaru, co pozwala na przydzielenie tego rozmiaru i uzyskanie informacji o tcache jako fragmentu, co pozwala na dodanie free hook jako adresu jednego indeksu, przydzielenie go i zapisanie na nim one gadgeta.
* [**Math Door. HTB Cyber Apocalypse CTF 2023**](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/math-door/)
* **Zapis po zwolnieniu** w celu dodania liczby do wskaźnika `fd`.
* W tej wyzwaniu potrzebne jest wiele **feng-shui sterty**. W opisie pokazano, jak **kontrolowanie głowy listy wolnych fragmentów Tcache** jest bardzo przydatne.
* **Wyciek Glibc** poprzez `stdout` (FSOP).
* **Zatrucie Tcache** w celu uzyskania arbitralnego zapisu.
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
</details>
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na githubie.

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

@ -10,13 +10,13 @@ Inne sposoby wsparcia HackTricks:
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów na GitHubie.
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
</details>
## Podstawowe informacje
Kiedy ten atak został odkryty, głównie pozwalał na WWW (Write What Where), jednak dodano **sprawdzenia**, co sprawia, że nowa wersja ataku jest bardziej interesująca, bardziej złożona i **bezużyteczna**.
Kiedy ten atak został odkryty, głównie pozwalał na WWW (Write What Where), jednak dodano **sprawdzenia**, co sprawiło, że nowa wersja ataku stała się bardziej interesująca, bardziej złożona i **bezużyteczna**.
### Przykład kodu:
@ -93,48 +93,48 @@ return 0;
### Cel
Ten atak pozwala **zmienić wskaźnik do fragmentu tak, aby wskazywał 3 adresy przed samym sobą**. Jeśli nowa lokalizacja (otoczenie, gdzie znajdował się wskaźnik) zawiera interesujące rzeczy, takie jak inne kontrolowalne alokacje / stos..., możliwe jest odczytanie/nadpisanie ich w celu spowodowania większej szkody.
Ten atak pozwala **zmienić wskaźnik na blok tak, aby wskazywał 3 adresy przed samym sobą**. Jeśli nowa lokalizacja (otoczenie, gdzie znajdował się wskaźnik) zawiera interesujące informacje, takie jak inne kontrolowalne alokacje / stos..., możliwe jest odczytanie/nadpisanie ich w celu spowodowania większej szkody.
* Jeśli ten wskaźnik znajdował się na stosie, ponieważ teraz wskazuje 3 adresy przed samym sobą, a użytkownik potencjalnie może go odczytać i zmodyfikować, będzie możliwe wyciekanie poufnych informacji ze stosu lub nawet modyfikowanie adresu powrotu (może) bez dotykania canary
* Jeśli ten wskaźnik znajdował się na stosie, ponieważ teraz wskazuje 3 adresy przed samym sobą, a użytkownik potencjalnie może go odczytać i zmodyfikować, będzie możliwe wyciekanie poufnych informacji ze stosu lub nawet modyfikacja adresu powrotu (może) bez dotykania canary
* W przykładach CTF ten wskaźnik znajduje się w tablicy wskaźników do innych alokacji, dlatego, ustawiając go 3 adresy przed i mając możliwość odczytu i zapisu, można sprawić, że inne wskaźniki wskazują na inne adresy.\
Ponieważ potencjalnie użytkownik może również odczytywać/zapisywać inne alokacje, może wyciekać informacje lub nadpisywać nowe adresy w dowolnych lokalizacjach (np. w GOT).
### Wymagania
* Pewna kontrola pamięci (np. stosu), aby utworzyć kilka fragmentów, nadając wartości niektórym atrybutom.
* Wyciek stosu w celu ustawienia wskaźników fałszywego fragmentu.
* Pewna kontrola pamięci (np. stos) w celu utworzenia kilku bloków, przypisując wartości do niektórych atrybutów.
* Wyciek stosu w celu ustawienia wskaźników fałszywego bloku.
### Atak
* Istnieją dwa fragmenty (fragment1 i fragment2)
* Atakujący kontroluje zawartość fragmentu1 i nagłówki fragmentu2.
* W fragmencie1 atakujący tworzy strukturę fałszywego fragmentu:
* Istnieją dwa bloki (blok1 i blok2)
* Atakujący kontroluje zawartość bloku1 i nagłówki bloku2.
* W bloku1 atakujący tworzy strukturę fałszywego bloku:
* Aby ominąć zabezpieczenia, upewnia się, że pole `size` jest poprawne, aby uniknąć błędu: `corrupted size vs. prev_size while consolidating`
* a pola `fd` i `bk` fałszywego fragmentu wskazują tam, gdzie wskaźnik fragmentu1 jest przechowywany z przesunięciami odpowiednio -3 i -2, więc `fake_chunk->fd->bk` i `fake_chunk->bk->fd` wskazują na pozycję w pamięci (stosie), gdzie znajduje się rzeczywisty adres fragmentu1:
* a pola `fd` i `bk` fałszywego bloku wskazują tam, gdzie wskaźnik bloku1 jest przechowywany z przesunięciami odpowiednio -3 i -2, więc `fake_chunk->fd->bk` i `fake_chunk->bk->fd` wskazują na pozycję w pamięci (stosie), gdzie znajduje się rzeczywisty adres bloku1:
<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>
* Nagłówki fragmentu2 są modyfikowane w taki sposób, aby wskazywały, że poprzedni fragment nie jest używany, a rozmiar to rozmiar zawartego fałszywego fragmentu.
* Gdy drugi fragment zostanie zwolniony, to następuje odłączenie tego fałszywego fragmentu:
* Nagłówki bloku2 są modyfikowane w taki sposób, aby wskazywały, że poprzedni blok nie jest używany, a rozmiar to rozmiar zawartego fałszywego bloku.
* Gdy drugi blok zostanie zwolniony, to następuje odłączenie tego fałszywego bloku:
* `fake_chunk->fd->bk` = `fake_chunk->bk`
* `fake_chunk->bk->fd` = `fake_chunk->fd`
* Wcześniej sprawiono, że `fake_chunk->fd->bk` i `fake_chunk->fd->bk` wskazują na to samo miejsce (lokalizację na stosie, gdzie przechowywany jest `fragment1`, więc był to poprawny lista połączona). Ponieważ **oba wskazują na tę samą lokalizację**, tylko ostatni (`fake_chunk->bk->fd = fake_chunk->fd`) będzie miał **skutek**.
* Spowoduje to **nadpisanie wskaźnika do fragmentu1 na stosie adresem (lub bajtami) przechowywanym 3 adresy wcześniej na stosie**.
* Dlatego jeśli atakujący mógłby kontrolować ponownie zawartość fragmentu1, będzie mógł **pisać wewnątrz stosu**, co pozwoli mu potencjalnie nadpisać adres powrotu, pomijając canary, oraz modyfikować wartości i wskaźniki zmiennych lokalnych. Nawet ponownie modyfikując adres fragmentu1 przechowywany na stosie na inną lokalizację, jeśli atakujący mógłby ponownie kontrolować zawartość fragmentu1, będzie mógł pisać w dowolnym miejscu.
* Należy zauważyć, że było to możliwe, ponieważ **adresy są przechowywane na stosie**. Ryzyko i eksploatacja mogą zależeć od **miejsca, gdzie są przechowywane adresy do fałszywego fragmentu**.
* Wcześniej sprawiono, że `fake_chunk->fd->bk` i `fake_chunk->bk->fd` wskazują na to samo miejsce (miejsce na stosie, gdzie przechowywany jest `blok1`, więc był to poprawny lista połączona). Ponieważ **oba wskazują na to samo miejsce**, tylko ostatni (`fake_chunk->bk->fd = fake_chunk->fd`) będzie **działać**.
* Spowoduje to **nadpisanie wskaźnika do bloku1 na stosie adresem (lub bajtami) przechowywanym 3 adresy wcześniej na stosie**.
* Dlatego jeśli atakujący mógłby ponownie kontrolować zawartość bloku1, będzie mógł **pisać wewnątrz stosu**, mając potencjalnie możliwość nadpisania adresu powrotu, pomijając canary, oraz modyfikacji wartości i wskaźników zmiennych lokalnych. Nawet ponownie modyfikując adres bloku1 przechowywany na stosie na innej lokalizacji, jeśli atakujący mógłby ponownie kontrolować zawartość bloku1, będzie mógł pisać w dowolnym miejscu.
* Należy zauważyć, że było to możliwe, ponieważ **adresy są przechowywane na stosie**. Ryzyko i eksploatacja mogą zależeć od **miejsca, gdzie są przechowywane adresy do fałszywego bloku**.
<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>
## Referencje
* [https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink\_exploit)
* Chociaż byłoby dziwne znalezienie ataku unlink nawet w CTF, tutaj znajdziesz kilka rozwiązań, gdzie ten atak był używany:
* Chociaż byłoby dziwne znalezienie ataku unlink nawet w CTF, tutaj znajdziesz kilka rozwiązań, gdzie ten atak został użyty:
* Przykład CTF: [https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14\_stkof/index.html)
* W tym przykładzie zamiast stosu jest tablica adresów zaalokowanych za pomocą malloc. Atak unlink jest wykonywany, aby móc zaalokować tutaj fragment, umożliwiając kontrolowanie wskaźników tablicy zaalokowanych adresów. Następnie istnieje inna funkcjonalność, która pozwala modyfikować zawartość fragmentów w tych adresach, co pozwala wskazywać adresy do GOT, modyfikować adresy funkcji w celu uzyskania wycieków i RCE.
* Inny przykład CTF: [https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html)
* Tak jak w poprzednim przykładzie, istnieje tablica adresów alokacji. Możliwe jest wykonanie ataku unlink, aby sprawić, że adres pierwszej alokacji wskazuje kilka pozycji przed rozpoczęciem tablicy, a następnie nadpisać tę alokację na nowej pozycji. Dlatego możliwe jest nadpisanie wskaźników innych alokacji, aby wskazywały na GOT atoi, uzyskać wyciek libc, a następnie nadpisać atoi GOT adresem do jednego gadżetu.
* W tym przykładzie zamiast stosu jest tablica adresów przydzielonych za pomocą malloc. Atak unlink jest wykonywany, aby możliwe było zaalokowanie bloku tutaj, umożliwiając kontrolowanie wskaźników tablicy adresów przydzielonych. Następnie istnieje inna funkcjonalność, która pozwala modyfikować zawartość bloków w tych adresach, co pozwala wskazywać adresy na GOT, modyfikować adresy funkcji w celu uzyskania wycieków i RCE.
* Kolejny przykład CTF: [https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16\_note2/index.html)
* Podobnie jak w poprzednim przykładzie, istnieje tablica adresów alokacji. Możliwe jest wykonanie ataku unlink, aby sprawić, że adres pierwszej alokacji wskazuje kilka pozycji przed rozpoczęciem tablicy, a następnie nadpisać tę alokację na nowej pozycji. Dzięki temu możliwe jest nadpisanie wskaźników innych alokacji, aby wskazywały na GOT atoi, uzyskać wyciek libc, a następnie nadpisać atoi GOT adresem do jednego gadżetu.
* Przykład CTF z niestandardowymi funkcjami malloc i free, które wykorzystują podatność bardzo podobną do ataku unlink: [https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw17\_minesweeper/index.html)
* Istnieje przepełnienie, które pozwala kontrolować wskaźniki FD i BK niestandardowego malloc, które zostaną (niestandardowo) zwolnione. Ponadto sterta ma ustawiony bit exec, więc możliwe jest wyciekanie adresu sterty i wskazywanie funkcji z GOT do fragmentu sterty z kodem powłoki do wykonania.
* Istnieje przepełnienie, które pozwala kontrolować wskaźniki FD i BK niestandardowego malloc, które zostaną (niestandardowo) zwolnione. Ponadto sterta ma ustawiony bit exec, więc możliwe jest wyciek adresu sterty i wskazanie funkcji z GOT na kawałek sterty z shellcodem do wykonania.
<details>

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

@ -22,48 +22,48 @@ Aby uzyskać więcej informacji na temat tego, co oznacza kubełek nieposortowan
[bins-and-memory-allocations.md](bins-and-memory-allocations.md)
{% endcontent-ref %}
Nieposortowane listy mogą zapisać adres w `unsorted_chunks (av)` w adresie `bk` fragmentu. Dlatego jeśli atakujący może **zmodyfikować adres wskaźnika bk** w fragmencie w kubełku nieposortowanym, może **zapisać ten adres w dowolnym adresie**, co może pomóc w wycieku adresów libc lub obejściu niektórych zabezpieczeń.
Nieposortowane listy mogą zapisać adres w `unsorted_chunks (av)` w adresie `bk` fragmentu. Dlatego jeśli atakujący może **zmodyfikować adres wskaźnika `bk`** w fragmencie w kubełku nieposortowanym, może **zapisać ten adres w dowolnym adresie**, co może pomóc w wycieku adresów Glibc lub obejściu niektórych zabezpieczeń.
W zasadzie ten atak pozwala **nadpisać dowolny adres dużą liczbą** (adres, który może być adresem sterty lub adresem libc), na przykład adresem stosu, który może być wyciekany, lub jakąś restrykcją, taką jak globalna zmienna **`global_max_fast`**, aby umożliwić tworzenie kubełków fast bin o większych rozmiarach (i przejście od ataku na kubełek nieposortowany do ataku na fast bin).
W zasadzie ten atak pozwala **ustawić dużą liczbę pod dowolnym adresem**. Ta duża liczba to adres, który może być adresem sterty lub adresem Glibc. Typowym celem jest **`global_max_fast`**, aby umożliwić tworzenie kubełków fast bin o większych rozmiarach (i przejście od ataku na kubełek nieposortowany do ataku na fast bin).
{% hint style="success" %}
Przyjrzenie się przykładowi podanemu w [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 użycie 0x4000 i 0x5000 zamiast 0x400 i 0x500 jako rozmiarów fragmentów (aby uniknąć tcaches) pozwala zobaczyć, że **obecnie** błąd **`malloc(): unsorted double linked list corrupted`** jest wywoływany.
Przyjrzenie się przykładowi podanemu w [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 użycie 0x4000 i 0x5000 zamiast 0x400 i 0x500 jako rozmiarów fragmentów (aby uniknąć Tcache) pozwala zobaczyć, że **obecnie** błąd **`malloc(): unsorted double linked list corrupted`** jest wywoływany.
Dlatego teraz ten atak na kubełek nieposortowany (oprócz innych sprawdzeń) wymaga również naprawienia podwójnej listy połączonej, aby to ominąć `victim->bck->fd == victim` lub nie `victim->fd == av (arena)`. Oznacza to, że adres, w który chcemy zapisać, musi mieć adres fałszywego fragmentu w swojej pozycji `fd`, a fałszywy fragment `fd` musi wskazywać na arenę.
Dlatego teraz ten atak na kubełek nieposortowany (oprócz innych sprawdzeń) wymaga również naprawienia zduplikowanej listy połączonej, aby to ominąć `victim->bk->fd == victim` lub nie `victim->fd == av (arena)`, co oznacza, że adres, gdzie chcemy zapisać, musi mieć adres fałszywego fragmentu w swojej pozycji `fd` i że fałszywy fragment `fd` wskazuje na arenę.
{% endhint %}
{% hint style="danger" %}
Zauważ, że ten atak psuje kubełek nieposortowany (a także mały i duży). Dlatego teraz możemy **korzystać tylko z alokacji z kubełka fast bin** (bardziej złożony program może wykonywać inne alokacje i się zawiesić), aby to wywołać, musimy **zaalokować ten sam rozmiar, inaczej program się zawiesi.**
Zauważ, że ten atak psuje kubełek nieposortowany (a także mały i duży). Dlatego teraz możemy **korzystać tylko z alokacji z kubełka fast bin** (bardziej złożony program może wykonywać inne alokacje i się zawieszać), aby wywołać to musimy **zaalokować ten sam rozmiar, inaczej program się zawiesi.**
Zauważ, że ustawienie **`global_max_fast`** może pomóc w tym przypadku, zakładając, że kubełek fast będzie w stanie obsłużyć wszystkie inne alokacje, aż exploit zostanie zakończony.
Zauważ, że nadpisanie **`global_max_fast`** może pomóc w tym przypadku, zakładając, że kubełek fast będzie w stanie obsłużyć wszystkie inne alokacje, aż atak zostanie zakończony.
{% endhint %}
Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) wyjaśnia to bardzo dobrze, chociaż jeśli zmodyfikujesz alokacje pamięci tak, aby alokować pamięć wystarczająco dużą, aby nie trafić do tcaches, zobaczysz, że wcześniej wspomniany błąd uniemożliwia zastosowanie tej techniki: **`malloc(): unsorted double linked list corrupted`**
Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) dobrze to wyjaśnia, chociaż jeśli zmodyfikujesz alokacje pamięci, aby alokować pamięć wystarczająco dużą, aby nie trafić do Tcache, zobaczysz, że wcześniej wspomniany błąd uniemożliwia zastosowanie tej techniki: **`malloc(): unsorted double linked list corrupted`**
## Atak na wyciek informacji z kubełka nieposortowanego
To tak naprawdę bardzo podstawowe pojęcie. Fragmenty w kubełku nieposortowanym będą miały wskaźniki podwójne wskaźniki, aby utworzyć kubełek. Pierwszy fragment w kubełku nieposortowanym będzie faktycznie mieć **FD** i **BK** łącza **wskazujące na część głównej areny (libc)**.\
Dlatego jeśli możesz **umieścić fragment w kubełku nieposortowanym i odczytać go** (użyj po zwolnieniu) lub **ponownie go zaalokować bez nadpisywania co najmniej 1 z wskaźników**, aby następnie go **odczytać**, możesz uzyskać **wyciek informacji z libc**.
To tak naprawdę bardzo podstawowe pojęcie. Fragmenty w kubełku nieposortowanym będą miały wskaźniki. Pierwszy fragment w kubełku nieposortowanym będzie faktycznie mieć **linki `fd` i `bk` wskazujące na część głównej areny (Glibc)**.\
Dlatego jeśli możesz **umieścić fragment w kubełku nieposortowanym i odczytać go** (użyj po zwolnieniu) lub **ponownie go zaalokować bez nadpisywania co najmniej 1 z wskaźników**, aby następnie go **odczytać**, możesz uzyskać **wyciek informacji z Glibc**.
Podobny [**atak użyty w tym opisie**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), polegał na wykorzystaniu struktury 4 fragmentów (A, B, C i D - D służył tylko do zapobiegania konsolidacji z fragmentem górnym), więc przepełnienie bajtów null w B zostało wykorzystane do spowodowania, że C wskazywało, że B jest nieużywane. Ponadto w B zmodyfikowano dane `prev_size`, więc rozmiar zamiast być rozmiarem B, był A+B.\
Następnie C został zwolniony i skonsolidowany z A+B (ale B nadal był używany). Zaalokowano nowy fragment o rozmiarze A, a następnie wyciekane były adresy libc, które zostały zapisane do B, skąd zostały wycieknięte.
Podobny [**atak użyty w tym opisie**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), polegał na wykorzystaniu struktury 4 fragmentów (A, B, C i D - D służył tylko do zapobieżenia konsolidacji z górnym fragmentem), więc przepełnienie zerowymi bajtami w B zostało wykorzystane do spowodowania, że C wskazywało, że B jest nieużywane. Ponadto w B zmodyfikowano dane `prev_size`, więc rozmiar zamiast być rozmiarem B, był A+B.\
Następnie C zostało zwolnione i skonsolidowane z A+B (ale B nadal był używany). Zaalokowano nowy fragment o rozmiarze A, a następnie wyciekły adresy Glibc, które zostały zapisane w B, skąd zostały wycieknięte.
## Odwołania i inne przykłady
* [**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)
* Celem jest nadpisanie zmiennej globalnej wartością większą niż 4869, aby można było uzyskać flagę, a PIE nie jest włączone.
* Możliwe jest generowanie fragmentów o dowolnych rozmiarach i występuje przepełnienie sterty o pożądanym rozmiarze.
* Atak rozpoczyna się od utworzenia 3 fragmentów: fragmentu0 do wykorzystania przepełnienia, fragmentu1 do przepełnienia i fragmentu2, aby fragmenty poprzednie nie zostały skonsolidowane z fragmentem górnym.
* Atak rozpoczyna się od utworzenia 3 fragmentów: fragmentu0 do wykorzystania przepełnienia, fragmentu1 do przepełnienia i fragmentu2, aby górny fragment nie konsolidował poprzednich.
* Następnie fragment1 jest zwalniany, a fragment0 jest przepełniany, aby wskaźnik `bk` fragmentu1 wskazywał na: `bk = magic - 0x10`
* Następnie zaalokowany jest fragment3 o tym samym rozmiarze co fragment1, co spowoduje atak na kubełek nieposortowany i zmodyfikuje wartość zmiennej globalnej, umożliwiając uzyskanie flagi.
* Następnie alokowany jest fragment3 o tym samym rozmiarze co fragment1, co spowoduje atak na kubełek nieposortowany i zmodyfikuje wartość zmiennej globalnej, umożliwiając uzyskanie flagi.
* [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html)
* Funkcja scalania jest podatna, ponieważ jeśli oba przekazane indeksy są takie same, to zrealokuje na nim i zwolni go, ale zwróci wskaźnik do tego zwolnionego obszaru, który można wykorzystać.
* Dlatego **tworzone są 2 fragmenty**: **fragment0**, który zostanie scalony sam ze sobą i fragment1, aby zapobiec konsolidacji z fragmentem górnym. Następnie funkcja scalania jest wywoływana z fragmentem0 dwa razy, co spowoduje użycie po zwolnieniu.
* Funkcja łączenia jest podatna, ponieważ jeśli oba przekazane indeksy są takie same, to zrealokuje na to i zwolni, ale zwróci wskaźnik do tego zwolnionego obszaru, który może być użyty.
* Dlatego **tworzone są 2 fragmenty**: **fragment0**, który zostanie połączony sam ze sobą i fragment1, aby zapobiec konsolidacji z górnym fragmentem. Następnie funkcja **merge jest wywoływana z fragmentem0** dwukrotnie, co spowoduje użycie po zwolnieniu.
* Następnie wywoływana jest funkcja **`view`** z indeksem 2 (który jest indeksem fragmentu użytego po zwolnieniu), co spowoduje **wyciek adresu libc**.
* Ponieważ binarny ma zabezpieczenia, aby alokować tylko rozmiary większe niż **`global_max_fast`**, więc nie używany jest fastbin, atak na kubełek nieposortowany zostanie wykorzystany do nadpisania zmiennej globalnej `global_max_fast`.
* Następnie możliwe jest wywołanie funkcji edycji z indeksem 2 (wskaźnik użyty po zwolnieniu) i nadpisanie wskaźnika `bk`, aby wskazywał na `p64(global_max_fast-0x10)`. Następnie tworząc nowy fragment użyje się wcześniej skompromitowanego adresu zwolnienia (0x20) i **wywoła atak na kubełek nieposortowany**, nadpisując `global_max_fast` dużą wartością, co teraz pozwala na tworzenie fragmentów w kubełkach fast.
* Ponieważ binarny ma zabezpieczenia, aby alokować tylko rozmiary większe niż **`global_max_fast`**, więc nie używany jest fastbin, atak na kubełek nieposortowany zostanie użyty do nadpisania zmiennej globalnej `global_max_fast`.
* Następnie możliwe jest wywołanie funkcji edycji z indeksem 2 (wskaźnik użyty po zwolnieniu) i nadpisanie wskaźnika `bk`, aby wskazywał na `p64(global_max_fast-0x10)`. Następnie tworzenie nowego fragmentu użyje wcześniej skompromitowanego adresu zwolnienia (0x20) i **spowoduje atak na kubełek nieposortowany**, nadpisując `global_max_fast` dużą wartością, co teraz pozwala na tworzenie fragmentów w kubełkach fast.
* Teraz wykonywany jest **atak na fast bin**:
* Po pierwsze odkryto, że możliwe jest pracowanie z **fragmentami fast o rozmiarze 200** w lokalizacji **`__free_hook`**:
* Po pierwsze odkryto, że możliwe jest pracowanie z szybkimi **fragmentami o rozmiarze 200** w lokalizacji **`__free_hook`**:
* <pre class="language-c"><code class="lang-c">gef➤ p &#x26;__free_hook
$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 &#x3C;__free_hook>
gef➤ x/60gx 0x7ff1e9e607a8 - 0x59
@ -75,21 +75,11 @@ gef➤ x/60gx 0x7ff1e9e607a8 - 0x59
* Jeśli uda nam się uzyskać szybki kawałek o rozmiarze 0x200 w tej lokalizacji, będzie możliwe nadpisanie wskaźnika funkcji, który zostanie wykonany
* W tym celu tworzony jest nowy kawałek o rozmiarze `0xfc` i funkcja scalająca jest wywoływana z tym wskaźnikiem dwukrotnie, w ten sposób uzyskujemy wskaźnik do zwolnionego kawałka o rozmiarze `0xfc*2 = 0x1f8` w szybkim pojemniku.
* Następnie funkcja edycji jest wywoływana w tym kawałku, aby zmodyfikować adres **`fd`** tego szybkiego pojemnika wskazujący na poprzednią funkcję **`__free_hook`**.
* Następnie tworzony jest kawałek o rozmiarze `0x1f8` w celu odzyskania z szybkiego pojemnika poprzedniego nieużytecznego kawałka, więc tworzony jest kolejny kawałek o rozmiarze `0x1f8`, aby uzyskać kawałek z szybkiego pojemnika w **`__free_hook`**, który jest nadpisany adresem funkcji **`system`**.
* Następnie tworzony jest kawałek o rozmiarze `0x1f8` w celu pobrania z szybkiego pojemnika poprzedniego nieużytecznego kawałka, więc tworzony jest kolejny kawałek o rozmiarze `0x1f8`, aby uzyskać kawałek z szybkiego pojemnika w **`__free_hook`**, który jest nadpisany adresem funkcji **`system`**.
* I wreszcie zwalniany jest kawałek zawierający ciąg znaków `/bin/sh\x00`, wywołując funkcję usuwania, co powoduje wywołanie funkcji **`__free_hook`**, która wskazuje na system z parametrem `/bin/sh\x00`.
* **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)
* Kolejny przykład nadużycia przepełnienia o 1B w celu skonsolidowania kawałków w nieuporządkowanym pojemniku i uzyskania wycieku informacji z libc, a następnie przeprowadzenia ataku na szybki pojemnik w celu nadpisania haka malloc adresem jednego gadżetu
<details>
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Inne sposoby wsparcia HackTricks:
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF** Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFTów**](https://opensea.io/collection/the-peass-family)
* **Dołącz do** 💬 [**Grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
* Kolejny przykład nadużycia przepełnienia o 1B w celu skonsolidowania kawałków w nieuporządkowanym pojemniku i uzyskania wycieku informacji o libc, a następnie przeprowadzenia ataku na szybki pojemnik w celu nadpisania haka malloc adresem jednego gadżetu
* [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
* Możemy przydzielać tylko kawałki o rozmiarze większym niż `0x100`.
* Nadpisanie `global_max_fast` za pomocą ataku na nieuporządkowany pojemnik (działa 1/16 razy ze względu na ASLR, ponieważ musimy zmodyfikować 12 bitów, ale musimy zmodyfikować 16 bitów).
* Atak na szybki pojemnik w celu zmodyfikowania globalnej tablicy kawałków. Zapewnia to arbitralne odczyt/zapis, co pozwala na modyfikację GOT i ustawienie pewnej funkcji na wskazanie `system`.