Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc

2025-02-16 22:18:27 +00:00 · 2024-06-13 21:22:58 +00:00 · 2024-06-13 21:22:58 +00:00 · 57771dc9bb
commit 57771dc9bb
parent 45427ba3cd
2 changed files with 82 additions and 41 deletions
--- a/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
+++ b/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md
@ -2,11 +2,11 @@

 <details>

-<summary><strong>Zacznij od zera i stań się ekspertem w hakowaniu 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>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)!
+* 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)**.**
@ -14,7 +14,7 @@ Inne sposoby wsparcia HackTricks:

 </details>

-## **Malloc Hook**
+## **Hook Malloc**

 Jak można przeczytać na [Oficjalnej stronie GNU](https://www.gnu.org/software/libc/manual/html\_node/Hooks-for-Malloc.html), zmienna **`__malloc_hook`** to wskaźnik wskazujący na **adres funkcji, która zostanie wywołana** za każdym razem, gdy zostanie wywołane `malloc()` **przechowywany w sekcji danych biblioteki libc**. Dlatego jeśli ten adres zostanie nadpisany na przykład przez **One Gadget** i zostanie wywołane `malloc`, to **One Gadget zostanie wywołany**.

@ -27,49 +27,58 @@ Więcej informacji na temat One Gadget znajdziesz w:
 {% endcontent-ref %}

 {% hint style="warning" %}
-Zauważ, że haki są **wyłączone dla GLIBC >= 2.34**. Istnieją inne techniki, które można stosować w nowoczesnych wersjach GLIBC. Zobacz: [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
+Zauważ, że haki są **wyłączone dla GLIBC >= 2.34**. Istnieją inne techniki, które można stosować w nowszych wersjach GLIBC. Zobacz: [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
 {% endhint %}

-## Free Hook
+## Hook Free

-To zostało wykorzystane w jednym z przykładów na stronie, wykorzystując atak na szybki blok po wcześniejszym wykorzystaniu ataku na nieuporządkowany blok:
+To zostało wykorzystane w jednym z przykładów na stronie, nadużywając ataku na szybki blok po wcześniejszym nadużyciu ataku na nieuporządkowany blok:

 {% content-ref url="../heap/unsorted-bin-attack.md" %}
 [unsorted-bin-attack.md](../heap/unsorted-bin-attack.md)
 {% endcontent-ref %}

-Teraz wykonywany jest **atak na szybki blok**:
+Fajny trik (z [**tutaj**](https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html)) to znalezienie lokalizacji hooka free, jeśli binarny plik ma symbole, to **zrób coś w stylu**:
+```
+gef➤  set __free_hook = 0xfacade
+gef➤  search-pattern 0xfacade
+```
+W tym samym poście znajdziesz przewodnik krok po kroku dotyczący lokalizacji adresu haka free bez symboli. Podsumowując, w funkcji free:

-* Po pierwsze odkryto, że można pracować z szybkimi **blokami 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>
+```armasm
+gef➤  x/20i free
+0xf75dedc0 <free>: push   ebx
+0xf75dedc1 <free+1>: call   0xf768f625
+0xf75dedc6 <free+6>: add    ebx,0x14323a
+0xf75dedcc <free+12>:  sub    esp,0x8
+0xf75dedcf <free+15>:  mov    eax,DWORD PTR [ebx-0x98]
+0xf75dedd5 <free+21>:  mov    ecx,DWORD PTR [esp+0x10]
+0xf75dedd9 <free+25>:  mov    eax,DWORD PTR [eax]
+0xf75deddb <free+27>:  test   eax,eax ;<--- PRZERWIJ TUTAJ
+0xf75deddd <free+29>:  jne    0xf75dee50 <free+144>
+```
+
+W wspomnianym punkcie przerwania w poprzednim kodzie w `$eax` będzie znajdować się adres haka free.
+
+Następnie wykonywany jest **szybki atak na bin**:
+
+- Po pierwsze odkryto, że możliwe jest pracowanie z szybkimi **kawałkami o rozmiarze 200** w lokalizacji **`__free_hook`**:
+- ```c
+gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
-<strong>0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
-</strong>0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
-0x7ff1e9e6076f &#x3C;list_all_lock+15>:      0x0000000000000000      0x0000000000000000
-0x7ff1e9e6077f &#x3C;_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-</code></pre>
-* Jeśli uda nam się uzyskać szybki blok o rozmiarze 0x200 w tej lokalizacji, będzie możliwe nadpisanie wskaźnika funkcji, która zostanie wykonana
-* W tym celu tworzony jest nowy blok o rozmiarze `0xfc` i funkcja scalania jest wywoływana z tym wskaźnikiem dwukrotnie, w ten sposób uzyskujemy wskaźnik do zwolnionego bloku o rozmiarze `0xfc*2 = 0x1f8` w szybkim bloku.
-* Następnie funkcja edycji jest wywoływana w tym bloku, aby zmodyfikować adres **`fd`** tego szybkiego bloku, aby wskazywał na poprzednią funkcję **`__free_hook`**.
-* Następnie tworzony jest blok o rozmiarze `0x1f8`, aby pobrać z szybkiego bloku poprzedni nieużyteczny blok, więc tworzony jest kolejny blok o rozmiarze `0x1f8`, aby uzyskać blok szybkiego bloku w **`__free_hook`**, który zostaje nadpisany adresem funkcji **`system`**.
-* I wreszcie blok zawierający ciąg znaków `/bin/sh\x00` jest zwalniany, wywołując funkcję usuwania, co powoduje wywołanie funkcji **`__free_hook`**, która wskazuje na system z parametrem `/bin/sh\x00`.
+0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
+0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+```
+- Jeśli uda nam się uzyskać szybki kawałek o rozmiarze 0x200 w tej lokalizacji, będzie możliwe nadpisanie wskaźnika funkcji, która zostanie wykonana.
+- W tym celu tworzony jest nowy kawałek o rozmiarze `0xfc`, a 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 binie.
+- Następnie funkcja edycji jest wywoływana w tym kawałku, aby zmodyfikować adres **`fd`** tego szybkiego binu, aby wskazywał na poprzednią funkcję **`__free_hook`**.
+- Następnie tworzony jest kawałek o rozmiarze `0x1f8`, aby pobrać z szybkiego binu poprzedni nieużyteczny kawałek, więc tworzony jest kolejny kawałek o rozmiarze `0x1f8`, aby uzyskać kawałek szybkiego binu w **`__free_hook`**, który zostaje nadpisany adresem funkcji **`system`**.
+- Na koniec 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`.

 ## Referencje

-* [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
-* [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
-
-<details>
-
-<summary><strong>Zacznij od zera i stań się ekspertem w hakowaniu 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)!
-* 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) github repos.
-
-</details>
+- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
+- [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
--- a/binary-exploitation/heap/house-of-force.md
+++ b/binary-exploitation/heap/house-of-force.md
@ -10,15 +10,16 @@ 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
+## Podstawowe Informacje

 ### Kod

 * Ta technika została załatana ([**tutaj**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) i powoduje ten błąd: `malloc(): corrupted top size`
+* Możesz wypróbować [**kod stąd**](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html), jeśli chcesz go przetestować.

 ### Cel

@ -26,15 +27,46 @@ Inne sposoby wsparcia HackTricks:

 ### Wymagania

-* Przepełnienie, które pozwala nadpisać rozmiar nagłówka głównego fragmentu (np. -1).
+* Przepełnienie, które pozwala nadpisać rozmiar nagłówka top chunk (np. -1).
 * Możliwość kontrolowania rozmiaru alokacji sterty

 ### Atak

-Jeśli atakujący chce mieć fragment w adresie P, po nadpisaniu rozmiaru głównego fragmentu wartością -1, najpierw potrzebne jest wykonanie malloc (\&top\_chunk - P). Należy zauważyć, że ten wskaźnik może znajdować się przed lub po top\_chunk, ponieważ dowolny rozmiar będzie mniejszy niż -1 (0xFFFFFFFFFFFFFFFF). Następnie, po zaalokowaniu tego początkowego fragmentu, główny fragment zostanie przeniesiony na pożądany adres P, a następny fragment będzie zaczynał się od tego adresu.
+Jeśli atakujący chce zaalokować fragment pamięci pod adresem P w celu nadpisania wartości, zaczyna od nadpisania rozmiaru top chunk `-1` (może to być wykonane poprzez przepełnienie). Zapewnia to, że malloc nie będzie używał mmap do żadnej alokacji, ponieważ Top chunk zawsze będzie miał wystarczająco dużo miejsca.

-### Odwołania
+Następnie oblicz odległość między adresem top chunk a docelowym miejscem alokacji. Jest to konieczne, ponieważ alokacja malloc o takim rozmiarze zostanie wykonana w celu przeniesienia top chunk do tej pozycji. Tak można łatwo obliczyć różnicę/rozmiar:
+```c
+// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
+/*
+* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
+* new_top = old_top + nb
+* nb = new_top - old_top
+* req + 2sizeof(long) = new_top - old_top
+* req = new_top - old_top - 2sizeof(long)
+* req = target - 2sizeof(long) - old_top - 2sizeof(long)
+* req = target - old_top - 4*sizeof(long)
+*/
+```
+Dlatego alokując rozmiar `cel - old_top - 4*sizeof(long)` (4 longi, ponieważ metadane top chunk i nowego chunka po alokacji) przesunie top chunk na adres, który chcemy nadpisać.\
+Następnie wykonaj kolejne malloc, aby uzyskać chunk zawierający na początku danych do zapisania docelowego adresu.
+
+### Odnośniki i Inne Przykłady

 * [https://github.com/shellphish/how2heap/tree/master](https://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
 * [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)
 * [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_force](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_force)
+* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.27/house\_of\_force.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.27/house\_of\_force.c)
+* [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.
+* Binarny plik ma przepełnienie, które można wykorzystać do zmodyfikowania rozmiaru top chunk, 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 chunk 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 przez 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 `Wprowadź swoje imię:` istnieje początkowa podatność, która pozwala na wyciek adresu z heap.
+* 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 wskazaną **nazwę hosta**. Ponieważ strcpy będzie kopiować zawartość s do chunka o rozmiarze 64B, możliwe jest **nadpisanie rozmiaru top chunk** danymi umieszczonymi w **nazwie hosta**.
+* Teraz, gdy możliwe jest dowolne zapisywanie, GOT `atoi` został nadpisany adresem printf. Następnie możliwe było wyciek adresu `IO_2_1_stderr` _z_ `%24$p`. I 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 dzięki temu wyciekowi ponownie nadpisać `atoi@got` z `system` i wywołać 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ż są tu 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, 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.